diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 0000000..8a0d659 --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,103 @@ +name: Tests + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + detect-changes: + runs-on: ubuntu-latest + outputs: + matrix: ${{ steps.set-matrix.outputs.matrix }} + any_changed: ${{ steps.set-matrix.outputs.any_changed }} + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Get changed files + id: changed-files + run: | + if [ "${{ github.event_name }}" = "pull_request" ]; then + echo "changed_files<> $GITHUB_OUTPUT + git diff --name-only origin/${{ github.base_ref }}..HEAD >> $GITHUB_OUTPUT + echo "EOF" >> $GITHUB_OUTPUT + else + echo "changed_files<> $GITHUB_OUTPUT + git diff --name-only HEAD~1..HEAD >> $GITHUB_OUTPUT + echo "EOF" >> $GITHUB_OUTPUT + fi + + - name: Set matrix for changed parsers + id: set-matrix + run: | + # List of all available parsers + ALL_PARSERS="redshift" + # Add more parsers here as they are added to the repository + # ALL_PARSERS="redshift mysql postgresql" + + CHANGED_FILES="${{ steps.changed-files.outputs.changed_files }}" + CHANGED_PARSERS="" + + for parser in $ALL_PARSERS; do + if echo "$CHANGED_FILES" | grep -q "^$parser/"; then + if [ -z "$CHANGED_PARSERS" ]; then + CHANGED_PARSERS="\"$parser\"" + else + CHANGED_PARSERS="$CHANGED_PARSERS,\"$parser\"" + fi + fi + done + + if [ -n "$CHANGED_PARSERS" ]; then + echo "matrix={\"parser\":[$CHANGED_PARSERS]}" >> $GITHUB_OUTPUT + echo "any_changed=true" >> $GITHUB_OUTPUT + echo "Changed parsers: $CHANGED_PARSERS" + else + echo "matrix={\"parser\":[]}" >> $GITHUB_OUTPUT + echo "any_changed=false" >> $GITHUB_OUTPUT + echo "No parser changes detected" + fi + + go-mod-tidy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + cache-dependency-path: go.sum + + - name: Verify go mod tidy + run: | + go mod tidy + git diff --exit-code -- go.mod go.sum + + go-tests: + needs: detect-changes + if: needs.detect-changes.outputs.any_changed == 'true' + runs-on: ubuntu-latest + strategy: + matrix: ${{ fromJSON(needs.detect-changes.outputs.matrix) }} + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-go@v5 + with: + go-version-file: go.mod + cache-dependency-path: go.sum + + - name: Run all tests + working-directory: ${{ matrix.parser }} + run: go test -p=8 -timeout 30m -ldflags "-w -s" -v ./... | tee test.log; exit ${PIPESTATUS[0]} + - name: Pretty print tests running time + working-directory: ${{ matrix.parser }} + # grep: filter out lines like "--- PASS: Test (15.04s)" + # sed: remove unnecessary characters + # awk: re-format lines to "PASS: Test (15.04s)" + # sort: cut into columns by delimiter ' ' (single space) and sort by column 3 (test time in seconds) as numeric type in reverse order (largest comes first) + # awk: accumulate sum by test time in seconds + run: grep --color=never -e '--- PASS:' -e '--- FAIL:' test.log | sed 's/[:()]//g' | awk '{print $2,$3,$4}' | sort -t' ' -nk3 -r | awk '{sum += $3; print $1,$2,$3,sum"s"}' diff --git a/.gitignore b/.gitignore index aaadf73..5b71a2d 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,7 @@ *.dll *.so *.dylib +**/.DS_Store # Test binary, built with `go test -c` *.test @@ -28,5 +29,8 @@ go.work.sum .env # Editor/IDE -# .idea/ -# .vscode/ +.idea/ + +# Plguin +# Intellij ANTLR plugin +**/gen/ \ No newline at end of file diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..ff4a681 --- /dev/null +++ b/go.mod @@ -0,0 +1,17 @@ +module github.com/bytebase/parser + +go 1.24.5 + +require ( + github.com/antlr4-go/antlr/v4 v4.13.1 + github.com/stretchr/testify v1.10.0 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) + +replace github.com/antlr4-go/antlr/v4 => github.com/bytebase/antlr/v4 v4.0.0-20240827034948-8c385f108920 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..c96f3a5 --- /dev/null +++ b/go.sum @@ -0,0 +1,14 @@ +github.com/bytebase/antlr/v4 v4.0.0-20240827034948-8c385f108920 h1:IfmPt5o5R70NKtOrs+QHOoCgViYZelZysGxVBvV4ybA= +github.com/bytebase/antlr/v4 v4.0.0-20240827034948-8c385f108920/go.mod h1:ykhjIPiv0IWpu3OGXCHdz2eUSe8UNGGD6baqjs8jSuU= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM= +golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/redshift/CLAUDE.md b/redshift/CLAUDE.md new file mode 100644 index 0000000..8782f0c --- /dev/null +++ b/redshift/CLAUDE.md @@ -0,0 +1,132 @@ +# Redshift Parser Development Guide + +## Project Overview + +This repository is a Redshift parser built with ANTLR 4, forked from github.com/bytebase/postgresql-parser. Due to incompatibility issues with PostgreSQL, this separate repository was created to support Amazon Redshift-specific syntax and features. + +## Architecture + +### Core Components + +1. **ANTLR Grammar Files**: + - `RedshiftLexer.g4` - Tokenization rules for Redshift SQL + - `RedshiftParser.g4` - Parser grammar with 200+ statement types + - Generated Go files: `redshift_parser.go`, `redshift_lexer.go`, etc. + +2. **Base Classes**: + - `redshift_parser_base.go` - Engine-aware parser with PostgreSQL/Redshift support + - `redshift_lexer_base.go` - Base lexer implementation + - `string_stack.go` - Utility for string stack operations + +3. **Supporting Files**: + - `keywords.go` - 600+ PostgreSQL keywords with reserved status + - `builtin_function.go` - Built-in function definitions + - `build.sh` - ANTLR code generation script + +### Engine Support + +The parser supports multiple database engines: +- `EnginePostgreSQL` - Standard PostgreSQL syntax +- `EngineRedshift` - Amazon Redshift-specific syntax extensions + +## Development Guidelines + +### Code Conventions + +1. **Follow existing patterns**: Always examine existing code before making changes +2. **Token/Rule/Name Convention**: Maintain consistency with current ANTLR grammar naming +3. **Engine-specific features**: Use engine detection for Redshift-specific syntax +4. **Error handling**: Implement proper error listeners and recovery mechanisms + +### Testing Requirements + +**CRITICAL**: Every change must include a related test case. + +1. **Test Structure**: + - Add SQL test files to the `examples/` directory + - Use Go-based tests in `parser_test.go` and `engine_specific_test.go` + - Tests automatically parse all SQL files in `examples/` + +2. **Test Content Sources**: + - Reference https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html + - Crawl syntax examples from AWS Redshift documentation + - Use real-world SQL examples when possible + +3. **Test Categories**: + - DDL: CREATE, ALTER, DROP statements + - DML: SELECT, INSERT, UPDATE, DELETE + - Redshift-specific: IDENTITY columns, DISTKEY, SORTKEY, etc. + - Advanced: Window functions, CTEs, JSON operations + +### Adding New Features + +1. **Grammar Changes**: + ```bash + # Edit RedshiftLexer.g4 or RedshiftParser.g4 + # Run build script to regenerate Go code + make build + ``` + +2. **Engine-Specific Logic**: + - Use `GetEngine()` method to detect Redshift vs PostgreSQL + - Implement conditional parsing for dialect-specific features + - See `engine_specific_test.go` for examples + +3. **Testing Process**: + - Create SQL test files in `examples/` + - Run tests: `go test -v` + - Verify both parsing success and error handling + +### Common Tasks + +#### Adding Redshift-Specific Syntax + +1. Identify the syntax difference from PostgreSQL +2. Update the appropriate grammar file (lexer or parser) +3. Add engine-specific logic if needed +4. Create test cases with AWS documentation examples +5. Verify tests pass for both engines + +#### Adding New Keywords + +1. Add to `keywords.go` with appropriate reserved status +2. Update lexer grammar if needed +3. Test keyword recognition in various contexts + +#### Adding Built-in Functions + +1. Add to `builtin_function.go` in appropriate category +2. Update parser rules if function has special syntax +3. Test function parsing and recognition + +## Build and Test Commands + +**IMPORTANT**: Always run `./build.sh` before running tests to generate the latest Go code from ANTLR grammars. + +```bash +# Generate parser code from ANTLR grammars (REQUIRED before testing) +make build + +# Run all tests +go test -v + +# Run specific test +go test -run TestParser -v + +# Run benchmarks +go test -bench=. -v +``` + +## References + +- [AWS Redshift SQL Commands](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) +- [ANTLR 4 Documentation](https://github.com/antlr/antlr4/blob/master/doc/index.md) +- [PostgreSQL Grammar Reference](https://github.com/tunnelvisionlabs/antlr4-postgresql) + +## Contributing + +1. Always add test cases for new features +2. Follow existing code patterns and conventions +3. Test against both PostgreSQL and Redshift engines +4. Use AWS documentation for accurate syntax examples +5. Ensure all tests pass before submitting changes \ No newline at end of file diff --git a/redshift/Makefile b/redshift/Makefile new file mode 100644 index 0000000..012e2ad --- /dev/null +++ b/redshift/Makefile @@ -0,0 +1,6 @@ +all: build test + +build: + antlr -Dlanguage=Go -package redshift -visitor -o . RedshiftLexer.g4 RedshiftParser.g4 + +test: go test -v -run TestRedshiftParser \ No newline at end of file diff --git a/redshift/README.md b/redshift/README.md new file mode 100644 index 0000000..6a5e149 --- /dev/null +++ b/redshift/README.md @@ -0,0 +1,202 @@ +# Redshift Parser + +A comprehensive SQL parser for Amazon Redshift built with ANTLR 4, optimized for Redshift-specific syntax. + +## Overview + +This project is a Go-based SQL parser specifically designed for Amazon Redshift. It originated as a fork of the PostgreSQL parser but has been restructured to focus exclusively on Redshift's unique syntax requirements. + +## Features + +- **Complete SQL Support**: Parses 200+ SQL statement types including DDL, DML, and advanced constructs +- **Redshift-Specific Syntax**: Full support for Redshift extensions like `IDENTITY` columns, `DISTKEY`, `SORTKEY`, and more +- **Redshift-Optimized**: Parser optimized exclusively for Redshift syntax and features +- **Comprehensive Testing**: 200+ test cases covering real-world SQL scenarios +- **High Performance**: Optimized for production use with parser reuse and efficient error handling + +## Installation + +```bash +go get github.com/bytebase/redshift-parser +``` + +## Quick Start + +```go +package main + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "github.com/bytebase/redshift-parser" +) + +func main() { + // Parse a Redshift-specific CREATE TABLE statement + sql := `CREATE TABLE users ( + id INT IDENTITY(1,1), + name VARCHAR(100), + email VARCHAR(255) UNIQUE + ) DISTKEY(id) SORTKEY(name);` + + // Create lexer and parser + input := antlr.NewInputStream(sql) + lexer := parser.NewRedshiftLexer(input) + stream := antlr.NewCommonTokenStream(lexer, 0) + p := parser.NewRedshiftParser(stream) + + // Parse the SQL + tree := p.Root() + + fmt.Println("Successfully parsed Redshift SQL!") +} +``` + +## Supported SQL Features + +### DDL (Data Definition Language) +- `CREATE TABLE` with Redshift-specific options (DISTKEY, SORTKEY, IDENTITY) +- `ALTER TABLE` with column modifications and constraints +- `CREATE INDEX` with various index types +- `CREATE VIEW` and materialized views +- `CREATE FUNCTION` and stored procedures + +### DML (Data Manipulation Language) +- `SELECT` with complex joins, subqueries, and window functions +- `INSERT` with conflict resolution (`ON CONFLICT`) +- `UPDATE` with joins and CTEs +- `DELETE` with complex conditions +- `MERGE` statements + +### Advanced Features +- Common Table Expressions (CTEs) +- Window functions and analytics +- JSON operations and path expressions +- Array operations +- Regular expressions +- Full-text search + +## Redshift-Specific Features + +The parser is optimized for Redshift's unique SQL extensions: + +- **IDENTITY columns**: `CREATE TABLE t (id INT IDENTITY(1,1))` +- **Distribution keys**: `DISTKEY(column_name)` +- **Sort keys**: `SORTKEY(column_name)` +- **Redshift built-in functions**: Comprehensive support for Redshift-specific functions +- **Data types**: All Redshift-supported data types including extensions + +## Development + +### Prerequisites +- Go 1.21+ +- ANTLR 4.13.2+ + +### Building from Source + +1. **Clone the repository**: +```bash +git clone https://github.com/bytebase/redshift-parser.git +cd redshift-parser +``` + +2. **Generate parser code**: +```bash +make build +``` + +3. **Run tests**: +```bash +go test -v +``` + +### Project Structure + +``` +redshift-parser/ +├── RedshiftLexer.g4 # ANTLR lexer grammar +├── RedshiftParser.g4 # ANTLR parser grammar +├── build.sh # Code generation script +├── redshift_lexer_base.go # Base lexer implementation +├── redshift_parser_base.go # Base parser implementation +├── keywords.go # 600+ SQL keywords +├── builtin_function.go # Built-in function definitions +├── examples/ # 200+ SQL test files +├── parser_test.go # Main test suite +└── CLAUDE.md # Development guide +``` + +## Testing + +The project includes comprehensive test coverage: + +```bash +# Run all tests +go test -v + +# Run specific test +go test -run TestRedshiftParser -v + +# Run benchmarks +go test -bench=. -v + +``` + +Test files are located in the `examples/` directory and cover: +- Basic SQL operations +- Complex queries with joins and subqueries +- Redshift-specific syntax +- Error handling scenarios +- Performance benchmarks + +## Grammar Files + +The parser is built using ANTLR 4 grammars: + +- **RedshiftLexer.g4**: Tokenization rules for SQL keywords, operators, and literals +- **RedshiftParser.g4**: Grammar rules for SQL statement parsing + +After modifying grammar files, regenerate the Go code: + +```bash +make build +``` + +## Contributing + +1. Fork the repository +2. Create a feature branch +3. Add tests for your changes +4. Ensure all tests pass +5. Update documentation as needed +6. Submit a pull request + +### Development Guidelines + +- Always run `./build.sh` before testing after grammar changes +- Add test cases for new SQL syntax support +- Follow existing code patterns and conventions +- Use AWS Redshift documentation for syntax reference +- Test against both PostgreSQL and Redshift engines + +## License + +This project is licensed under the MIT License. See the grammar files for additional license information from the original PostgreSQL grammar contributors. + +## Acknowledgments + +- Based on the PostgreSQL grammar from [Tunnel Vision Labs](https://github.com/tunnelvisionlabs/antlr4-postgresql) +- Forked from [Bytebase PostgreSQL Parser](https://github.com/bytebase/postgresql-parser) +- Built with [ANTLR 4](https://github.com/antlr/antlr4) + +## Related Projects + +- [Bytebase](https://github.com/bytebase/bytebase) - Database DevOps platform +- [PostgreSQL Parser](https://github.com/bytebase/postgresql-parser) - Original PostgreSQL parser +- [ANTLR 4](https://github.com/antlr/antlr4) - Parser generator toolkit + +## Support + +- [GitHub Issues](https://github.com/bytebase/redshift-parser/issues) - Bug reports and feature requests +- [AWS Redshift Documentation](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) - SQL syntax reference +- [ANTLR Documentation](https://github.com/antlr/antlr4/blob/master/doc/index.md) - Grammar development guide \ No newline at end of file diff --git a/redshift/RedshiftLexer.g4 b/redshift/RedshiftLexer.g4 new file mode 100755 index 0000000..d66e96b --- /dev/null +++ b/redshift/RedshiftLexer.g4 @@ -0,0 +1,3928 @@ +/* +based on +https://github.com/tunnelvisionlabs/antlr4-grammar-postgresql/blob/master/src/com/tunnelvisionlabs/postgresql/PostgreSqlLexer.g4 +*/ + +/* + * [The "MIT license"] + * Copyright (C) 2014 Sam Harwell, Tunnel Vision Laboratories, LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * 1. The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * 2. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * 3. Except as contained in this notice, the name of Tunnel Vision + * Laboratories, LLC. shall not be used in advertising or otherwise to + * promote the sale, use or other dealings in this Software without prior + * written authorization from Tunnel Vision Laboratories, LLC. + */ +lexer grammar RedshiftLexer; +/* Reference: + * http://www.postgresql.org/docs/9.3/static/sql-syntax-lexical.html + */ + +options { + superClass = RedshiftLexerBase; + caseInsensitive = true; +} + +@ header +{ +} +@ members +{ +/* This field stores the tags which are used to detect the end of a dollar-quoted string literal. + */ +} +// + +// SPECIAL CHARACTERS (4.1.4) + +// + +// Note that Asterisk is a valid operator, but does not have the type Operator due to its syntactic use in locations + +// that are not expressions. + +Dollar + : '$' + ; + +OPEN_PAREN + : '(' + ; + +CLOSE_PAREN + : ')' + ; + +OPEN_BRACKET + : '[' + ; + +CLOSE_BRACKET + : ']' + ; + +COMMA + : ',' + ; + +SEMI + : ';' + ; + +COLON + : ':' + ; + +STAR + : '*' + ; + +EQUAL + : '=' + ; + +DOT + : '.' + ; + //NamedArgument : ':='; + +PLUS + : '+' + ; + +MINUS + : '-' + ; + +SLASH + : '/' + ; + +CARET + : '^' + ; + +LT + : '<' + ; + +GT + : '>' + ; + +LESS_LESS + : '<<' + ; + +GREATER_GREATER + : '>>' + ; + +COLON_EQUALS + : ':=' + ; + +LESS_EQUALS + : '<=' + ; + +EQUALS_GREATER + : '=>' + ; + +GREATER_EQUALS + : '>=' + ; + +DOT_DOT + : '..' + ; + +NOT_EQUALS + : '<>' + ; + +TYPECAST + : '::' + ; + +PERCENT + : '%' + ; + +PARAM + : '$' ([0-9])+ + ; + // + + // OPERATORS (4.1.3) + + // + + // this rule does not allow + or - at the end of a multi-character operator + +Operator + : ((OperatorCharacter | ('+' | '-' + {p.checkLA('-')}?)+ (OperatorCharacter | '/' + {p.checkLA('*')}?) | '/' + {p.checkLA('*')}?)+ | // special handling for the single-character operators + and - + [+-]) + //TODO somehow rewrite this part without using Actions + + { + l.HandleLessLessGreaterGreater(); + } + ; +/* This rule handles operators which end with + or -, and sets the token type to Operator. It is comprised of four + * parts, in order: + * + * 1. A prefix, which does not contain a character from the required set which allows + or - to appear at the end of + * the operator. + * 2. A character from the required set which allows + or - to appear at the end of the operator. + * 3. An optional sub-token which takes the form of an operator which does not include a + or - at the end of the + * sub-token. + * 4. A suffix sequence of + and - characters. + */ + + +OperatorEndingWithPlusMinus + : (OperatorCharacterNotAllowPlusMinusAtEnd | '-' + {p.checkLA('-')}? | '/' + {p.checkLA('*')}?)* OperatorCharacterAllowPlusMinusAtEnd Operator? ('+' | '-' + {p.checkLA('-')}?)+ -> type (Operator) + ; + // Each of the following fragment rules omits the +, -, and / characters, which must always be handled in a special way + + // by the operator rules above. + +fragment OperatorCharacter + : [*<>=~!@%^&|`?#] + ; + // these are the operator characters that don't count towards one ending with + or - + +fragment OperatorCharacterNotAllowPlusMinusAtEnd + : [*<>=+] + ; + // an operator may end with + or - if it contains one of these characters + +fragment OperatorCharacterAllowPlusMinusAtEnd + : [~!@%^&|`?#] + ; + // + + // KEYWORDS (Appendix C) + + // + + // + + // reserved keywords + + // + +ALL + : 'ALL' + ; + +ANALYSE + : 'ANALYSE' + ; + +ANALYZE + : 'ANALYZE' + ; + +AND + : 'AND' + ; + +ANY + : 'ANY' + ; + +ARRAY + : 'ARRAY' + ; + +AS + : 'AS' + ; + +ASC + : 'ASC' + ; + +ASYMMETRIC + : 'ASYMMETRIC' + ; + +BOTH + : 'BOTH' + ; + +CASE + : 'CASE' + ; + +CAST + : 'CAST' + ; + +CHECK + : 'CHECK' + ; + +COLLATE + : 'COLLATE' + ; + +COLUMN + : 'COLUMN' + ; + +CONSTRAINT + : 'CONSTRAINT' + ; + +CREATE + : 'CREATE' + ; + +CURRENT_CATALOG + : 'CURRENT_CATALOG' + ; + +CURRENT_DATE + : 'CURRENT_DATE' + ; + +CURRENT_ROLE + : 'CURRENT_ROLE' + ; + +CURRENT_TIME + : 'CURRENT_TIME' + ; + +CURRENT_TIMESTAMP + : 'CURRENT_TIMESTAMP' + ; + +CURRENT_USER + : 'CURRENT_USER' + ; + +DEFAULT + : 'DEFAULT' + ; + +DEFERRABLE + : 'DEFERRABLE' + ; + +DESC + : 'DESC' + ; + +DISTINCT + : 'DISTINCT' + ; + +DO + : 'DO' + ; + +ELSE + : 'ELSE' + ; + +EXCEPT + : 'EXCEPT' + ; + +FALSE_P + : 'FALSE' + ; + +FETCH + : 'FETCH' + ; + +FOR + : 'FOR' + ; + +FOREIGN + : 'FOREIGN' + ; + +FROM + : 'FROM' + ; + +GRANT + : 'GRANT' + ; + +GROUP_P + : 'GROUP' + ; + +HAVING + : 'HAVING' + ; + +IN_P + : 'IN' + ; + +INITIALLY + : 'INITIALLY' + ; + +INTERSECT + : 'INTERSECT' + ; + +INTO + : 'INTO' + ; + +LATERAL_P + : 'LATERAL' + ; + +LEADING + : 'LEADING' + ; + +LIMIT + : 'LIMIT' + ; + +LOCALTIME + : 'LOCALTIME' + ; + +LOCALTIMESTAMP + : 'LOCALTIMESTAMP' + ; + +NOT + : 'NOT' + ; + +NULL_P + : 'NULL' + ; + +OFFSET + : 'OFFSET' + ; + +ON + : 'ON' + ; + +ONLY + : 'ONLY' + ; + +OR + : 'OR' + ; + +ORDER + : 'ORDER' + ; + +PLACING + : 'PLACING' + ; + +PRIMARY + : 'PRIMARY' + ; + +PUBLIC + : 'PUBLIC' + ; + +REFERENCES + : 'REFERENCES' + ; + +RETURNING + : 'RETURNING' + ; + +SELECT + : 'SELECT' + ; + +SESSION_USER + : 'SESSION_USER' + ; + +SOME + : 'SOME' + ; + +SYMMETRIC + : 'SYMMETRIC' + ; + +TABLE + : 'TABLE' + ; + +THEN + : 'THEN' + ; + +TO + : 'TO' + ; + +TRAILING + : 'TRAILING' + ; + +TRUE_P + : 'TRUE' + ; + +UNION + : 'UNION' + ; + +UNIQUE + : 'UNIQUE' + ; + +USER + : 'USER' + ; + +USING + : 'USING' + ; + +VARIADIC + : 'VARIADIC' + ; + +WHEN + : 'WHEN' + ; + +WHERE + : 'WHERE' + ; + +WINDOW + : 'WINDOW' + ; + +WITH + : 'WITH' + ; + + // + + // reserved keywords (can be function or type) + + // + +AUTHORIZATION + : 'AUTHORIZATION' + ; + +BINARY + : 'BINARY' + ; + +BINDING + : 'BINDING' + ; + +COLLATION + : 'COLLATION' + ; + +CONCURRENTLY + : 'CONCURRENTLY' + ; + +CROSS + : 'CROSS' + ; + +CURRENT_SCHEMA + : 'CURRENT_SCHEMA' + ; + +FREEZE + : 'FREEZE' + ; + +FULL + : 'FULL' + ; + +ILIKE + : 'ILIKE' + ; + +INNER_P + : 'INNER' + ; + +IS + : 'IS' + ; + +ISNULL + : 'ISNULL' + ; + +JOIN + : 'JOIN' + ; + +LEFT + : 'LEFT' + ; + +LIKE + : 'LIKE' + ; + +NATURAL + : 'NATURAL' + ; + +NOTNULL + : 'NOTNULL' + ; + +OUTER_P + : 'OUTER' + ; + +OVER + : 'OVER' + ; + +OVERLAPS + : 'OVERLAPS' + ; + +RIGHT + : 'RIGHT' + ; + +SIMILAR + : 'SIMILAR' + ; + +VERBOSE + : 'VERBOSE' + ; + // + + // non-reserved keywords + + // + +ABORT_P + : 'ABORT' + ; + +ABSOLUTE_P + : 'ABSOLUTE' + ; + +ACCESS + : 'ACCESS' + ; + +ACTION + : 'ACTION' + ; + +ADD_P + : 'ADD' + ; + +ADMIN + : 'ADMIN' + ; + +AFTER + : 'AFTER' + ; + +AGGREGATE + : 'AGGREGATE' + ; + +ALSO + : 'ALSO' + ; + +ALTER + : 'ALTER' + ; + +ALWAYS + : 'ALWAYS' + ; + +ASSERTION + : 'ASSERTION' + ; + +ASSIGNMENT + : 'ASSIGNMENT' + ; + +AT + : 'AT' + ; + +ATTRIBUTE + : 'ATTRIBUTE' + ; + +BACKWARD + : 'BACKWARD' + ; + +BEFORE + : 'BEFORE' + ; + +BEGIN_P + : 'BEGIN' + ; + +BY + : 'BY' + ; + +CACHE + : 'CACHE' + ; + +CALLED + : 'CALLED' + ; + +CASCADE + : 'CASCADE' + ; + +CASCADED + : 'CASCADED' + ; + +CATALOG + : 'CATALOG' + ; + +CHAIN + : 'CHAIN' + ; + +CHARACTERISTICS + : 'CHARACTERISTICS' + ; + +CHECKPOINT + : 'CHECKPOINT' + ; + +CLASS + : 'CLASS' + ; + +CLOSE + : 'CLOSE' + ; + +CLUSTER + : 'CLUSTER' + ; + +COMMENT + : 'COMMENT' + ; + +COMMENTS + : 'COMMENTS' + ; + +COMMIT + : 'COMMIT' + ; + +COMMITTED + : 'COMMITTED' + ; + +CONFIGURATION + : 'CONFIGURATION' + ; + +CONNECTION + : 'CONNECTION' + ; + +CONSTRAINTS + : 'CONSTRAINTS' + ; + +CONTENT_P + : 'CONTENT' + ; + +CONTINUE_P + : 'CONTINUE' + ; + +CONVERSION_P + : 'CONVERSION' + ; + +COPY + : 'COPY' + ; + +COST + : 'COST' + ; + +CSV + : 'CSV' + ; + +JSON + : 'JSON' + ; + +CURSOR + : 'CURSOR' + ; + +CYCLE + : 'CYCLE' + ; + +DATA_P + : 'DATA' + ; + +DATA_CATALOG + : 'DATA_CATALOG' + ; + +DATABASE + : 'DATABASE' + ; + +DAY_P + : 'DAY' + ; + +DEALLOCATE + : 'DEALLOCATE' + ; + +DECLARE + : 'DECLARE' + ; + +DEFAULTS + : 'DEFAULTS' + ; + +DEFERRED + : 'DEFERRED' + ; + +DEFINER + : 'DEFINER' + ; + +DELETE_P + : 'DELETE' + ; + +DELIMITER + : 'DELIMITER' + ; + +DELIMITERS + : 'DELIMITERS' + ; + +DICTIONARY + : 'DICTIONARY' + ; + +DISABLE_P + : 'DISABLE' + ; + +DISCARD + : 'DISCARD' + ; + +DOCUMENT_P + : 'DOCUMENT' + ; + +DOMAIN_P + : 'DOMAIN' + ; + +DOUBLE_P + : 'DOUBLE' + ; + +DROP + : 'DROP' + ; + +EACH + : 'EACH' + ; + +ENABLE_P + : 'ENABLE' + ; + +ENCODING + : 'ENCODING' + ; + +ENCRYPTED + : 'ENCRYPTED' + ; + +ENUM_P + : 'ENUM' + ; + +ESCAPE + : 'ESCAPE' + ; + +EVENT + : 'EVENT' + ; + +EXCLUDE + : 'EXCLUDE' + ; + +EXCLUDING + : 'EXCLUDING' + ; + +EXCLUSIVE + : 'EXCLUSIVE' + ; + +EXECUTE + : 'EXECUTE' + ; + +EXPLAIN + : 'EXPLAIN' + ; + +EXTENSION + : 'EXTENSION' + ; + +EXTERNAL + : 'EXTERNAL' + ; + +FAMILY + : 'FAMILY' + ; + +FIRST_P + : 'FIRST' + ; + +FOLLOWING + : 'FOLLOWING' + ; + +FORCE + : 'FORCE' + ; + +FORWARD + : 'FORWARD' + ; + +FUNCTION + : 'FUNCTION' + ; + +FUNCTIONS + : 'FUNCTIONS' + ; + +GLOBAL + : 'GLOBAL' + ; + +GRANTED + : 'GRANTED' + ; + +HANDLER + : 'HANDLER' + ; + +HEADER_P + : 'HEADER' + ; + +HOLD + : 'HOLD' + ; + +HOUR_P + : 'HOUR' + ; + +IDENTITY_P + : 'IDENTITY' + ; + +IF_P + : 'IF' + ; + +IMMEDIATE + : 'IMMEDIATE' + ; + +IMMUTABLE + : 'IMMUTABLE' + ; + +IMPLICIT_P + : 'IMPLICIT' + ; + +INCLUDING + : 'INCLUDING' + ; + +INCREMENT + : 'INCREMENT' + ; + +INDEX + : 'INDEX' + ; + +INDEXES + : 'INDEXES' + ; + +INHERIT + : 'INHERIT' + ; + +INHERITS + : 'INHERITS' + ; + +INLINE_P + : 'INLINE' + ; + +INSENSITIVE + : 'INSENSITIVE' + ; + +INSERT + : 'INSERT' + ; + +INSTEAD + : 'INSTEAD' + ; + +INVOKER + : 'INVOKER' + ; + +ISOLATION + : 'ISOLATION' + ; + +KEY + : 'KEY' + ; + +LABEL + : 'LABEL' + ; + +LANGUAGE + : 'LANGUAGE' + ; + +LARGE_P + : 'LARGE' + ; + +LAST_P + : 'LAST' + ; + //LC_COLLATE : 'LC'_'COLLATE; + + //LC_CTYPE : 'LC'_'CTYPE; + +LEAKPROOF + : 'LEAKPROOF' + ; + +LEVEL + : 'LEVEL' + ; + +LISTEN + : 'LISTEN' + ; + +LOAD + : 'LOAD' + ; + +LOCAL + : 'LOCAL' + ; + +LOCATION + : 'LOCATION' + ; + +LOCK_P + : 'LOCK' + ; + +MAPPING + : 'MAPPING' + ; + +MATCH + : 'MATCH' + ; + +MATCHED + : 'MATCHED' + ; + +MATERIALIZED + : 'MATERIALIZED' + ; + +MAXVALUE + : 'MAXVALUE' + ; + +MERGE + : 'MERGE' + ; + +MINUTE_P + : 'MINUTE' + ; + +MINVALUE + : 'MINVALUE' + ; + +MODE + : 'MODE' + ; + +MONTH_P + : 'MONTH' + ; + +MOVE + : 'MOVE' + ; + +NAME_P + : 'NAME' + ; + +NAMES + : 'NAMES' + ; + +NEXT + : 'NEXT' + ; + +NO + : 'NO' + ; + +NOTHING + : 'NOTHING' + ; + +NOTIFY + : 'NOTIFY' + ; + +NOWAIT + : 'NOWAIT' + ; + +NULLS_P + : 'NULLS' + ; + +OBJECT_P + : 'OBJECT' + ; + +OF + : 'OF' + ; + +OFF + : 'OFF' + ; + +OIDS + : 'OIDS' + ; + +OPERATOR + : 'OPERATOR' + ; + +OPTION + : 'OPTION' + ; + +OPTIONS + : 'OPTIONS' + ; + +OWNED + : 'OWNED' + ; + +OWNER + : 'OWNER' + ; + +PARSER + : 'PARSER' + ; + +PARTIAL + : 'PARTIAL' + ; + +PARTITION + : 'PARTITION' + ; + +PASSING + : 'PASSING' + ; + +PASSWORD + : 'PASSWORD' + ; + +PLANS + : 'PLANS' + ; + +PRECEDING + : 'PRECEDING' + ; + +PREDICATE + : 'PREDICATE' + ; + +PREPARE + : 'PREPARE' + ; + +PREPARED + : 'PREPARED' + ; + +PRESERVE + : 'PRESERVE' + ; + +PRIOR + : 'PRIOR' + ; + +PRIVILEGES + : 'PRIVILEGES' + ; + +PROCEDURAL + : 'PROCEDURAL' + ; + +PROCEDURE + : 'PROCEDURE' + ; + +PROGRAM + : 'PROGRAM' + ; + +QUOTE + : 'QUOTE' + ; + +RANGE + : 'RANGE' + ; + +READ + : 'READ' + ; + +REASSIGN + : 'REASSIGN' + ; + +RECHECK + : 'RECHECK' + ; + +RECURSIVE + : 'RECURSIVE' + ; + +REF + : 'REF' + ; + +REFRESH + : 'REFRESH' + ; + +REINDEX + : 'REINDEX' + ; + +RELATIVE_P + : 'RELATIVE' + ; + +RELEASE + : 'RELEASE' + ; + +RENAME + : 'RENAME' + ; + +REPEATABLE + : 'REPEATABLE' + ; + +REPLACE + : 'REPLACE' + ; + +REPLICA + : 'REPLICA' + ; + +RESET + : 'RESET' + ; + +RESTART + : 'RESTART' + ; + +RESTRICT + : 'RESTRICT' + ; + +RETURNS + : 'RETURNS' + ; + +REVOKE + : 'REVOKE' + ; + +ROLE + : 'ROLE' + ; + +ROLLBACK + : 'ROLLBACK' + ; + +ROWS + : 'ROWS' + ; + +RULE + : 'RULE' + ; + +SAVEPOINT + : 'SAVEPOINT' + ; + +SCHEMA + : 'SCHEMA' + ; + +SCROLL + : 'SCROLL' + ; + +SEARCH + : 'SEARCH' + ; + +SECOND_P + : 'SECOND' + ; + +SECURITY + : 'SECURITY' + ; + +SEQUENCE + : 'SEQUENCE' + ; + +SEQUENCES + : 'SEQUENCES' + ; + +SERIALIZABLE + : 'SERIALIZABLE' + ; + +SERVER + : 'SERVER' + ; + +SESSION + : 'SESSION' + ; + +SET + : 'SET' + ; + +SHARE + : 'SHARE' + ; + +SHOW + : 'SHOW' + ; + +SIMPLE + : 'SIMPLE' + ; + +SNAPSHOT + : 'SNAPSHOT' + ; + +STABLE + : 'STABLE' + ; + +STANDALONE_P + : 'STANDALONE' + ; + +START + : 'START' + ; + +STATEMENT + : 'STATEMENT' + ; + +STATISTICS + : 'STATISTICS' + ; + +STDIN + : 'STDIN' + ; + +STDOUT + : 'STDOUT' + ; + +STORAGE + : 'STORAGE' + ; + +STRICT_P + : 'STRICT' + ; + +STRIP_P + : 'STRIP' + ; + +SYSID + : 'SYSID' + ; + +SYSTEM_P + : 'SYSTEM' + ; + +TABLES + : 'TABLES' + ; + +TABLESPACE + : 'TABLESPACE' + ; + +TEMP + : 'TEMP' + ; + +TEMPLATE + : 'TEMPLATE' + ; + +TEMPORARY + : 'TEMPORARY' + ; + +TEXT_P + : 'TEXT' + ; + +TRANSACTION + : 'TRANSACTION' + ; + +TRIGGER + : 'TRIGGER' + ; + +TRUNCATE + : 'TRUNCATE' + ; + +TRUSTED + : 'TRUSTED' + ; + +TYPE_P + : 'TYPE' + ; + +TYPES_P + : 'TYPES' + ; + +UNBOUNDED + : 'UNBOUNDED' + ; + +UNCOMMITTED + : 'UNCOMMITTED' + ; + +UNENCRYPTED + : 'UNENCRYPTED' + ; + +UNKNOWN + : 'UNKNOWN' + ; + +UNLISTEN + : 'UNLISTEN' + ; + +UNLOGGED + : 'UNLOGGED' + ; + +UNTIL + : 'UNTIL' + ; + +UPDATE + : 'UPDATE' + ; + +VACUUM + : 'VACUUM' + ; + +VALID + : 'VALID' + ; + +VALIDATE + : 'VALIDATE' + ; + +VALIDATOR + : 'VALIDATOR' + ; + //VALUE : 'VALUE; + +VARYING + : 'VARYING' + ; + +VERSION_P + : 'VERSION' + ; + +VIEW + : 'VIEW' + ; + +VOLATILE + : 'VOLATILE' + ; + +WHITESPACE_P + : 'WHITESPACE' + ; + +WITHOUT + : 'WITHOUT' + ; + +WORK + : 'WORK' + ; + +WRAPPER + : 'WRAPPER' + ; + +WRITE + : 'WRITE' + ; + +XML_P + : 'XML' + ; + +YEAR_P + : 'YEAR' + ; + +YES_P + : 'YES' + ; + +ZONE + : 'ZONE' + ; + +// REDSHIFT-SPECIFIC KEYWORDS +// These tokens are specific to Amazon Redshift and not part of standard PostgreSQL + +// Datashare Commands +QUALIFY + : 'QUALIFY' + ; + +CONNECT + : 'CONNECT' + ; + +TOP + : 'TOP' + ; + +VARBYTE + : 'VARBYTE' + ; + +VARBINARY + : 'VARBINARY' + ; + +CONJUNCTION + : 'CONJUNCTION' + ; + +DEFINITION + : 'DEFINITION' + ; + +DATASHARE + : 'DATASHARE' + ; + +FILE + : 'FILE' + ; + +PUBLICACCESSIBLE + : 'PUBLICACCESSIBLE' + ; + +INCLUDENEW + : 'INCLUDENEW' + ; + +// External Data Sources +IAM_ROLE + : 'IAM_ROLE' + ; + +CATALOG_ROLE + : 'CATALOG_ROLE' + ; + +CATALOG_ID + : 'CATALOG_ID' + ; + +HIVE + : 'HIVE' + ; + +METASTORE + : 'METASTORE' + ; + +URI + : 'URI' + ; + +POSTGRES + : 'POSTGRES' + ; + +MYSQL + : 'MYSQL' + ; + +SECRET_ARN + : 'SECRET_ARN' + ; + +KINESIS + : 'KINESIS' + ; + +KAFKA + : 'KAFKA' + ; + +MSK + : 'MSK' + ; + +AUTHENTICATION + : 'AUTHENTICATION' + ; + +AUTHENTICATION_ARN + : 'AUTHENTICATION_ARN' + ; + +SESSION_TOKEN + : 'SESSION' + ; + +MTLS + : 'MTLS' + ; + +// Security/Policy +MASKING + : 'MASKING' + ; + +RLS + : 'RLS' + ; + +IDENTITY + : 'IDENTITY' + ; + +PROVIDER + : 'PROVIDER' + ; + +PROTECTED + : 'PROTECTED' + ; + +// ML/Model Commands +MODEL + : 'MODEL' + ; + +TARGET + : 'TARGET' + ; + +SAGEMAKER + : 'SAGEMAKER' + ; + +AUTO + : 'AUTO' + ; + +MODEL_TYPE + : 'MODEL_TYPE' + ; + +PROBLEM_TYPE + : 'PROBLEM_TYPE' + ; + +OBJECTIVE + : 'OBJECTIVE' + ; + +PREPROCESSORS + : 'PREPROCESSORS' + ; + +HYPERPARAMETERS + : 'HYPERPARAMETERS' + ; + +XGBOOST + : 'XGBOOST' + ; + +MLP + : 'MLP' + ; + +LINEAR_LEARNER + : 'LINEAR_LEARNER' + ; + +KMEANS + : 'KMEANS' + ; + +FORECAST + : 'FORECAST' + ; + +REGRESSION + : 'REGRESSION' + ; + +BINARY_CLASSIFICATION + : 'BINARY_CLASSIFICATION' + ; + +MULTICLASS_CLASSIFICATION + : 'MULTICLASS_CLASSIFICATION' + ; + +S3_BUCKET + : 'S3_BUCKET' + ; + +TAGS + : 'TAGS' + ; + +KMS_KEY_ID + : 'KMS_KEY_ID' + ; + +S3_GARBAGE_COLLECT + : 'S3_GARBAGE_COLLECT' + ; + +MAX_CELLS + : 'MAX_CELLS' + ; + +MAX_RUNTIME + : 'MAX_RUNTIME' + ; + +HORIZON + : 'HORIZON' + ; + +FREQUENCY + : 'FREQUENCY' + ; + +PERCENTILES + : 'PERCENTILES' + ; + +MAX_BATCH_ROWS + : 'MAX_BATCH_ROWS' + ; + +// UNLOAD Command +UNLOAD + : 'UNLOAD' + ; + +MANIFEST + : 'MANIFEST' + ; + +ADDQUOTES + : 'ADDQUOTES' + ; + +ALLOWOVERWRITE + : 'ALLOWOVERWRITE' + ; + +CLEANPATH + : 'CLEANPATH' + ; + +MAXFILESIZE + : 'MAXFILESIZE' + ; + +ROWGROUPSIZE + : 'ROWGROUPSIZE' + ; + +BZIP2 + : 'BZIP2' + ; + +GZIP + : 'GZIP' + ; + +ZSTD + : 'ZSTD' + ; + +// Show Commands +DATABASES + : 'DATABASES' + ; + +DATASHARES + : 'DATASHARES' + ; + +GRANTS + : 'GRANTS' + ; + +// Session/Connection +USE + : 'USE' + ; + +CANCEL + : 'CANCEL' + ; + +SESSION_AUTHORIZATION + : 'SESSION_AUTHORIZATION' + ; + +SESSION_CHARACTERISTICS + : 'SESSION_CHARACTERISTICS' + ; + +// General +COMPRESSION + : 'COMPRESSION' + ; + +LIBRARY + : 'LIBRARY' + ; + +APPEND + : 'APPEND' + ; + +// Size Units +MB + : 'MB' + ; + +GB + : 'GB' + ; + +// Common Redshift Keywords +ACCOUNT + : 'ACCOUNT' + ; + +NAMESPACE + : 'NAMESPACE' + ; + +DESCRIBE + : 'DESCRIBE' + ; + +// Additional Redshift-specific tokens +NONATOMIC + : 'NONATOMIC' + ; + +MANAGEDBY + : 'MANAGEDBY' + ; + +ADX + : 'ADX' + ; + +REMOVE + : 'REMOVE' + ; + +DUPLICATES + : 'DUPLICATES' + ; + +BEDROCK + : 'BEDROCK' + ; + +MODEL_ID + : 'MODEL_ID' + ; + +PROMPT + : 'PROMPT' + ; + +SUFFIX + : 'SUFFIX' + ; + +REQUEST_TYPE + : 'REQUEST_TYPE' + ; + +RESPONSE_TYPE + : 'RESPONSE_TYPE' + ; + +RAW + : 'RAW' + ; + +UNIFIED + : 'UNIFIED' + ; + +SUPER + : 'SUPER' + ; + +CI + : 'CI' + ; + +CS + : 'CS' + ; + +PLPYTHONU + : 'PLPYTHONU' + ; + +FILLTARGET + : 'FILLTARGET' + ; + +IGNOREEXTRA + : 'IGNOREEXTRA' + ; + +CREATEUSER + : 'CREATEUSER' + ; + +NOCREATEUSER + : 'NOCREATEUSER' + ; + +// Additional commonly used tokens (avoiding conflicts with existing _P tokens and identifiers) +REGION + : 'REGION' + ; + +PORT + : 'PORT' + ; + +REDSHIFT + : 'REDSHIFT' + ; + +IAM + : 'IAM' + ; + +CREATEDB + : 'CREATEDB' + ; + +NOCREATEDB + : 'NOCREATEDB' + ; + +RESTRICTED + : 'RESTRICTED' + ; + +UNLIMITED + : 'UNLIMITED' + ; + +EXTERNALID + : 'EXTERNALID' + ; + +TIMEOUT + : 'TIMEOUT' + ; + +SYSLOG + : 'SYSLOG' + ; + +CREDENTIALS + : 'CREDENTIALS' + ; + +UNRESTRICTED + : 'UNRESTRICTED' + ; + +PARAMETERS + : 'PARAMETERS' + ; + +APPLICATION_ARN + : 'APPLICATION_ARN' + ; + +AUTO_CREATE_ROLES + : 'AUTO_CREATE_ROLES' + ; + +COMPROWS + : 'COMPROWS' + ; + +PROVIDER_URL + : 'PROVIDER_URL' + ; + +PROVIDER_URL_PORT + : 'PROVIDER_URL_PORT' + ; + +ATTRIBUTE_MAP + : 'ATTRIBUTE_MAP' + ; + +PROVIDER_ARN + : 'PROVIDER_ARN' + ; + +ASSUME_ROLE_ARN + : 'ASSUME_ROLE_ARN' + ; + + +PROPERTIES + : 'PROPERTIES' + ; + +AVRO + : 'AVRO' + ; + +RCFILE + : 'RCFILE' + ; + +SEQUENCEFILE + : 'SEQUENCEFILE' + ; + +TEXTFILE + : 'TEXTFILE' + ; + +ORC + : 'ORC' + ; + +ION + : 'ION' + ; + +LAMBDA + : 'LAMBDA' + ; + +FIXEDWIDTH + : 'FIXEDWIDTH' + ; + +// Missing tokens causing implicit definition warnings (avoiding conflicts with _P versions) +PARQUET + : 'PARQUET' + ; + +LZOP + : 'LZOP' + ; + +REMOVEQUOTES + : 'REMOVEQUOTES' + ; + +TRUNCATECOLUMNS + : 'TRUNCATECOLUMNS' + ; + +FILLRECORD + : 'FILLRECORD' + ; + +BLANKSASNULL + : 'BLANKSASNULL' + ; + +EMPTYASNULL + : 'EMPTYASNULL' + ; + +MAXERROR + : 'MAXERROR' + ; + +DATEFORMAT + : 'DATEFORMAT' + ; + +TIMEFORMAT + : 'TIMEFORMAT' + ; + +ACCEPTINVCHARS + : 'ACCEPTINVCHARS' + ; + +ACCEPTANYDATE + : 'ACCEPTANYDATE' + ; + +IGNOREHEADER + : 'IGNOREHEADER' + ; + +IGNOREBLANKLINES + : 'IGNOREBLANKLINES' + ; + +COMPUPDATE + : 'COMPUPDATE' + ; + +STATUPDATE + : 'STATUPDATE' + ; + +EXPLICIT_IDS + : 'EXPLICIT_IDS' + ; + +READRATIO + : 'READRATIO' + ; + +ROUNDEC + : 'ROUNDEC' + ; + +TRIMBLANKS + : 'TRIMBLANKS' + ; + +PRESET + : 'PRESET' + ; + +ACCESS_KEY_ID + : 'ACCESS_KEY_ID' + ; + +SECRET_ACCESS_KEY + : 'SECRET_ACCESS_KEY' + ; + +SESSION_TOKEN_KW + : 'SESSION_TOKEN' + ; + +HEADER + : 'HEADER' + ; + +SETTINGS + : 'SETTINGS' + ; + +FUNCTION_NAME + : 'FUNCTION_NAME' + ; + + // + + // non-reserved keywords (can not be function or type) + + // + +ATOMIC_P + : 'ATOMIC' + ; + +BETWEEN + : 'BETWEEN' + ; + +BIGINT + : 'BIGINT' + ; + +BIT + : 'BIT' + ; + +BOOLEAN_P + : 'BOOLEAN' + ; + +CHAR_P + : 'CHAR' + ; + +CHARACTER + : 'CHARACTER' + ; + +COALESCE + : 'COALESCE' + ; + +DEC + : 'DEC' + ; + +DECIMAL_P + : 'DECIMAL' + ; + +EXISTS + : 'EXISTS' + ; + +EXTRACT + : 'EXTRACT' + ; + +FLOAT_P + : 'FLOAT' + ; + +GREATEST + : 'GREATEST' + ; + +INOUT + : 'INOUT' + ; + +INT_P + : 'INT' + ; + +INTEGER + : 'INTEGER' + ; + +INTERVAL + : 'INTERVAL' + ; + +LEAST + : 'LEAST' + ; + +NATIONAL + : 'NATIONAL' + ; + +NCHAR + : 'NCHAR' + ; + +NONE + : 'NONE' + ; + +NULLIF + : 'NULLIF' + ; + +NUMERIC + : 'NUMERIC' + ; + +OVERLAY + : 'OVERLAY' + ; + +PARAMETER + : 'PARAMETER' + ; + +POSITION + : 'POSITION' + ; + +PRECISION + : 'PRECISION' + ; + +REAL + : 'REAL' + ; + +ROW + : 'ROW' + ; + +SETOF + : 'SETOF' + ; + +SMALLINT + : 'SMALLINT' + ; + +SUBSTRING + : 'SUBSTRING' + ; + +TIME + : 'TIME' + ; + +TIMESTAMP + : 'TIMESTAMP' + ; + +TREAT + : 'TREAT' + ; + +TRIM + : 'TRIM' + ; + +VALUES + : 'VALUES' + ; + +VARCHAR + : 'VARCHAR' + ; + +XMLATTRIBUTES + : 'XMLATTRIBUTES' + ; + +XMLCOMMENT + : 'XMLCOMMENT' + ; + +XMLAGG + : 'XMLAGG' + ; + +XML_IS_WELL_FORMED + : 'XML_IS_WELL_FORMED' + ; + +XML_IS_WELL_FORMED_DOCUMENT + : 'XML_IS_WELL_FORMED_DOCUMENT' + ; + +XML_IS_WELL_FORMED_CONTENT + : 'XML_IS_WELL_FORMED_CONTENT' + ; + +XPATH + : 'XPATH' + ; + +XPATH_EXISTS + : 'XPATH_EXISTS' + ; + +XMLCONCAT + : 'XMLCONCAT' + ; + +XMLELEMENT + : 'XMLELEMENT' + ; + +XMLEXISTS + : 'XMLEXISTS' + ; + +XMLFOREST + : 'XMLFOREST' + ; + +XMLPARSE + : 'XMLPARSE' + ; + +XMLPI + : 'XMLPI' + ; + +XMLROOT + : 'XMLROOT' + ; + +XMLSERIALIZE + : 'XMLSERIALIZE' + ; + //MISSED + +CALL + : 'CALL' + ; + +CURRENT_P + : 'CURRENT' + ; + +ATTACH + : 'ATTACH' + ; + +DETACH + : 'DETACH' + ; + +EXPRESSION + : 'EXPRESSION' + ; + +GENERATED + : 'GENERATED' + ; + +LOGGED + : 'LOGGED' + ; + +STORED + : 'STORED' + ; + +// External table format tokens +SERDE + : 'SERDE' + ; + +SERDEPROPERTIES + : 'SERDEPROPERTIES' + ; + +INPUTFORMAT + : 'INPUTFORMAT' + ; + +OUTPUTFORMAT + : 'OUTPUTFORMAT' + ; + +FIELDS + : 'FIELDS' + ; + +COLLECTION + : 'COLLECTION' + ; + +ITEMS + : 'ITEMS' + ; + +TERMINATED + : 'TERMINATED' + ; + +ESCAPED + : 'ESCAPED' + ; + +DEFINED + : 'DEFINED' + ; + +LINES + : 'LINES' + ; + +KEYS + : 'KEYS' + ; + +PARTITIONED + : 'PARTITIONED' + ; + +// Complex type tokens +STRUCT + : 'STRUCT' + ; + +MAP + : 'MAP' + ; + +STRING + : 'STRING' + ; + +DELIMITED + : 'DELIMITED' + ; + +// Privilges and roles tokens +USAGE + : 'USAGE' + ; + +IGNORE + : 'IGNORE' + ; + +LANGUAGES + : 'LANGUAGES' + ; + +JOB + : 'JOB' + ; + +JOBS + : 'JOBS' + ; + +VIA + : 'VIA' + ; + +ASSUMEROLE + : 'ASSUMEROLE' + ; + +// External function tokens +RETRY_TIMEOUT + : 'RETRY_TIMEOUT' + ; + +MAX_BATCH_SIZE + : 'MAX_BATCH_SIZE' + ; + +MAX_PAYLOAD_IN_MB + : 'MAX_PAYLOAD_IN_MB' + ; + +KB + : 'KB' + ; + + +INCLUDE + : 'INCLUDE' + ; + +ROUTINE + : 'ROUTINE' + ; + +TRANSFORM + : 'TRANSFORM' + ; + +IMPORT_P + : 'IMPORT' + ; + +POLICY + : 'POLICY' + ; + +PRIORITY + : 'PRIORITY' + ; + +METHOD + : 'METHOD' + ; + +REFERENCING + : 'REFERENCING' + ; + +NEW + : 'NEW' + ; + +OLD + : 'OLD' + ; + +VALUE_P + : 'VALUE' + ; + +SUBSCRIPTION + : 'SUBSCRIPTION' + ; + +PUBLICATION + : 'PUBLICATION' + ; + +OUT_P + : 'OUT' + ; + +END_P + : 'END' + ; + +ROUTINES + : 'ROUTINES' + ; + +SCHEMAS + : 'SCHEMAS' + ; + +PROCEDURES + : 'PROCEDURES' + ; + +INPUT_P + : 'INPUT' + ; + +SUPPORT + : 'SUPPORT' + ; + +PARALLEL + : 'PARALLEL' + ; + +SQL_P + : 'SQL' + ; + +DEPENDS + : 'DEPENDS' + ; + +OVERRIDING + : 'OVERRIDING' + ; + +CONFLICT + : 'CONFLICT' + ; + +SKIP_P + : 'SKIP' + ; + +LOCKED + : 'LOCKED' + ; + +TIES + : 'TIES' + ; + +ROLLUP + : 'ROLLUP' + ; + +CUBE + : 'CUBE' + ; + +GROUPING + : 'GROUPING' + ; + +SETS + : 'SETS' + ; + +TABLESAMPLE + : 'TABLESAMPLE' + ; + +ORDINALITY + : 'ORDINALITY' + ; + +XMLTABLE + : 'XMLTABLE' + ; + +COLUMNS + : 'COLUMNS' + ; + +XMLNAMESPACES + : 'XMLNAMESPACES' + ; + +ROWTYPE + : 'ROWTYPE' + ; + +NORMALIZED + : 'NORMALIZED' + ; + +WITHIN + : 'WITHIN' + ; + +FILTER + : 'FILTER' + ; + +GROUPS + : 'GROUPS' + ; + +OTHERS + : 'OTHERS' + ; + +NFC + : 'NFC' + ; + +NFD + : 'NFD' + ; + +NFKC + : 'NFKC' + ; + +NFKD + : 'NFKD' + ; + +UESCAPE + : 'UESCAPE' + ; + +VIEWS + : 'VIEWS' + ; + +NORMALIZE + : 'NORMALIZE' + ; + +DUMP + : 'DUMP' + ; + +PRINT_STRICT_PARAMS + : 'PRINT_STRICT_PARAMS' + ; + +VARIABLE_CONFLICT + : 'VARIABLE_CONFLICT' + ; + +ERROR + : 'ERROR' + ; + +USE_VARIABLE + : 'USE_VARIABLE' + ; + +USE_COLUMN + : 'USE_COLUMN' + ; + +ALIAS + : 'ALIAS' + ; + +CONSTANT + : 'CONSTANT' + ; + +PERFORM + : 'PERFORM' + ; + +GET + : 'GET' + ; + +DIAGNOSTICS + : 'DIAGNOSTICS' + ; + +STACKED + : 'STACKED' + ; + +ELSIF + : 'ELSIF' + ; + +WHILE + : 'WHILE' + ; + +REVERSE + : 'REVERSE' + ; + +FOREACH + : 'FOREACH' + ; + +SLICE + : 'SLICE' + ; + +EXIT + : 'EXIT' + ; + +RETURN + : 'RETURN' + ; + +QUERY + : 'QUERY' + ; + +RAISE + : 'RAISE' + ; + +SQLSTATE + : 'SQLSTATE' + ; + +DEBUG + : 'DEBUG' + ; + +LOG + : 'LOG' + ; + +INFO + : 'INFO' + ; + +NOTICE + : 'NOTICE' + ; + +WARNING + : 'WARNING' + ; + +EXCEPTION + : 'EXCEPTION' + ; + +ASSERT + : 'ASSERT' + ; + +LOOP + : 'LOOP' + ; + +OPEN + : 'OPEN' + ; + // + + // IDENTIFIERS (4.1.1) + + // + +ABS + : 'ABS' + ; + +CBRT + : 'CBRT' + ; + +CEIL + : 'CEIL' + ; + +CEILING + : 'CEILING' + ; + +DEGREES + : 'DEGREES' + ; + +DIV + : 'DIV' + ; + +EXP + : 'EXP' + ; + +FACTORIAL + : 'FACTORIAL' + ; + +FLOOR + : 'FLOOR' + ; + +GCD + : 'GCD' + ; + +LCM + : 'LCM' + ; + +LN + : 'LN' + ; + +LOG10 + : 'LOG10' + ; + +MIN_SCALE + : 'MIN_SCALE' + ; + +MOD + : 'MOD' + ; + +PI + : 'PI' + ; + +POWER + : 'POWER' + ; + +RADIANS + : 'RADIANS' + ; + +ROUND + : 'ROUND' + ; + +SCALE + : 'SCALE' + ; + +SIGN + : 'SIGN' + ; + +SQRT + : 'SQRT' + ; + +TRIM_SCALE + : 'TRIM_SCALE' + ; + +TRUNC + : 'TRUNC' + ; + +WIDTH_BUCKET + : 'WIDTH_BUCKET' + ; + +RANDOM + : 'RANDOM' + ; + +SETSEED + : 'SETSEED' + ; + +ACOS + : 'ACOS' + ; + +ACOSD + : 'ACOSD' + ; + +ASIN + : 'ASIN' + ; + +ASIND + : 'ASIND' + ; + +ATAN + : 'ATAN' + ; + +ATAND + : 'ATAND' + ; + +ATAN2 + : 'ATAN2' + ; + +ATAN2D + : 'ATAN2D' + ; + +COS + : 'COS' + ; + +COSD + : 'COSD' + ; + +COT + : 'COT' + ; + +COTD + : 'COTD' + ; + +SIN + : 'SIN' + ; + +SIND + : 'SIND' + ; + +TAN + : 'TAN' + ; + +TAND + : 'TAND' + ; + +SINH + : 'SINH' + ; + +COSH + : 'COSH' + ; + +TANH + : 'TANH' + ; + +ASINH + : 'ASINH' + ; + +ACOSH + : 'ACOSH' + ; + +ATANH + : 'ATANH' + ; + +BIT_LENGTH + : 'BIT_LENGTH' + ; + +CHAR_LENGTH + : 'CHAR_LENGTH' + ; + +CHARACTER_LENGTH + : 'CHARACTER_LENGTH' + ; + +LOWER + : 'LOWER' + ; + +OCTET_LENGTH + : 'OCTET_LENGTH' + ; + +UPPER + : 'UPPER' + ; + +ASCII + : 'ASCII' + ; + +BTRIM + : 'BTRIM' + ; + +CHR + : 'CHR' + ; + +CONCAT + : 'CONCAT' + ; + +CONCAT_WS + : 'CONCAT_WS' + ; + +FORMAT + : 'FORMAT' + ; + +INITCAP + : 'INITCAP' + ; + +LENGTH + : 'LENGTH' + ; + +LPAD + : 'LPAD' + ; + +LTRIM + : 'LTRIM' + ; + +MD5 + : 'MD5' + ; + +PARSE_IDENT + : 'PARSE_IDENT' + ; + +PG_CLIENT_ENCODING + : 'PG_CLIENT_ENCODING' + ; + +QUOTE_IDENT + : 'QUOTE_IDENT' + ; + +QUOTE_LITERAL + : 'QUOTE_LITERAL' + ; + +QUOTE_NULLABLE + : 'QUOTE_NULLABLE' + ; + +REGEXP_COUNT + : 'REGEXP_COUNT' + ; + +REGEXP_INSTR + : 'REGEXP_INSTR' + ; + +REGEXP_LIKE + : 'REGEXP_LIKE' + ; + +REGEXP_MATCH + : 'REGEXP_MATCH' + ; + +REGEXP_MATCHES + : 'REGEXP_MATCHES' + ; + +REGEXP_REPLACE + : 'REGEXP_REPLACE' + ; + +REGEXP_SPLIT_TO_ARRAY + : 'REGEXP_SPLIT_TO_ARRAY' + ; + +REGEXP_SPLIT_TO_TABLE + : 'REGEXP_SPLIT_TO_TABLE' + ; + +REGEXP_SUBSTR + : 'REGEXP_SUBSTR' + ; + +REPEAT + : 'REPEAT' + ; + +RPAD + : 'RPAD' + ; + +RTRIM + : 'RTRIM' + ; + +SPLIT_PART + : 'SPLIT_PART' + ; + +STARTS_WITH + : 'STARTS_WITH' + ; + +STRING_TO_ARRAY + : 'STRING_TO_ARRAY' + ; + +STRING_TO_TABLE + : 'STRING_TO_TABLE' + ; + +STRPOS + : 'STRPOS' + ; + +SUBSTR + : 'SUBSTR' + ; + +TO_ASCII + : 'TO_ASCII' + ; + +TO_HEX + : 'TO_HEX' + ; + +TRANSLATE + : 'TRANSLATE' + ; + +UNISTR + : 'UNISTR' + ; + +AGE + : 'AGE' + ; + +CLOCK_TIMESTAMP + : 'CLOCK_TIMESTAMP' + ; + +DATE_BIN + : 'DATE_BIN' + ; + +DATE_PART + : 'DATE_PART' + ; + +DATE_TRUNC + : 'DATE_TRUNC' + ; + +ISFINITE + : 'ISFINITE' + ; + +JUSTIFY_DAYS + : 'JUSTIFY_DAYS' + ; + +JUSTIFY_HOURS + : 'JUSTIFY_HOURS' + ; + +JUSTIFY_INTERVAL + : 'JUSTIFY_INTERVAL' + ; + +MAKE_DATE + : 'MAKE_DATE' + ; + +MAKE_INTERVAL + : 'MAKE_INTERVAL' + ; + +MAKE_TIME + : 'MAKE_TIME' + ; + +MAKE_TIMESTAMP + : 'MAKE_TIMESTAMP' + ; + +MAKE_TIMESTAMPTZ + : 'MAKE_TIMESTAMPTZ' + ; + +NOW + : 'NOW' + ; + +STATEMENT_TIMESTAMP + : 'STATEMENT_TIMESTAMP' + ; + +TIMEOFDAY + : 'TIMEOFDAY' + ; + +TRANSACTION_TIMESTAMP + : 'TRANSACTION_TIMESTAMP' + ; + +TO_TIMESTAMP + : 'TO_TIMESTAMP' + ; + +TO_CHAR + : 'TO_CHAR' + ; + +TO_DATE + : 'TO_DATE' + ; + +TO_NUMBER + : 'TO_NUMBER' + ; + +ENCODE + : 'ENCODE' + ; + +DISTKEY + : 'DISTKEY' + ; + +SORTKEY + : 'SORTKEY' + ; + +DISTSTYLE + : 'DISTSTYLE' + ; + +BACKUP + : 'BACKUP' + ; + +COMPOUND + : 'COMPOUND' + ; + +INTERLEAVED + : 'INTERLEAVED' + ; + +EVEN + : 'EVEN' + ; + +CASE_SENSITIVE + : 'CASE_SENSITIVE' + ; + +QUOTA + : 'QUOTA' + ; + +TB + : 'TB' + ; + +BOOST + : 'BOOST' + ; + +RECLUSTER + : 'RECLUSTER' + ; + +SORT + : 'SORT' + ; + +PERCENT_WORD + : 'PERCENT' + ; + +CASE_INSENSITIVE + : 'CASE_INSENSITIVE' + ; + +Identifier + : IdentifierStartChar IdentifierChar* + ; + +TemporaryIdentifier + : '#' Identifier + ; + +NamespaceUser + : Identifier ':' Identifier + ; + +fragment IdentifierStartChar options { caseInsensitive=false; } + : // these are the valid identifier start characters below 0x7F + [a-zA-Z_] + | // these are the valid characters from 0x80 to 0xFF + [\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF] + | // these are the letters above 0xFF which only need a single UTF-16 code unit + [\u0100-\uD7FF\uE000-\uFFFF] + {p.charIsLetter()}? + | // letters which require multiple UTF-16 code units + [\uD800-\uDBFF] [\uDC00-\uDFFF] + { p.CheckIfUtf32Letter() }? + + ; + +fragment IdentifierChar + : StrictIdentifierChar + | '$' + ; + +fragment StrictIdentifierChar + : IdentifierStartChar + | [0-9] + ; +/* Quoted Identifiers + * + * These are divided into four separate tokens, allowing distinction of valid quoted identifiers from invalid quoted + * identifiers without sacrificing the ability of the lexer to reliably recover from lexical errors in the input. + */ + + +QuotedIdentifier + : UnterminatedQuotedIdentifier '"' + ; + // This is a quoted identifier which only contains valid characters but is not terminated + +UnterminatedQuotedIdentifier + : '"' ('""' | ~ [\u0000"])* + ; + // This is a quoted identifier which is terminated but contains a \u0000 character + +InvalidQuotedIdentifier + : InvalidUnterminatedQuotedIdentifier '"' + ; + // This is a quoted identifier which is unterminated and contains a \u0000 character + +InvalidUnterminatedQuotedIdentifier + : '"' ('""' | ~ '"')* + ; +/* Unicode Quoted Identifiers + * + * These are divided into four separate tokens, allowing distinction of valid Unicode quoted identifiers from invalid + * Unicode quoted identifiers without sacrificing the ability of the lexer to reliably recover from lexical errors in + * the input. Note that escape sequences are never checked as part of this determination due to the ability of users + * to change the escape character with a UESCAPE clause following the Unicode quoted identifier. + * + * TODO: these rules assume "" is still a valid escape sequence within a Unicode quoted identifier. + */ + + +UnicodeQuotedIdentifier + : 'U' '&' QuotedIdentifier + ; + // This is a Unicode quoted identifier which only contains valid characters but is not terminated + +UnterminatedUnicodeQuotedIdentifier + : 'U' '&' UnterminatedQuotedIdentifier + ; + // This is a Unicode quoted identifier which is terminated but contains a \u0000 character + +InvalidUnicodeQuotedIdentifier + : 'U' '&' InvalidQuotedIdentifier + ; + // This is a Unicode quoted identifier which is unterminated and contains a \u0000 character + +InvalidUnterminatedUnicodeQuotedIdentifier + : 'U' '&' InvalidUnterminatedQuotedIdentifier + ; + // + + // CONSTANTS (4.1.2) + + // + + // String Constants (4.1.2.1) + +StringConstant + : UnterminatedStringConstant '\'' + ; + +UnterminatedStringConstant + : '\'' ('\'\'' | ~ '\'')* + ; + // String Constants with C-style Escapes (4.1.2.2) + +BeginEscapeStringConstant + : 'E' '\'' -> more , pushMode (EscapeStringConstantMode) + ; + // String Constants with Unicode Escapes (4.1.2.3) + + // + + // Note that escape sequences are never checked as part of this token due to the ability of users to change the escape + + // character with a UESCAPE clause following the Unicode string constant. + + // + + // TODO: these rules assume '' is still a valid escape sequence within a Unicode string constant. + +UnicodeEscapeStringConstant + : UnterminatedUnicodeEscapeStringConstant '\'' + ; + +UnterminatedUnicodeEscapeStringConstant + : 'U' '&' UnterminatedStringConstant + ; + // Dollar-quoted String Constants (4.1.2.4) + +BeginDollarStringConstant + : '$' Tag? '$' + {l.pushTag();} -> pushMode (DollarQuotedStringMode) + ; +/* "The tag, if any, of a dollar-quoted string follows the same rules as an + * unquoted identifier, except that it cannot contain a dollar sign." + */ + + +fragment Tag + : IdentifierStartChar StrictIdentifierChar* + ; + // Bit-strings Constants (4.1.2.5) + +BinaryStringConstant + : UnterminatedBinaryStringConstant '\'' + ; + +UnterminatedBinaryStringConstant + : 'B' '\'' [01]* + ; + +InvalidBinaryStringConstant + : InvalidUnterminatedBinaryStringConstant '\'' + ; + +InvalidUnterminatedBinaryStringConstant + : 'B' UnterminatedStringConstant + ; + +HexadecimalStringConstant + : UnterminatedHexadecimalStringConstant '\'' + ; + +UnterminatedHexadecimalStringConstant + : 'X' '\'' [0-9A-F]* + ; + +InvalidHexadecimalStringConstant + : InvalidUnterminatedHexadecimalStringConstant '\'' + ; + +InvalidUnterminatedHexadecimalStringConstant + : 'X' UnterminatedStringConstant + ; + // Numeric Constants (4.1.2.6) + +Integral + : Digits + ; + +NumericFail + : Digits '..' + {l.HandleNumericFail();} + ; + +Numeric + : Digits '.' Digits? /*? replaced with + to solve problem with DOT_DOT .. but this surely must be rewriten */ + + ('E' [+-]? Digits)? + | '.' Digits ('E' [+-]? Digits)? + | Digits 'E' [+-]? Digits + ; + +fragment Digits + : [0-9]+ + ; + +PLSQLVARIABLENAME + : ':' [A-Z_] [A-Z_0-9$]* + ; + +PLSQLIDENTIFIER + : ':"' ('\\' . | '""' | ~ ('"' | '\\'))* '"' + ; + // + + // WHITESPACE (4.1) + + // + +Whitespace + : [ \t] -> channel (HIDDEN) + ; + +Newline + : ('\r' '\n'? | '\n') -> channel (HIDDEN) + ; + // + + // COMMENTS (4.1.5) + + // + +LineComment + : '--' ~ [\r\n]* -> channel (HIDDEN) + ; + +BlockComment + : ('/*' ('/'* BlockComment | ~ [/*] | '/'+ ~ [/*] | '*'+ ~ [/*])* '*'* '*/') -> channel (HIDDEN) + ; + +UnterminatedBlockComment + : '/*' ('/'* BlockComment | // these characters are not part of special sequences in a block comment + ~ [/*] | // handle / or * characters which are not part of /* or */ and do not appear at the end of the file + ('/'+ ~ [/*] | '*'+ ~ [/*]))* + // Handle the case of / or * characters at the end of the file, or a nested unterminated block comment + ('/'+ | '*'+ | '/'* UnterminatedBlockComment)? + // Optional assertion to make sure this rule is working as intended + + { + l.UnterminatedBlockCommentDebugAssert(); + } + ; + // + + // META-COMMANDS + + // + + // http://www.postgresql.org/docs/9.3/static/app-psql.html + +MetaCommand + : '\\' (~ [\r\n\\"] | '"' ~ [\r\n"]* '"')* ('"' ~ [\r\n"]*)? + ; + +EndMetaCommand + : '\\\\' + ; + // + + // ERROR + + // + + // Any character which does not match one of the above rules will appear in the token stream as an ErrorCharacter token. + + // This ensures the lexer itself will never encounter a syntax error, so all error handling may be performed by the + + // parser. + +ErrorCharacter + : . + ; + +mode EscapeStringConstantMode; +EscapeStringConstant + : EscapeStringText '\'' -> mode (AfterEscapeStringConstantMode) + ; + +UnterminatedEscapeStringConstant + : EscapeStringText + // Handle a final unmatched \ character appearing at the end of the file + '\\'? EOF + ; + +fragment EscapeStringText options { caseInsensitive=false; } + : ('\'\'' | '\\' ( // two-digit hex escapes are still valid when treated as single-digit escapes + 'x' [0-9a-fA-F] | + 'u' [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] | + 'U' [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] | // Any character other than the Unicode escapes can follow a backslash. Some have special meaning, + // but that doesn't affect the syntax. + ~ [xuU]) | ~ ['\\])* + ; + +InvalidEscapeStringConstant + : InvalidEscapeStringText '\'' -> mode (AfterEscapeStringConstantMode) + ; + +InvalidUnterminatedEscapeStringConstant + : InvalidEscapeStringText + // Handle a final unmatched \ character appearing at the end of the file + '\\'? EOF + ; + +fragment InvalidEscapeStringText + : ('\'\'' | '\\' . | ~ ['\\])* + ; + +mode AfterEscapeStringConstantMode; +AfterEscapeStringConstantMode_Whitespace + : Whitespace -> type (Whitespace) , channel (HIDDEN) + ; + +AfterEscapeStringConstantMode_Newline + : Newline -> type (Newline) , channel (HIDDEN) , mode (AfterEscapeStringConstantWithNewlineMode) + ; + +AfterEscapeStringConstantMode_NotContinued + : + {} // intentionally empty + -> skip , popMode + ; + +mode AfterEscapeStringConstantWithNewlineMode; +AfterEscapeStringConstantWithNewlineMode_Whitespace + : Whitespace -> type (Whitespace) , channel (HIDDEN) + ; + +AfterEscapeStringConstantWithNewlineMode_Newline + : Newline -> type (Newline) , channel (HIDDEN) + ; + +AfterEscapeStringConstantWithNewlineMode_Continued + : '\'' -> more , mode (EscapeStringConstantMode) + ; + +AfterEscapeStringConstantWithNewlineMode_NotContinued + : + {} // intentionally empty + -> skip , popMode + ; + +mode DollarQuotedStringMode; +DollarText + : ~ '$'+ + //| '$'([0-9])+ + | // this alternative improves the efficiency of handling $ characters within a dollar-quoted string which are + + // not part of the ending tag. + '$' ~ '$'* + ; + +EndDollarStringConstant + : ('$' Tag? '$') + {p.isTag()}? + {l.popTag();} -> popMode + ; diff --git a/redshift/RedshiftLexer.interp b/redshift/RedshiftLexer.interp new file mode 100644 index 0000000..d6a1639 --- /dev/null +++ b/redshift/RedshiftLexer.interp @@ -0,0 +1,2725 @@ +token literal names: +null +'$' +'(' +')' +'[' +']' +',' +';' +':' +'*' +'=' +'.' +'+' +'-' +'/' +'^' +'<' +'>' +'<<' +'>>' +':=' +'<=' +'=>' +'>=' +'..' +'<>' +'::' +'%' +null +null +'ALL' +'ANALYSE' +'ANALYZE' +'AND' +'ANY' +'ARRAY' +'AS' +'ASC' +'ASYMMETRIC' +'BOTH' +'CASE' +'CAST' +'CHECK' +'COLLATE' +'COLUMN' +'CONSTRAINT' +'CREATE' +'CURRENT_CATALOG' +'CURRENT_DATE' +'CURRENT_ROLE' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DEFAULT' +'DEFERRABLE' +'DESC' +'DISTINCT' +'DO' +'ELSE' +'EXCEPT' +'FALSE' +'FETCH' +'FOR' +'FOREIGN' +'FROM' +'GRANT' +'GROUP' +'HAVING' +'IN' +'INITIALLY' +'INTERSECT' +'INTO' +'LATERAL' +'LEADING' +'LIMIT' +'LOCALTIME' +'LOCALTIMESTAMP' +'NOT' +'NULL' +'OFFSET' +'ON' +'ONLY' +'OR' +'ORDER' +'PLACING' +'PRIMARY' +'PUBLIC' +'REFERENCES' +'RETURNING' +'SELECT' +'SESSION_USER' +'SOME' +'SYMMETRIC' +'TABLE' +'THEN' +'TO' +'TRAILING' +'TRUE' +'UNION' +'UNIQUE' +'USER' +'USING' +'VARIADIC' +'WHEN' +'WHERE' +'WINDOW' +'WITH' +'AUTHORIZATION' +'BINARY' +'BINDING' +'COLLATION' +'CONCURRENTLY' +'CROSS' +'CURRENT_SCHEMA' +'FREEZE' +'FULL' +'ILIKE' +'INNER' +'IS' +'ISNULL' +'JOIN' +'LEFT' +'LIKE' +'NATURAL' +'NOTNULL' +'OUTER' +'OVER' +'OVERLAPS' +'RIGHT' +'SIMILAR' +'VERBOSE' +'ABORT' +'ABSOLUTE' +'ACCESS' +'ACTION' +'ADD' +'ADMIN' +'AFTER' +'AGGREGATE' +'ALSO' +'ALTER' +'ALWAYS' +'ASSERTION' +'ASSIGNMENT' +'AT' +'ATTRIBUTE' +'BACKWARD' +'BEFORE' +'BEGIN' +'BY' +'CACHE' +'CALLED' +'CASCADE' +'CASCADED' +'CATALOG' +'CHAIN' +'CHARACTERISTICS' +'CHECKPOINT' +'CLASS' +'CLOSE' +'CLUSTER' +'COMMENT' +'COMMENTS' +'COMMIT' +'COMMITTED' +'CONFIGURATION' +'CONNECTION' +'CONSTRAINTS' +'CONTENT' +'CONTINUE' +'CONVERSION' +'COPY' +'COST' +'CSV' +'JSON' +'CURSOR' +'CYCLE' +'DATA' +'DATA_CATALOG' +'DATABASE' +'DAY' +'DEALLOCATE' +'DECLARE' +'DEFAULTS' +'DEFERRED' +'DEFINER' +'DELETE' +'DELIMITER' +'DELIMITERS' +'DICTIONARY' +'DISABLE' +'DISCARD' +'DOCUMENT' +'DOMAIN' +'DOUBLE' +'DROP' +'EACH' +'ENABLE' +'ENCODING' +'ENCRYPTED' +'ENUM' +'ESCAPE' +'EVENT' +'EXCLUDE' +'EXCLUDING' +'EXCLUSIVE' +'EXECUTE' +'EXPLAIN' +'EXTENSION' +'EXTERNAL' +'FAMILY' +'FIRST' +'FOLLOWING' +'FORCE' +'FORWARD' +'FUNCTION' +'FUNCTIONS' +'GLOBAL' +'GRANTED' +'HANDLER' +null +'HOLD' +'HOUR' +null +'IF' +'IMMEDIATE' +'IMMUTABLE' +'IMPLICIT' +'INCLUDING' +'INCREMENT' +'INDEX' +'INDEXES' +'INHERIT' +'INHERITS' +'INLINE' +'INSENSITIVE' +'INSERT' +'INSTEAD' +'INVOKER' +'ISOLATION' +'KEY' +'LABEL' +'LANGUAGE' +'LARGE' +'LAST' +'LEAKPROOF' +'LEVEL' +'LISTEN' +'LOAD' +'LOCAL' +'LOCATION' +'LOCK' +'MAPPING' +'MATCH' +'MATCHED' +'MATERIALIZED' +'MAXVALUE' +'MERGE' +'MINUTE' +'MINVALUE' +'MODE' +'MONTH' +'MOVE' +'NAME' +'NAMES' +'NEXT' +'NO' +'NOTHING' +'NOTIFY' +'NOWAIT' +'NULLS' +'OBJECT' +'OF' +'OFF' +'OIDS' +'OPERATOR' +'OPTION' +'OPTIONS' +'OWNED' +'OWNER' +'PARSER' +'PARTIAL' +'PARTITION' +'PASSING' +'PASSWORD' +'PLANS' +'PRECEDING' +'PREDICATE' +'PREPARE' +'PREPARED' +'PRESERVE' +'PRIOR' +'PRIVILEGES' +'PROCEDURAL' +'PROCEDURE' +'PROGRAM' +'QUOTE' +'RANGE' +'READ' +'REASSIGN' +'RECHECK' +'RECURSIVE' +'REF' +'REFRESH' +'REINDEX' +'RELATIVE' +'RELEASE' +'RENAME' +'REPEATABLE' +'REPLACE' +'REPLICA' +'RESET' +'RESTART' +'RESTRICT' +'RETURNS' +'REVOKE' +'ROLE' +'ROLLBACK' +'ROWS' +'RULE' +'SAVEPOINT' +'SCHEMA' +'SCROLL' +'SEARCH' +'SECOND' +'SECURITY' +'SEQUENCE' +'SEQUENCES' +'SERIALIZABLE' +'SERVER' +null +'SET' +'SHARE' +'SHOW' +'SIMPLE' +'SNAPSHOT' +'STABLE' +'STANDALONE' +'START' +'STATEMENT' +'STATISTICS' +'STDIN' +'STDOUT' +'STORAGE' +'STRICT' +'STRIP' +'SYSID' +'SYSTEM' +'TABLES' +'TABLESPACE' +'TEMP' +'TEMPLATE' +'TEMPORARY' +'TEXT' +'TRANSACTION' +'TRIGGER' +'TRUNCATE' +'TRUSTED' +'TYPE' +'TYPES' +'UNBOUNDED' +'UNCOMMITTED' +'UNENCRYPTED' +'UNKNOWN' +'UNLISTEN' +'UNLOGGED' +'UNTIL' +'UPDATE' +'VACUUM' +'VALID' +'VALIDATE' +'VALIDATOR' +'VARYING' +'VERSION' +'VIEW' +'VOLATILE' +'WHITESPACE' +'WITHOUT' +'WORK' +'WRAPPER' +'WRITE' +'XML' +'YEAR' +'YES' +'ZONE' +'QUALIFY' +'CONNECT' +'TOP' +'VARBYTE' +'VARBINARY' +'CONJUNCTION' +'DEFINITION' +'DATASHARE' +'FILE' +'PUBLICACCESSIBLE' +'INCLUDENEW' +'IAM_ROLE' +'CATALOG_ROLE' +'CATALOG_ID' +'HIVE' +'METASTORE' +'URI' +'POSTGRES' +'MYSQL' +'SECRET_ARN' +'KINESIS' +'KAFKA' +'MSK' +'AUTHENTICATION' +'AUTHENTICATION_ARN' +null +'MTLS' +'MASKING' +'RLS' +null +'PROVIDER' +'PROTECTED' +'MODEL' +'TARGET' +'SAGEMAKER' +'AUTO' +'MODEL_TYPE' +'PROBLEM_TYPE' +'OBJECTIVE' +'PREPROCESSORS' +'HYPERPARAMETERS' +'XGBOOST' +'MLP' +'LINEAR_LEARNER' +'KMEANS' +'FORECAST' +'REGRESSION' +'BINARY_CLASSIFICATION' +'MULTICLASS_CLASSIFICATION' +'S3_BUCKET' +'TAGS' +'KMS_KEY_ID' +'S3_GARBAGE_COLLECT' +'MAX_CELLS' +'MAX_RUNTIME' +'HORIZON' +'FREQUENCY' +'PERCENTILES' +'MAX_BATCH_ROWS' +'UNLOAD' +'MANIFEST' +'ADDQUOTES' +'ALLOWOVERWRITE' +'CLEANPATH' +'MAXFILESIZE' +'ROWGROUPSIZE' +'BZIP2' +'GZIP' +'ZSTD' +'DATABASES' +'DATASHARES' +'GRANTS' +'USE' +'CANCEL' +'SESSION_AUTHORIZATION' +'SESSION_CHARACTERISTICS' +'COMPRESSION' +'LIBRARY' +'APPEND' +'MB' +'GB' +'ACCOUNT' +'NAMESPACE' +'DESCRIBE' +'NONATOMIC' +'MANAGEDBY' +'ADX' +'REMOVE' +'DUPLICATES' +'BEDROCK' +'MODEL_ID' +'PROMPT' +'SUFFIX' +'REQUEST_TYPE' +'RESPONSE_TYPE' +'RAW' +'UNIFIED' +'SUPER' +'CI' +'CS' +'PLPYTHONU' +'FILLTARGET' +'IGNOREEXTRA' +'CREATEUSER' +'NOCREATEUSER' +'REGION' +'PORT' +'REDSHIFT' +'IAM' +'CREATEDB' +'NOCREATEDB' +'RESTRICTED' +'UNLIMITED' +'EXTERNALID' +'TIMEOUT' +'SYSLOG' +'CREDENTIALS' +'UNRESTRICTED' +'PARAMETERS' +'APPLICATION_ARN' +'AUTO_CREATE_ROLES' +'COMPROWS' +'PROVIDER_URL' +'PROVIDER_URL_PORT' +'ATTRIBUTE_MAP' +'PROVIDER_ARN' +'ASSUME_ROLE_ARN' +'PROPERTIES' +'AVRO' +'RCFILE' +'SEQUENCEFILE' +'TEXTFILE' +'ORC' +'ION' +'LAMBDA' +'FIXEDWIDTH' +'PARQUET' +'LZOP' +'REMOVEQUOTES' +'TRUNCATECOLUMNS' +'FILLRECORD' +'BLANKSASNULL' +'EMPTYASNULL' +'MAXERROR' +'DATEFORMAT' +'TIMEFORMAT' +'ACCEPTINVCHARS' +'ACCEPTANYDATE' +'IGNOREHEADER' +'IGNOREBLANKLINES' +'COMPUPDATE' +'STATUPDATE' +'EXPLICIT_IDS' +'READRATIO' +'ROUNDEC' +'TRIMBLANKS' +'PRESET' +'ACCESS_KEY_ID' +'SECRET_ACCESS_KEY' +'SESSION_TOKEN' +null +'SETTINGS' +'FUNCTION_NAME' +'ATOMIC' +'BETWEEN' +'BIGINT' +'BIT' +'BOOLEAN' +'CHAR' +'CHARACTER' +'COALESCE' +'DEC' +'DECIMAL' +'EXISTS' +'EXTRACT' +'FLOAT' +'GREATEST' +'INOUT' +'INT' +'INTEGER' +'INTERVAL' +'LEAST' +'NATIONAL' +'NCHAR' +'NONE' +'NULLIF' +'NUMERIC' +'OVERLAY' +'PARAMETER' +'POSITION' +'PRECISION' +'REAL' +'ROW' +'SETOF' +'SMALLINT' +'SUBSTRING' +'TIME' +'TIMESTAMP' +'TREAT' +'TRIM' +'VALUES' +'VARCHAR' +'XMLATTRIBUTES' +'XMLCOMMENT' +'XMLAGG' +'XML_IS_WELL_FORMED' +'XML_IS_WELL_FORMED_DOCUMENT' +'XML_IS_WELL_FORMED_CONTENT' +'XPATH' +'XPATH_EXISTS' +'XMLCONCAT' +'XMLELEMENT' +'XMLEXISTS' +'XMLFOREST' +'XMLPARSE' +'XMLPI' +'XMLROOT' +'XMLSERIALIZE' +'CALL' +'CURRENT' +'ATTACH' +'DETACH' +'EXPRESSION' +'GENERATED' +'LOGGED' +'STORED' +'SERDE' +'SERDEPROPERTIES' +'INPUTFORMAT' +'OUTPUTFORMAT' +'FIELDS' +'COLLECTION' +'ITEMS' +'TERMINATED' +'ESCAPED' +'DEFINED' +'LINES' +'KEYS' +'PARTITIONED' +'STRUCT' +'MAP' +'STRING' +'DELIMITED' +'USAGE' +'IGNORE' +'LANGUAGES' +'JOB' +'JOBS' +'VIA' +'ASSUMEROLE' +'RETRY_TIMEOUT' +'MAX_BATCH_SIZE' +'MAX_PAYLOAD_IN_MB' +'KB' +'INCLUDE' +'ROUTINE' +'TRANSFORM' +'IMPORT' +'POLICY' +'PRIORITY' +'METHOD' +'REFERENCING' +'NEW' +'OLD' +'VALUE' +'SUBSCRIPTION' +'PUBLICATION' +'OUT' +'END' +'ROUTINES' +'SCHEMAS' +'PROCEDURES' +'INPUT' +'SUPPORT' +'PARALLEL' +'SQL' +'DEPENDS' +'OVERRIDING' +'CONFLICT' +'SKIP' +'LOCKED' +'TIES' +'ROLLUP' +'CUBE' +'GROUPING' +'SETS' +'TABLESAMPLE' +'ORDINALITY' +'XMLTABLE' +'COLUMNS' +'XMLNAMESPACES' +'ROWTYPE' +'NORMALIZED' +'WITHIN' +'FILTER' +'GROUPS' +'OTHERS' +'NFC' +'NFD' +'NFKC' +'NFKD' +'UESCAPE' +'VIEWS' +'NORMALIZE' +'DUMP' +'PRINT_STRICT_PARAMS' +'VARIABLE_CONFLICT' +'ERROR' +'USE_VARIABLE' +'USE_COLUMN' +'ALIAS' +'CONSTANT' +'PERFORM' +'GET' +'DIAGNOSTICS' +'STACKED' +'ELSIF' +'WHILE' +'REVERSE' +'FOREACH' +'SLICE' +'EXIT' +'RETURN' +'QUERY' +'RAISE' +'SQLSTATE' +'DEBUG' +'LOG' +'INFO' +'NOTICE' +'WARNING' +'EXCEPTION' +'ASSERT' +'LOOP' +'OPEN' +'ABS' +'CBRT' +'CEIL' +'CEILING' +'DEGREES' +'DIV' +'EXP' +'FACTORIAL' +'FLOOR' +'GCD' +'LCM' +'LN' +'LOG10' +'MIN_SCALE' +'MOD' +'PI' +'POWER' +'RADIANS' +'ROUND' +'SCALE' +'SIGN' +'SQRT' +'TRIM_SCALE' +'TRUNC' +'WIDTH_BUCKET' +'RANDOM' +'SETSEED' +'ACOS' +'ACOSD' +'ASIN' +'ASIND' +'ATAN' +'ATAND' +'ATAN2' +'ATAN2D' +'COS' +'COSD' +'COT' +'COTD' +'SIN' +'SIND' +'TAN' +'TAND' +'SINH' +'COSH' +'TANH' +'ASINH' +'ACOSH' +'ATANH' +'BIT_LENGTH' +'CHAR_LENGTH' +'CHARACTER_LENGTH' +'LOWER' +'OCTET_LENGTH' +'UPPER' +'ASCII' +'BTRIM' +'CHR' +'CONCAT' +'CONCAT_WS' +'FORMAT' +'INITCAP' +'LENGTH' +'LPAD' +'LTRIM' +'MD5' +'PARSE_IDENT' +'PG_CLIENT_ENCODING' +'QUOTE_IDENT' +'QUOTE_LITERAL' +'QUOTE_NULLABLE' +'REGEXP_COUNT' +'REGEXP_INSTR' +'REGEXP_LIKE' +'REGEXP_MATCH' +'REGEXP_MATCHES' +'REGEXP_REPLACE' +'REGEXP_SPLIT_TO_ARRAY' +'REGEXP_SPLIT_TO_TABLE' +'REGEXP_SUBSTR' +'REPEAT' +'RPAD' +'RTRIM' +'SPLIT_PART' +'STARTS_WITH' +'STRING_TO_ARRAY' +'STRING_TO_TABLE' +'STRPOS' +'SUBSTR' +'TO_ASCII' +'TO_HEX' +'TRANSLATE' +'UNISTR' +'AGE' +'CLOCK_TIMESTAMP' +'DATE_BIN' +'DATE_PART' +'DATE_TRUNC' +'ISFINITE' +'JUSTIFY_DAYS' +'JUSTIFY_HOURS' +'JUSTIFY_INTERVAL' +'MAKE_DATE' +'MAKE_INTERVAL' +'MAKE_TIME' +'MAKE_TIMESTAMP' +'MAKE_TIMESTAMPTZ' +'NOW' +'STATEMENT_TIMESTAMP' +'TIMEOFDAY' +'TRANSACTION_TIMESTAMP' +'TO_TIMESTAMP' +'TO_CHAR' +'TO_DATE' +'TO_NUMBER' +'ENCODE' +'DISTKEY' +'SORTKEY' +'DISTSTYLE' +'BACKUP' +'COMPOUND' +'INTERLEAVED' +'EVEN' +'CASE_SENSITIVE' +'QUOTA' +'TB' +'BOOST' +'RECLUSTER' +'SORT' +'PERCENT' +'CASE_INSENSITIVE' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'\\\\' +null +null +null +null +null +null +null +null +null +'\'' + +token symbolic names: +null +Dollar +OPEN_PAREN +CLOSE_PAREN +OPEN_BRACKET +CLOSE_BRACKET +COMMA +SEMI +COLON +STAR +EQUAL +DOT +PLUS +MINUS +SLASH +CARET +LT +GT +LESS_LESS +GREATER_GREATER +COLON_EQUALS +LESS_EQUALS +EQUALS_GREATER +GREATER_EQUALS +DOT_DOT +NOT_EQUALS +TYPECAST +PERCENT +PARAM +Operator +ALL +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASYMMETRIC +BOTH +CASE +CAST +CHECK +COLLATE +COLUMN +CONSTRAINT +CREATE +CURRENT_CATALOG +CURRENT_DATE +CURRENT_ROLE +CURRENT_TIME +CURRENT_TIMESTAMP +CURRENT_USER +DEFAULT +DEFERRABLE +DESC +DISTINCT +DO +ELSE +EXCEPT +FALSE_P +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP_P +HAVING +IN_P +INITIALLY +INTERSECT +INTO +LATERAL_P +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL_P +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +PUBLIC +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE_P +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +AUTHORIZATION +BINARY +BINDING +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER_P +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER_P +OVER +OVERLAPS +RIGHT +SIMILAR +VERBOSE +ABORT_P +ABSOLUTE_P +ACCESS +ACTION +ADD_P +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTRIBUTE +BACKWARD +BEFORE +BEGIN_P +BY +CACHE +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONNECTION +CONSTRAINTS +CONTENT_P +CONTINUE_P +CONVERSION_P +COPY +COST +CSV +JSON +CURSOR +CYCLE +DATA_P +DATA_CATALOG +DATABASE +DAY_P +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE_P +DELIMITER +DELIMITERS +DICTIONARY +DISABLE_P +DISCARD +DOCUMENT_P +DOMAIN_P +DOUBLE_P +DROP +EACH +ENABLE_P +ENCODING +ENCRYPTED +ENUM_P +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FIRST_P +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GLOBAL +GRANTED +HANDLER +HEADER_P +HOLD +HOUR_P +IDENTITY_P +IF_P +IMMEDIATE +IMMUTABLE +IMPLICIT_P +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE_P +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE_P +LAST_P +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK_P +MAPPING +MATCH +MATCHED +MATERIALIZED +MAXVALUE +MERGE +MINUTE_P +MINVALUE +MODE +MONTH_P +MOVE +NAME_P +NAMES +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS_P +OBJECT_P +OF +OFF +OIDS +OPERATOR +OPTION +OPTIONS +OWNED +OWNER +PARSER +PARTIAL +PARTITION +PASSING +PASSWORD +PLANS +PRECEDING +PREDICATE +PREPARE +PREPARED +PRESERVE +PRIOR +PRIVILEGES +PROCEDURAL +PROCEDURE +PROGRAM +QUOTE +RANGE +READ +REASSIGN +RECHECK +RECURSIVE +REF +REFRESH +REINDEX +RELATIVE_P +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROWS +RULE +SAVEPOINT +SCHEMA +SCROLL +SEARCH +SECOND_P +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SHARE +SHOW +SIMPLE +SNAPSHOT +STABLE +STANDALONE_P +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STRICT_P +STRIP_P +SYSID +SYSTEM_P +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT_P +TRANSACTION +TRIGGER +TRUNCATE +TRUSTED +TYPE_P +TYPES_P +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VARYING +VERSION_P +VIEW +VOLATILE +WHITESPACE_P +WITHOUT +WORK +WRAPPER +WRITE +XML_P +YEAR_P +YES_P +ZONE +QUALIFY +CONNECT +TOP +VARBYTE +VARBINARY +CONJUNCTION +DEFINITION +DATASHARE +FILE +PUBLICACCESSIBLE +INCLUDENEW +IAM_ROLE +CATALOG_ROLE +CATALOG_ID +HIVE +METASTORE +URI +POSTGRES +MYSQL +SECRET_ARN +KINESIS +KAFKA +MSK +AUTHENTICATION +AUTHENTICATION_ARN +SESSION_TOKEN +MTLS +MASKING +RLS +IDENTITY +PROVIDER +PROTECTED +MODEL +TARGET +SAGEMAKER +AUTO +MODEL_TYPE +PROBLEM_TYPE +OBJECTIVE +PREPROCESSORS +HYPERPARAMETERS +XGBOOST +MLP +LINEAR_LEARNER +KMEANS +FORECAST +REGRESSION +BINARY_CLASSIFICATION +MULTICLASS_CLASSIFICATION +S3_BUCKET +TAGS +KMS_KEY_ID +S3_GARBAGE_COLLECT +MAX_CELLS +MAX_RUNTIME +HORIZON +FREQUENCY +PERCENTILES +MAX_BATCH_ROWS +UNLOAD +MANIFEST +ADDQUOTES +ALLOWOVERWRITE +CLEANPATH +MAXFILESIZE +ROWGROUPSIZE +BZIP2 +GZIP +ZSTD +DATABASES +DATASHARES +GRANTS +USE +CANCEL +SESSION_AUTHORIZATION +SESSION_CHARACTERISTICS +COMPRESSION +LIBRARY +APPEND +MB +GB +ACCOUNT +NAMESPACE +DESCRIBE +NONATOMIC +MANAGEDBY +ADX +REMOVE +DUPLICATES +BEDROCK +MODEL_ID +PROMPT +SUFFIX +REQUEST_TYPE +RESPONSE_TYPE +RAW +UNIFIED +SUPER +CI +CS +PLPYTHONU +FILLTARGET +IGNOREEXTRA +CREATEUSER +NOCREATEUSER +REGION +PORT +REDSHIFT +IAM +CREATEDB +NOCREATEDB +RESTRICTED +UNLIMITED +EXTERNALID +TIMEOUT +SYSLOG +CREDENTIALS +UNRESTRICTED +PARAMETERS +APPLICATION_ARN +AUTO_CREATE_ROLES +COMPROWS +PROVIDER_URL +PROVIDER_URL_PORT +ATTRIBUTE_MAP +PROVIDER_ARN +ASSUME_ROLE_ARN +PROPERTIES +AVRO +RCFILE +SEQUENCEFILE +TEXTFILE +ORC +ION +LAMBDA +FIXEDWIDTH +PARQUET +LZOP +REMOVEQUOTES +TRUNCATECOLUMNS +FILLRECORD +BLANKSASNULL +EMPTYASNULL +MAXERROR +DATEFORMAT +TIMEFORMAT +ACCEPTINVCHARS +ACCEPTANYDATE +IGNOREHEADER +IGNOREBLANKLINES +COMPUPDATE +STATUPDATE +EXPLICIT_IDS +READRATIO +ROUNDEC +TRIMBLANKS +PRESET +ACCESS_KEY_ID +SECRET_ACCESS_KEY +SESSION_TOKEN_KW +HEADER +SETTINGS +FUNCTION_NAME +ATOMIC_P +BETWEEN +BIGINT +BIT +BOOLEAN_P +CHAR_P +CHARACTER +COALESCE +DEC +DECIMAL_P +EXISTS +EXTRACT +FLOAT_P +GREATEST +INOUT +INT_P +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OVERLAY +PARAMETER +POSITION +PRECISION +REAL +ROW +SETOF +SMALLINT +SUBSTRING +TIME +TIMESTAMP +TREAT +TRIM +VALUES +VARCHAR +XMLATTRIBUTES +XMLCOMMENT +XMLAGG +XML_IS_WELL_FORMED +XML_IS_WELL_FORMED_DOCUMENT +XML_IS_WELL_FORMED_CONTENT +XPATH +XPATH_EXISTS +XMLCONCAT +XMLELEMENT +XMLEXISTS +XMLFOREST +XMLPARSE +XMLPI +XMLROOT +XMLSERIALIZE +CALL +CURRENT_P +ATTACH +DETACH +EXPRESSION +GENERATED +LOGGED +STORED +SERDE +SERDEPROPERTIES +INPUTFORMAT +OUTPUTFORMAT +FIELDS +COLLECTION +ITEMS +TERMINATED +ESCAPED +DEFINED +LINES +KEYS +PARTITIONED +STRUCT +MAP +STRING +DELIMITED +USAGE +IGNORE +LANGUAGES +JOB +JOBS +VIA +ASSUMEROLE +RETRY_TIMEOUT +MAX_BATCH_SIZE +MAX_PAYLOAD_IN_MB +KB +INCLUDE +ROUTINE +TRANSFORM +IMPORT_P +POLICY +PRIORITY +METHOD +REFERENCING +NEW +OLD +VALUE_P +SUBSCRIPTION +PUBLICATION +OUT_P +END_P +ROUTINES +SCHEMAS +PROCEDURES +INPUT_P +SUPPORT +PARALLEL +SQL_P +DEPENDS +OVERRIDING +CONFLICT +SKIP_P +LOCKED +TIES +ROLLUP +CUBE +GROUPING +SETS +TABLESAMPLE +ORDINALITY +XMLTABLE +COLUMNS +XMLNAMESPACES +ROWTYPE +NORMALIZED +WITHIN +FILTER +GROUPS +OTHERS +NFC +NFD +NFKC +NFKD +UESCAPE +VIEWS +NORMALIZE +DUMP +PRINT_STRICT_PARAMS +VARIABLE_CONFLICT +ERROR +USE_VARIABLE +USE_COLUMN +ALIAS +CONSTANT +PERFORM +GET +DIAGNOSTICS +STACKED +ELSIF +WHILE +REVERSE +FOREACH +SLICE +EXIT +RETURN +QUERY +RAISE +SQLSTATE +DEBUG +LOG +INFO +NOTICE +WARNING +EXCEPTION +ASSERT +LOOP +OPEN +ABS +CBRT +CEIL +CEILING +DEGREES +DIV +EXP +FACTORIAL +FLOOR +GCD +LCM +LN +LOG10 +MIN_SCALE +MOD +PI +POWER +RADIANS +ROUND +SCALE +SIGN +SQRT +TRIM_SCALE +TRUNC +WIDTH_BUCKET +RANDOM +SETSEED +ACOS +ACOSD +ASIN +ASIND +ATAN +ATAND +ATAN2 +ATAN2D +COS +COSD +COT +COTD +SIN +SIND +TAN +TAND +SINH +COSH +TANH +ASINH +ACOSH +ATANH +BIT_LENGTH +CHAR_LENGTH +CHARACTER_LENGTH +LOWER +OCTET_LENGTH +UPPER +ASCII +BTRIM +CHR +CONCAT +CONCAT_WS +FORMAT +INITCAP +LENGTH +LPAD +LTRIM +MD5 +PARSE_IDENT +PG_CLIENT_ENCODING +QUOTE_IDENT +QUOTE_LITERAL +QUOTE_NULLABLE +REGEXP_COUNT +REGEXP_INSTR +REGEXP_LIKE +REGEXP_MATCH +REGEXP_MATCHES +REGEXP_REPLACE +REGEXP_SPLIT_TO_ARRAY +REGEXP_SPLIT_TO_TABLE +REGEXP_SUBSTR +REPEAT +RPAD +RTRIM +SPLIT_PART +STARTS_WITH +STRING_TO_ARRAY +STRING_TO_TABLE +STRPOS +SUBSTR +TO_ASCII +TO_HEX +TRANSLATE +UNISTR +AGE +CLOCK_TIMESTAMP +DATE_BIN +DATE_PART +DATE_TRUNC +ISFINITE +JUSTIFY_DAYS +JUSTIFY_HOURS +JUSTIFY_INTERVAL +MAKE_DATE +MAKE_INTERVAL +MAKE_TIME +MAKE_TIMESTAMP +MAKE_TIMESTAMPTZ +NOW +STATEMENT_TIMESTAMP +TIMEOFDAY +TRANSACTION_TIMESTAMP +TO_TIMESTAMP +TO_CHAR +TO_DATE +TO_NUMBER +ENCODE +DISTKEY +SORTKEY +DISTSTYLE +BACKUP +COMPOUND +INTERLEAVED +EVEN +CASE_SENSITIVE +QUOTA +TB +BOOST +RECLUSTER +SORT +PERCENT_WORD +CASE_INSENSITIVE +Identifier +TemporaryIdentifier +NamespaceUser +QuotedIdentifier +UnterminatedQuotedIdentifier +InvalidQuotedIdentifier +InvalidUnterminatedQuotedIdentifier +UnicodeQuotedIdentifier +UnterminatedUnicodeQuotedIdentifier +InvalidUnicodeQuotedIdentifier +InvalidUnterminatedUnicodeQuotedIdentifier +StringConstant +UnterminatedStringConstant +UnicodeEscapeStringConstant +UnterminatedUnicodeEscapeStringConstant +BeginDollarStringConstant +BinaryStringConstant +UnterminatedBinaryStringConstant +InvalidBinaryStringConstant +InvalidUnterminatedBinaryStringConstant +HexadecimalStringConstant +UnterminatedHexadecimalStringConstant +InvalidHexadecimalStringConstant +InvalidUnterminatedHexadecimalStringConstant +Integral +NumericFail +Numeric +PLSQLVARIABLENAME +PLSQLIDENTIFIER +Whitespace +Newline +LineComment +BlockComment +UnterminatedBlockComment +MetaCommand +EndMetaCommand +ErrorCharacter +EscapeStringConstant +UnterminatedEscapeStringConstant +InvalidEscapeStringConstant +InvalidUnterminatedEscapeStringConstant +AfterEscapeStringConstantMode_NotContinued +AfterEscapeStringConstantWithNewlineMode_NotContinued +DollarText +EndDollarStringConstant +AfterEscapeStringConstantWithNewlineMode_Continued + +rule names: +Dollar +OPEN_PAREN +CLOSE_PAREN +OPEN_BRACKET +CLOSE_BRACKET +COMMA +SEMI +COLON +STAR +EQUAL +DOT +PLUS +MINUS +SLASH +CARET +LT +GT +LESS_LESS +GREATER_GREATER +COLON_EQUALS +LESS_EQUALS +EQUALS_GREATER +GREATER_EQUALS +DOT_DOT +NOT_EQUALS +TYPECAST +PERCENT +PARAM +Operator +OperatorEndingWithPlusMinus +OperatorCharacter +OperatorCharacterNotAllowPlusMinusAtEnd +OperatorCharacterAllowPlusMinusAtEnd +ALL +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASYMMETRIC +BOTH +CASE +CAST +CHECK +COLLATE +COLUMN +CONSTRAINT +CREATE +CURRENT_CATALOG +CURRENT_DATE +CURRENT_ROLE +CURRENT_TIME +CURRENT_TIMESTAMP +CURRENT_USER +DEFAULT +DEFERRABLE +DESC +DISTINCT +DO +ELSE +EXCEPT +FALSE_P +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP_P +HAVING +IN_P +INITIALLY +INTERSECT +INTO +LATERAL_P +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL_P +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +PUBLIC +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE_P +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +AUTHORIZATION +BINARY +BINDING +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER_P +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER_P +OVER +OVERLAPS +RIGHT +SIMILAR +VERBOSE +ABORT_P +ABSOLUTE_P +ACCESS +ACTION +ADD_P +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTRIBUTE +BACKWARD +BEFORE +BEGIN_P +BY +CACHE +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONNECTION +CONSTRAINTS +CONTENT_P +CONTINUE_P +CONVERSION_P +COPY +COST +CSV +JSON +CURSOR +CYCLE +DATA_P +DATA_CATALOG +DATABASE +DAY_P +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE_P +DELIMITER +DELIMITERS +DICTIONARY +DISABLE_P +DISCARD +DOCUMENT_P +DOMAIN_P +DOUBLE_P +DROP +EACH +ENABLE_P +ENCODING +ENCRYPTED +ENUM_P +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FIRST_P +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GLOBAL +GRANTED +HANDLER +HEADER_P +HOLD +HOUR_P +IDENTITY_P +IF_P +IMMEDIATE +IMMUTABLE +IMPLICIT_P +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE_P +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE_P +LAST_P +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK_P +MAPPING +MATCH +MATCHED +MATERIALIZED +MAXVALUE +MERGE +MINUTE_P +MINVALUE +MODE +MONTH_P +MOVE +NAME_P +NAMES +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS_P +OBJECT_P +OF +OFF +OIDS +OPERATOR +OPTION +OPTIONS +OWNED +OWNER +PARSER +PARTIAL +PARTITION +PASSING +PASSWORD +PLANS +PRECEDING +PREDICATE +PREPARE +PREPARED +PRESERVE +PRIOR +PRIVILEGES +PROCEDURAL +PROCEDURE +PROGRAM +QUOTE +RANGE +READ +REASSIGN +RECHECK +RECURSIVE +REF +REFRESH +REINDEX +RELATIVE_P +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROWS +RULE +SAVEPOINT +SCHEMA +SCROLL +SEARCH +SECOND_P +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SHARE +SHOW +SIMPLE +SNAPSHOT +STABLE +STANDALONE_P +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STRICT_P +STRIP_P +SYSID +SYSTEM_P +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT_P +TRANSACTION +TRIGGER +TRUNCATE +TRUSTED +TYPE_P +TYPES_P +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VARYING +VERSION_P +VIEW +VOLATILE +WHITESPACE_P +WITHOUT +WORK +WRAPPER +WRITE +XML_P +YEAR_P +YES_P +ZONE +QUALIFY +CONNECT +TOP +VARBYTE +VARBINARY +CONJUNCTION +DEFINITION +DATASHARE +FILE +PUBLICACCESSIBLE +INCLUDENEW +IAM_ROLE +CATALOG_ROLE +CATALOG_ID +HIVE +METASTORE +URI +POSTGRES +MYSQL +SECRET_ARN +KINESIS +KAFKA +MSK +AUTHENTICATION +AUTHENTICATION_ARN +SESSION_TOKEN +MTLS +MASKING +RLS +IDENTITY +PROVIDER +PROTECTED +MODEL +TARGET +SAGEMAKER +AUTO +MODEL_TYPE +PROBLEM_TYPE +OBJECTIVE +PREPROCESSORS +HYPERPARAMETERS +XGBOOST +MLP +LINEAR_LEARNER +KMEANS +FORECAST +REGRESSION +BINARY_CLASSIFICATION +MULTICLASS_CLASSIFICATION +S3_BUCKET +TAGS +KMS_KEY_ID +S3_GARBAGE_COLLECT +MAX_CELLS +MAX_RUNTIME +HORIZON +FREQUENCY +PERCENTILES +MAX_BATCH_ROWS +UNLOAD +MANIFEST +ADDQUOTES +ALLOWOVERWRITE +CLEANPATH +MAXFILESIZE +ROWGROUPSIZE +BZIP2 +GZIP +ZSTD +DATABASES +DATASHARES +GRANTS +USE +CANCEL +SESSION_AUTHORIZATION +SESSION_CHARACTERISTICS +COMPRESSION +LIBRARY +APPEND +MB +GB +ACCOUNT +NAMESPACE +DESCRIBE +NONATOMIC +MANAGEDBY +ADX +REMOVE +DUPLICATES +BEDROCK +MODEL_ID +PROMPT +SUFFIX +REQUEST_TYPE +RESPONSE_TYPE +RAW +UNIFIED +SUPER +CI +CS +PLPYTHONU +FILLTARGET +IGNOREEXTRA +CREATEUSER +NOCREATEUSER +REGION +PORT +REDSHIFT +IAM +CREATEDB +NOCREATEDB +RESTRICTED +UNLIMITED +EXTERNALID +TIMEOUT +SYSLOG +CREDENTIALS +UNRESTRICTED +PARAMETERS +APPLICATION_ARN +AUTO_CREATE_ROLES +COMPROWS +PROVIDER_URL +PROVIDER_URL_PORT +ATTRIBUTE_MAP +PROVIDER_ARN +ASSUME_ROLE_ARN +PROPERTIES +AVRO +RCFILE +SEQUENCEFILE +TEXTFILE +ORC +ION +LAMBDA +FIXEDWIDTH +PARQUET +LZOP +REMOVEQUOTES +TRUNCATECOLUMNS +FILLRECORD +BLANKSASNULL +EMPTYASNULL +MAXERROR +DATEFORMAT +TIMEFORMAT +ACCEPTINVCHARS +ACCEPTANYDATE +IGNOREHEADER +IGNOREBLANKLINES +COMPUPDATE +STATUPDATE +EXPLICIT_IDS +READRATIO +ROUNDEC +TRIMBLANKS +PRESET +ACCESS_KEY_ID +SECRET_ACCESS_KEY +SESSION_TOKEN_KW +HEADER +SETTINGS +FUNCTION_NAME +ATOMIC_P +BETWEEN +BIGINT +BIT +BOOLEAN_P +CHAR_P +CHARACTER +COALESCE +DEC +DECIMAL_P +EXISTS +EXTRACT +FLOAT_P +GREATEST +INOUT +INT_P +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OVERLAY +PARAMETER +POSITION +PRECISION +REAL +ROW +SETOF +SMALLINT +SUBSTRING +TIME +TIMESTAMP +TREAT +TRIM +VALUES +VARCHAR +XMLATTRIBUTES +XMLCOMMENT +XMLAGG +XML_IS_WELL_FORMED +XML_IS_WELL_FORMED_DOCUMENT +XML_IS_WELL_FORMED_CONTENT +XPATH +XPATH_EXISTS +XMLCONCAT +XMLELEMENT +XMLEXISTS +XMLFOREST +XMLPARSE +XMLPI +XMLROOT +XMLSERIALIZE +CALL +CURRENT_P +ATTACH +DETACH +EXPRESSION +GENERATED +LOGGED +STORED +SERDE +SERDEPROPERTIES +INPUTFORMAT +OUTPUTFORMAT +FIELDS +COLLECTION +ITEMS +TERMINATED +ESCAPED +DEFINED +LINES +KEYS +PARTITIONED +STRUCT +MAP +STRING +DELIMITED +USAGE +IGNORE +LANGUAGES +JOB +JOBS +VIA +ASSUMEROLE +RETRY_TIMEOUT +MAX_BATCH_SIZE +MAX_PAYLOAD_IN_MB +KB +INCLUDE +ROUTINE +TRANSFORM +IMPORT_P +POLICY +PRIORITY +METHOD +REFERENCING +NEW +OLD +VALUE_P +SUBSCRIPTION +PUBLICATION +OUT_P +END_P +ROUTINES +SCHEMAS +PROCEDURES +INPUT_P +SUPPORT +PARALLEL +SQL_P +DEPENDS +OVERRIDING +CONFLICT +SKIP_P +LOCKED +TIES +ROLLUP +CUBE +GROUPING +SETS +TABLESAMPLE +ORDINALITY +XMLTABLE +COLUMNS +XMLNAMESPACES +ROWTYPE +NORMALIZED +WITHIN +FILTER +GROUPS +OTHERS +NFC +NFD +NFKC +NFKD +UESCAPE +VIEWS +NORMALIZE +DUMP +PRINT_STRICT_PARAMS +VARIABLE_CONFLICT +ERROR +USE_VARIABLE +USE_COLUMN +ALIAS +CONSTANT +PERFORM +GET +DIAGNOSTICS +STACKED +ELSIF +WHILE +REVERSE +FOREACH +SLICE +EXIT +RETURN +QUERY +RAISE +SQLSTATE +DEBUG +LOG +INFO +NOTICE +WARNING +EXCEPTION +ASSERT +LOOP +OPEN +ABS +CBRT +CEIL +CEILING +DEGREES +DIV +EXP +FACTORIAL +FLOOR +GCD +LCM +LN +LOG10 +MIN_SCALE +MOD +PI +POWER +RADIANS +ROUND +SCALE +SIGN +SQRT +TRIM_SCALE +TRUNC +WIDTH_BUCKET +RANDOM +SETSEED +ACOS +ACOSD +ASIN +ASIND +ATAN +ATAND +ATAN2 +ATAN2D +COS +COSD +COT +COTD +SIN +SIND +TAN +TAND +SINH +COSH +TANH +ASINH +ACOSH +ATANH +BIT_LENGTH +CHAR_LENGTH +CHARACTER_LENGTH +LOWER +OCTET_LENGTH +UPPER +ASCII +BTRIM +CHR +CONCAT +CONCAT_WS +FORMAT +INITCAP +LENGTH +LPAD +LTRIM +MD5 +PARSE_IDENT +PG_CLIENT_ENCODING +QUOTE_IDENT +QUOTE_LITERAL +QUOTE_NULLABLE +REGEXP_COUNT +REGEXP_INSTR +REGEXP_LIKE +REGEXP_MATCH +REGEXP_MATCHES +REGEXP_REPLACE +REGEXP_SPLIT_TO_ARRAY +REGEXP_SPLIT_TO_TABLE +REGEXP_SUBSTR +REPEAT +RPAD +RTRIM +SPLIT_PART +STARTS_WITH +STRING_TO_ARRAY +STRING_TO_TABLE +STRPOS +SUBSTR +TO_ASCII +TO_HEX +TRANSLATE +UNISTR +AGE +CLOCK_TIMESTAMP +DATE_BIN +DATE_PART +DATE_TRUNC +ISFINITE +JUSTIFY_DAYS +JUSTIFY_HOURS +JUSTIFY_INTERVAL +MAKE_DATE +MAKE_INTERVAL +MAKE_TIME +MAKE_TIMESTAMP +MAKE_TIMESTAMPTZ +NOW +STATEMENT_TIMESTAMP +TIMEOFDAY +TRANSACTION_TIMESTAMP +TO_TIMESTAMP +TO_CHAR +TO_DATE +TO_NUMBER +ENCODE +DISTKEY +SORTKEY +DISTSTYLE +BACKUP +COMPOUND +INTERLEAVED +EVEN +CASE_SENSITIVE +QUOTA +TB +BOOST +RECLUSTER +SORT +PERCENT_WORD +CASE_INSENSITIVE +Identifier +TemporaryIdentifier +NamespaceUser +IdentifierStartChar +IdentifierChar +StrictIdentifierChar +QuotedIdentifier +UnterminatedQuotedIdentifier +InvalidQuotedIdentifier +InvalidUnterminatedQuotedIdentifier +UnicodeQuotedIdentifier +UnterminatedUnicodeQuotedIdentifier +InvalidUnicodeQuotedIdentifier +InvalidUnterminatedUnicodeQuotedIdentifier +StringConstant +UnterminatedStringConstant +BeginEscapeStringConstant +UnicodeEscapeStringConstant +UnterminatedUnicodeEscapeStringConstant +BeginDollarStringConstant +Tag +BinaryStringConstant +UnterminatedBinaryStringConstant +InvalidBinaryStringConstant +InvalidUnterminatedBinaryStringConstant +HexadecimalStringConstant +UnterminatedHexadecimalStringConstant +InvalidHexadecimalStringConstant +InvalidUnterminatedHexadecimalStringConstant +Integral +NumericFail +Numeric +Digits +PLSQLVARIABLENAME +PLSQLIDENTIFIER +Whitespace +Newline +LineComment +BlockComment +UnterminatedBlockComment +MetaCommand +EndMetaCommand +ErrorCharacter +EscapeStringConstant +UnterminatedEscapeStringConstant +EscapeStringText +InvalidEscapeStringConstant +InvalidUnterminatedEscapeStringConstant +InvalidEscapeStringText +AfterEscapeStringConstantMode_Whitespace +AfterEscapeStringConstantMode_Newline +AfterEscapeStringConstantMode_NotContinued +AfterEscapeStringConstantWithNewlineMode_Whitespace +AfterEscapeStringConstantWithNewlineMode_Newline +AfterEscapeStringConstantWithNewlineMode_Continued +AfterEscapeStringConstantWithNewlineMode_NotContinued +DollarText +EndDollarStringConstant + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE +EscapeStringConstantMode +AfterEscapeStringConstantMode +AfterEscapeStringConstantWithNewlineMode +DollarQuotedStringMode + +atn: +[4, 0, 896, 9322, 6, -1, 6, -1, 6, -1, 6, -1, 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, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 4, 27, 1895, 8, 27, 11, 27, 12, 27, 1896, 1, 28, 1, 28, 1, 28, 1, 28, 4, 28, 1903, 8, 28, 11, 28, 12, 28, 1904, 1, 28, 1, 28, 1, 28, 3, 28, 1910, 8, 28, 1, 28, 1, 28, 4, 28, 1914, 8, 28, 11, 28, 12, 28, 1915, 1, 28, 3, 28, 1919, 8, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 1928, 8, 29, 10, 29, 12, 29, 1931, 9, 29, 1, 29, 1, 29, 3, 29, 1935, 8, 29, 1, 29, 1, 29, 1, 29, 4, 29, 1940, 8, 29, 11, 29, 12, 29, 1941, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 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, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 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, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 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, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 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, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 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, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 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, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 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, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 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, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 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, 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, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 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, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 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, 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, 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, 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, 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, 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, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 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, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 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, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 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, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 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, 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, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 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, 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, 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, 192, 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, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 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, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 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, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 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, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, 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, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 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, 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, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 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, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 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, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 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, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 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, 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, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 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, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 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, 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, 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, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 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, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 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, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 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, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, 1, 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, 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, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 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, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 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, 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, 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, 342, 1, 342, 1, 342, 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, 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, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 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, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 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, 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, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 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, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 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, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, 1, 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, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 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, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, 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, 390, 1, 390, 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 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, 405, 1, 405, 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, 407, 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, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 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, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 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, 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, 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, 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, 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, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 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, 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, 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, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 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, 435, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 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, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 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, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 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, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 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, 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, 450, 1, 450, 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, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 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, 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, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 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, 467, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 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, 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, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 483, 1, 483, 1, 483, 1, 483, 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, 486, 1, 486, 1, 486, 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, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 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, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 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, 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, 504, 1, 504, 1, 504, 1, 504, 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, 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, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 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, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, 1, 520, 1, 520, 1, 520, 1, 521, 1, 521, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 523, 1, 523, 1, 523, 1, 523, 1, 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, 524, 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, 526, 1, 526, 1, 526, 1, 526, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 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, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 541, 1, 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, 542, 1, 543, 1, 543, 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, 545, 1, 545, 1, 545, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 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, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 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, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 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, 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, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 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, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 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, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 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, 580, 1, 580, 1, 580, 1, 580, 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, 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, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 590, 1, 590, 1, 590, 1, 590, 1, 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, 591, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 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, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 604, 1, 604, 1, 604, 1, 604, 1, 604, 1, 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, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, 1, 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, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 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, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 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, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 641, 1, 641, 1, 641, 1, 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, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 650, 1, 650, 1, 650, 1, 650, 1, 651, 1, 651, 1, 651, 1, 651, 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, 653, 1, 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, 655, 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, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 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, 662, 1, 662, 1, 663, 1, 663, 1, 663, 1, 663, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 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, 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, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 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, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 683, 1, 683, 1, 683, 1, 683, 1, 683, 1, 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 685, 1, 685, 1, 685, 1, 685, 1, 686, 1, 686, 1, 686, 1, 686, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 701, 1, 701, 1, 701, 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 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, 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, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 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, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 715, 1, 715, 1, 715, 1, 715, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 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, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 723, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 727, 1, 728, 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 732, 1, 732, 1, 733, 1, 733, 1, 733, 1, 733, 1, 734, 1, 734, 1, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 737, 1, 737, 1, 737, 1, 737, 1, 738, 1, 738, 1, 738, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 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, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 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, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 750, 1, 750, 1, 750, 1, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 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, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 758, 1, 758, 1, 758, 1, 758, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 760, 1, 760, 1, 760, 1, 760, 1, 761, 1, 761, 1, 761, 1, 761, 1, 761, 1, 762, 1, 762, 1, 762, 1, 762, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 764, 1, 764, 1, 764, 1, 764, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 766, 1, 766, 1, 766, 1, 766, 1, 766, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 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, 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, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 780, 1, 780, 1, 780, 1, 780, 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, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 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, 790, 1, 790, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 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, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 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, 798, 1, 798, 1, 798, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 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, 801, 1, 801, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 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, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 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, 813, 1, 813, 1, 814, 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, 815, 1, 815, 1, 815, 1, 816, 1, 816, 1, 816, 1, 816, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 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, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 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, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, 1, 830, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, 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, 841, 1, 841, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 848, 1, 848, 1, 848, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 854, 1, 854, 5, 854, 8850, 8, 854, 10, 854, 12, 854, 8853, 9, 854, 1, 855, 1, 855, 1, 855, 1, 856, 1, 856, 1, 856, 1, 856, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 3, 857, 8868, 8, 857, 1, 858, 1, 858, 3, 858, 8872, 8, 858, 1, 859, 1, 859, 3, 859, 8876, 8, 859, 1, 860, 1, 860, 1, 860, 1, 861, 1, 861, 1, 861, 1, 861, 5, 861, 8885, 8, 861, 10, 861, 12, 861, 8888, 9, 861, 1, 862, 1, 862, 1, 862, 1, 863, 1, 863, 1, 863, 1, 863, 5, 863, 8897, 8, 863, 10, 863, 12, 863, 8900, 9, 863, 1, 864, 1, 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 866, 1, 866, 1, 866, 1, 866, 1, 867, 1, 867, 1, 867, 1, 867, 1, 868, 1, 868, 1, 868, 1, 869, 1, 869, 1, 869, 1, 869, 5, 869, 8925, 8, 869, 10, 869, 12, 869, 8928, 9, 869, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 871, 1, 871, 1, 871, 1, 872, 1, 872, 1, 872, 1, 872, 1, 873, 1, 873, 3, 873, 8945, 8, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 874, 1, 874, 5, 874, 8954, 8, 874, 10, 874, 12, 874, 8957, 9, 874, 1, 875, 1, 875, 1, 875, 1, 876, 1, 876, 1, 876, 5, 876, 8965, 8, 876, 10, 876, 12, 876, 8968, 9, 876, 1, 877, 1, 877, 1, 877, 1, 878, 1, 878, 1, 878, 1, 879, 1, 879, 1, 879, 1, 880, 1, 880, 1, 880, 5, 880, 8982, 8, 880, 10, 880, 12, 880, 8985, 9, 880, 1, 881, 1, 881, 1, 881, 1, 882, 1, 882, 1, 882, 1, 883, 1, 883, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 885, 1, 885, 1, 885, 3, 885, 9004, 8, 885, 1, 885, 1, 885, 3, 885, 9008, 8, 885, 1, 885, 3, 885, 9011, 8, 885, 1, 885, 1, 885, 1, 885, 1, 885, 3, 885, 9017, 8, 885, 1, 885, 3, 885, 9020, 8, 885, 1, 885, 1, 885, 1, 885, 3, 885, 9025, 8, 885, 1, 885, 1, 885, 3, 885, 9029, 8, 885, 1, 886, 4, 886, 9032, 8, 886, 11, 886, 12, 886, 9033, 1, 887, 1, 887, 1, 887, 5, 887, 9039, 8, 887, 10, 887, 12, 887, 9042, 9, 887, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 5, 888, 9052, 8, 888, 10, 888, 12, 888, 9055, 9, 888, 1, 888, 1, 888, 1, 889, 1, 889, 1, 889, 1, 889, 1, 890, 1, 890, 3, 890, 9065, 8, 890, 1, 890, 3, 890, 9068, 8, 890, 1, 890, 1, 890, 1, 891, 1, 891, 1, 891, 1, 891, 5, 891, 9076, 8, 891, 10, 891, 12, 891, 9079, 9, 891, 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, 892, 5, 892, 9087, 8, 892, 10, 892, 12, 892, 9090, 9, 892, 1, 892, 1, 892, 1, 892, 4, 892, 9095, 8, 892, 11, 892, 12, 892, 9096, 1, 892, 1, 892, 4, 892, 9101, 8, 892, 11, 892, 12, 892, 9102, 1, 892, 5, 892, 9106, 8, 892, 10, 892, 12, 892, 9109, 9, 892, 1, 892, 5, 892, 9112, 8, 892, 10, 892, 12, 892, 9115, 9, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 893, 1, 893, 1, 893, 1, 893, 5, 893, 9126, 8, 893, 10, 893, 12, 893, 9129, 9, 893, 1, 893, 1, 893, 1, 893, 4, 893, 9134, 8, 893, 11, 893, 12, 893, 9135, 1, 893, 1, 893, 4, 893, 9140, 8, 893, 11, 893, 12, 893, 9141, 1, 893, 3, 893, 9145, 8, 893, 5, 893, 9147, 8, 893, 10, 893, 12, 893, 9150, 9, 893, 1, 893, 4, 893, 9153, 8, 893, 11, 893, 12, 893, 9154, 1, 893, 4, 893, 9158, 8, 893, 11, 893, 12, 893, 9159, 1, 893, 5, 893, 9163, 8, 893, 10, 893, 12, 893, 9166, 9, 893, 1, 893, 3, 893, 9169, 8, 893, 1, 893, 1, 893, 1, 894, 1, 894, 1, 894, 1, 894, 5, 894, 9177, 8, 894, 10, 894, 12, 894, 9180, 9, 894, 1, 894, 5, 894, 9183, 8, 894, 10, 894, 12, 894, 9186, 9, 894, 1, 894, 1, 894, 5, 894, 9190, 8, 894, 10, 894, 12, 894, 9193, 9, 894, 3, 894, 9195, 8, 894, 1, 895, 1, 895, 1, 895, 1, 896, 1, 896, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 3, 898, 9209, 8, 898, 1, 898, 1, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 3, 899, 9233, 8, 899, 1, 899, 5, 899, 9236, 8, 899, 10, 899, 12, 899, 9239, 9, 899, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 901, 1, 901, 3, 901, 9248, 8, 901, 1, 901, 1, 901, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 5, 902, 9257, 8, 902, 10, 902, 12, 902, 9260, 9, 902, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 910, 4, 910, 9299, 8, 910, 11, 910, 12, 910, 9300, 1, 910, 1, 910, 5, 910, 9305, 8, 910, 10, 910, 12, 910, 9308, 9, 910, 3, 910, 9310, 8, 910, 1, 911, 1, 911, 3, 911, 9314, 8, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 0, 0, 912, 5, 1, 7, 2, 9, 3, 11, 4, 13, 5, 15, 6, 17, 7, 19, 8, 21, 9, 23, 10, 25, 11, 27, 12, 29, 13, 31, 14, 33, 15, 35, 16, 37, 17, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 0, 65, 0, 67, 0, 69, 0, 71, 30, 73, 31, 75, 32, 77, 33, 79, 34, 81, 35, 83, 36, 85, 37, 87, 38, 89, 39, 91, 40, 93, 41, 95, 42, 97, 43, 99, 44, 101, 45, 103, 46, 105, 47, 107, 48, 109, 49, 111, 50, 113, 51, 115, 52, 117, 53, 119, 54, 121, 55, 123, 56, 125, 57, 127, 58, 129, 59, 131, 60, 133, 61, 135, 62, 137, 63, 139, 64, 141, 65, 143, 66, 145, 67, 147, 68, 149, 69, 151, 70, 153, 71, 155, 72, 157, 73, 159, 74, 161, 75, 163, 76, 165, 77, 167, 78, 169, 79, 171, 80, 173, 81, 175, 82, 177, 83, 179, 84, 181, 85, 183, 86, 185, 87, 187, 88, 189, 89, 191, 90, 193, 91, 195, 92, 197, 93, 199, 94, 201, 95, 203, 96, 205, 97, 207, 98, 209, 99, 211, 100, 213, 101, 215, 102, 217, 103, 219, 104, 221, 105, 223, 106, 225, 107, 227, 108, 229, 109, 231, 110, 233, 111, 235, 112, 237, 113, 239, 114, 241, 115, 243, 116, 245, 117, 247, 118, 249, 119, 251, 120, 253, 121, 255, 122, 257, 123, 259, 124, 261, 125, 263, 126, 265, 127, 267, 128, 269, 129, 271, 130, 273, 131, 275, 132, 277, 133, 279, 134, 281, 135, 283, 136, 285, 137, 287, 138, 289, 139, 291, 140, 293, 141, 295, 142, 297, 143, 299, 144, 301, 145, 303, 146, 305, 147, 307, 148, 309, 149, 311, 150, 313, 151, 315, 152, 317, 153, 319, 154, 321, 155, 323, 156, 325, 157, 327, 158, 329, 159, 331, 160, 333, 161, 335, 162, 337, 163, 339, 164, 341, 165, 343, 166, 345, 167, 347, 168, 349, 169, 351, 170, 353, 171, 355, 172, 357, 173, 359, 174, 361, 175, 363, 176, 365, 177, 367, 178, 369, 179, 371, 180, 373, 181, 375, 182, 377, 183, 379, 184, 381, 185, 383, 186, 385, 187, 387, 188, 389, 189, 391, 190, 393, 191, 395, 192, 397, 193, 399, 194, 401, 195, 403, 196, 405, 197, 407, 198, 409, 199, 411, 200, 413, 201, 415, 202, 417, 203, 419, 204, 421, 205, 423, 206, 425, 207, 427, 208, 429, 209, 431, 210, 433, 211, 435, 212, 437, 213, 439, 214, 441, 215, 443, 216, 445, 217, 447, 218, 449, 219, 451, 220, 453, 221, 455, 222, 457, 223, 459, 224, 461, 225, 463, 226, 465, 227, 467, 228, 469, 229, 471, 230, 473, 231, 475, 232, 477, 233, 479, 234, 481, 235, 483, 236, 485, 237, 487, 238, 489, 239, 491, 240, 493, 241, 495, 242, 497, 243, 499, 244, 501, 245, 503, 246, 505, 247, 507, 248, 509, 249, 511, 250, 513, 251, 515, 252, 517, 253, 519, 254, 521, 255, 523, 256, 525, 257, 527, 258, 529, 259, 531, 260, 533, 261, 535, 262, 537, 263, 539, 264, 541, 265, 543, 266, 545, 267, 547, 268, 549, 269, 551, 270, 553, 271, 555, 272, 557, 273, 559, 274, 561, 275, 563, 276, 565, 277, 567, 278, 569, 279, 571, 280, 573, 281, 575, 282, 577, 283, 579, 284, 581, 285, 583, 286, 585, 287, 587, 288, 589, 289, 591, 290, 593, 291, 595, 292, 597, 293, 599, 294, 601, 295, 603, 296, 605, 297, 607, 298, 609, 299, 611, 300, 613, 301, 615, 302, 617, 303, 619, 304, 621, 305, 623, 306, 625, 307, 627, 308, 629, 309, 631, 310, 633, 311, 635, 312, 637, 313, 639, 314, 641, 315, 643, 316, 645, 317, 647, 318, 649, 319, 651, 320, 653, 321, 655, 322, 657, 323, 659, 324, 661, 325, 663, 326, 665, 327, 667, 328, 669, 329, 671, 330, 673, 331, 675, 332, 677, 333, 679, 334, 681, 335, 683, 336, 685, 337, 687, 338, 689, 339, 691, 340, 693, 341, 695, 342, 697, 343, 699, 344, 701, 345, 703, 346, 705, 347, 707, 348, 709, 349, 711, 350, 713, 351, 715, 352, 717, 353, 719, 354, 721, 355, 723, 356, 725, 357, 727, 358, 729, 359, 731, 360, 733, 361, 735, 362, 737, 363, 739, 364, 741, 365, 743, 366, 745, 367, 747, 368, 749, 369, 751, 370, 753, 371, 755, 372, 757, 373, 759, 374, 761, 375, 763, 376, 765, 377, 767, 378, 769, 379, 771, 380, 773, 381, 775, 382, 777, 383, 779, 384, 781, 385, 783, 386, 785, 387, 787, 388, 789, 389, 791, 390, 793, 391, 795, 392, 797, 393, 799, 394, 801, 395, 803, 396, 805, 397, 807, 398, 809, 399, 811, 400, 813, 401, 815, 402, 817, 403, 819, 404, 821, 405, 823, 406, 825, 407, 827, 408, 829, 409, 831, 410, 833, 411, 835, 412, 837, 413, 839, 414, 841, 415, 843, 416, 845, 417, 847, 418, 849, 419, 851, 420, 853, 421, 855, 422, 857, 423, 859, 424, 861, 425, 863, 426, 865, 427, 867, 428, 869, 429, 871, 430, 873, 431, 875, 432, 877, 433, 879, 434, 881, 435, 883, 436, 885, 437, 887, 438, 889, 439, 891, 440, 893, 441, 895, 442, 897, 443, 899, 444, 901, 445, 903, 446, 905, 447, 907, 448, 909, 449, 911, 450, 913, 451, 915, 452, 917, 453, 919, 454, 921, 455, 923, 456, 925, 457, 927, 458, 929, 459, 931, 460, 933, 461, 935, 462, 937, 463, 939, 464, 941, 465, 943, 466, 945, 467, 947, 468, 949, 469, 951, 470, 953, 471, 955, 472, 957, 473, 959, 474, 961, 475, 963, 476, 965, 477, 967, 478, 969, 479, 971, 480, 973, 481, 975, 482, 977, 483, 979, 484, 981, 485, 983, 486, 985, 487, 987, 488, 989, 489, 991, 490, 993, 491, 995, 492, 997, 493, 999, 494, 1001, 495, 1003, 496, 1005, 497, 1007, 498, 1009, 499, 1011, 500, 1013, 501, 1015, 502, 1017, 503, 1019, 504, 1021, 505, 1023, 506, 1025, 507, 1027, 508, 1029, 509, 1031, 510, 1033, 511, 1035, 512, 1037, 513, 1039, 514, 1041, 515, 1043, 516, 1045, 517, 1047, 518, 1049, 519, 1051, 520, 1053, 521, 1055, 522, 1057, 523, 1059, 524, 1061, 525, 1063, 526, 1065, 527, 1067, 528, 1069, 529, 1071, 530, 1073, 531, 1075, 532, 1077, 533, 1079, 534, 1081, 535, 1083, 536, 1085, 537, 1087, 538, 1089, 539, 1091, 540, 1093, 541, 1095, 542, 1097, 543, 1099, 544, 1101, 545, 1103, 546, 1105, 547, 1107, 548, 1109, 549, 1111, 550, 1113, 551, 1115, 552, 1117, 553, 1119, 554, 1121, 555, 1123, 556, 1125, 557, 1127, 558, 1129, 559, 1131, 560, 1133, 561, 1135, 562, 1137, 563, 1139, 564, 1141, 565, 1143, 566, 1145, 567, 1147, 568, 1149, 569, 1151, 570, 1153, 571, 1155, 572, 1157, 573, 1159, 574, 1161, 575, 1163, 576, 1165, 577, 1167, 578, 1169, 579, 1171, 580, 1173, 581, 1175, 582, 1177, 583, 1179, 584, 1181, 585, 1183, 586, 1185, 587, 1187, 588, 1189, 589, 1191, 590, 1193, 591, 1195, 592, 1197, 593, 1199, 594, 1201, 595, 1203, 596, 1205, 597, 1207, 598, 1209, 599, 1211, 600, 1213, 601, 1215, 602, 1217, 603, 1219, 604, 1221, 605, 1223, 606, 1225, 607, 1227, 608, 1229, 609, 1231, 610, 1233, 611, 1235, 612, 1237, 613, 1239, 614, 1241, 615, 1243, 616, 1245, 617, 1247, 618, 1249, 619, 1251, 620, 1253, 621, 1255, 622, 1257, 623, 1259, 624, 1261, 625, 1263, 626, 1265, 627, 1267, 628, 1269, 629, 1271, 630, 1273, 631, 1275, 632, 1277, 633, 1279, 634, 1281, 635, 1283, 636, 1285, 637, 1287, 638, 1289, 639, 1291, 640, 1293, 641, 1295, 642, 1297, 643, 1299, 644, 1301, 645, 1303, 646, 1305, 647, 1307, 648, 1309, 649, 1311, 650, 1313, 651, 1315, 652, 1317, 653, 1319, 654, 1321, 655, 1323, 656, 1325, 657, 1327, 658, 1329, 659, 1331, 660, 1333, 661, 1335, 662, 1337, 663, 1339, 664, 1341, 665, 1343, 666, 1345, 667, 1347, 668, 1349, 669, 1351, 670, 1353, 671, 1355, 672, 1357, 673, 1359, 674, 1361, 675, 1363, 676, 1365, 677, 1367, 678, 1369, 679, 1371, 680, 1373, 681, 1375, 682, 1377, 683, 1379, 684, 1381, 685, 1383, 686, 1385, 687, 1387, 688, 1389, 689, 1391, 690, 1393, 691, 1395, 692, 1397, 693, 1399, 694, 1401, 695, 1403, 696, 1405, 697, 1407, 698, 1409, 699, 1411, 700, 1413, 701, 1415, 702, 1417, 703, 1419, 704, 1421, 705, 1423, 706, 1425, 707, 1427, 708, 1429, 709, 1431, 710, 1433, 711, 1435, 712, 1437, 713, 1439, 714, 1441, 715, 1443, 716, 1445, 717, 1447, 718, 1449, 719, 1451, 720, 1453, 721, 1455, 722, 1457, 723, 1459, 724, 1461, 725, 1463, 726, 1465, 727, 1467, 728, 1469, 729, 1471, 730, 1473, 731, 1475, 732, 1477, 733, 1479, 734, 1481, 735, 1483, 736, 1485, 737, 1487, 738, 1489, 739, 1491, 740, 1493, 741, 1495, 742, 1497, 743, 1499, 744, 1501, 745, 1503, 746, 1505, 747, 1507, 748, 1509, 749, 1511, 750, 1513, 751, 1515, 752, 1517, 753, 1519, 754, 1521, 755, 1523, 756, 1525, 757, 1527, 758, 1529, 759, 1531, 760, 1533, 761, 1535, 762, 1537, 763, 1539, 764, 1541, 765, 1543, 766, 1545, 767, 1547, 768, 1549, 769, 1551, 770, 1553, 771, 1555, 772, 1557, 773, 1559, 774, 1561, 775, 1563, 776, 1565, 777, 1567, 778, 1569, 779, 1571, 780, 1573, 781, 1575, 782, 1577, 783, 1579, 784, 1581, 785, 1583, 786, 1585, 787, 1587, 788, 1589, 789, 1591, 790, 1593, 791, 1595, 792, 1597, 793, 1599, 794, 1601, 795, 1603, 796, 1605, 797, 1607, 798, 1609, 799, 1611, 800, 1613, 801, 1615, 802, 1617, 803, 1619, 804, 1621, 805, 1623, 806, 1625, 807, 1627, 808, 1629, 809, 1631, 810, 1633, 811, 1635, 812, 1637, 813, 1639, 814, 1641, 815, 1643, 816, 1645, 817, 1647, 818, 1649, 819, 1651, 820, 1653, 821, 1655, 822, 1657, 823, 1659, 824, 1661, 825, 1663, 826, 1665, 827, 1667, 828, 1669, 829, 1671, 830, 1673, 831, 1675, 832, 1677, 833, 1679, 834, 1681, 835, 1683, 836, 1685, 837, 1687, 838, 1689, 839, 1691, 840, 1693, 841, 1695, 842, 1697, 843, 1699, 844, 1701, 845, 1703, 846, 1705, 847, 1707, 848, 1709, 849, 1711, 850, 1713, 851, 1715, 852, 1717, 853, 1719, 0, 1721, 0, 1723, 0, 1725, 854, 1727, 855, 1729, 856, 1731, 857, 1733, 858, 1735, 859, 1737, 860, 1739, 861, 1741, 862, 1743, 863, 1745, 0, 1747, 864, 1749, 865, 1751, 866, 1753, 0, 1755, 867, 1757, 868, 1759, 869, 1761, 870, 1763, 871, 1765, 872, 1767, 873, 1769, 874, 1771, 875, 1773, 876, 1775, 877, 1777, 0, 1779, 878, 1781, 879, 1783, 880, 1785, 881, 1787, 882, 1789, 883, 1791, 884, 1793, 885, 1795, 886, 1797, 887, 1799, 888, 1801, 889, 1803, 0, 1805, 890, 1807, 891, 1809, 0, 1811, 0, 1813, 0, 1815, 892, 1817, 0, 1819, 0, 1821, 896, 1823, 893, 1825, 894, 1827, 895, 5, 0, 1, 2, 3, 4, 51, 1, 0, 48, 57, 2, 0, 43, 43, 45, 45, 9, 0, 33, 33, 35, 35, 37, 38, 42, 42, 60, 64, 94, 94, 96, 96, 124, 124, 126, 126, 2, 0, 42, 43, 60, 62, 8, 0, 33, 33, 35, 35, 37, 38, 63, 64, 94, 94, 96, 96, 124, 124, 126, 126, 2, 0, 65, 65, 97, 97, 2, 0, 76, 76, 108, 108, 2, 0, 78, 78, 110, 110, 2, 0, 89, 89, 121, 121, 2, 0, 83, 83, 115, 115, 2, 0, 69, 69, 101, 101, 2, 0, 90, 90, 122, 122, 2, 0, 68, 68, 100, 100, 2, 0, 82, 82, 114, 114, 2, 0, 67, 67, 99, 99, 2, 0, 77, 77, 109, 109, 2, 0, 84, 84, 116, 116, 2, 0, 73, 73, 105, 105, 2, 0, 66, 66, 98, 98, 2, 0, 79, 79, 111, 111, 2, 0, 72, 72, 104, 104, 2, 0, 75, 75, 107, 107, 2, 0, 85, 85, 117, 117, 2, 0, 71, 71, 103, 103, 2, 0, 80, 80, 112, 112, 2, 0, 70, 70, 102, 102, 2, 0, 88, 88, 120, 120, 2, 0, 86, 86, 118, 118, 2, 0, 81, 81, 113, 113, 2, 0, 87, 87, 119, 119, 2, 0, 74, 74, 106, 106, 9, 0, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 255, 2, 0, 256, 55295, 57344, 65535, 1, 0, 55296, 56319, 1, 0, 56320, 57343, 2, 0, 0, 0, 34, 34, 1, 0, 34, 34, 1, 0, 39, 39, 1, 0, 48, 49, 3, 0, 48, 57, 65, 70, 97, 102, 3, 0, 65, 90, 95, 95, 97, 122, 5, 0, 36, 36, 48, 57, 65, 90, 95, 95, 97, 122, 2, 0, 34, 34, 92, 92, 2, 0, 9, 9, 32, 32, 2, 0, 10, 10, 13, 13, 2, 0, 42, 42, 47, 47, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 3, 0, 10, 10, 13, 13, 34, 34, 3, 0, 85, 85, 117, 117, 120, 120, 2, 0, 39, 39, 92, 92, 1, 0, 36, 36, 9393, 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, 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, 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, 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, 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, 1, 1799, 1, 0, 0, 0, 1, 1801, 1, 0, 0, 0, 1, 1805, 1, 0, 0, 0, 1, 1807, 1, 0, 0, 0, 2, 1811, 1, 0, 0, 0, 2, 1813, 1, 0, 0, 0, 2, 1815, 1, 0, 0, 0, 3, 1817, 1, 0, 0, 0, 3, 1819, 1, 0, 0, 0, 3, 1821, 1, 0, 0, 0, 3, 1823, 1, 0, 0, 0, 4, 1825, 1, 0, 0, 0, 4, 1827, 1, 0, 0, 0, 5, 1829, 1, 0, 0, 0, 7, 1831, 1, 0, 0, 0, 9, 1833, 1, 0, 0, 0, 11, 1835, 1, 0, 0, 0, 13, 1837, 1, 0, 0, 0, 15, 1839, 1, 0, 0, 0, 17, 1841, 1, 0, 0, 0, 19, 1843, 1, 0, 0, 0, 21, 1845, 1, 0, 0, 0, 23, 1847, 1, 0, 0, 0, 25, 1849, 1, 0, 0, 0, 27, 1851, 1, 0, 0, 0, 29, 1853, 1, 0, 0, 0, 31, 1855, 1, 0, 0, 0, 33, 1857, 1, 0, 0, 0, 35, 1859, 1, 0, 0, 0, 37, 1861, 1, 0, 0, 0, 39, 1863, 1, 0, 0, 0, 41, 1866, 1, 0, 0, 0, 43, 1869, 1, 0, 0, 0, 45, 1872, 1, 0, 0, 0, 47, 1875, 1, 0, 0, 0, 49, 1878, 1, 0, 0, 0, 51, 1881, 1, 0, 0, 0, 53, 1884, 1, 0, 0, 0, 55, 1887, 1, 0, 0, 0, 57, 1890, 1, 0, 0, 0, 59, 1892, 1, 0, 0, 0, 61, 1918, 1, 0, 0, 0, 63, 1929, 1, 0, 0, 0, 65, 1945, 1, 0, 0, 0, 67, 1947, 1, 0, 0, 0, 69, 1949, 1, 0, 0, 0, 71, 1951, 1, 0, 0, 0, 73, 1955, 1, 0, 0, 0, 75, 1963, 1, 0, 0, 0, 77, 1971, 1, 0, 0, 0, 79, 1975, 1, 0, 0, 0, 81, 1979, 1, 0, 0, 0, 83, 1985, 1, 0, 0, 0, 85, 1988, 1, 0, 0, 0, 87, 1992, 1, 0, 0, 0, 89, 2003, 1, 0, 0, 0, 91, 2008, 1, 0, 0, 0, 93, 2013, 1, 0, 0, 0, 95, 2018, 1, 0, 0, 0, 97, 2024, 1, 0, 0, 0, 99, 2032, 1, 0, 0, 0, 101, 2039, 1, 0, 0, 0, 103, 2050, 1, 0, 0, 0, 105, 2057, 1, 0, 0, 0, 107, 2073, 1, 0, 0, 0, 109, 2086, 1, 0, 0, 0, 111, 2099, 1, 0, 0, 0, 113, 2112, 1, 0, 0, 0, 115, 2130, 1, 0, 0, 0, 117, 2143, 1, 0, 0, 0, 119, 2151, 1, 0, 0, 0, 121, 2162, 1, 0, 0, 0, 123, 2167, 1, 0, 0, 0, 125, 2176, 1, 0, 0, 0, 127, 2179, 1, 0, 0, 0, 129, 2184, 1, 0, 0, 0, 131, 2191, 1, 0, 0, 0, 133, 2197, 1, 0, 0, 0, 135, 2203, 1, 0, 0, 0, 137, 2207, 1, 0, 0, 0, 139, 2215, 1, 0, 0, 0, 141, 2220, 1, 0, 0, 0, 143, 2226, 1, 0, 0, 0, 145, 2232, 1, 0, 0, 0, 147, 2239, 1, 0, 0, 0, 149, 2242, 1, 0, 0, 0, 151, 2252, 1, 0, 0, 0, 153, 2262, 1, 0, 0, 0, 155, 2267, 1, 0, 0, 0, 157, 2275, 1, 0, 0, 0, 159, 2283, 1, 0, 0, 0, 161, 2289, 1, 0, 0, 0, 163, 2299, 1, 0, 0, 0, 165, 2314, 1, 0, 0, 0, 167, 2318, 1, 0, 0, 0, 169, 2323, 1, 0, 0, 0, 171, 2330, 1, 0, 0, 0, 173, 2333, 1, 0, 0, 0, 175, 2338, 1, 0, 0, 0, 177, 2341, 1, 0, 0, 0, 179, 2347, 1, 0, 0, 0, 181, 2355, 1, 0, 0, 0, 183, 2363, 1, 0, 0, 0, 185, 2370, 1, 0, 0, 0, 187, 2381, 1, 0, 0, 0, 189, 2391, 1, 0, 0, 0, 191, 2398, 1, 0, 0, 0, 193, 2411, 1, 0, 0, 0, 195, 2416, 1, 0, 0, 0, 197, 2426, 1, 0, 0, 0, 199, 2432, 1, 0, 0, 0, 201, 2437, 1, 0, 0, 0, 203, 2440, 1, 0, 0, 0, 205, 2449, 1, 0, 0, 0, 207, 2454, 1, 0, 0, 0, 209, 2460, 1, 0, 0, 0, 211, 2467, 1, 0, 0, 0, 213, 2472, 1, 0, 0, 0, 215, 2478, 1, 0, 0, 0, 217, 2487, 1, 0, 0, 0, 219, 2492, 1, 0, 0, 0, 221, 2498, 1, 0, 0, 0, 223, 2505, 1, 0, 0, 0, 225, 2510, 1, 0, 0, 0, 227, 2524, 1, 0, 0, 0, 229, 2531, 1, 0, 0, 0, 231, 2539, 1, 0, 0, 0, 233, 2549, 1, 0, 0, 0, 235, 2562, 1, 0, 0, 0, 237, 2568, 1, 0, 0, 0, 239, 2583, 1, 0, 0, 0, 241, 2590, 1, 0, 0, 0, 243, 2595, 1, 0, 0, 0, 245, 2601, 1, 0, 0, 0, 247, 2607, 1, 0, 0, 0, 249, 2610, 1, 0, 0, 0, 251, 2617, 1, 0, 0, 0, 253, 2622, 1, 0, 0, 0, 255, 2627, 1, 0, 0, 0, 257, 2632, 1, 0, 0, 0, 259, 2640, 1, 0, 0, 0, 261, 2648, 1, 0, 0, 0, 263, 2654, 1, 0, 0, 0, 265, 2659, 1, 0, 0, 0, 267, 2668, 1, 0, 0, 0, 269, 2674, 1, 0, 0, 0, 271, 2682, 1, 0, 0, 0, 273, 2690, 1, 0, 0, 0, 275, 2696, 1, 0, 0, 0, 277, 2705, 1, 0, 0, 0, 279, 2712, 1, 0, 0, 0, 281, 2719, 1, 0, 0, 0, 283, 2723, 1, 0, 0, 0, 285, 2729, 1, 0, 0, 0, 287, 2735, 1, 0, 0, 0, 289, 2745, 1, 0, 0, 0, 291, 2750, 1, 0, 0, 0, 293, 2756, 1, 0, 0, 0, 295, 2763, 1, 0, 0, 0, 297, 2773, 1, 0, 0, 0, 299, 2784, 1, 0, 0, 0, 301, 2787, 1, 0, 0, 0, 303, 2797, 1, 0, 0, 0, 305, 2806, 1, 0, 0, 0, 307, 2813, 1, 0, 0, 0, 309, 2819, 1, 0, 0, 0, 311, 2822, 1, 0, 0, 0, 313, 2828, 1, 0, 0, 0, 315, 2835, 1, 0, 0, 0, 317, 2843, 1, 0, 0, 0, 319, 2852, 1, 0, 0, 0, 321, 2860, 1, 0, 0, 0, 323, 2866, 1, 0, 0, 0, 325, 2882, 1, 0, 0, 0, 327, 2893, 1, 0, 0, 0, 329, 2899, 1, 0, 0, 0, 331, 2905, 1, 0, 0, 0, 333, 2913, 1, 0, 0, 0, 335, 2921, 1, 0, 0, 0, 337, 2930, 1, 0, 0, 0, 339, 2937, 1, 0, 0, 0, 341, 2947, 1, 0, 0, 0, 343, 2961, 1, 0, 0, 0, 345, 2972, 1, 0, 0, 0, 347, 2984, 1, 0, 0, 0, 349, 2992, 1, 0, 0, 0, 351, 3001, 1, 0, 0, 0, 353, 3012, 1, 0, 0, 0, 355, 3017, 1, 0, 0, 0, 357, 3022, 1, 0, 0, 0, 359, 3026, 1, 0, 0, 0, 361, 3031, 1, 0, 0, 0, 363, 3038, 1, 0, 0, 0, 365, 3044, 1, 0, 0, 0, 367, 3049, 1, 0, 0, 0, 369, 3062, 1, 0, 0, 0, 371, 3071, 1, 0, 0, 0, 373, 3075, 1, 0, 0, 0, 375, 3086, 1, 0, 0, 0, 377, 3094, 1, 0, 0, 0, 379, 3103, 1, 0, 0, 0, 381, 3112, 1, 0, 0, 0, 383, 3120, 1, 0, 0, 0, 385, 3127, 1, 0, 0, 0, 387, 3137, 1, 0, 0, 0, 389, 3148, 1, 0, 0, 0, 391, 3159, 1, 0, 0, 0, 393, 3167, 1, 0, 0, 0, 395, 3175, 1, 0, 0, 0, 397, 3184, 1, 0, 0, 0, 399, 3191, 1, 0, 0, 0, 401, 3198, 1, 0, 0, 0, 403, 3203, 1, 0, 0, 0, 405, 3208, 1, 0, 0, 0, 407, 3215, 1, 0, 0, 0, 409, 3224, 1, 0, 0, 0, 411, 3234, 1, 0, 0, 0, 413, 3239, 1, 0, 0, 0, 415, 3246, 1, 0, 0, 0, 417, 3252, 1, 0, 0, 0, 419, 3260, 1, 0, 0, 0, 421, 3270, 1, 0, 0, 0, 423, 3280, 1, 0, 0, 0, 425, 3288, 1, 0, 0, 0, 427, 3296, 1, 0, 0, 0, 429, 3306, 1, 0, 0, 0, 431, 3315, 1, 0, 0, 0, 433, 3322, 1, 0, 0, 0, 435, 3328, 1, 0, 0, 0, 437, 3338, 1, 0, 0, 0, 439, 3344, 1, 0, 0, 0, 441, 3352, 1, 0, 0, 0, 443, 3361, 1, 0, 0, 0, 445, 3371, 1, 0, 0, 0, 447, 3378, 1, 0, 0, 0, 449, 3386, 1, 0, 0, 0, 451, 3394, 1, 0, 0, 0, 453, 3401, 1, 0, 0, 0, 455, 3406, 1, 0, 0, 0, 457, 3411, 1, 0, 0, 0, 459, 3420, 1, 0, 0, 0, 461, 3423, 1, 0, 0, 0, 463, 3433, 1, 0, 0, 0, 465, 3443, 1, 0, 0, 0, 467, 3452, 1, 0, 0, 0, 469, 3462, 1, 0, 0, 0, 471, 3472, 1, 0, 0, 0, 473, 3478, 1, 0, 0, 0, 475, 3486, 1, 0, 0, 0, 477, 3494, 1, 0, 0, 0, 479, 3503, 1, 0, 0, 0, 481, 3510, 1, 0, 0, 0, 483, 3522, 1, 0, 0, 0, 485, 3529, 1, 0, 0, 0, 487, 3537, 1, 0, 0, 0, 489, 3545, 1, 0, 0, 0, 491, 3555, 1, 0, 0, 0, 493, 3559, 1, 0, 0, 0, 495, 3565, 1, 0, 0, 0, 497, 3574, 1, 0, 0, 0, 499, 3580, 1, 0, 0, 0, 501, 3585, 1, 0, 0, 0, 503, 3595, 1, 0, 0, 0, 505, 3601, 1, 0, 0, 0, 507, 3608, 1, 0, 0, 0, 509, 3613, 1, 0, 0, 0, 511, 3619, 1, 0, 0, 0, 513, 3628, 1, 0, 0, 0, 515, 3633, 1, 0, 0, 0, 517, 3641, 1, 0, 0, 0, 519, 3647, 1, 0, 0, 0, 521, 3655, 1, 0, 0, 0, 523, 3668, 1, 0, 0, 0, 525, 3677, 1, 0, 0, 0, 527, 3683, 1, 0, 0, 0, 529, 3690, 1, 0, 0, 0, 531, 3699, 1, 0, 0, 0, 533, 3704, 1, 0, 0, 0, 535, 3710, 1, 0, 0, 0, 537, 3715, 1, 0, 0, 0, 539, 3720, 1, 0, 0, 0, 541, 3726, 1, 0, 0, 0, 543, 3731, 1, 0, 0, 0, 545, 3734, 1, 0, 0, 0, 547, 3742, 1, 0, 0, 0, 549, 3749, 1, 0, 0, 0, 551, 3756, 1, 0, 0, 0, 553, 3762, 1, 0, 0, 0, 555, 3769, 1, 0, 0, 0, 557, 3772, 1, 0, 0, 0, 559, 3776, 1, 0, 0, 0, 561, 3781, 1, 0, 0, 0, 563, 3790, 1, 0, 0, 0, 565, 3797, 1, 0, 0, 0, 567, 3805, 1, 0, 0, 0, 569, 3811, 1, 0, 0, 0, 571, 3817, 1, 0, 0, 0, 573, 3824, 1, 0, 0, 0, 575, 3832, 1, 0, 0, 0, 577, 3842, 1, 0, 0, 0, 579, 3850, 1, 0, 0, 0, 581, 3859, 1, 0, 0, 0, 583, 3865, 1, 0, 0, 0, 585, 3875, 1, 0, 0, 0, 587, 3885, 1, 0, 0, 0, 589, 3893, 1, 0, 0, 0, 591, 3902, 1, 0, 0, 0, 593, 3911, 1, 0, 0, 0, 595, 3917, 1, 0, 0, 0, 597, 3928, 1, 0, 0, 0, 599, 3939, 1, 0, 0, 0, 601, 3949, 1, 0, 0, 0, 603, 3957, 1, 0, 0, 0, 605, 3963, 1, 0, 0, 0, 607, 3969, 1, 0, 0, 0, 609, 3974, 1, 0, 0, 0, 611, 3983, 1, 0, 0, 0, 613, 3991, 1, 0, 0, 0, 615, 4001, 1, 0, 0, 0, 617, 4005, 1, 0, 0, 0, 619, 4013, 1, 0, 0, 0, 621, 4021, 1, 0, 0, 0, 623, 4030, 1, 0, 0, 0, 625, 4038, 1, 0, 0, 0, 627, 4045, 1, 0, 0, 0, 629, 4056, 1, 0, 0, 0, 631, 4064, 1, 0, 0, 0, 633, 4072, 1, 0, 0, 0, 635, 4078, 1, 0, 0, 0, 637, 4086, 1, 0, 0, 0, 639, 4095, 1, 0, 0, 0, 641, 4103, 1, 0, 0, 0, 643, 4110, 1, 0, 0, 0, 645, 4115, 1, 0, 0, 0, 647, 4124, 1, 0, 0, 0, 649, 4129, 1, 0, 0, 0, 651, 4134, 1, 0, 0, 0, 653, 4144, 1, 0, 0, 0, 655, 4151, 1, 0, 0, 0, 657, 4158, 1, 0, 0, 0, 659, 4165, 1, 0, 0, 0, 661, 4172, 1, 0, 0, 0, 663, 4181, 1, 0, 0, 0, 665, 4190, 1, 0, 0, 0, 667, 4200, 1, 0, 0, 0, 669, 4213, 1, 0, 0, 0, 671, 4220, 1, 0, 0, 0, 673, 4228, 1, 0, 0, 0, 675, 4232, 1, 0, 0, 0, 677, 4238, 1, 0, 0, 0, 679, 4243, 1, 0, 0, 0, 681, 4250, 1, 0, 0, 0, 683, 4259, 1, 0, 0, 0, 685, 4266, 1, 0, 0, 0, 687, 4277, 1, 0, 0, 0, 689, 4283, 1, 0, 0, 0, 691, 4293, 1, 0, 0, 0, 693, 4304, 1, 0, 0, 0, 695, 4310, 1, 0, 0, 0, 697, 4317, 1, 0, 0, 0, 699, 4325, 1, 0, 0, 0, 701, 4332, 1, 0, 0, 0, 703, 4338, 1, 0, 0, 0, 705, 4344, 1, 0, 0, 0, 707, 4351, 1, 0, 0, 0, 709, 4358, 1, 0, 0, 0, 711, 4369, 1, 0, 0, 0, 713, 4374, 1, 0, 0, 0, 715, 4383, 1, 0, 0, 0, 717, 4393, 1, 0, 0, 0, 719, 4398, 1, 0, 0, 0, 721, 4410, 1, 0, 0, 0, 723, 4418, 1, 0, 0, 0, 725, 4427, 1, 0, 0, 0, 727, 4435, 1, 0, 0, 0, 729, 4440, 1, 0, 0, 0, 731, 4446, 1, 0, 0, 0, 733, 4456, 1, 0, 0, 0, 735, 4468, 1, 0, 0, 0, 737, 4480, 1, 0, 0, 0, 739, 4488, 1, 0, 0, 0, 741, 4497, 1, 0, 0, 0, 743, 4506, 1, 0, 0, 0, 745, 4512, 1, 0, 0, 0, 747, 4519, 1, 0, 0, 0, 749, 4526, 1, 0, 0, 0, 751, 4532, 1, 0, 0, 0, 753, 4541, 1, 0, 0, 0, 755, 4551, 1, 0, 0, 0, 757, 4559, 1, 0, 0, 0, 759, 4567, 1, 0, 0, 0, 761, 4572, 1, 0, 0, 0, 763, 4581, 1, 0, 0, 0, 765, 4592, 1, 0, 0, 0, 767, 4600, 1, 0, 0, 0, 769, 4605, 1, 0, 0, 0, 771, 4613, 1, 0, 0, 0, 773, 4619, 1, 0, 0, 0, 775, 4623, 1, 0, 0, 0, 777, 4628, 1, 0, 0, 0, 779, 4632, 1, 0, 0, 0, 781, 4637, 1, 0, 0, 0, 783, 4645, 1, 0, 0, 0, 785, 4653, 1, 0, 0, 0, 787, 4657, 1, 0, 0, 0, 789, 4665, 1, 0, 0, 0, 791, 4675, 1, 0, 0, 0, 793, 4687, 1, 0, 0, 0, 795, 4698, 1, 0, 0, 0, 797, 4708, 1, 0, 0, 0, 799, 4713, 1, 0, 0, 0, 801, 4730, 1, 0, 0, 0, 803, 4741, 1, 0, 0, 0, 805, 4750, 1, 0, 0, 0, 807, 4763, 1, 0, 0, 0, 809, 4774, 1, 0, 0, 0, 811, 4779, 1, 0, 0, 0, 813, 4789, 1, 0, 0, 0, 815, 4793, 1, 0, 0, 0, 817, 4802, 1, 0, 0, 0, 819, 4808, 1, 0, 0, 0, 821, 4819, 1, 0, 0, 0, 823, 4827, 1, 0, 0, 0, 825, 4833, 1, 0, 0, 0, 827, 4837, 1, 0, 0, 0, 829, 4852, 1, 0, 0, 0, 831, 4871, 1, 0, 0, 0, 833, 4879, 1, 0, 0, 0, 835, 4884, 1, 0, 0, 0, 837, 4892, 1, 0, 0, 0, 839, 4896, 1, 0, 0, 0, 841, 4905, 1, 0, 0, 0, 843, 4914, 1, 0, 0, 0, 845, 4924, 1, 0, 0, 0, 847, 4930, 1, 0, 0, 0, 849, 4937, 1, 0, 0, 0, 851, 4947, 1, 0, 0, 0, 853, 4952, 1, 0, 0, 0, 855, 4963, 1, 0, 0, 0, 857, 4976, 1, 0, 0, 0, 859, 4986, 1, 0, 0, 0, 861, 5000, 1, 0, 0, 0, 863, 5016, 1, 0, 0, 0, 865, 5024, 1, 0, 0, 0, 867, 5028, 1, 0, 0, 0, 869, 5043, 1, 0, 0, 0, 871, 5050, 1, 0, 0, 0, 873, 5059, 1, 0, 0, 0, 875, 5070, 1, 0, 0, 0, 877, 5092, 1, 0, 0, 0, 879, 5118, 1, 0, 0, 0, 881, 5128, 1, 0, 0, 0, 883, 5133, 1, 0, 0, 0, 885, 5144, 1, 0, 0, 0, 887, 5163, 1, 0, 0, 0, 889, 5173, 1, 0, 0, 0, 891, 5185, 1, 0, 0, 0, 893, 5193, 1, 0, 0, 0, 895, 5203, 1, 0, 0, 0, 897, 5215, 1, 0, 0, 0, 899, 5230, 1, 0, 0, 0, 901, 5237, 1, 0, 0, 0, 903, 5246, 1, 0, 0, 0, 905, 5256, 1, 0, 0, 0, 907, 5271, 1, 0, 0, 0, 909, 5281, 1, 0, 0, 0, 911, 5293, 1, 0, 0, 0, 913, 5306, 1, 0, 0, 0, 915, 5312, 1, 0, 0, 0, 917, 5317, 1, 0, 0, 0, 919, 5322, 1, 0, 0, 0, 921, 5332, 1, 0, 0, 0, 923, 5343, 1, 0, 0, 0, 925, 5350, 1, 0, 0, 0, 927, 5354, 1, 0, 0, 0, 929, 5361, 1, 0, 0, 0, 931, 5383, 1, 0, 0, 0, 933, 5407, 1, 0, 0, 0, 935, 5419, 1, 0, 0, 0, 937, 5427, 1, 0, 0, 0, 939, 5434, 1, 0, 0, 0, 941, 5437, 1, 0, 0, 0, 943, 5440, 1, 0, 0, 0, 945, 5448, 1, 0, 0, 0, 947, 5458, 1, 0, 0, 0, 949, 5467, 1, 0, 0, 0, 951, 5477, 1, 0, 0, 0, 953, 5487, 1, 0, 0, 0, 955, 5491, 1, 0, 0, 0, 957, 5498, 1, 0, 0, 0, 959, 5509, 1, 0, 0, 0, 961, 5517, 1, 0, 0, 0, 963, 5526, 1, 0, 0, 0, 965, 5533, 1, 0, 0, 0, 967, 5540, 1, 0, 0, 0, 969, 5553, 1, 0, 0, 0, 971, 5567, 1, 0, 0, 0, 973, 5571, 1, 0, 0, 0, 975, 5579, 1, 0, 0, 0, 977, 5585, 1, 0, 0, 0, 979, 5588, 1, 0, 0, 0, 981, 5591, 1, 0, 0, 0, 983, 5601, 1, 0, 0, 0, 985, 5612, 1, 0, 0, 0, 987, 5624, 1, 0, 0, 0, 989, 5635, 1, 0, 0, 0, 991, 5648, 1, 0, 0, 0, 993, 5655, 1, 0, 0, 0, 995, 5660, 1, 0, 0, 0, 997, 5669, 1, 0, 0, 0, 999, 5673, 1, 0, 0, 0, 1001, 5682, 1, 0, 0, 0, 1003, 5693, 1, 0, 0, 0, 1005, 5704, 1, 0, 0, 0, 1007, 5714, 1, 0, 0, 0, 1009, 5725, 1, 0, 0, 0, 1011, 5733, 1, 0, 0, 0, 1013, 5740, 1, 0, 0, 0, 1015, 5752, 1, 0, 0, 0, 1017, 5765, 1, 0, 0, 0, 1019, 5776, 1, 0, 0, 0, 1021, 5792, 1, 0, 0, 0, 1023, 5810, 1, 0, 0, 0, 1025, 5819, 1, 0, 0, 0, 1027, 5832, 1, 0, 0, 0, 1029, 5850, 1, 0, 0, 0, 1031, 5864, 1, 0, 0, 0, 1033, 5877, 1, 0, 0, 0, 1035, 5893, 1, 0, 0, 0, 1037, 5904, 1, 0, 0, 0, 1039, 5909, 1, 0, 0, 0, 1041, 5916, 1, 0, 0, 0, 1043, 5929, 1, 0, 0, 0, 1045, 5938, 1, 0, 0, 0, 1047, 5942, 1, 0, 0, 0, 1049, 5946, 1, 0, 0, 0, 1051, 5953, 1, 0, 0, 0, 1053, 5964, 1, 0, 0, 0, 1055, 5972, 1, 0, 0, 0, 1057, 5977, 1, 0, 0, 0, 1059, 5990, 1, 0, 0, 0, 1061, 6006, 1, 0, 0, 0, 1063, 6017, 1, 0, 0, 0, 1065, 6030, 1, 0, 0, 0, 1067, 6042, 1, 0, 0, 0, 1069, 6051, 1, 0, 0, 0, 1071, 6062, 1, 0, 0, 0, 1073, 6073, 1, 0, 0, 0, 1075, 6088, 1, 0, 0, 0, 1077, 6102, 1, 0, 0, 0, 1079, 6115, 1, 0, 0, 0, 1081, 6132, 1, 0, 0, 0, 1083, 6143, 1, 0, 0, 0, 1085, 6154, 1, 0, 0, 0, 1087, 6167, 1, 0, 0, 0, 1089, 6177, 1, 0, 0, 0, 1091, 6185, 1, 0, 0, 0, 1093, 6196, 1, 0, 0, 0, 1095, 6203, 1, 0, 0, 0, 1097, 6217, 1, 0, 0, 0, 1099, 6235, 1, 0, 0, 0, 1101, 6249, 1, 0, 0, 0, 1103, 6256, 1, 0, 0, 0, 1105, 6265, 1, 0, 0, 0, 1107, 6279, 1, 0, 0, 0, 1109, 6286, 1, 0, 0, 0, 1111, 6294, 1, 0, 0, 0, 1113, 6301, 1, 0, 0, 0, 1115, 6305, 1, 0, 0, 0, 1117, 6313, 1, 0, 0, 0, 1119, 6318, 1, 0, 0, 0, 1121, 6328, 1, 0, 0, 0, 1123, 6337, 1, 0, 0, 0, 1125, 6341, 1, 0, 0, 0, 1127, 6349, 1, 0, 0, 0, 1129, 6356, 1, 0, 0, 0, 1131, 6364, 1, 0, 0, 0, 1133, 6370, 1, 0, 0, 0, 1135, 6379, 1, 0, 0, 0, 1137, 6385, 1, 0, 0, 0, 1139, 6389, 1, 0, 0, 0, 1141, 6397, 1, 0, 0, 0, 1143, 6406, 1, 0, 0, 0, 1145, 6412, 1, 0, 0, 0, 1147, 6421, 1, 0, 0, 0, 1149, 6427, 1, 0, 0, 0, 1151, 6432, 1, 0, 0, 0, 1153, 6439, 1, 0, 0, 0, 1155, 6447, 1, 0, 0, 0, 1157, 6455, 1, 0, 0, 0, 1159, 6465, 1, 0, 0, 0, 1161, 6474, 1, 0, 0, 0, 1163, 6484, 1, 0, 0, 0, 1165, 6489, 1, 0, 0, 0, 1167, 6493, 1, 0, 0, 0, 1169, 6499, 1, 0, 0, 0, 1171, 6508, 1, 0, 0, 0, 1173, 6518, 1, 0, 0, 0, 1175, 6523, 1, 0, 0, 0, 1177, 6533, 1, 0, 0, 0, 1179, 6539, 1, 0, 0, 0, 1181, 6544, 1, 0, 0, 0, 1183, 6551, 1, 0, 0, 0, 1185, 6559, 1, 0, 0, 0, 1187, 6573, 1, 0, 0, 0, 1189, 6584, 1, 0, 0, 0, 1191, 6591, 1, 0, 0, 0, 1193, 6610, 1, 0, 0, 0, 1195, 6638, 1, 0, 0, 0, 1197, 6665, 1, 0, 0, 0, 1199, 6671, 1, 0, 0, 0, 1201, 6684, 1, 0, 0, 0, 1203, 6694, 1, 0, 0, 0, 1205, 6705, 1, 0, 0, 0, 1207, 6715, 1, 0, 0, 0, 1209, 6725, 1, 0, 0, 0, 1211, 6734, 1, 0, 0, 0, 1213, 6740, 1, 0, 0, 0, 1215, 6748, 1, 0, 0, 0, 1217, 6761, 1, 0, 0, 0, 1219, 6766, 1, 0, 0, 0, 1221, 6774, 1, 0, 0, 0, 1223, 6781, 1, 0, 0, 0, 1225, 6788, 1, 0, 0, 0, 1227, 6799, 1, 0, 0, 0, 1229, 6809, 1, 0, 0, 0, 1231, 6816, 1, 0, 0, 0, 1233, 6823, 1, 0, 0, 0, 1235, 6829, 1, 0, 0, 0, 1237, 6845, 1, 0, 0, 0, 1239, 6857, 1, 0, 0, 0, 1241, 6870, 1, 0, 0, 0, 1243, 6877, 1, 0, 0, 0, 1245, 6888, 1, 0, 0, 0, 1247, 6894, 1, 0, 0, 0, 1249, 6905, 1, 0, 0, 0, 1251, 6913, 1, 0, 0, 0, 1253, 6921, 1, 0, 0, 0, 1255, 6927, 1, 0, 0, 0, 1257, 6932, 1, 0, 0, 0, 1259, 6944, 1, 0, 0, 0, 1261, 6951, 1, 0, 0, 0, 1263, 6955, 1, 0, 0, 0, 1265, 6962, 1, 0, 0, 0, 1267, 6972, 1, 0, 0, 0, 1269, 6978, 1, 0, 0, 0, 1271, 6985, 1, 0, 0, 0, 1273, 6995, 1, 0, 0, 0, 1275, 6999, 1, 0, 0, 0, 1277, 7004, 1, 0, 0, 0, 1279, 7008, 1, 0, 0, 0, 1281, 7019, 1, 0, 0, 0, 1283, 7033, 1, 0, 0, 0, 1285, 7048, 1, 0, 0, 0, 1287, 7066, 1, 0, 0, 0, 1289, 7069, 1, 0, 0, 0, 1291, 7077, 1, 0, 0, 0, 1293, 7085, 1, 0, 0, 0, 1295, 7095, 1, 0, 0, 0, 1297, 7102, 1, 0, 0, 0, 1299, 7109, 1, 0, 0, 0, 1301, 7118, 1, 0, 0, 0, 1303, 7125, 1, 0, 0, 0, 1305, 7137, 1, 0, 0, 0, 1307, 7141, 1, 0, 0, 0, 1309, 7145, 1, 0, 0, 0, 1311, 7151, 1, 0, 0, 0, 1313, 7164, 1, 0, 0, 0, 1315, 7176, 1, 0, 0, 0, 1317, 7180, 1, 0, 0, 0, 1319, 7184, 1, 0, 0, 0, 1321, 7193, 1, 0, 0, 0, 1323, 7201, 1, 0, 0, 0, 1325, 7212, 1, 0, 0, 0, 1327, 7218, 1, 0, 0, 0, 1329, 7226, 1, 0, 0, 0, 1331, 7235, 1, 0, 0, 0, 1333, 7239, 1, 0, 0, 0, 1335, 7247, 1, 0, 0, 0, 1337, 7258, 1, 0, 0, 0, 1339, 7267, 1, 0, 0, 0, 1341, 7272, 1, 0, 0, 0, 1343, 7279, 1, 0, 0, 0, 1345, 7284, 1, 0, 0, 0, 1347, 7291, 1, 0, 0, 0, 1349, 7296, 1, 0, 0, 0, 1351, 7305, 1, 0, 0, 0, 1353, 7310, 1, 0, 0, 0, 1355, 7322, 1, 0, 0, 0, 1357, 7333, 1, 0, 0, 0, 1359, 7342, 1, 0, 0, 0, 1361, 7350, 1, 0, 0, 0, 1363, 7364, 1, 0, 0, 0, 1365, 7372, 1, 0, 0, 0, 1367, 7383, 1, 0, 0, 0, 1369, 7390, 1, 0, 0, 0, 1371, 7397, 1, 0, 0, 0, 1373, 7404, 1, 0, 0, 0, 1375, 7411, 1, 0, 0, 0, 1377, 7415, 1, 0, 0, 0, 1379, 7419, 1, 0, 0, 0, 1381, 7424, 1, 0, 0, 0, 1383, 7429, 1, 0, 0, 0, 1385, 7437, 1, 0, 0, 0, 1387, 7443, 1, 0, 0, 0, 1389, 7453, 1, 0, 0, 0, 1391, 7458, 1, 0, 0, 0, 1393, 7478, 1, 0, 0, 0, 1395, 7496, 1, 0, 0, 0, 1397, 7502, 1, 0, 0, 0, 1399, 7515, 1, 0, 0, 0, 1401, 7526, 1, 0, 0, 0, 1403, 7532, 1, 0, 0, 0, 1405, 7541, 1, 0, 0, 0, 1407, 7549, 1, 0, 0, 0, 1409, 7553, 1, 0, 0, 0, 1411, 7565, 1, 0, 0, 0, 1413, 7573, 1, 0, 0, 0, 1415, 7579, 1, 0, 0, 0, 1417, 7585, 1, 0, 0, 0, 1419, 7593, 1, 0, 0, 0, 1421, 7601, 1, 0, 0, 0, 1423, 7607, 1, 0, 0, 0, 1425, 7612, 1, 0, 0, 0, 1427, 7619, 1, 0, 0, 0, 1429, 7625, 1, 0, 0, 0, 1431, 7631, 1, 0, 0, 0, 1433, 7640, 1, 0, 0, 0, 1435, 7646, 1, 0, 0, 0, 1437, 7650, 1, 0, 0, 0, 1439, 7655, 1, 0, 0, 0, 1441, 7662, 1, 0, 0, 0, 1443, 7670, 1, 0, 0, 0, 1445, 7680, 1, 0, 0, 0, 1447, 7687, 1, 0, 0, 0, 1449, 7692, 1, 0, 0, 0, 1451, 7697, 1, 0, 0, 0, 1453, 7701, 1, 0, 0, 0, 1455, 7706, 1, 0, 0, 0, 1457, 7711, 1, 0, 0, 0, 1459, 7719, 1, 0, 0, 0, 1461, 7727, 1, 0, 0, 0, 1463, 7731, 1, 0, 0, 0, 1465, 7735, 1, 0, 0, 0, 1467, 7745, 1, 0, 0, 0, 1469, 7751, 1, 0, 0, 0, 1471, 7755, 1, 0, 0, 0, 1473, 7759, 1, 0, 0, 0, 1475, 7762, 1, 0, 0, 0, 1477, 7768, 1, 0, 0, 0, 1479, 7778, 1, 0, 0, 0, 1481, 7782, 1, 0, 0, 0, 1483, 7785, 1, 0, 0, 0, 1485, 7791, 1, 0, 0, 0, 1487, 7799, 1, 0, 0, 0, 1489, 7805, 1, 0, 0, 0, 1491, 7811, 1, 0, 0, 0, 1493, 7816, 1, 0, 0, 0, 1495, 7821, 1, 0, 0, 0, 1497, 7832, 1, 0, 0, 0, 1499, 7838, 1, 0, 0, 0, 1501, 7851, 1, 0, 0, 0, 1503, 7858, 1, 0, 0, 0, 1505, 7866, 1, 0, 0, 0, 1507, 7871, 1, 0, 0, 0, 1509, 7877, 1, 0, 0, 0, 1511, 7882, 1, 0, 0, 0, 1513, 7888, 1, 0, 0, 0, 1515, 7893, 1, 0, 0, 0, 1517, 7899, 1, 0, 0, 0, 1519, 7905, 1, 0, 0, 0, 1521, 7912, 1, 0, 0, 0, 1523, 7916, 1, 0, 0, 0, 1525, 7921, 1, 0, 0, 0, 1527, 7925, 1, 0, 0, 0, 1529, 7930, 1, 0, 0, 0, 1531, 7934, 1, 0, 0, 0, 1533, 7939, 1, 0, 0, 0, 1535, 7943, 1, 0, 0, 0, 1537, 7948, 1, 0, 0, 0, 1539, 7953, 1, 0, 0, 0, 1541, 7958, 1, 0, 0, 0, 1543, 7963, 1, 0, 0, 0, 1545, 7969, 1, 0, 0, 0, 1547, 7975, 1, 0, 0, 0, 1549, 7981, 1, 0, 0, 0, 1551, 7992, 1, 0, 0, 0, 1553, 8004, 1, 0, 0, 0, 1555, 8021, 1, 0, 0, 0, 1557, 8027, 1, 0, 0, 0, 1559, 8040, 1, 0, 0, 0, 1561, 8046, 1, 0, 0, 0, 1563, 8052, 1, 0, 0, 0, 1565, 8058, 1, 0, 0, 0, 1567, 8062, 1, 0, 0, 0, 1569, 8069, 1, 0, 0, 0, 1571, 8079, 1, 0, 0, 0, 1573, 8086, 1, 0, 0, 0, 1575, 8094, 1, 0, 0, 0, 1577, 8101, 1, 0, 0, 0, 1579, 8106, 1, 0, 0, 0, 1581, 8112, 1, 0, 0, 0, 1583, 8116, 1, 0, 0, 0, 1585, 8128, 1, 0, 0, 0, 1587, 8147, 1, 0, 0, 0, 1589, 8159, 1, 0, 0, 0, 1591, 8173, 1, 0, 0, 0, 1593, 8188, 1, 0, 0, 0, 1595, 8201, 1, 0, 0, 0, 1597, 8214, 1, 0, 0, 0, 1599, 8226, 1, 0, 0, 0, 1601, 8239, 1, 0, 0, 0, 1603, 8254, 1, 0, 0, 0, 1605, 8269, 1, 0, 0, 0, 1607, 8291, 1, 0, 0, 0, 1609, 8313, 1, 0, 0, 0, 1611, 8327, 1, 0, 0, 0, 1613, 8334, 1, 0, 0, 0, 1615, 8339, 1, 0, 0, 0, 1617, 8345, 1, 0, 0, 0, 1619, 8356, 1, 0, 0, 0, 1621, 8368, 1, 0, 0, 0, 1623, 8384, 1, 0, 0, 0, 1625, 8400, 1, 0, 0, 0, 1627, 8407, 1, 0, 0, 0, 1629, 8414, 1, 0, 0, 0, 1631, 8423, 1, 0, 0, 0, 1633, 8430, 1, 0, 0, 0, 1635, 8440, 1, 0, 0, 0, 1637, 8447, 1, 0, 0, 0, 1639, 8451, 1, 0, 0, 0, 1641, 8467, 1, 0, 0, 0, 1643, 8476, 1, 0, 0, 0, 1645, 8486, 1, 0, 0, 0, 1647, 8497, 1, 0, 0, 0, 1649, 8506, 1, 0, 0, 0, 1651, 8519, 1, 0, 0, 0, 1653, 8533, 1, 0, 0, 0, 1655, 8550, 1, 0, 0, 0, 1657, 8560, 1, 0, 0, 0, 1659, 8574, 1, 0, 0, 0, 1661, 8584, 1, 0, 0, 0, 1663, 8599, 1, 0, 0, 0, 1665, 8616, 1, 0, 0, 0, 1667, 8620, 1, 0, 0, 0, 1669, 8640, 1, 0, 0, 0, 1671, 8650, 1, 0, 0, 0, 1673, 8672, 1, 0, 0, 0, 1675, 8685, 1, 0, 0, 0, 1677, 8693, 1, 0, 0, 0, 1679, 8701, 1, 0, 0, 0, 1681, 8711, 1, 0, 0, 0, 1683, 8718, 1, 0, 0, 0, 1685, 8726, 1, 0, 0, 0, 1687, 8734, 1, 0, 0, 0, 1689, 8744, 1, 0, 0, 0, 1691, 8751, 1, 0, 0, 0, 1693, 8760, 1, 0, 0, 0, 1695, 8772, 1, 0, 0, 0, 1697, 8777, 1, 0, 0, 0, 1699, 8792, 1, 0, 0, 0, 1701, 8798, 1, 0, 0, 0, 1703, 8801, 1, 0, 0, 0, 1705, 8807, 1, 0, 0, 0, 1707, 8817, 1, 0, 0, 0, 1709, 8822, 1, 0, 0, 0, 1711, 8830, 1, 0, 0, 0, 1713, 8847, 1, 0, 0, 0, 1715, 8854, 1, 0, 0, 0, 1717, 8857, 1, 0, 0, 0, 1719, 8867, 1, 0, 0, 0, 1721, 8871, 1, 0, 0, 0, 1723, 8875, 1, 0, 0, 0, 1725, 8877, 1, 0, 0, 0, 1727, 8880, 1, 0, 0, 0, 1729, 8889, 1, 0, 0, 0, 1731, 8892, 1, 0, 0, 0, 1733, 8901, 1, 0, 0, 0, 1735, 8905, 1, 0, 0, 0, 1737, 8909, 1, 0, 0, 0, 1739, 8913, 1, 0, 0, 0, 1741, 8917, 1, 0, 0, 0, 1743, 8920, 1, 0, 0, 0, 1745, 8929, 1, 0, 0, 0, 1747, 8935, 1, 0, 0, 0, 1749, 8938, 1, 0, 0, 0, 1751, 8942, 1, 0, 0, 0, 1753, 8951, 1, 0, 0, 0, 1755, 8958, 1, 0, 0, 0, 1757, 8961, 1, 0, 0, 0, 1759, 8969, 1, 0, 0, 0, 1761, 8972, 1, 0, 0, 0, 1763, 8975, 1, 0, 0, 0, 1765, 8978, 1, 0, 0, 0, 1767, 8986, 1, 0, 0, 0, 1769, 8989, 1, 0, 0, 0, 1771, 8992, 1, 0, 0, 0, 1773, 8994, 1, 0, 0, 0, 1775, 9028, 1, 0, 0, 0, 1777, 9031, 1, 0, 0, 0, 1779, 9035, 1, 0, 0, 0, 1781, 9043, 1, 0, 0, 0, 1783, 9058, 1, 0, 0, 0, 1785, 9067, 1, 0, 0, 0, 1787, 9071, 1, 0, 0, 0, 1789, 9082, 1, 0, 0, 0, 1791, 9121, 1, 0, 0, 0, 1793, 9172, 1, 0, 0, 0, 1795, 9196, 1, 0, 0, 0, 1797, 9199, 1, 0, 0, 0, 1799, 9201, 1, 0, 0, 0, 1801, 9206, 1, 0, 0, 0, 1803, 9237, 1, 0, 0, 0, 1805, 9240, 1, 0, 0, 0, 1807, 9245, 1, 0, 0, 0, 1809, 9258, 1, 0, 0, 0, 1811, 9261, 1, 0, 0, 0, 1813, 9266, 1, 0, 0, 0, 1815, 9272, 1, 0, 0, 0, 1817, 9277, 1, 0, 0, 0, 1819, 9282, 1, 0, 0, 0, 1821, 9287, 1, 0, 0, 0, 1823, 9292, 1, 0, 0, 0, 1825, 9309, 1, 0, 0, 0, 1827, 9311, 1, 0, 0, 0, 1829, 1830, 5, 36, 0, 0, 1830, 6, 1, 0, 0, 0, 1831, 1832, 5, 40, 0, 0, 1832, 8, 1, 0, 0, 0, 1833, 1834, 5, 41, 0, 0, 1834, 10, 1, 0, 0, 0, 1835, 1836, 5, 91, 0, 0, 1836, 12, 1, 0, 0, 0, 1837, 1838, 5, 93, 0, 0, 1838, 14, 1, 0, 0, 0, 1839, 1840, 5, 44, 0, 0, 1840, 16, 1, 0, 0, 0, 1841, 1842, 5, 59, 0, 0, 1842, 18, 1, 0, 0, 0, 1843, 1844, 5, 58, 0, 0, 1844, 20, 1, 0, 0, 0, 1845, 1846, 5, 42, 0, 0, 1846, 22, 1, 0, 0, 0, 1847, 1848, 5, 61, 0, 0, 1848, 24, 1, 0, 0, 0, 1849, 1850, 5, 46, 0, 0, 1850, 26, 1, 0, 0, 0, 1851, 1852, 5, 43, 0, 0, 1852, 28, 1, 0, 0, 0, 1853, 1854, 5, 45, 0, 0, 1854, 30, 1, 0, 0, 0, 1855, 1856, 5, 47, 0, 0, 1856, 32, 1, 0, 0, 0, 1857, 1858, 5, 94, 0, 0, 1858, 34, 1, 0, 0, 0, 1859, 1860, 5, 60, 0, 0, 1860, 36, 1, 0, 0, 0, 1861, 1862, 5, 62, 0, 0, 1862, 38, 1, 0, 0, 0, 1863, 1864, 5, 60, 0, 0, 1864, 1865, 5, 60, 0, 0, 1865, 40, 1, 0, 0, 0, 1866, 1867, 5, 62, 0, 0, 1867, 1868, 5, 62, 0, 0, 1868, 42, 1, 0, 0, 0, 1869, 1870, 5, 58, 0, 0, 1870, 1871, 5, 61, 0, 0, 1871, 44, 1, 0, 0, 0, 1872, 1873, 5, 60, 0, 0, 1873, 1874, 5, 61, 0, 0, 1874, 46, 1, 0, 0, 0, 1875, 1876, 5, 61, 0, 0, 1876, 1877, 5, 62, 0, 0, 1877, 48, 1, 0, 0, 0, 1878, 1879, 5, 62, 0, 0, 1879, 1880, 5, 61, 0, 0, 1880, 50, 1, 0, 0, 0, 1881, 1882, 5, 46, 0, 0, 1882, 1883, 5, 46, 0, 0, 1883, 52, 1, 0, 0, 0, 1884, 1885, 5, 60, 0, 0, 1885, 1886, 5, 62, 0, 0, 1886, 54, 1, 0, 0, 0, 1887, 1888, 5, 58, 0, 0, 1888, 1889, 5, 58, 0, 0, 1889, 56, 1, 0, 0, 0, 1890, 1891, 5, 37, 0, 0, 1891, 58, 1, 0, 0, 0, 1892, 1894, 5, 36, 0, 0, 1893, 1895, 7, 0, 0, 0, 1894, 1893, 1, 0, 0, 0, 1895, 1896, 1, 0, 0, 0, 1896, 1894, 1, 0, 0, 0, 1896, 1897, 1, 0, 0, 0, 1897, 60, 1, 0, 0, 0, 1898, 1914, 3, 65, 30, 0, 1899, 1903, 5, 43, 0, 0, 1900, 1901, 5, 45, 0, 0, 1901, 1903, 4, 28, 0, 0, 1902, 1899, 1, 0, 0, 0, 1902, 1900, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 1902, 1, 0, 0, 0, 1904, 1905, 1, 0, 0, 0, 1905, 1909, 1, 0, 0, 0, 1906, 1910, 3, 65, 30, 0, 1907, 1908, 5, 47, 0, 0, 1908, 1910, 4, 28, 1, 0, 1909, 1906, 1, 0, 0, 0, 1909, 1907, 1, 0, 0, 0, 1910, 1914, 1, 0, 0, 0, 1911, 1912, 5, 47, 0, 0, 1912, 1914, 4, 28, 2, 0, 1913, 1898, 1, 0, 0, 0, 1913, 1902, 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1913, 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1919, 1, 0, 0, 0, 1917, 1919, 7, 1, 0, 0, 1918, 1913, 1, 0, 0, 0, 1918, 1917, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920, 1921, 6, 28, 0, 0, 1921, 62, 1, 0, 0, 0, 1922, 1928, 3, 67, 31, 0, 1923, 1924, 5, 45, 0, 0, 1924, 1928, 4, 29, 3, 0, 1925, 1926, 5, 47, 0, 0, 1926, 1928, 4, 29, 4, 0, 1927, 1922, 1, 0, 0, 0, 1927, 1923, 1, 0, 0, 0, 1927, 1925, 1, 0, 0, 0, 1928, 1931, 1, 0, 0, 0, 1929, 1927, 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, 1932, 1, 0, 0, 0, 1931, 1929, 1, 0, 0, 0, 1932, 1934, 3, 69, 32, 0, 1933, 1935, 3, 61, 28, 0, 1934, 1933, 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1939, 1, 0, 0, 0, 1936, 1940, 5, 43, 0, 0, 1937, 1938, 5, 45, 0, 0, 1938, 1940, 4, 29, 5, 0, 1939, 1936, 1, 0, 0, 0, 1939, 1937, 1, 0, 0, 0, 1940, 1941, 1, 0, 0, 0, 1941, 1939, 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1944, 6, 29, 1, 0, 1944, 64, 1, 0, 0, 0, 1945, 1946, 7, 2, 0, 0, 1946, 66, 1, 0, 0, 0, 1947, 1948, 7, 3, 0, 0, 1948, 68, 1, 0, 0, 0, 1949, 1950, 7, 4, 0, 0, 1950, 70, 1, 0, 0, 0, 1951, 1952, 7, 5, 0, 0, 1952, 1953, 7, 6, 0, 0, 1953, 1954, 7, 6, 0, 0, 1954, 72, 1, 0, 0, 0, 1955, 1956, 7, 5, 0, 0, 1956, 1957, 7, 7, 0, 0, 1957, 1958, 7, 5, 0, 0, 1958, 1959, 7, 6, 0, 0, 1959, 1960, 7, 8, 0, 0, 1960, 1961, 7, 9, 0, 0, 1961, 1962, 7, 10, 0, 0, 1962, 74, 1, 0, 0, 0, 1963, 1964, 7, 5, 0, 0, 1964, 1965, 7, 7, 0, 0, 1965, 1966, 7, 5, 0, 0, 1966, 1967, 7, 6, 0, 0, 1967, 1968, 7, 8, 0, 0, 1968, 1969, 7, 11, 0, 0, 1969, 1970, 7, 10, 0, 0, 1970, 76, 1, 0, 0, 0, 1971, 1972, 7, 5, 0, 0, 1972, 1973, 7, 7, 0, 0, 1973, 1974, 7, 12, 0, 0, 1974, 78, 1, 0, 0, 0, 1975, 1976, 7, 5, 0, 0, 1976, 1977, 7, 7, 0, 0, 1977, 1978, 7, 8, 0, 0, 1978, 80, 1, 0, 0, 0, 1979, 1980, 7, 5, 0, 0, 1980, 1981, 7, 13, 0, 0, 1981, 1982, 7, 13, 0, 0, 1982, 1983, 7, 5, 0, 0, 1983, 1984, 7, 8, 0, 0, 1984, 82, 1, 0, 0, 0, 1985, 1986, 7, 5, 0, 0, 1986, 1987, 7, 9, 0, 0, 1987, 84, 1, 0, 0, 0, 1988, 1989, 7, 5, 0, 0, 1989, 1990, 7, 9, 0, 0, 1990, 1991, 7, 14, 0, 0, 1991, 86, 1, 0, 0, 0, 1992, 1993, 7, 5, 0, 0, 1993, 1994, 7, 9, 0, 0, 1994, 1995, 7, 8, 0, 0, 1995, 1996, 7, 15, 0, 0, 1996, 1997, 7, 15, 0, 0, 1997, 1998, 7, 10, 0, 0, 1998, 1999, 7, 16, 0, 0, 1999, 2000, 7, 13, 0, 0, 2000, 2001, 7, 17, 0, 0, 2001, 2002, 7, 14, 0, 0, 2002, 88, 1, 0, 0, 0, 2003, 2004, 7, 18, 0, 0, 2004, 2005, 7, 19, 0, 0, 2005, 2006, 7, 16, 0, 0, 2006, 2007, 7, 20, 0, 0, 2007, 90, 1, 0, 0, 0, 2008, 2009, 7, 14, 0, 0, 2009, 2010, 7, 5, 0, 0, 2010, 2011, 7, 9, 0, 0, 2011, 2012, 7, 10, 0, 0, 2012, 92, 1, 0, 0, 0, 2013, 2014, 7, 14, 0, 0, 2014, 2015, 7, 5, 0, 0, 2015, 2016, 7, 9, 0, 0, 2016, 2017, 7, 16, 0, 0, 2017, 94, 1, 0, 0, 0, 2018, 2019, 7, 14, 0, 0, 2019, 2020, 7, 20, 0, 0, 2020, 2021, 7, 10, 0, 0, 2021, 2022, 7, 14, 0, 0, 2022, 2023, 7, 21, 0, 0, 2023, 96, 1, 0, 0, 0, 2024, 2025, 7, 14, 0, 0, 2025, 2026, 7, 19, 0, 0, 2026, 2027, 7, 6, 0, 0, 2027, 2028, 7, 6, 0, 0, 2028, 2029, 7, 5, 0, 0, 2029, 2030, 7, 16, 0, 0, 2030, 2031, 7, 10, 0, 0, 2031, 98, 1, 0, 0, 0, 2032, 2033, 7, 14, 0, 0, 2033, 2034, 7, 19, 0, 0, 2034, 2035, 7, 6, 0, 0, 2035, 2036, 7, 22, 0, 0, 2036, 2037, 7, 15, 0, 0, 2037, 2038, 7, 7, 0, 0, 2038, 100, 1, 0, 0, 0, 2039, 2040, 7, 14, 0, 0, 2040, 2041, 7, 19, 0, 0, 2041, 2042, 7, 7, 0, 0, 2042, 2043, 7, 9, 0, 0, 2043, 2044, 7, 16, 0, 0, 2044, 2045, 7, 13, 0, 0, 2045, 2046, 7, 5, 0, 0, 2046, 2047, 7, 17, 0, 0, 2047, 2048, 7, 7, 0, 0, 2048, 2049, 7, 16, 0, 0, 2049, 102, 1, 0, 0, 0, 2050, 2051, 7, 14, 0, 0, 2051, 2052, 7, 13, 0, 0, 2052, 2053, 7, 10, 0, 0, 2053, 2054, 7, 5, 0, 0, 2054, 2055, 7, 16, 0, 0, 2055, 2056, 7, 10, 0, 0, 2056, 104, 1, 0, 0, 0, 2057, 2058, 7, 14, 0, 0, 2058, 2059, 7, 22, 0, 0, 2059, 2060, 7, 13, 0, 0, 2060, 2061, 7, 13, 0, 0, 2061, 2062, 7, 10, 0, 0, 2062, 2063, 7, 7, 0, 0, 2063, 2064, 7, 16, 0, 0, 2064, 2065, 5, 95, 0, 0, 2065, 2066, 7, 14, 0, 0, 2066, 2067, 7, 5, 0, 0, 2067, 2068, 7, 16, 0, 0, 2068, 2069, 7, 5, 0, 0, 2069, 2070, 7, 6, 0, 0, 2070, 2071, 7, 19, 0, 0, 2071, 2072, 7, 23, 0, 0, 2072, 106, 1, 0, 0, 0, 2073, 2074, 7, 14, 0, 0, 2074, 2075, 7, 22, 0, 0, 2075, 2076, 7, 13, 0, 0, 2076, 2077, 7, 13, 0, 0, 2077, 2078, 7, 10, 0, 0, 2078, 2079, 7, 7, 0, 0, 2079, 2080, 7, 16, 0, 0, 2080, 2081, 5, 95, 0, 0, 2081, 2082, 7, 12, 0, 0, 2082, 2083, 7, 5, 0, 0, 2083, 2084, 7, 16, 0, 0, 2084, 2085, 7, 10, 0, 0, 2085, 108, 1, 0, 0, 0, 2086, 2087, 7, 14, 0, 0, 2087, 2088, 7, 22, 0, 0, 2088, 2089, 7, 13, 0, 0, 2089, 2090, 7, 13, 0, 0, 2090, 2091, 7, 10, 0, 0, 2091, 2092, 7, 7, 0, 0, 2092, 2093, 7, 16, 0, 0, 2093, 2094, 5, 95, 0, 0, 2094, 2095, 7, 13, 0, 0, 2095, 2096, 7, 19, 0, 0, 2096, 2097, 7, 6, 0, 0, 2097, 2098, 7, 10, 0, 0, 2098, 110, 1, 0, 0, 0, 2099, 2100, 7, 14, 0, 0, 2100, 2101, 7, 22, 0, 0, 2101, 2102, 7, 13, 0, 0, 2102, 2103, 7, 13, 0, 0, 2103, 2104, 7, 10, 0, 0, 2104, 2105, 7, 7, 0, 0, 2105, 2106, 7, 16, 0, 0, 2106, 2107, 5, 95, 0, 0, 2107, 2108, 7, 16, 0, 0, 2108, 2109, 7, 17, 0, 0, 2109, 2110, 7, 15, 0, 0, 2110, 2111, 7, 10, 0, 0, 2111, 112, 1, 0, 0, 0, 2112, 2113, 7, 14, 0, 0, 2113, 2114, 7, 22, 0, 0, 2114, 2115, 7, 13, 0, 0, 2115, 2116, 7, 13, 0, 0, 2116, 2117, 7, 10, 0, 0, 2117, 2118, 7, 7, 0, 0, 2118, 2119, 7, 16, 0, 0, 2119, 2120, 5, 95, 0, 0, 2120, 2121, 7, 16, 0, 0, 2121, 2122, 7, 17, 0, 0, 2122, 2123, 7, 15, 0, 0, 2123, 2124, 7, 10, 0, 0, 2124, 2125, 7, 9, 0, 0, 2125, 2126, 7, 16, 0, 0, 2126, 2127, 7, 5, 0, 0, 2127, 2128, 7, 15, 0, 0, 2128, 2129, 7, 24, 0, 0, 2129, 114, 1, 0, 0, 0, 2130, 2131, 7, 14, 0, 0, 2131, 2132, 7, 22, 0, 0, 2132, 2133, 7, 13, 0, 0, 2133, 2134, 7, 13, 0, 0, 2134, 2135, 7, 10, 0, 0, 2135, 2136, 7, 7, 0, 0, 2136, 2137, 7, 16, 0, 0, 2137, 2138, 5, 95, 0, 0, 2138, 2139, 7, 22, 0, 0, 2139, 2140, 7, 9, 0, 0, 2140, 2141, 7, 10, 0, 0, 2141, 2142, 7, 13, 0, 0, 2142, 116, 1, 0, 0, 0, 2143, 2144, 7, 12, 0, 0, 2144, 2145, 7, 10, 0, 0, 2145, 2146, 7, 25, 0, 0, 2146, 2147, 7, 5, 0, 0, 2147, 2148, 7, 22, 0, 0, 2148, 2149, 7, 6, 0, 0, 2149, 2150, 7, 16, 0, 0, 2150, 118, 1, 0, 0, 0, 2151, 2152, 7, 12, 0, 0, 2152, 2153, 7, 10, 0, 0, 2153, 2154, 7, 25, 0, 0, 2154, 2155, 7, 10, 0, 0, 2155, 2156, 7, 13, 0, 0, 2156, 2157, 7, 13, 0, 0, 2157, 2158, 7, 5, 0, 0, 2158, 2159, 7, 18, 0, 0, 2159, 2160, 7, 6, 0, 0, 2160, 2161, 7, 10, 0, 0, 2161, 120, 1, 0, 0, 0, 2162, 2163, 7, 12, 0, 0, 2163, 2164, 7, 10, 0, 0, 2164, 2165, 7, 9, 0, 0, 2165, 2166, 7, 14, 0, 0, 2166, 122, 1, 0, 0, 0, 2167, 2168, 7, 12, 0, 0, 2168, 2169, 7, 17, 0, 0, 2169, 2170, 7, 9, 0, 0, 2170, 2171, 7, 16, 0, 0, 2171, 2172, 7, 17, 0, 0, 2172, 2173, 7, 7, 0, 0, 2173, 2174, 7, 14, 0, 0, 2174, 2175, 7, 16, 0, 0, 2175, 124, 1, 0, 0, 0, 2176, 2177, 7, 12, 0, 0, 2177, 2178, 7, 19, 0, 0, 2178, 126, 1, 0, 0, 0, 2179, 2180, 7, 10, 0, 0, 2180, 2181, 7, 6, 0, 0, 2181, 2182, 7, 9, 0, 0, 2182, 2183, 7, 10, 0, 0, 2183, 128, 1, 0, 0, 0, 2184, 2185, 7, 10, 0, 0, 2185, 2186, 7, 26, 0, 0, 2186, 2187, 7, 14, 0, 0, 2187, 2188, 7, 10, 0, 0, 2188, 2189, 7, 24, 0, 0, 2189, 2190, 7, 16, 0, 0, 2190, 130, 1, 0, 0, 0, 2191, 2192, 7, 25, 0, 0, 2192, 2193, 7, 5, 0, 0, 2193, 2194, 7, 6, 0, 0, 2194, 2195, 7, 9, 0, 0, 2195, 2196, 7, 10, 0, 0, 2196, 132, 1, 0, 0, 0, 2197, 2198, 7, 25, 0, 0, 2198, 2199, 7, 10, 0, 0, 2199, 2200, 7, 16, 0, 0, 2200, 2201, 7, 14, 0, 0, 2201, 2202, 7, 20, 0, 0, 2202, 134, 1, 0, 0, 0, 2203, 2204, 7, 25, 0, 0, 2204, 2205, 7, 19, 0, 0, 2205, 2206, 7, 13, 0, 0, 2206, 136, 1, 0, 0, 0, 2207, 2208, 7, 25, 0, 0, 2208, 2209, 7, 19, 0, 0, 2209, 2210, 7, 13, 0, 0, 2210, 2211, 7, 10, 0, 0, 2211, 2212, 7, 17, 0, 0, 2212, 2213, 7, 23, 0, 0, 2213, 2214, 7, 7, 0, 0, 2214, 138, 1, 0, 0, 0, 2215, 2216, 7, 25, 0, 0, 2216, 2217, 7, 13, 0, 0, 2217, 2218, 7, 19, 0, 0, 2218, 2219, 7, 15, 0, 0, 2219, 140, 1, 0, 0, 0, 2220, 2221, 7, 23, 0, 0, 2221, 2222, 7, 13, 0, 0, 2222, 2223, 7, 5, 0, 0, 2223, 2224, 7, 7, 0, 0, 2224, 2225, 7, 16, 0, 0, 2225, 142, 1, 0, 0, 0, 2226, 2227, 7, 23, 0, 0, 2227, 2228, 7, 13, 0, 0, 2228, 2229, 7, 19, 0, 0, 2229, 2230, 7, 22, 0, 0, 2230, 2231, 7, 24, 0, 0, 2231, 144, 1, 0, 0, 0, 2232, 2233, 7, 20, 0, 0, 2233, 2234, 7, 5, 0, 0, 2234, 2235, 7, 27, 0, 0, 2235, 2236, 7, 17, 0, 0, 2236, 2237, 7, 7, 0, 0, 2237, 2238, 7, 23, 0, 0, 2238, 146, 1, 0, 0, 0, 2239, 2240, 7, 17, 0, 0, 2240, 2241, 7, 7, 0, 0, 2241, 148, 1, 0, 0, 0, 2242, 2243, 7, 17, 0, 0, 2243, 2244, 7, 7, 0, 0, 2244, 2245, 7, 17, 0, 0, 2245, 2246, 7, 16, 0, 0, 2246, 2247, 7, 17, 0, 0, 2247, 2248, 7, 5, 0, 0, 2248, 2249, 7, 6, 0, 0, 2249, 2250, 7, 6, 0, 0, 2250, 2251, 7, 8, 0, 0, 2251, 150, 1, 0, 0, 0, 2252, 2253, 7, 17, 0, 0, 2253, 2254, 7, 7, 0, 0, 2254, 2255, 7, 16, 0, 0, 2255, 2256, 7, 10, 0, 0, 2256, 2257, 7, 13, 0, 0, 2257, 2258, 7, 9, 0, 0, 2258, 2259, 7, 10, 0, 0, 2259, 2260, 7, 14, 0, 0, 2260, 2261, 7, 16, 0, 0, 2261, 152, 1, 0, 0, 0, 2262, 2263, 7, 17, 0, 0, 2263, 2264, 7, 7, 0, 0, 2264, 2265, 7, 16, 0, 0, 2265, 2266, 7, 19, 0, 0, 2266, 154, 1, 0, 0, 0, 2267, 2268, 7, 6, 0, 0, 2268, 2269, 7, 5, 0, 0, 2269, 2270, 7, 16, 0, 0, 2270, 2271, 7, 10, 0, 0, 2271, 2272, 7, 13, 0, 0, 2272, 2273, 7, 5, 0, 0, 2273, 2274, 7, 6, 0, 0, 2274, 156, 1, 0, 0, 0, 2275, 2276, 7, 6, 0, 0, 2276, 2277, 7, 10, 0, 0, 2277, 2278, 7, 5, 0, 0, 2278, 2279, 7, 12, 0, 0, 2279, 2280, 7, 17, 0, 0, 2280, 2281, 7, 7, 0, 0, 2281, 2282, 7, 23, 0, 0, 2282, 158, 1, 0, 0, 0, 2283, 2284, 7, 6, 0, 0, 2284, 2285, 7, 17, 0, 0, 2285, 2286, 7, 15, 0, 0, 2286, 2287, 7, 17, 0, 0, 2287, 2288, 7, 16, 0, 0, 2288, 160, 1, 0, 0, 0, 2289, 2290, 7, 6, 0, 0, 2290, 2291, 7, 19, 0, 0, 2291, 2292, 7, 14, 0, 0, 2292, 2293, 7, 5, 0, 0, 2293, 2294, 7, 6, 0, 0, 2294, 2295, 7, 16, 0, 0, 2295, 2296, 7, 17, 0, 0, 2296, 2297, 7, 15, 0, 0, 2297, 2298, 7, 10, 0, 0, 2298, 162, 1, 0, 0, 0, 2299, 2300, 7, 6, 0, 0, 2300, 2301, 7, 19, 0, 0, 2301, 2302, 7, 14, 0, 0, 2302, 2303, 7, 5, 0, 0, 2303, 2304, 7, 6, 0, 0, 2304, 2305, 7, 16, 0, 0, 2305, 2306, 7, 17, 0, 0, 2306, 2307, 7, 15, 0, 0, 2307, 2308, 7, 10, 0, 0, 2308, 2309, 7, 9, 0, 0, 2309, 2310, 7, 16, 0, 0, 2310, 2311, 7, 5, 0, 0, 2311, 2312, 7, 15, 0, 0, 2312, 2313, 7, 24, 0, 0, 2313, 164, 1, 0, 0, 0, 2314, 2315, 7, 7, 0, 0, 2315, 2316, 7, 19, 0, 0, 2316, 2317, 7, 16, 0, 0, 2317, 166, 1, 0, 0, 0, 2318, 2319, 7, 7, 0, 0, 2319, 2320, 7, 22, 0, 0, 2320, 2321, 7, 6, 0, 0, 2321, 2322, 7, 6, 0, 0, 2322, 168, 1, 0, 0, 0, 2323, 2324, 7, 19, 0, 0, 2324, 2325, 7, 25, 0, 0, 2325, 2326, 7, 25, 0, 0, 2326, 2327, 7, 9, 0, 0, 2327, 2328, 7, 10, 0, 0, 2328, 2329, 7, 16, 0, 0, 2329, 170, 1, 0, 0, 0, 2330, 2331, 7, 19, 0, 0, 2331, 2332, 7, 7, 0, 0, 2332, 172, 1, 0, 0, 0, 2333, 2334, 7, 19, 0, 0, 2334, 2335, 7, 7, 0, 0, 2335, 2336, 7, 6, 0, 0, 2336, 2337, 7, 8, 0, 0, 2337, 174, 1, 0, 0, 0, 2338, 2339, 7, 19, 0, 0, 2339, 2340, 7, 13, 0, 0, 2340, 176, 1, 0, 0, 0, 2341, 2342, 7, 19, 0, 0, 2342, 2343, 7, 13, 0, 0, 2343, 2344, 7, 12, 0, 0, 2344, 2345, 7, 10, 0, 0, 2345, 2346, 7, 13, 0, 0, 2346, 178, 1, 0, 0, 0, 2347, 2348, 7, 24, 0, 0, 2348, 2349, 7, 6, 0, 0, 2349, 2350, 7, 5, 0, 0, 2350, 2351, 7, 14, 0, 0, 2351, 2352, 7, 17, 0, 0, 2352, 2353, 7, 7, 0, 0, 2353, 2354, 7, 23, 0, 0, 2354, 180, 1, 0, 0, 0, 2355, 2356, 7, 24, 0, 0, 2356, 2357, 7, 13, 0, 0, 2357, 2358, 7, 17, 0, 0, 2358, 2359, 7, 15, 0, 0, 2359, 2360, 7, 5, 0, 0, 2360, 2361, 7, 13, 0, 0, 2361, 2362, 7, 8, 0, 0, 2362, 182, 1, 0, 0, 0, 2363, 2364, 7, 24, 0, 0, 2364, 2365, 7, 22, 0, 0, 2365, 2366, 7, 18, 0, 0, 2366, 2367, 7, 6, 0, 0, 2367, 2368, 7, 17, 0, 0, 2368, 2369, 7, 14, 0, 0, 2369, 184, 1, 0, 0, 0, 2370, 2371, 7, 13, 0, 0, 2371, 2372, 7, 10, 0, 0, 2372, 2373, 7, 25, 0, 0, 2373, 2374, 7, 10, 0, 0, 2374, 2375, 7, 13, 0, 0, 2375, 2376, 7, 10, 0, 0, 2376, 2377, 7, 7, 0, 0, 2377, 2378, 7, 14, 0, 0, 2378, 2379, 7, 10, 0, 0, 2379, 2380, 7, 9, 0, 0, 2380, 186, 1, 0, 0, 0, 2381, 2382, 7, 13, 0, 0, 2382, 2383, 7, 10, 0, 0, 2383, 2384, 7, 16, 0, 0, 2384, 2385, 7, 22, 0, 0, 2385, 2386, 7, 13, 0, 0, 2386, 2387, 7, 7, 0, 0, 2387, 2388, 7, 17, 0, 0, 2388, 2389, 7, 7, 0, 0, 2389, 2390, 7, 23, 0, 0, 2390, 188, 1, 0, 0, 0, 2391, 2392, 7, 9, 0, 0, 2392, 2393, 7, 10, 0, 0, 2393, 2394, 7, 6, 0, 0, 2394, 2395, 7, 10, 0, 0, 2395, 2396, 7, 14, 0, 0, 2396, 2397, 7, 16, 0, 0, 2397, 190, 1, 0, 0, 0, 2398, 2399, 7, 9, 0, 0, 2399, 2400, 7, 10, 0, 0, 2400, 2401, 7, 9, 0, 0, 2401, 2402, 7, 9, 0, 0, 2402, 2403, 7, 17, 0, 0, 2403, 2404, 7, 19, 0, 0, 2404, 2405, 7, 7, 0, 0, 2405, 2406, 5, 95, 0, 0, 2406, 2407, 7, 22, 0, 0, 2407, 2408, 7, 9, 0, 0, 2408, 2409, 7, 10, 0, 0, 2409, 2410, 7, 13, 0, 0, 2410, 192, 1, 0, 0, 0, 2411, 2412, 7, 9, 0, 0, 2412, 2413, 7, 19, 0, 0, 2413, 2414, 7, 15, 0, 0, 2414, 2415, 7, 10, 0, 0, 2415, 194, 1, 0, 0, 0, 2416, 2417, 7, 9, 0, 0, 2417, 2418, 7, 8, 0, 0, 2418, 2419, 7, 15, 0, 0, 2419, 2420, 7, 15, 0, 0, 2420, 2421, 7, 10, 0, 0, 2421, 2422, 7, 16, 0, 0, 2422, 2423, 7, 13, 0, 0, 2423, 2424, 7, 17, 0, 0, 2424, 2425, 7, 14, 0, 0, 2425, 196, 1, 0, 0, 0, 2426, 2427, 7, 16, 0, 0, 2427, 2428, 7, 5, 0, 0, 2428, 2429, 7, 18, 0, 0, 2429, 2430, 7, 6, 0, 0, 2430, 2431, 7, 10, 0, 0, 2431, 198, 1, 0, 0, 0, 2432, 2433, 7, 16, 0, 0, 2433, 2434, 7, 20, 0, 0, 2434, 2435, 7, 10, 0, 0, 2435, 2436, 7, 7, 0, 0, 2436, 200, 1, 0, 0, 0, 2437, 2438, 7, 16, 0, 0, 2438, 2439, 7, 19, 0, 0, 2439, 202, 1, 0, 0, 0, 2440, 2441, 7, 16, 0, 0, 2441, 2442, 7, 13, 0, 0, 2442, 2443, 7, 5, 0, 0, 2443, 2444, 7, 17, 0, 0, 2444, 2445, 7, 6, 0, 0, 2445, 2446, 7, 17, 0, 0, 2446, 2447, 7, 7, 0, 0, 2447, 2448, 7, 23, 0, 0, 2448, 204, 1, 0, 0, 0, 2449, 2450, 7, 16, 0, 0, 2450, 2451, 7, 13, 0, 0, 2451, 2452, 7, 22, 0, 0, 2452, 2453, 7, 10, 0, 0, 2453, 206, 1, 0, 0, 0, 2454, 2455, 7, 22, 0, 0, 2455, 2456, 7, 7, 0, 0, 2456, 2457, 7, 17, 0, 0, 2457, 2458, 7, 19, 0, 0, 2458, 2459, 7, 7, 0, 0, 2459, 208, 1, 0, 0, 0, 2460, 2461, 7, 22, 0, 0, 2461, 2462, 7, 7, 0, 0, 2462, 2463, 7, 17, 0, 0, 2463, 2464, 7, 28, 0, 0, 2464, 2465, 7, 22, 0, 0, 2465, 2466, 7, 10, 0, 0, 2466, 210, 1, 0, 0, 0, 2467, 2468, 7, 22, 0, 0, 2468, 2469, 7, 9, 0, 0, 2469, 2470, 7, 10, 0, 0, 2470, 2471, 7, 13, 0, 0, 2471, 212, 1, 0, 0, 0, 2472, 2473, 7, 22, 0, 0, 2473, 2474, 7, 9, 0, 0, 2474, 2475, 7, 17, 0, 0, 2475, 2476, 7, 7, 0, 0, 2476, 2477, 7, 23, 0, 0, 2477, 214, 1, 0, 0, 0, 2478, 2479, 7, 27, 0, 0, 2479, 2480, 7, 5, 0, 0, 2480, 2481, 7, 13, 0, 0, 2481, 2482, 7, 17, 0, 0, 2482, 2483, 7, 5, 0, 0, 2483, 2484, 7, 12, 0, 0, 2484, 2485, 7, 17, 0, 0, 2485, 2486, 7, 14, 0, 0, 2486, 216, 1, 0, 0, 0, 2487, 2488, 7, 29, 0, 0, 2488, 2489, 7, 20, 0, 0, 2489, 2490, 7, 10, 0, 0, 2490, 2491, 7, 7, 0, 0, 2491, 218, 1, 0, 0, 0, 2492, 2493, 7, 29, 0, 0, 2493, 2494, 7, 20, 0, 0, 2494, 2495, 7, 10, 0, 0, 2495, 2496, 7, 13, 0, 0, 2496, 2497, 7, 10, 0, 0, 2497, 220, 1, 0, 0, 0, 2498, 2499, 7, 29, 0, 0, 2499, 2500, 7, 17, 0, 0, 2500, 2501, 7, 7, 0, 0, 2501, 2502, 7, 12, 0, 0, 2502, 2503, 7, 19, 0, 0, 2503, 2504, 7, 29, 0, 0, 2504, 222, 1, 0, 0, 0, 2505, 2506, 7, 29, 0, 0, 2506, 2507, 7, 17, 0, 0, 2507, 2508, 7, 16, 0, 0, 2508, 2509, 7, 20, 0, 0, 2509, 224, 1, 0, 0, 0, 2510, 2511, 7, 5, 0, 0, 2511, 2512, 7, 22, 0, 0, 2512, 2513, 7, 16, 0, 0, 2513, 2514, 7, 20, 0, 0, 2514, 2515, 7, 19, 0, 0, 2515, 2516, 7, 13, 0, 0, 2516, 2517, 7, 17, 0, 0, 2517, 2518, 7, 11, 0, 0, 2518, 2519, 7, 5, 0, 0, 2519, 2520, 7, 16, 0, 0, 2520, 2521, 7, 17, 0, 0, 2521, 2522, 7, 19, 0, 0, 2522, 2523, 7, 7, 0, 0, 2523, 226, 1, 0, 0, 0, 2524, 2525, 7, 18, 0, 0, 2525, 2526, 7, 17, 0, 0, 2526, 2527, 7, 7, 0, 0, 2527, 2528, 7, 5, 0, 0, 2528, 2529, 7, 13, 0, 0, 2529, 2530, 7, 8, 0, 0, 2530, 228, 1, 0, 0, 0, 2531, 2532, 7, 18, 0, 0, 2532, 2533, 7, 17, 0, 0, 2533, 2534, 7, 7, 0, 0, 2534, 2535, 7, 12, 0, 0, 2535, 2536, 7, 17, 0, 0, 2536, 2537, 7, 7, 0, 0, 2537, 2538, 7, 23, 0, 0, 2538, 230, 1, 0, 0, 0, 2539, 2540, 7, 14, 0, 0, 2540, 2541, 7, 19, 0, 0, 2541, 2542, 7, 6, 0, 0, 2542, 2543, 7, 6, 0, 0, 2543, 2544, 7, 5, 0, 0, 2544, 2545, 7, 16, 0, 0, 2545, 2546, 7, 17, 0, 0, 2546, 2547, 7, 19, 0, 0, 2547, 2548, 7, 7, 0, 0, 2548, 232, 1, 0, 0, 0, 2549, 2550, 7, 14, 0, 0, 2550, 2551, 7, 19, 0, 0, 2551, 2552, 7, 7, 0, 0, 2552, 2553, 7, 14, 0, 0, 2553, 2554, 7, 22, 0, 0, 2554, 2555, 7, 13, 0, 0, 2555, 2556, 7, 13, 0, 0, 2556, 2557, 7, 10, 0, 0, 2557, 2558, 7, 7, 0, 0, 2558, 2559, 7, 16, 0, 0, 2559, 2560, 7, 6, 0, 0, 2560, 2561, 7, 8, 0, 0, 2561, 234, 1, 0, 0, 0, 2562, 2563, 7, 14, 0, 0, 2563, 2564, 7, 13, 0, 0, 2564, 2565, 7, 19, 0, 0, 2565, 2566, 7, 9, 0, 0, 2566, 2567, 7, 9, 0, 0, 2567, 236, 1, 0, 0, 0, 2568, 2569, 7, 14, 0, 0, 2569, 2570, 7, 22, 0, 0, 2570, 2571, 7, 13, 0, 0, 2571, 2572, 7, 13, 0, 0, 2572, 2573, 7, 10, 0, 0, 2573, 2574, 7, 7, 0, 0, 2574, 2575, 7, 16, 0, 0, 2575, 2576, 5, 95, 0, 0, 2576, 2577, 7, 9, 0, 0, 2577, 2578, 7, 14, 0, 0, 2578, 2579, 7, 20, 0, 0, 2579, 2580, 7, 10, 0, 0, 2580, 2581, 7, 15, 0, 0, 2581, 2582, 7, 5, 0, 0, 2582, 238, 1, 0, 0, 0, 2583, 2584, 7, 25, 0, 0, 2584, 2585, 7, 13, 0, 0, 2585, 2586, 7, 10, 0, 0, 2586, 2587, 7, 10, 0, 0, 2587, 2588, 7, 11, 0, 0, 2588, 2589, 7, 10, 0, 0, 2589, 240, 1, 0, 0, 0, 2590, 2591, 7, 25, 0, 0, 2591, 2592, 7, 22, 0, 0, 2592, 2593, 7, 6, 0, 0, 2593, 2594, 7, 6, 0, 0, 2594, 242, 1, 0, 0, 0, 2595, 2596, 7, 17, 0, 0, 2596, 2597, 7, 6, 0, 0, 2597, 2598, 7, 17, 0, 0, 2598, 2599, 7, 21, 0, 0, 2599, 2600, 7, 10, 0, 0, 2600, 244, 1, 0, 0, 0, 2601, 2602, 7, 17, 0, 0, 2602, 2603, 7, 7, 0, 0, 2603, 2604, 7, 7, 0, 0, 2604, 2605, 7, 10, 0, 0, 2605, 2606, 7, 13, 0, 0, 2606, 246, 1, 0, 0, 0, 2607, 2608, 7, 17, 0, 0, 2608, 2609, 7, 9, 0, 0, 2609, 248, 1, 0, 0, 0, 2610, 2611, 7, 17, 0, 0, 2611, 2612, 7, 9, 0, 0, 2612, 2613, 7, 7, 0, 0, 2613, 2614, 7, 22, 0, 0, 2614, 2615, 7, 6, 0, 0, 2615, 2616, 7, 6, 0, 0, 2616, 250, 1, 0, 0, 0, 2617, 2618, 7, 30, 0, 0, 2618, 2619, 7, 19, 0, 0, 2619, 2620, 7, 17, 0, 0, 2620, 2621, 7, 7, 0, 0, 2621, 252, 1, 0, 0, 0, 2622, 2623, 7, 6, 0, 0, 2623, 2624, 7, 10, 0, 0, 2624, 2625, 7, 25, 0, 0, 2625, 2626, 7, 16, 0, 0, 2626, 254, 1, 0, 0, 0, 2627, 2628, 7, 6, 0, 0, 2628, 2629, 7, 17, 0, 0, 2629, 2630, 7, 21, 0, 0, 2630, 2631, 7, 10, 0, 0, 2631, 256, 1, 0, 0, 0, 2632, 2633, 7, 7, 0, 0, 2633, 2634, 7, 5, 0, 0, 2634, 2635, 7, 16, 0, 0, 2635, 2636, 7, 22, 0, 0, 2636, 2637, 7, 13, 0, 0, 2637, 2638, 7, 5, 0, 0, 2638, 2639, 7, 6, 0, 0, 2639, 258, 1, 0, 0, 0, 2640, 2641, 7, 7, 0, 0, 2641, 2642, 7, 19, 0, 0, 2642, 2643, 7, 16, 0, 0, 2643, 2644, 7, 7, 0, 0, 2644, 2645, 7, 22, 0, 0, 2645, 2646, 7, 6, 0, 0, 2646, 2647, 7, 6, 0, 0, 2647, 260, 1, 0, 0, 0, 2648, 2649, 7, 19, 0, 0, 2649, 2650, 7, 22, 0, 0, 2650, 2651, 7, 16, 0, 0, 2651, 2652, 7, 10, 0, 0, 2652, 2653, 7, 13, 0, 0, 2653, 262, 1, 0, 0, 0, 2654, 2655, 7, 19, 0, 0, 2655, 2656, 7, 27, 0, 0, 2656, 2657, 7, 10, 0, 0, 2657, 2658, 7, 13, 0, 0, 2658, 264, 1, 0, 0, 0, 2659, 2660, 7, 19, 0, 0, 2660, 2661, 7, 27, 0, 0, 2661, 2662, 7, 10, 0, 0, 2662, 2663, 7, 13, 0, 0, 2663, 2664, 7, 6, 0, 0, 2664, 2665, 7, 5, 0, 0, 2665, 2666, 7, 24, 0, 0, 2666, 2667, 7, 9, 0, 0, 2667, 266, 1, 0, 0, 0, 2668, 2669, 7, 13, 0, 0, 2669, 2670, 7, 17, 0, 0, 2670, 2671, 7, 23, 0, 0, 2671, 2672, 7, 20, 0, 0, 2672, 2673, 7, 16, 0, 0, 2673, 268, 1, 0, 0, 0, 2674, 2675, 7, 9, 0, 0, 2675, 2676, 7, 17, 0, 0, 2676, 2677, 7, 15, 0, 0, 2677, 2678, 7, 17, 0, 0, 2678, 2679, 7, 6, 0, 0, 2679, 2680, 7, 5, 0, 0, 2680, 2681, 7, 13, 0, 0, 2681, 270, 1, 0, 0, 0, 2682, 2683, 7, 27, 0, 0, 2683, 2684, 7, 10, 0, 0, 2684, 2685, 7, 13, 0, 0, 2685, 2686, 7, 18, 0, 0, 2686, 2687, 7, 19, 0, 0, 2687, 2688, 7, 9, 0, 0, 2688, 2689, 7, 10, 0, 0, 2689, 272, 1, 0, 0, 0, 2690, 2691, 7, 5, 0, 0, 2691, 2692, 7, 18, 0, 0, 2692, 2693, 7, 19, 0, 0, 2693, 2694, 7, 13, 0, 0, 2694, 2695, 7, 16, 0, 0, 2695, 274, 1, 0, 0, 0, 2696, 2697, 7, 5, 0, 0, 2697, 2698, 7, 18, 0, 0, 2698, 2699, 7, 9, 0, 0, 2699, 2700, 7, 19, 0, 0, 2700, 2701, 7, 6, 0, 0, 2701, 2702, 7, 22, 0, 0, 2702, 2703, 7, 16, 0, 0, 2703, 2704, 7, 10, 0, 0, 2704, 276, 1, 0, 0, 0, 2705, 2706, 7, 5, 0, 0, 2706, 2707, 7, 14, 0, 0, 2707, 2708, 7, 14, 0, 0, 2708, 2709, 7, 10, 0, 0, 2709, 2710, 7, 9, 0, 0, 2710, 2711, 7, 9, 0, 0, 2711, 278, 1, 0, 0, 0, 2712, 2713, 7, 5, 0, 0, 2713, 2714, 7, 14, 0, 0, 2714, 2715, 7, 16, 0, 0, 2715, 2716, 7, 17, 0, 0, 2716, 2717, 7, 19, 0, 0, 2717, 2718, 7, 7, 0, 0, 2718, 280, 1, 0, 0, 0, 2719, 2720, 7, 5, 0, 0, 2720, 2721, 7, 12, 0, 0, 2721, 2722, 7, 12, 0, 0, 2722, 282, 1, 0, 0, 0, 2723, 2724, 7, 5, 0, 0, 2724, 2725, 7, 12, 0, 0, 2725, 2726, 7, 15, 0, 0, 2726, 2727, 7, 17, 0, 0, 2727, 2728, 7, 7, 0, 0, 2728, 284, 1, 0, 0, 0, 2729, 2730, 7, 5, 0, 0, 2730, 2731, 7, 25, 0, 0, 2731, 2732, 7, 16, 0, 0, 2732, 2733, 7, 10, 0, 0, 2733, 2734, 7, 13, 0, 0, 2734, 286, 1, 0, 0, 0, 2735, 2736, 7, 5, 0, 0, 2736, 2737, 7, 23, 0, 0, 2737, 2738, 7, 23, 0, 0, 2738, 2739, 7, 13, 0, 0, 2739, 2740, 7, 10, 0, 0, 2740, 2741, 7, 23, 0, 0, 2741, 2742, 7, 5, 0, 0, 2742, 2743, 7, 16, 0, 0, 2743, 2744, 7, 10, 0, 0, 2744, 288, 1, 0, 0, 0, 2745, 2746, 7, 5, 0, 0, 2746, 2747, 7, 6, 0, 0, 2747, 2748, 7, 9, 0, 0, 2748, 2749, 7, 19, 0, 0, 2749, 290, 1, 0, 0, 0, 2750, 2751, 7, 5, 0, 0, 2751, 2752, 7, 6, 0, 0, 2752, 2753, 7, 16, 0, 0, 2753, 2754, 7, 10, 0, 0, 2754, 2755, 7, 13, 0, 0, 2755, 292, 1, 0, 0, 0, 2756, 2757, 7, 5, 0, 0, 2757, 2758, 7, 6, 0, 0, 2758, 2759, 7, 29, 0, 0, 2759, 2760, 7, 5, 0, 0, 2760, 2761, 7, 8, 0, 0, 2761, 2762, 7, 9, 0, 0, 2762, 294, 1, 0, 0, 0, 2763, 2764, 7, 5, 0, 0, 2764, 2765, 7, 9, 0, 0, 2765, 2766, 7, 9, 0, 0, 2766, 2767, 7, 10, 0, 0, 2767, 2768, 7, 13, 0, 0, 2768, 2769, 7, 16, 0, 0, 2769, 2770, 7, 17, 0, 0, 2770, 2771, 7, 19, 0, 0, 2771, 2772, 7, 7, 0, 0, 2772, 296, 1, 0, 0, 0, 2773, 2774, 7, 5, 0, 0, 2774, 2775, 7, 9, 0, 0, 2775, 2776, 7, 9, 0, 0, 2776, 2777, 7, 17, 0, 0, 2777, 2778, 7, 23, 0, 0, 2778, 2779, 7, 7, 0, 0, 2779, 2780, 7, 15, 0, 0, 2780, 2781, 7, 10, 0, 0, 2781, 2782, 7, 7, 0, 0, 2782, 2783, 7, 16, 0, 0, 2783, 298, 1, 0, 0, 0, 2784, 2785, 7, 5, 0, 0, 2785, 2786, 7, 16, 0, 0, 2786, 300, 1, 0, 0, 0, 2787, 2788, 7, 5, 0, 0, 2788, 2789, 7, 16, 0, 0, 2789, 2790, 7, 16, 0, 0, 2790, 2791, 7, 13, 0, 0, 2791, 2792, 7, 17, 0, 0, 2792, 2793, 7, 18, 0, 0, 2793, 2794, 7, 22, 0, 0, 2794, 2795, 7, 16, 0, 0, 2795, 2796, 7, 10, 0, 0, 2796, 302, 1, 0, 0, 0, 2797, 2798, 7, 18, 0, 0, 2798, 2799, 7, 5, 0, 0, 2799, 2800, 7, 14, 0, 0, 2800, 2801, 7, 21, 0, 0, 2801, 2802, 7, 29, 0, 0, 2802, 2803, 7, 5, 0, 0, 2803, 2804, 7, 13, 0, 0, 2804, 2805, 7, 12, 0, 0, 2805, 304, 1, 0, 0, 0, 2806, 2807, 7, 18, 0, 0, 2807, 2808, 7, 10, 0, 0, 2808, 2809, 7, 25, 0, 0, 2809, 2810, 7, 19, 0, 0, 2810, 2811, 7, 13, 0, 0, 2811, 2812, 7, 10, 0, 0, 2812, 306, 1, 0, 0, 0, 2813, 2814, 7, 18, 0, 0, 2814, 2815, 7, 10, 0, 0, 2815, 2816, 7, 23, 0, 0, 2816, 2817, 7, 17, 0, 0, 2817, 2818, 7, 7, 0, 0, 2818, 308, 1, 0, 0, 0, 2819, 2820, 7, 18, 0, 0, 2820, 2821, 7, 8, 0, 0, 2821, 310, 1, 0, 0, 0, 2822, 2823, 7, 14, 0, 0, 2823, 2824, 7, 5, 0, 0, 2824, 2825, 7, 14, 0, 0, 2825, 2826, 7, 20, 0, 0, 2826, 2827, 7, 10, 0, 0, 2827, 312, 1, 0, 0, 0, 2828, 2829, 7, 14, 0, 0, 2829, 2830, 7, 5, 0, 0, 2830, 2831, 7, 6, 0, 0, 2831, 2832, 7, 6, 0, 0, 2832, 2833, 7, 10, 0, 0, 2833, 2834, 7, 12, 0, 0, 2834, 314, 1, 0, 0, 0, 2835, 2836, 7, 14, 0, 0, 2836, 2837, 7, 5, 0, 0, 2837, 2838, 7, 9, 0, 0, 2838, 2839, 7, 14, 0, 0, 2839, 2840, 7, 5, 0, 0, 2840, 2841, 7, 12, 0, 0, 2841, 2842, 7, 10, 0, 0, 2842, 316, 1, 0, 0, 0, 2843, 2844, 7, 14, 0, 0, 2844, 2845, 7, 5, 0, 0, 2845, 2846, 7, 9, 0, 0, 2846, 2847, 7, 14, 0, 0, 2847, 2848, 7, 5, 0, 0, 2848, 2849, 7, 12, 0, 0, 2849, 2850, 7, 10, 0, 0, 2850, 2851, 7, 12, 0, 0, 2851, 318, 1, 0, 0, 0, 2852, 2853, 7, 14, 0, 0, 2853, 2854, 7, 5, 0, 0, 2854, 2855, 7, 16, 0, 0, 2855, 2856, 7, 5, 0, 0, 2856, 2857, 7, 6, 0, 0, 2857, 2858, 7, 19, 0, 0, 2858, 2859, 7, 23, 0, 0, 2859, 320, 1, 0, 0, 0, 2860, 2861, 7, 14, 0, 0, 2861, 2862, 7, 20, 0, 0, 2862, 2863, 7, 5, 0, 0, 2863, 2864, 7, 17, 0, 0, 2864, 2865, 7, 7, 0, 0, 2865, 322, 1, 0, 0, 0, 2866, 2867, 7, 14, 0, 0, 2867, 2868, 7, 20, 0, 0, 2868, 2869, 7, 5, 0, 0, 2869, 2870, 7, 13, 0, 0, 2870, 2871, 7, 5, 0, 0, 2871, 2872, 7, 14, 0, 0, 2872, 2873, 7, 16, 0, 0, 2873, 2874, 7, 10, 0, 0, 2874, 2875, 7, 13, 0, 0, 2875, 2876, 7, 17, 0, 0, 2876, 2877, 7, 9, 0, 0, 2877, 2878, 7, 16, 0, 0, 2878, 2879, 7, 17, 0, 0, 2879, 2880, 7, 14, 0, 0, 2880, 2881, 7, 9, 0, 0, 2881, 324, 1, 0, 0, 0, 2882, 2883, 7, 14, 0, 0, 2883, 2884, 7, 20, 0, 0, 2884, 2885, 7, 10, 0, 0, 2885, 2886, 7, 14, 0, 0, 2886, 2887, 7, 21, 0, 0, 2887, 2888, 7, 24, 0, 0, 2888, 2889, 7, 19, 0, 0, 2889, 2890, 7, 17, 0, 0, 2890, 2891, 7, 7, 0, 0, 2891, 2892, 7, 16, 0, 0, 2892, 326, 1, 0, 0, 0, 2893, 2894, 7, 14, 0, 0, 2894, 2895, 7, 6, 0, 0, 2895, 2896, 7, 5, 0, 0, 2896, 2897, 7, 9, 0, 0, 2897, 2898, 7, 9, 0, 0, 2898, 328, 1, 0, 0, 0, 2899, 2900, 7, 14, 0, 0, 2900, 2901, 7, 6, 0, 0, 2901, 2902, 7, 19, 0, 0, 2902, 2903, 7, 9, 0, 0, 2903, 2904, 7, 10, 0, 0, 2904, 330, 1, 0, 0, 0, 2905, 2906, 7, 14, 0, 0, 2906, 2907, 7, 6, 0, 0, 2907, 2908, 7, 22, 0, 0, 2908, 2909, 7, 9, 0, 0, 2909, 2910, 7, 16, 0, 0, 2910, 2911, 7, 10, 0, 0, 2911, 2912, 7, 13, 0, 0, 2912, 332, 1, 0, 0, 0, 2913, 2914, 7, 14, 0, 0, 2914, 2915, 7, 19, 0, 0, 2915, 2916, 7, 15, 0, 0, 2916, 2917, 7, 15, 0, 0, 2917, 2918, 7, 10, 0, 0, 2918, 2919, 7, 7, 0, 0, 2919, 2920, 7, 16, 0, 0, 2920, 334, 1, 0, 0, 0, 2921, 2922, 7, 14, 0, 0, 2922, 2923, 7, 19, 0, 0, 2923, 2924, 7, 15, 0, 0, 2924, 2925, 7, 15, 0, 0, 2925, 2926, 7, 10, 0, 0, 2926, 2927, 7, 7, 0, 0, 2927, 2928, 7, 16, 0, 0, 2928, 2929, 7, 9, 0, 0, 2929, 336, 1, 0, 0, 0, 2930, 2931, 7, 14, 0, 0, 2931, 2932, 7, 19, 0, 0, 2932, 2933, 7, 15, 0, 0, 2933, 2934, 7, 15, 0, 0, 2934, 2935, 7, 17, 0, 0, 2935, 2936, 7, 16, 0, 0, 2936, 338, 1, 0, 0, 0, 2937, 2938, 7, 14, 0, 0, 2938, 2939, 7, 19, 0, 0, 2939, 2940, 7, 15, 0, 0, 2940, 2941, 7, 15, 0, 0, 2941, 2942, 7, 17, 0, 0, 2942, 2943, 7, 16, 0, 0, 2943, 2944, 7, 16, 0, 0, 2944, 2945, 7, 10, 0, 0, 2945, 2946, 7, 12, 0, 0, 2946, 340, 1, 0, 0, 0, 2947, 2948, 7, 14, 0, 0, 2948, 2949, 7, 19, 0, 0, 2949, 2950, 7, 7, 0, 0, 2950, 2951, 7, 25, 0, 0, 2951, 2952, 7, 17, 0, 0, 2952, 2953, 7, 23, 0, 0, 2953, 2954, 7, 22, 0, 0, 2954, 2955, 7, 13, 0, 0, 2955, 2956, 7, 5, 0, 0, 2956, 2957, 7, 16, 0, 0, 2957, 2958, 7, 17, 0, 0, 2958, 2959, 7, 19, 0, 0, 2959, 2960, 7, 7, 0, 0, 2960, 342, 1, 0, 0, 0, 2961, 2962, 7, 14, 0, 0, 2962, 2963, 7, 19, 0, 0, 2963, 2964, 7, 7, 0, 0, 2964, 2965, 7, 7, 0, 0, 2965, 2966, 7, 10, 0, 0, 2966, 2967, 7, 14, 0, 0, 2967, 2968, 7, 16, 0, 0, 2968, 2969, 7, 17, 0, 0, 2969, 2970, 7, 19, 0, 0, 2970, 2971, 7, 7, 0, 0, 2971, 344, 1, 0, 0, 0, 2972, 2973, 7, 14, 0, 0, 2973, 2974, 7, 19, 0, 0, 2974, 2975, 7, 7, 0, 0, 2975, 2976, 7, 9, 0, 0, 2976, 2977, 7, 16, 0, 0, 2977, 2978, 7, 13, 0, 0, 2978, 2979, 7, 5, 0, 0, 2979, 2980, 7, 17, 0, 0, 2980, 2981, 7, 7, 0, 0, 2981, 2982, 7, 16, 0, 0, 2982, 2983, 7, 9, 0, 0, 2983, 346, 1, 0, 0, 0, 2984, 2985, 7, 14, 0, 0, 2985, 2986, 7, 19, 0, 0, 2986, 2987, 7, 7, 0, 0, 2987, 2988, 7, 16, 0, 0, 2988, 2989, 7, 10, 0, 0, 2989, 2990, 7, 7, 0, 0, 2990, 2991, 7, 16, 0, 0, 2991, 348, 1, 0, 0, 0, 2992, 2993, 7, 14, 0, 0, 2993, 2994, 7, 19, 0, 0, 2994, 2995, 7, 7, 0, 0, 2995, 2996, 7, 16, 0, 0, 2996, 2997, 7, 17, 0, 0, 2997, 2998, 7, 7, 0, 0, 2998, 2999, 7, 22, 0, 0, 2999, 3000, 7, 10, 0, 0, 3000, 350, 1, 0, 0, 0, 3001, 3002, 7, 14, 0, 0, 3002, 3003, 7, 19, 0, 0, 3003, 3004, 7, 7, 0, 0, 3004, 3005, 7, 27, 0, 0, 3005, 3006, 7, 10, 0, 0, 3006, 3007, 7, 13, 0, 0, 3007, 3008, 7, 9, 0, 0, 3008, 3009, 7, 17, 0, 0, 3009, 3010, 7, 19, 0, 0, 3010, 3011, 7, 7, 0, 0, 3011, 352, 1, 0, 0, 0, 3012, 3013, 7, 14, 0, 0, 3013, 3014, 7, 19, 0, 0, 3014, 3015, 7, 24, 0, 0, 3015, 3016, 7, 8, 0, 0, 3016, 354, 1, 0, 0, 0, 3017, 3018, 7, 14, 0, 0, 3018, 3019, 7, 19, 0, 0, 3019, 3020, 7, 9, 0, 0, 3020, 3021, 7, 16, 0, 0, 3021, 356, 1, 0, 0, 0, 3022, 3023, 7, 14, 0, 0, 3023, 3024, 7, 9, 0, 0, 3024, 3025, 7, 27, 0, 0, 3025, 358, 1, 0, 0, 0, 3026, 3027, 7, 30, 0, 0, 3027, 3028, 7, 9, 0, 0, 3028, 3029, 7, 19, 0, 0, 3029, 3030, 7, 7, 0, 0, 3030, 360, 1, 0, 0, 0, 3031, 3032, 7, 14, 0, 0, 3032, 3033, 7, 22, 0, 0, 3033, 3034, 7, 13, 0, 0, 3034, 3035, 7, 9, 0, 0, 3035, 3036, 7, 19, 0, 0, 3036, 3037, 7, 13, 0, 0, 3037, 362, 1, 0, 0, 0, 3038, 3039, 7, 14, 0, 0, 3039, 3040, 7, 8, 0, 0, 3040, 3041, 7, 14, 0, 0, 3041, 3042, 7, 6, 0, 0, 3042, 3043, 7, 10, 0, 0, 3043, 364, 1, 0, 0, 0, 3044, 3045, 7, 12, 0, 0, 3045, 3046, 7, 5, 0, 0, 3046, 3047, 7, 16, 0, 0, 3047, 3048, 7, 5, 0, 0, 3048, 366, 1, 0, 0, 0, 3049, 3050, 7, 12, 0, 0, 3050, 3051, 7, 5, 0, 0, 3051, 3052, 7, 16, 0, 0, 3052, 3053, 7, 5, 0, 0, 3053, 3054, 5, 95, 0, 0, 3054, 3055, 7, 14, 0, 0, 3055, 3056, 7, 5, 0, 0, 3056, 3057, 7, 16, 0, 0, 3057, 3058, 7, 5, 0, 0, 3058, 3059, 7, 6, 0, 0, 3059, 3060, 7, 19, 0, 0, 3060, 3061, 7, 23, 0, 0, 3061, 368, 1, 0, 0, 0, 3062, 3063, 7, 12, 0, 0, 3063, 3064, 7, 5, 0, 0, 3064, 3065, 7, 16, 0, 0, 3065, 3066, 7, 5, 0, 0, 3066, 3067, 7, 18, 0, 0, 3067, 3068, 7, 5, 0, 0, 3068, 3069, 7, 9, 0, 0, 3069, 3070, 7, 10, 0, 0, 3070, 370, 1, 0, 0, 0, 3071, 3072, 7, 12, 0, 0, 3072, 3073, 7, 5, 0, 0, 3073, 3074, 7, 8, 0, 0, 3074, 372, 1, 0, 0, 0, 3075, 3076, 7, 12, 0, 0, 3076, 3077, 7, 10, 0, 0, 3077, 3078, 7, 5, 0, 0, 3078, 3079, 7, 6, 0, 0, 3079, 3080, 7, 6, 0, 0, 3080, 3081, 7, 19, 0, 0, 3081, 3082, 7, 14, 0, 0, 3082, 3083, 7, 5, 0, 0, 3083, 3084, 7, 16, 0, 0, 3084, 3085, 7, 10, 0, 0, 3085, 374, 1, 0, 0, 0, 3086, 3087, 7, 12, 0, 0, 3087, 3088, 7, 10, 0, 0, 3088, 3089, 7, 14, 0, 0, 3089, 3090, 7, 6, 0, 0, 3090, 3091, 7, 5, 0, 0, 3091, 3092, 7, 13, 0, 0, 3092, 3093, 7, 10, 0, 0, 3093, 376, 1, 0, 0, 0, 3094, 3095, 7, 12, 0, 0, 3095, 3096, 7, 10, 0, 0, 3096, 3097, 7, 25, 0, 0, 3097, 3098, 7, 5, 0, 0, 3098, 3099, 7, 22, 0, 0, 3099, 3100, 7, 6, 0, 0, 3100, 3101, 7, 16, 0, 0, 3101, 3102, 7, 9, 0, 0, 3102, 378, 1, 0, 0, 0, 3103, 3104, 7, 12, 0, 0, 3104, 3105, 7, 10, 0, 0, 3105, 3106, 7, 25, 0, 0, 3106, 3107, 7, 10, 0, 0, 3107, 3108, 7, 13, 0, 0, 3108, 3109, 7, 13, 0, 0, 3109, 3110, 7, 10, 0, 0, 3110, 3111, 7, 12, 0, 0, 3111, 380, 1, 0, 0, 0, 3112, 3113, 7, 12, 0, 0, 3113, 3114, 7, 10, 0, 0, 3114, 3115, 7, 25, 0, 0, 3115, 3116, 7, 17, 0, 0, 3116, 3117, 7, 7, 0, 0, 3117, 3118, 7, 10, 0, 0, 3118, 3119, 7, 13, 0, 0, 3119, 382, 1, 0, 0, 0, 3120, 3121, 7, 12, 0, 0, 3121, 3122, 7, 10, 0, 0, 3122, 3123, 7, 6, 0, 0, 3123, 3124, 7, 10, 0, 0, 3124, 3125, 7, 16, 0, 0, 3125, 3126, 7, 10, 0, 0, 3126, 384, 1, 0, 0, 0, 3127, 3128, 7, 12, 0, 0, 3128, 3129, 7, 10, 0, 0, 3129, 3130, 7, 6, 0, 0, 3130, 3131, 7, 17, 0, 0, 3131, 3132, 7, 15, 0, 0, 3132, 3133, 7, 17, 0, 0, 3133, 3134, 7, 16, 0, 0, 3134, 3135, 7, 10, 0, 0, 3135, 3136, 7, 13, 0, 0, 3136, 386, 1, 0, 0, 0, 3137, 3138, 7, 12, 0, 0, 3138, 3139, 7, 10, 0, 0, 3139, 3140, 7, 6, 0, 0, 3140, 3141, 7, 17, 0, 0, 3141, 3142, 7, 15, 0, 0, 3142, 3143, 7, 17, 0, 0, 3143, 3144, 7, 16, 0, 0, 3144, 3145, 7, 10, 0, 0, 3145, 3146, 7, 13, 0, 0, 3146, 3147, 7, 9, 0, 0, 3147, 388, 1, 0, 0, 0, 3148, 3149, 7, 12, 0, 0, 3149, 3150, 7, 17, 0, 0, 3150, 3151, 7, 14, 0, 0, 3151, 3152, 7, 16, 0, 0, 3152, 3153, 7, 17, 0, 0, 3153, 3154, 7, 19, 0, 0, 3154, 3155, 7, 7, 0, 0, 3155, 3156, 7, 5, 0, 0, 3156, 3157, 7, 13, 0, 0, 3157, 3158, 7, 8, 0, 0, 3158, 390, 1, 0, 0, 0, 3159, 3160, 7, 12, 0, 0, 3160, 3161, 7, 17, 0, 0, 3161, 3162, 7, 9, 0, 0, 3162, 3163, 7, 5, 0, 0, 3163, 3164, 7, 18, 0, 0, 3164, 3165, 7, 6, 0, 0, 3165, 3166, 7, 10, 0, 0, 3166, 392, 1, 0, 0, 0, 3167, 3168, 7, 12, 0, 0, 3168, 3169, 7, 17, 0, 0, 3169, 3170, 7, 9, 0, 0, 3170, 3171, 7, 14, 0, 0, 3171, 3172, 7, 5, 0, 0, 3172, 3173, 7, 13, 0, 0, 3173, 3174, 7, 12, 0, 0, 3174, 394, 1, 0, 0, 0, 3175, 3176, 7, 12, 0, 0, 3176, 3177, 7, 19, 0, 0, 3177, 3178, 7, 14, 0, 0, 3178, 3179, 7, 22, 0, 0, 3179, 3180, 7, 15, 0, 0, 3180, 3181, 7, 10, 0, 0, 3181, 3182, 7, 7, 0, 0, 3182, 3183, 7, 16, 0, 0, 3183, 396, 1, 0, 0, 0, 3184, 3185, 7, 12, 0, 0, 3185, 3186, 7, 19, 0, 0, 3186, 3187, 7, 15, 0, 0, 3187, 3188, 7, 5, 0, 0, 3188, 3189, 7, 17, 0, 0, 3189, 3190, 7, 7, 0, 0, 3190, 398, 1, 0, 0, 0, 3191, 3192, 7, 12, 0, 0, 3192, 3193, 7, 19, 0, 0, 3193, 3194, 7, 22, 0, 0, 3194, 3195, 7, 18, 0, 0, 3195, 3196, 7, 6, 0, 0, 3196, 3197, 7, 10, 0, 0, 3197, 400, 1, 0, 0, 0, 3198, 3199, 7, 12, 0, 0, 3199, 3200, 7, 13, 0, 0, 3200, 3201, 7, 19, 0, 0, 3201, 3202, 7, 24, 0, 0, 3202, 402, 1, 0, 0, 0, 3203, 3204, 7, 10, 0, 0, 3204, 3205, 7, 5, 0, 0, 3205, 3206, 7, 14, 0, 0, 3206, 3207, 7, 20, 0, 0, 3207, 404, 1, 0, 0, 0, 3208, 3209, 7, 10, 0, 0, 3209, 3210, 7, 7, 0, 0, 3210, 3211, 7, 5, 0, 0, 3211, 3212, 7, 18, 0, 0, 3212, 3213, 7, 6, 0, 0, 3213, 3214, 7, 10, 0, 0, 3214, 406, 1, 0, 0, 0, 3215, 3216, 7, 10, 0, 0, 3216, 3217, 7, 7, 0, 0, 3217, 3218, 7, 14, 0, 0, 3218, 3219, 7, 19, 0, 0, 3219, 3220, 7, 12, 0, 0, 3220, 3221, 7, 17, 0, 0, 3221, 3222, 7, 7, 0, 0, 3222, 3223, 7, 23, 0, 0, 3223, 408, 1, 0, 0, 0, 3224, 3225, 7, 10, 0, 0, 3225, 3226, 7, 7, 0, 0, 3226, 3227, 7, 14, 0, 0, 3227, 3228, 7, 13, 0, 0, 3228, 3229, 7, 8, 0, 0, 3229, 3230, 7, 24, 0, 0, 3230, 3231, 7, 16, 0, 0, 3231, 3232, 7, 10, 0, 0, 3232, 3233, 7, 12, 0, 0, 3233, 410, 1, 0, 0, 0, 3234, 3235, 7, 10, 0, 0, 3235, 3236, 7, 7, 0, 0, 3236, 3237, 7, 22, 0, 0, 3237, 3238, 7, 15, 0, 0, 3238, 412, 1, 0, 0, 0, 3239, 3240, 7, 10, 0, 0, 3240, 3241, 7, 9, 0, 0, 3241, 3242, 7, 14, 0, 0, 3242, 3243, 7, 5, 0, 0, 3243, 3244, 7, 24, 0, 0, 3244, 3245, 7, 10, 0, 0, 3245, 414, 1, 0, 0, 0, 3246, 3247, 7, 10, 0, 0, 3247, 3248, 7, 27, 0, 0, 3248, 3249, 7, 10, 0, 0, 3249, 3250, 7, 7, 0, 0, 3250, 3251, 7, 16, 0, 0, 3251, 416, 1, 0, 0, 0, 3252, 3253, 7, 10, 0, 0, 3253, 3254, 7, 26, 0, 0, 3254, 3255, 7, 14, 0, 0, 3255, 3256, 7, 6, 0, 0, 3256, 3257, 7, 22, 0, 0, 3257, 3258, 7, 12, 0, 0, 3258, 3259, 7, 10, 0, 0, 3259, 418, 1, 0, 0, 0, 3260, 3261, 7, 10, 0, 0, 3261, 3262, 7, 26, 0, 0, 3262, 3263, 7, 14, 0, 0, 3263, 3264, 7, 6, 0, 0, 3264, 3265, 7, 22, 0, 0, 3265, 3266, 7, 12, 0, 0, 3266, 3267, 7, 17, 0, 0, 3267, 3268, 7, 7, 0, 0, 3268, 3269, 7, 23, 0, 0, 3269, 420, 1, 0, 0, 0, 3270, 3271, 7, 10, 0, 0, 3271, 3272, 7, 26, 0, 0, 3272, 3273, 7, 14, 0, 0, 3273, 3274, 7, 6, 0, 0, 3274, 3275, 7, 22, 0, 0, 3275, 3276, 7, 9, 0, 0, 3276, 3277, 7, 17, 0, 0, 3277, 3278, 7, 27, 0, 0, 3278, 3279, 7, 10, 0, 0, 3279, 422, 1, 0, 0, 0, 3280, 3281, 7, 10, 0, 0, 3281, 3282, 7, 26, 0, 0, 3282, 3283, 7, 10, 0, 0, 3283, 3284, 7, 14, 0, 0, 3284, 3285, 7, 22, 0, 0, 3285, 3286, 7, 16, 0, 0, 3286, 3287, 7, 10, 0, 0, 3287, 424, 1, 0, 0, 0, 3288, 3289, 7, 10, 0, 0, 3289, 3290, 7, 26, 0, 0, 3290, 3291, 7, 24, 0, 0, 3291, 3292, 7, 6, 0, 0, 3292, 3293, 7, 5, 0, 0, 3293, 3294, 7, 17, 0, 0, 3294, 3295, 7, 7, 0, 0, 3295, 426, 1, 0, 0, 0, 3296, 3297, 7, 10, 0, 0, 3297, 3298, 7, 26, 0, 0, 3298, 3299, 7, 16, 0, 0, 3299, 3300, 7, 10, 0, 0, 3300, 3301, 7, 7, 0, 0, 3301, 3302, 7, 9, 0, 0, 3302, 3303, 7, 17, 0, 0, 3303, 3304, 7, 19, 0, 0, 3304, 3305, 7, 7, 0, 0, 3305, 428, 1, 0, 0, 0, 3306, 3307, 7, 10, 0, 0, 3307, 3308, 7, 26, 0, 0, 3308, 3309, 7, 16, 0, 0, 3309, 3310, 7, 10, 0, 0, 3310, 3311, 7, 13, 0, 0, 3311, 3312, 7, 7, 0, 0, 3312, 3313, 7, 5, 0, 0, 3313, 3314, 7, 6, 0, 0, 3314, 430, 1, 0, 0, 0, 3315, 3316, 7, 25, 0, 0, 3316, 3317, 7, 5, 0, 0, 3317, 3318, 7, 15, 0, 0, 3318, 3319, 7, 17, 0, 0, 3319, 3320, 7, 6, 0, 0, 3320, 3321, 7, 8, 0, 0, 3321, 432, 1, 0, 0, 0, 3322, 3323, 7, 25, 0, 0, 3323, 3324, 7, 17, 0, 0, 3324, 3325, 7, 13, 0, 0, 3325, 3326, 7, 9, 0, 0, 3326, 3327, 7, 16, 0, 0, 3327, 434, 1, 0, 0, 0, 3328, 3329, 7, 25, 0, 0, 3329, 3330, 7, 19, 0, 0, 3330, 3331, 7, 6, 0, 0, 3331, 3332, 7, 6, 0, 0, 3332, 3333, 7, 19, 0, 0, 3333, 3334, 7, 29, 0, 0, 3334, 3335, 7, 17, 0, 0, 3335, 3336, 7, 7, 0, 0, 3336, 3337, 7, 23, 0, 0, 3337, 436, 1, 0, 0, 0, 3338, 3339, 7, 25, 0, 0, 3339, 3340, 7, 19, 0, 0, 3340, 3341, 7, 13, 0, 0, 3341, 3342, 7, 14, 0, 0, 3342, 3343, 7, 10, 0, 0, 3343, 438, 1, 0, 0, 0, 3344, 3345, 7, 25, 0, 0, 3345, 3346, 7, 19, 0, 0, 3346, 3347, 7, 13, 0, 0, 3347, 3348, 7, 29, 0, 0, 3348, 3349, 7, 5, 0, 0, 3349, 3350, 7, 13, 0, 0, 3350, 3351, 7, 12, 0, 0, 3351, 440, 1, 0, 0, 0, 3352, 3353, 7, 25, 0, 0, 3353, 3354, 7, 22, 0, 0, 3354, 3355, 7, 7, 0, 0, 3355, 3356, 7, 14, 0, 0, 3356, 3357, 7, 16, 0, 0, 3357, 3358, 7, 17, 0, 0, 3358, 3359, 7, 19, 0, 0, 3359, 3360, 7, 7, 0, 0, 3360, 442, 1, 0, 0, 0, 3361, 3362, 7, 25, 0, 0, 3362, 3363, 7, 22, 0, 0, 3363, 3364, 7, 7, 0, 0, 3364, 3365, 7, 14, 0, 0, 3365, 3366, 7, 16, 0, 0, 3366, 3367, 7, 17, 0, 0, 3367, 3368, 7, 19, 0, 0, 3368, 3369, 7, 7, 0, 0, 3369, 3370, 7, 9, 0, 0, 3370, 444, 1, 0, 0, 0, 3371, 3372, 7, 23, 0, 0, 3372, 3373, 7, 6, 0, 0, 3373, 3374, 7, 19, 0, 0, 3374, 3375, 7, 18, 0, 0, 3375, 3376, 7, 5, 0, 0, 3376, 3377, 7, 6, 0, 0, 3377, 446, 1, 0, 0, 0, 3378, 3379, 7, 23, 0, 0, 3379, 3380, 7, 13, 0, 0, 3380, 3381, 7, 5, 0, 0, 3381, 3382, 7, 7, 0, 0, 3382, 3383, 7, 16, 0, 0, 3383, 3384, 7, 10, 0, 0, 3384, 3385, 7, 12, 0, 0, 3385, 448, 1, 0, 0, 0, 3386, 3387, 7, 20, 0, 0, 3387, 3388, 7, 5, 0, 0, 3388, 3389, 7, 7, 0, 0, 3389, 3390, 7, 12, 0, 0, 3390, 3391, 7, 6, 0, 0, 3391, 3392, 7, 10, 0, 0, 3392, 3393, 7, 13, 0, 0, 3393, 450, 1, 0, 0, 0, 3394, 3395, 7, 20, 0, 0, 3395, 3396, 7, 10, 0, 0, 3396, 3397, 7, 5, 0, 0, 3397, 3398, 7, 12, 0, 0, 3398, 3399, 7, 10, 0, 0, 3399, 3400, 7, 13, 0, 0, 3400, 452, 1, 0, 0, 0, 3401, 3402, 7, 20, 0, 0, 3402, 3403, 7, 19, 0, 0, 3403, 3404, 7, 6, 0, 0, 3404, 3405, 7, 12, 0, 0, 3405, 454, 1, 0, 0, 0, 3406, 3407, 7, 20, 0, 0, 3407, 3408, 7, 19, 0, 0, 3408, 3409, 7, 22, 0, 0, 3409, 3410, 7, 13, 0, 0, 3410, 456, 1, 0, 0, 0, 3411, 3412, 7, 17, 0, 0, 3412, 3413, 7, 12, 0, 0, 3413, 3414, 7, 10, 0, 0, 3414, 3415, 7, 7, 0, 0, 3415, 3416, 7, 16, 0, 0, 3416, 3417, 7, 17, 0, 0, 3417, 3418, 7, 16, 0, 0, 3418, 3419, 7, 8, 0, 0, 3419, 458, 1, 0, 0, 0, 3420, 3421, 7, 17, 0, 0, 3421, 3422, 7, 25, 0, 0, 3422, 460, 1, 0, 0, 0, 3423, 3424, 7, 17, 0, 0, 3424, 3425, 7, 15, 0, 0, 3425, 3426, 7, 15, 0, 0, 3426, 3427, 7, 10, 0, 0, 3427, 3428, 7, 12, 0, 0, 3428, 3429, 7, 17, 0, 0, 3429, 3430, 7, 5, 0, 0, 3430, 3431, 7, 16, 0, 0, 3431, 3432, 7, 10, 0, 0, 3432, 462, 1, 0, 0, 0, 3433, 3434, 7, 17, 0, 0, 3434, 3435, 7, 15, 0, 0, 3435, 3436, 7, 15, 0, 0, 3436, 3437, 7, 22, 0, 0, 3437, 3438, 7, 16, 0, 0, 3438, 3439, 7, 5, 0, 0, 3439, 3440, 7, 18, 0, 0, 3440, 3441, 7, 6, 0, 0, 3441, 3442, 7, 10, 0, 0, 3442, 464, 1, 0, 0, 0, 3443, 3444, 7, 17, 0, 0, 3444, 3445, 7, 15, 0, 0, 3445, 3446, 7, 24, 0, 0, 3446, 3447, 7, 6, 0, 0, 3447, 3448, 7, 17, 0, 0, 3448, 3449, 7, 14, 0, 0, 3449, 3450, 7, 17, 0, 0, 3450, 3451, 7, 16, 0, 0, 3451, 466, 1, 0, 0, 0, 3452, 3453, 7, 17, 0, 0, 3453, 3454, 7, 7, 0, 0, 3454, 3455, 7, 14, 0, 0, 3455, 3456, 7, 6, 0, 0, 3456, 3457, 7, 22, 0, 0, 3457, 3458, 7, 12, 0, 0, 3458, 3459, 7, 17, 0, 0, 3459, 3460, 7, 7, 0, 0, 3460, 3461, 7, 23, 0, 0, 3461, 468, 1, 0, 0, 0, 3462, 3463, 7, 17, 0, 0, 3463, 3464, 7, 7, 0, 0, 3464, 3465, 7, 14, 0, 0, 3465, 3466, 7, 13, 0, 0, 3466, 3467, 7, 10, 0, 0, 3467, 3468, 7, 15, 0, 0, 3468, 3469, 7, 10, 0, 0, 3469, 3470, 7, 7, 0, 0, 3470, 3471, 7, 16, 0, 0, 3471, 470, 1, 0, 0, 0, 3472, 3473, 7, 17, 0, 0, 3473, 3474, 7, 7, 0, 0, 3474, 3475, 7, 12, 0, 0, 3475, 3476, 7, 10, 0, 0, 3476, 3477, 7, 26, 0, 0, 3477, 472, 1, 0, 0, 0, 3478, 3479, 7, 17, 0, 0, 3479, 3480, 7, 7, 0, 0, 3480, 3481, 7, 12, 0, 0, 3481, 3482, 7, 10, 0, 0, 3482, 3483, 7, 26, 0, 0, 3483, 3484, 7, 10, 0, 0, 3484, 3485, 7, 9, 0, 0, 3485, 474, 1, 0, 0, 0, 3486, 3487, 7, 17, 0, 0, 3487, 3488, 7, 7, 0, 0, 3488, 3489, 7, 20, 0, 0, 3489, 3490, 7, 10, 0, 0, 3490, 3491, 7, 13, 0, 0, 3491, 3492, 7, 17, 0, 0, 3492, 3493, 7, 16, 0, 0, 3493, 476, 1, 0, 0, 0, 3494, 3495, 7, 17, 0, 0, 3495, 3496, 7, 7, 0, 0, 3496, 3497, 7, 20, 0, 0, 3497, 3498, 7, 10, 0, 0, 3498, 3499, 7, 13, 0, 0, 3499, 3500, 7, 17, 0, 0, 3500, 3501, 7, 16, 0, 0, 3501, 3502, 7, 9, 0, 0, 3502, 478, 1, 0, 0, 0, 3503, 3504, 7, 17, 0, 0, 3504, 3505, 7, 7, 0, 0, 3505, 3506, 7, 6, 0, 0, 3506, 3507, 7, 17, 0, 0, 3507, 3508, 7, 7, 0, 0, 3508, 3509, 7, 10, 0, 0, 3509, 480, 1, 0, 0, 0, 3510, 3511, 7, 17, 0, 0, 3511, 3512, 7, 7, 0, 0, 3512, 3513, 7, 9, 0, 0, 3513, 3514, 7, 10, 0, 0, 3514, 3515, 7, 7, 0, 0, 3515, 3516, 7, 9, 0, 0, 3516, 3517, 7, 17, 0, 0, 3517, 3518, 7, 16, 0, 0, 3518, 3519, 7, 17, 0, 0, 3519, 3520, 7, 27, 0, 0, 3520, 3521, 7, 10, 0, 0, 3521, 482, 1, 0, 0, 0, 3522, 3523, 7, 17, 0, 0, 3523, 3524, 7, 7, 0, 0, 3524, 3525, 7, 9, 0, 0, 3525, 3526, 7, 10, 0, 0, 3526, 3527, 7, 13, 0, 0, 3527, 3528, 7, 16, 0, 0, 3528, 484, 1, 0, 0, 0, 3529, 3530, 7, 17, 0, 0, 3530, 3531, 7, 7, 0, 0, 3531, 3532, 7, 9, 0, 0, 3532, 3533, 7, 16, 0, 0, 3533, 3534, 7, 10, 0, 0, 3534, 3535, 7, 5, 0, 0, 3535, 3536, 7, 12, 0, 0, 3536, 486, 1, 0, 0, 0, 3537, 3538, 7, 17, 0, 0, 3538, 3539, 7, 7, 0, 0, 3539, 3540, 7, 27, 0, 0, 3540, 3541, 7, 19, 0, 0, 3541, 3542, 7, 21, 0, 0, 3542, 3543, 7, 10, 0, 0, 3543, 3544, 7, 13, 0, 0, 3544, 488, 1, 0, 0, 0, 3545, 3546, 7, 17, 0, 0, 3546, 3547, 7, 9, 0, 0, 3547, 3548, 7, 19, 0, 0, 3548, 3549, 7, 6, 0, 0, 3549, 3550, 7, 5, 0, 0, 3550, 3551, 7, 16, 0, 0, 3551, 3552, 7, 17, 0, 0, 3552, 3553, 7, 19, 0, 0, 3553, 3554, 7, 7, 0, 0, 3554, 490, 1, 0, 0, 0, 3555, 3556, 7, 21, 0, 0, 3556, 3557, 7, 10, 0, 0, 3557, 3558, 7, 8, 0, 0, 3558, 492, 1, 0, 0, 0, 3559, 3560, 7, 6, 0, 0, 3560, 3561, 7, 5, 0, 0, 3561, 3562, 7, 18, 0, 0, 3562, 3563, 7, 10, 0, 0, 3563, 3564, 7, 6, 0, 0, 3564, 494, 1, 0, 0, 0, 3565, 3566, 7, 6, 0, 0, 3566, 3567, 7, 5, 0, 0, 3567, 3568, 7, 7, 0, 0, 3568, 3569, 7, 23, 0, 0, 3569, 3570, 7, 22, 0, 0, 3570, 3571, 7, 5, 0, 0, 3571, 3572, 7, 23, 0, 0, 3572, 3573, 7, 10, 0, 0, 3573, 496, 1, 0, 0, 0, 3574, 3575, 7, 6, 0, 0, 3575, 3576, 7, 5, 0, 0, 3576, 3577, 7, 13, 0, 0, 3577, 3578, 7, 23, 0, 0, 3578, 3579, 7, 10, 0, 0, 3579, 498, 1, 0, 0, 0, 3580, 3581, 7, 6, 0, 0, 3581, 3582, 7, 5, 0, 0, 3582, 3583, 7, 9, 0, 0, 3583, 3584, 7, 16, 0, 0, 3584, 500, 1, 0, 0, 0, 3585, 3586, 7, 6, 0, 0, 3586, 3587, 7, 10, 0, 0, 3587, 3588, 7, 5, 0, 0, 3588, 3589, 7, 21, 0, 0, 3589, 3590, 7, 24, 0, 0, 3590, 3591, 7, 13, 0, 0, 3591, 3592, 7, 19, 0, 0, 3592, 3593, 7, 19, 0, 0, 3593, 3594, 7, 25, 0, 0, 3594, 502, 1, 0, 0, 0, 3595, 3596, 7, 6, 0, 0, 3596, 3597, 7, 10, 0, 0, 3597, 3598, 7, 27, 0, 0, 3598, 3599, 7, 10, 0, 0, 3599, 3600, 7, 6, 0, 0, 3600, 504, 1, 0, 0, 0, 3601, 3602, 7, 6, 0, 0, 3602, 3603, 7, 17, 0, 0, 3603, 3604, 7, 9, 0, 0, 3604, 3605, 7, 16, 0, 0, 3605, 3606, 7, 10, 0, 0, 3606, 3607, 7, 7, 0, 0, 3607, 506, 1, 0, 0, 0, 3608, 3609, 7, 6, 0, 0, 3609, 3610, 7, 19, 0, 0, 3610, 3611, 7, 5, 0, 0, 3611, 3612, 7, 12, 0, 0, 3612, 508, 1, 0, 0, 0, 3613, 3614, 7, 6, 0, 0, 3614, 3615, 7, 19, 0, 0, 3615, 3616, 7, 14, 0, 0, 3616, 3617, 7, 5, 0, 0, 3617, 3618, 7, 6, 0, 0, 3618, 510, 1, 0, 0, 0, 3619, 3620, 7, 6, 0, 0, 3620, 3621, 7, 19, 0, 0, 3621, 3622, 7, 14, 0, 0, 3622, 3623, 7, 5, 0, 0, 3623, 3624, 7, 16, 0, 0, 3624, 3625, 7, 17, 0, 0, 3625, 3626, 7, 19, 0, 0, 3626, 3627, 7, 7, 0, 0, 3627, 512, 1, 0, 0, 0, 3628, 3629, 7, 6, 0, 0, 3629, 3630, 7, 19, 0, 0, 3630, 3631, 7, 14, 0, 0, 3631, 3632, 7, 21, 0, 0, 3632, 514, 1, 0, 0, 0, 3633, 3634, 7, 15, 0, 0, 3634, 3635, 7, 5, 0, 0, 3635, 3636, 7, 24, 0, 0, 3636, 3637, 7, 24, 0, 0, 3637, 3638, 7, 17, 0, 0, 3638, 3639, 7, 7, 0, 0, 3639, 3640, 7, 23, 0, 0, 3640, 516, 1, 0, 0, 0, 3641, 3642, 7, 15, 0, 0, 3642, 3643, 7, 5, 0, 0, 3643, 3644, 7, 16, 0, 0, 3644, 3645, 7, 14, 0, 0, 3645, 3646, 7, 20, 0, 0, 3646, 518, 1, 0, 0, 0, 3647, 3648, 7, 15, 0, 0, 3648, 3649, 7, 5, 0, 0, 3649, 3650, 7, 16, 0, 0, 3650, 3651, 7, 14, 0, 0, 3651, 3652, 7, 20, 0, 0, 3652, 3653, 7, 10, 0, 0, 3653, 3654, 7, 12, 0, 0, 3654, 520, 1, 0, 0, 0, 3655, 3656, 7, 15, 0, 0, 3656, 3657, 7, 5, 0, 0, 3657, 3658, 7, 16, 0, 0, 3658, 3659, 7, 10, 0, 0, 3659, 3660, 7, 13, 0, 0, 3660, 3661, 7, 17, 0, 0, 3661, 3662, 7, 5, 0, 0, 3662, 3663, 7, 6, 0, 0, 3663, 3664, 7, 17, 0, 0, 3664, 3665, 7, 11, 0, 0, 3665, 3666, 7, 10, 0, 0, 3666, 3667, 7, 12, 0, 0, 3667, 522, 1, 0, 0, 0, 3668, 3669, 7, 15, 0, 0, 3669, 3670, 7, 5, 0, 0, 3670, 3671, 7, 26, 0, 0, 3671, 3672, 7, 27, 0, 0, 3672, 3673, 7, 5, 0, 0, 3673, 3674, 7, 6, 0, 0, 3674, 3675, 7, 22, 0, 0, 3675, 3676, 7, 10, 0, 0, 3676, 524, 1, 0, 0, 0, 3677, 3678, 7, 15, 0, 0, 3678, 3679, 7, 10, 0, 0, 3679, 3680, 7, 13, 0, 0, 3680, 3681, 7, 23, 0, 0, 3681, 3682, 7, 10, 0, 0, 3682, 526, 1, 0, 0, 0, 3683, 3684, 7, 15, 0, 0, 3684, 3685, 7, 17, 0, 0, 3685, 3686, 7, 7, 0, 0, 3686, 3687, 7, 22, 0, 0, 3687, 3688, 7, 16, 0, 0, 3688, 3689, 7, 10, 0, 0, 3689, 528, 1, 0, 0, 0, 3690, 3691, 7, 15, 0, 0, 3691, 3692, 7, 17, 0, 0, 3692, 3693, 7, 7, 0, 0, 3693, 3694, 7, 27, 0, 0, 3694, 3695, 7, 5, 0, 0, 3695, 3696, 7, 6, 0, 0, 3696, 3697, 7, 22, 0, 0, 3697, 3698, 7, 10, 0, 0, 3698, 530, 1, 0, 0, 0, 3699, 3700, 7, 15, 0, 0, 3700, 3701, 7, 19, 0, 0, 3701, 3702, 7, 12, 0, 0, 3702, 3703, 7, 10, 0, 0, 3703, 532, 1, 0, 0, 0, 3704, 3705, 7, 15, 0, 0, 3705, 3706, 7, 19, 0, 0, 3706, 3707, 7, 7, 0, 0, 3707, 3708, 7, 16, 0, 0, 3708, 3709, 7, 20, 0, 0, 3709, 534, 1, 0, 0, 0, 3710, 3711, 7, 15, 0, 0, 3711, 3712, 7, 19, 0, 0, 3712, 3713, 7, 27, 0, 0, 3713, 3714, 7, 10, 0, 0, 3714, 536, 1, 0, 0, 0, 3715, 3716, 7, 7, 0, 0, 3716, 3717, 7, 5, 0, 0, 3717, 3718, 7, 15, 0, 0, 3718, 3719, 7, 10, 0, 0, 3719, 538, 1, 0, 0, 0, 3720, 3721, 7, 7, 0, 0, 3721, 3722, 7, 5, 0, 0, 3722, 3723, 7, 15, 0, 0, 3723, 3724, 7, 10, 0, 0, 3724, 3725, 7, 9, 0, 0, 3725, 540, 1, 0, 0, 0, 3726, 3727, 7, 7, 0, 0, 3727, 3728, 7, 10, 0, 0, 3728, 3729, 7, 26, 0, 0, 3729, 3730, 7, 16, 0, 0, 3730, 542, 1, 0, 0, 0, 3731, 3732, 7, 7, 0, 0, 3732, 3733, 7, 19, 0, 0, 3733, 544, 1, 0, 0, 0, 3734, 3735, 7, 7, 0, 0, 3735, 3736, 7, 19, 0, 0, 3736, 3737, 7, 16, 0, 0, 3737, 3738, 7, 20, 0, 0, 3738, 3739, 7, 17, 0, 0, 3739, 3740, 7, 7, 0, 0, 3740, 3741, 7, 23, 0, 0, 3741, 546, 1, 0, 0, 0, 3742, 3743, 7, 7, 0, 0, 3743, 3744, 7, 19, 0, 0, 3744, 3745, 7, 16, 0, 0, 3745, 3746, 7, 17, 0, 0, 3746, 3747, 7, 25, 0, 0, 3747, 3748, 7, 8, 0, 0, 3748, 548, 1, 0, 0, 0, 3749, 3750, 7, 7, 0, 0, 3750, 3751, 7, 19, 0, 0, 3751, 3752, 7, 29, 0, 0, 3752, 3753, 7, 5, 0, 0, 3753, 3754, 7, 17, 0, 0, 3754, 3755, 7, 16, 0, 0, 3755, 550, 1, 0, 0, 0, 3756, 3757, 7, 7, 0, 0, 3757, 3758, 7, 22, 0, 0, 3758, 3759, 7, 6, 0, 0, 3759, 3760, 7, 6, 0, 0, 3760, 3761, 7, 9, 0, 0, 3761, 552, 1, 0, 0, 0, 3762, 3763, 7, 19, 0, 0, 3763, 3764, 7, 18, 0, 0, 3764, 3765, 7, 30, 0, 0, 3765, 3766, 7, 10, 0, 0, 3766, 3767, 7, 14, 0, 0, 3767, 3768, 7, 16, 0, 0, 3768, 554, 1, 0, 0, 0, 3769, 3770, 7, 19, 0, 0, 3770, 3771, 7, 25, 0, 0, 3771, 556, 1, 0, 0, 0, 3772, 3773, 7, 19, 0, 0, 3773, 3774, 7, 25, 0, 0, 3774, 3775, 7, 25, 0, 0, 3775, 558, 1, 0, 0, 0, 3776, 3777, 7, 19, 0, 0, 3777, 3778, 7, 17, 0, 0, 3778, 3779, 7, 12, 0, 0, 3779, 3780, 7, 9, 0, 0, 3780, 560, 1, 0, 0, 0, 3781, 3782, 7, 19, 0, 0, 3782, 3783, 7, 24, 0, 0, 3783, 3784, 7, 10, 0, 0, 3784, 3785, 7, 13, 0, 0, 3785, 3786, 7, 5, 0, 0, 3786, 3787, 7, 16, 0, 0, 3787, 3788, 7, 19, 0, 0, 3788, 3789, 7, 13, 0, 0, 3789, 562, 1, 0, 0, 0, 3790, 3791, 7, 19, 0, 0, 3791, 3792, 7, 24, 0, 0, 3792, 3793, 7, 16, 0, 0, 3793, 3794, 7, 17, 0, 0, 3794, 3795, 7, 19, 0, 0, 3795, 3796, 7, 7, 0, 0, 3796, 564, 1, 0, 0, 0, 3797, 3798, 7, 19, 0, 0, 3798, 3799, 7, 24, 0, 0, 3799, 3800, 7, 16, 0, 0, 3800, 3801, 7, 17, 0, 0, 3801, 3802, 7, 19, 0, 0, 3802, 3803, 7, 7, 0, 0, 3803, 3804, 7, 9, 0, 0, 3804, 566, 1, 0, 0, 0, 3805, 3806, 7, 19, 0, 0, 3806, 3807, 7, 29, 0, 0, 3807, 3808, 7, 7, 0, 0, 3808, 3809, 7, 10, 0, 0, 3809, 3810, 7, 12, 0, 0, 3810, 568, 1, 0, 0, 0, 3811, 3812, 7, 19, 0, 0, 3812, 3813, 7, 29, 0, 0, 3813, 3814, 7, 7, 0, 0, 3814, 3815, 7, 10, 0, 0, 3815, 3816, 7, 13, 0, 0, 3816, 570, 1, 0, 0, 0, 3817, 3818, 7, 24, 0, 0, 3818, 3819, 7, 5, 0, 0, 3819, 3820, 7, 13, 0, 0, 3820, 3821, 7, 9, 0, 0, 3821, 3822, 7, 10, 0, 0, 3822, 3823, 7, 13, 0, 0, 3823, 572, 1, 0, 0, 0, 3824, 3825, 7, 24, 0, 0, 3825, 3826, 7, 5, 0, 0, 3826, 3827, 7, 13, 0, 0, 3827, 3828, 7, 16, 0, 0, 3828, 3829, 7, 17, 0, 0, 3829, 3830, 7, 5, 0, 0, 3830, 3831, 7, 6, 0, 0, 3831, 574, 1, 0, 0, 0, 3832, 3833, 7, 24, 0, 0, 3833, 3834, 7, 5, 0, 0, 3834, 3835, 7, 13, 0, 0, 3835, 3836, 7, 16, 0, 0, 3836, 3837, 7, 17, 0, 0, 3837, 3838, 7, 16, 0, 0, 3838, 3839, 7, 17, 0, 0, 3839, 3840, 7, 19, 0, 0, 3840, 3841, 7, 7, 0, 0, 3841, 576, 1, 0, 0, 0, 3842, 3843, 7, 24, 0, 0, 3843, 3844, 7, 5, 0, 0, 3844, 3845, 7, 9, 0, 0, 3845, 3846, 7, 9, 0, 0, 3846, 3847, 7, 17, 0, 0, 3847, 3848, 7, 7, 0, 0, 3848, 3849, 7, 23, 0, 0, 3849, 578, 1, 0, 0, 0, 3850, 3851, 7, 24, 0, 0, 3851, 3852, 7, 5, 0, 0, 3852, 3853, 7, 9, 0, 0, 3853, 3854, 7, 9, 0, 0, 3854, 3855, 7, 29, 0, 0, 3855, 3856, 7, 19, 0, 0, 3856, 3857, 7, 13, 0, 0, 3857, 3858, 7, 12, 0, 0, 3858, 580, 1, 0, 0, 0, 3859, 3860, 7, 24, 0, 0, 3860, 3861, 7, 6, 0, 0, 3861, 3862, 7, 5, 0, 0, 3862, 3863, 7, 7, 0, 0, 3863, 3864, 7, 9, 0, 0, 3864, 582, 1, 0, 0, 0, 3865, 3866, 7, 24, 0, 0, 3866, 3867, 7, 13, 0, 0, 3867, 3868, 7, 10, 0, 0, 3868, 3869, 7, 14, 0, 0, 3869, 3870, 7, 10, 0, 0, 3870, 3871, 7, 12, 0, 0, 3871, 3872, 7, 17, 0, 0, 3872, 3873, 7, 7, 0, 0, 3873, 3874, 7, 23, 0, 0, 3874, 584, 1, 0, 0, 0, 3875, 3876, 7, 24, 0, 0, 3876, 3877, 7, 13, 0, 0, 3877, 3878, 7, 10, 0, 0, 3878, 3879, 7, 12, 0, 0, 3879, 3880, 7, 17, 0, 0, 3880, 3881, 7, 14, 0, 0, 3881, 3882, 7, 5, 0, 0, 3882, 3883, 7, 16, 0, 0, 3883, 3884, 7, 10, 0, 0, 3884, 586, 1, 0, 0, 0, 3885, 3886, 7, 24, 0, 0, 3886, 3887, 7, 13, 0, 0, 3887, 3888, 7, 10, 0, 0, 3888, 3889, 7, 24, 0, 0, 3889, 3890, 7, 5, 0, 0, 3890, 3891, 7, 13, 0, 0, 3891, 3892, 7, 10, 0, 0, 3892, 588, 1, 0, 0, 0, 3893, 3894, 7, 24, 0, 0, 3894, 3895, 7, 13, 0, 0, 3895, 3896, 7, 10, 0, 0, 3896, 3897, 7, 24, 0, 0, 3897, 3898, 7, 5, 0, 0, 3898, 3899, 7, 13, 0, 0, 3899, 3900, 7, 10, 0, 0, 3900, 3901, 7, 12, 0, 0, 3901, 590, 1, 0, 0, 0, 3902, 3903, 7, 24, 0, 0, 3903, 3904, 7, 13, 0, 0, 3904, 3905, 7, 10, 0, 0, 3905, 3906, 7, 9, 0, 0, 3906, 3907, 7, 10, 0, 0, 3907, 3908, 7, 13, 0, 0, 3908, 3909, 7, 27, 0, 0, 3909, 3910, 7, 10, 0, 0, 3910, 592, 1, 0, 0, 0, 3911, 3912, 7, 24, 0, 0, 3912, 3913, 7, 13, 0, 0, 3913, 3914, 7, 17, 0, 0, 3914, 3915, 7, 19, 0, 0, 3915, 3916, 7, 13, 0, 0, 3916, 594, 1, 0, 0, 0, 3917, 3918, 7, 24, 0, 0, 3918, 3919, 7, 13, 0, 0, 3919, 3920, 7, 17, 0, 0, 3920, 3921, 7, 27, 0, 0, 3921, 3922, 7, 17, 0, 0, 3922, 3923, 7, 6, 0, 0, 3923, 3924, 7, 10, 0, 0, 3924, 3925, 7, 23, 0, 0, 3925, 3926, 7, 10, 0, 0, 3926, 3927, 7, 9, 0, 0, 3927, 596, 1, 0, 0, 0, 3928, 3929, 7, 24, 0, 0, 3929, 3930, 7, 13, 0, 0, 3930, 3931, 7, 19, 0, 0, 3931, 3932, 7, 14, 0, 0, 3932, 3933, 7, 10, 0, 0, 3933, 3934, 7, 12, 0, 0, 3934, 3935, 7, 22, 0, 0, 3935, 3936, 7, 13, 0, 0, 3936, 3937, 7, 5, 0, 0, 3937, 3938, 7, 6, 0, 0, 3938, 598, 1, 0, 0, 0, 3939, 3940, 7, 24, 0, 0, 3940, 3941, 7, 13, 0, 0, 3941, 3942, 7, 19, 0, 0, 3942, 3943, 7, 14, 0, 0, 3943, 3944, 7, 10, 0, 0, 3944, 3945, 7, 12, 0, 0, 3945, 3946, 7, 22, 0, 0, 3946, 3947, 7, 13, 0, 0, 3947, 3948, 7, 10, 0, 0, 3948, 600, 1, 0, 0, 0, 3949, 3950, 7, 24, 0, 0, 3950, 3951, 7, 13, 0, 0, 3951, 3952, 7, 19, 0, 0, 3952, 3953, 7, 23, 0, 0, 3953, 3954, 7, 13, 0, 0, 3954, 3955, 7, 5, 0, 0, 3955, 3956, 7, 15, 0, 0, 3956, 602, 1, 0, 0, 0, 3957, 3958, 7, 28, 0, 0, 3958, 3959, 7, 22, 0, 0, 3959, 3960, 7, 19, 0, 0, 3960, 3961, 7, 16, 0, 0, 3961, 3962, 7, 10, 0, 0, 3962, 604, 1, 0, 0, 0, 3963, 3964, 7, 13, 0, 0, 3964, 3965, 7, 5, 0, 0, 3965, 3966, 7, 7, 0, 0, 3966, 3967, 7, 23, 0, 0, 3967, 3968, 7, 10, 0, 0, 3968, 606, 1, 0, 0, 0, 3969, 3970, 7, 13, 0, 0, 3970, 3971, 7, 10, 0, 0, 3971, 3972, 7, 5, 0, 0, 3972, 3973, 7, 12, 0, 0, 3973, 608, 1, 0, 0, 0, 3974, 3975, 7, 13, 0, 0, 3975, 3976, 7, 10, 0, 0, 3976, 3977, 7, 5, 0, 0, 3977, 3978, 7, 9, 0, 0, 3978, 3979, 7, 9, 0, 0, 3979, 3980, 7, 17, 0, 0, 3980, 3981, 7, 23, 0, 0, 3981, 3982, 7, 7, 0, 0, 3982, 610, 1, 0, 0, 0, 3983, 3984, 7, 13, 0, 0, 3984, 3985, 7, 10, 0, 0, 3985, 3986, 7, 14, 0, 0, 3986, 3987, 7, 20, 0, 0, 3987, 3988, 7, 10, 0, 0, 3988, 3989, 7, 14, 0, 0, 3989, 3990, 7, 21, 0, 0, 3990, 612, 1, 0, 0, 0, 3991, 3992, 7, 13, 0, 0, 3992, 3993, 7, 10, 0, 0, 3993, 3994, 7, 14, 0, 0, 3994, 3995, 7, 22, 0, 0, 3995, 3996, 7, 13, 0, 0, 3996, 3997, 7, 9, 0, 0, 3997, 3998, 7, 17, 0, 0, 3998, 3999, 7, 27, 0, 0, 3999, 4000, 7, 10, 0, 0, 4000, 614, 1, 0, 0, 0, 4001, 4002, 7, 13, 0, 0, 4002, 4003, 7, 10, 0, 0, 4003, 4004, 7, 25, 0, 0, 4004, 616, 1, 0, 0, 0, 4005, 4006, 7, 13, 0, 0, 4006, 4007, 7, 10, 0, 0, 4007, 4008, 7, 25, 0, 0, 4008, 4009, 7, 13, 0, 0, 4009, 4010, 7, 10, 0, 0, 4010, 4011, 7, 9, 0, 0, 4011, 4012, 7, 20, 0, 0, 4012, 618, 1, 0, 0, 0, 4013, 4014, 7, 13, 0, 0, 4014, 4015, 7, 10, 0, 0, 4015, 4016, 7, 17, 0, 0, 4016, 4017, 7, 7, 0, 0, 4017, 4018, 7, 12, 0, 0, 4018, 4019, 7, 10, 0, 0, 4019, 4020, 7, 26, 0, 0, 4020, 620, 1, 0, 0, 0, 4021, 4022, 7, 13, 0, 0, 4022, 4023, 7, 10, 0, 0, 4023, 4024, 7, 6, 0, 0, 4024, 4025, 7, 5, 0, 0, 4025, 4026, 7, 16, 0, 0, 4026, 4027, 7, 17, 0, 0, 4027, 4028, 7, 27, 0, 0, 4028, 4029, 7, 10, 0, 0, 4029, 622, 1, 0, 0, 0, 4030, 4031, 7, 13, 0, 0, 4031, 4032, 7, 10, 0, 0, 4032, 4033, 7, 6, 0, 0, 4033, 4034, 7, 10, 0, 0, 4034, 4035, 7, 5, 0, 0, 4035, 4036, 7, 9, 0, 0, 4036, 4037, 7, 10, 0, 0, 4037, 624, 1, 0, 0, 0, 4038, 4039, 7, 13, 0, 0, 4039, 4040, 7, 10, 0, 0, 4040, 4041, 7, 7, 0, 0, 4041, 4042, 7, 5, 0, 0, 4042, 4043, 7, 15, 0, 0, 4043, 4044, 7, 10, 0, 0, 4044, 626, 1, 0, 0, 0, 4045, 4046, 7, 13, 0, 0, 4046, 4047, 7, 10, 0, 0, 4047, 4048, 7, 24, 0, 0, 4048, 4049, 7, 10, 0, 0, 4049, 4050, 7, 5, 0, 0, 4050, 4051, 7, 16, 0, 0, 4051, 4052, 7, 5, 0, 0, 4052, 4053, 7, 18, 0, 0, 4053, 4054, 7, 6, 0, 0, 4054, 4055, 7, 10, 0, 0, 4055, 628, 1, 0, 0, 0, 4056, 4057, 7, 13, 0, 0, 4057, 4058, 7, 10, 0, 0, 4058, 4059, 7, 24, 0, 0, 4059, 4060, 7, 6, 0, 0, 4060, 4061, 7, 5, 0, 0, 4061, 4062, 7, 14, 0, 0, 4062, 4063, 7, 10, 0, 0, 4063, 630, 1, 0, 0, 0, 4064, 4065, 7, 13, 0, 0, 4065, 4066, 7, 10, 0, 0, 4066, 4067, 7, 24, 0, 0, 4067, 4068, 7, 6, 0, 0, 4068, 4069, 7, 17, 0, 0, 4069, 4070, 7, 14, 0, 0, 4070, 4071, 7, 5, 0, 0, 4071, 632, 1, 0, 0, 0, 4072, 4073, 7, 13, 0, 0, 4073, 4074, 7, 10, 0, 0, 4074, 4075, 7, 9, 0, 0, 4075, 4076, 7, 10, 0, 0, 4076, 4077, 7, 16, 0, 0, 4077, 634, 1, 0, 0, 0, 4078, 4079, 7, 13, 0, 0, 4079, 4080, 7, 10, 0, 0, 4080, 4081, 7, 9, 0, 0, 4081, 4082, 7, 16, 0, 0, 4082, 4083, 7, 5, 0, 0, 4083, 4084, 7, 13, 0, 0, 4084, 4085, 7, 16, 0, 0, 4085, 636, 1, 0, 0, 0, 4086, 4087, 7, 13, 0, 0, 4087, 4088, 7, 10, 0, 0, 4088, 4089, 7, 9, 0, 0, 4089, 4090, 7, 16, 0, 0, 4090, 4091, 7, 13, 0, 0, 4091, 4092, 7, 17, 0, 0, 4092, 4093, 7, 14, 0, 0, 4093, 4094, 7, 16, 0, 0, 4094, 638, 1, 0, 0, 0, 4095, 4096, 7, 13, 0, 0, 4096, 4097, 7, 10, 0, 0, 4097, 4098, 7, 16, 0, 0, 4098, 4099, 7, 22, 0, 0, 4099, 4100, 7, 13, 0, 0, 4100, 4101, 7, 7, 0, 0, 4101, 4102, 7, 9, 0, 0, 4102, 640, 1, 0, 0, 0, 4103, 4104, 7, 13, 0, 0, 4104, 4105, 7, 10, 0, 0, 4105, 4106, 7, 27, 0, 0, 4106, 4107, 7, 19, 0, 0, 4107, 4108, 7, 21, 0, 0, 4108, 4109, 7, 10, 0, 0, 4109, 642, 1, 0, 0, 0, 4110, 4111, 7, 13, 0, 0, 4111, 4112, 7, 19, 0, 0, 4112, 4113, 7, 6, 0, 0, 4113, 4114, 7, 10, 0, 0, 4114, 644, 1, 0, 0, 0, 4115, 4116, 7, 13, 0, 0, 4116, 4117, 7, 19, 0, 0, 4117, 4118, 7, 6, 0, 0, 4118, 4119, 7, 6, 0, 0, 4119, 4120, 7, 18, 0, 0, 4120, 4121, 7, 5, 0, 0, 4121, 4122, 7, 14, 0, 0, 4122, 4123, 7, 21, 0, 0, 4123, 646, 1, 0, 0, 0, 4124, 4125, 7, 13, 0, 0, 4125, 4126, 7, 19, 0, 0, 4126, 4127, 7, 29, 0, 0, 4127, 4128, 7, 9, 0, 0, 4128, 648, 1, 0, 0, 0, 4129, 4130, 7, 13, 0, 0, 4130, 4131, 7, 22, 0, 0, 4131, 4132, 7, 6, 0, 0, 4132, 4133, 7, 10, 0, 0, 4133, 650, 1, 0, 0, 0, 4134, 4135, 7, 9, 0, 0, 4135, 4136, 7, 5, 0, 0, 4136, 4137, 7, 27, 0, 0, 4137, 4138, 7, 10, 0, 0, 4138, 4139, 7, 24, 0, 0, 4139, 4140, 7, 19, 0, 0, 4140, 4141, 7, 17, 0, 0, 4141, 4142, 7, 7, 0, 0, 4142, 4143, 7, 16, 0, 0, 4143, 652, 1, 0, 0, 0, 4144, 4145, 7, 9, 0, 0, 4145, 4146, 7, 14, 0, 0, 4146, 4147, 7, 20, 0, 0, 4147, 4148, 7, 10, 0, 0, 4148, 4149, 7, 15, 0, 0, 4149, 4150, 7, 5, 0, 0, 4150, 654, 1, 0, 0, 0, 4151, 4152, 7, 9, 0, 0, 4152, 4153, 7, 14, 0, 0, 4153, 4154, 7, 13, 0, 0, 4154, 4155, 7, 19, 0, 0, 4155, 4156, 7, 6, 0, 0, 4156, 4157, 7, 6, 0, 0, 4157, 656, 1, 0, 0, 0, 4158, 4159, 7, 9, 0, 0, 4159, 4160, 7, 10, 0, 0, 4160, 4161, 7, 5, 0, 0, 4161, 4162, 7, 13, 0, 0, 4162, 4163, 7, 14, 0, 0, 4163, 4164, 7, 20, 0, 0, 4164, 658, 1, 0, 0, 0, 4165, 4166, 7, 9, 0, 0, 4166, 4167, 7, 10, 0, 0, 4167, 4168, 7, 14, 0, 0, 4168, 4169, 7, 19, 0, 0, 4169, 4170, 7, 7, 0, 0, 4170, 4171, 7, 12, 0, 0, 4171, 660, 1, 0, 0, 0, 4172, 4173, 7, 9, 0, 0, 4173, 4174, 7, 10, 0, 0, 4174, 4175, 7, 14, 0, 0, 4175, 4176, 7, 22, 0, 0, 4176, 4177, 7, 13, 0, 0, 4177, 4178, 7, 17, 0, 0, 4178, 4179, 7, 16, 0, 0, 4179, 4180, 7, 8, 0, 0, 4180, 662, 1, 0, 0, 0, 4181, 4182, 7, 9, 0, 0, 4182, 4183, 7, 10, 0, 0, 4183, 4184, 7, 28, 0, 0, 4184, 4185, 7, 22, 0, 0, 4185, 4186, 7, 10, 0, 0, 4186, 4187, 7, 7, 0, 0, 4187, 4188, 7, 14, 0, 0, 4188, 4189, 7, 10, 0, 0, 4189, 664, 1, 0, 0, 0, 4190, 4191, 7, 9, 0, 0, 4191, 4192, 7, 10, 0, 0, 4192, 4193, 7, 28, 0, 0, 4193, 4194, 7, 22, 0, 0, 4194, 4195, 7, 10, 0, 0, 4195, 4196, 7, 7, 0, 0, 4196, 4197, 7, 14, 0, 0, 4197, 4198, 7, 10, 0, 0, 4198, 4199, 7, 9, 0, 0, 4199, 666, 1, 0, 0, 0, 4200, 4201, 7, 9, 0, 0, 4201, 4202, 7, 10, 0, 0, 4202, 4203, 7, 13, 0, 0, 4203, 4204, 7, 17, 0, 0, 4204, 4205, 7, 5, 0, 0, 4205, 4206, 7, 6, 0, 0, 4206, 4207, 7, 17, 0, 0, 4207, 4208, 7, 11, 0, 0, 4208, 4209, 7, 5, 0, 0, 4209, 4210, 7, 18, 0, 0, 4210, 4211, 7, 6, 0, 0, 4211, 4212, 7, 10, 0, 0, 4212, 668, 1, 0, 0, 0, 4213, 4214, 7, 9, 0, 0, 4214, 4215, 7, 10, 0, 0, 4215, 4216, 7, 13, 0, 0, 4216, 4217, 7, 27, 0, 0, 4217, 4218, 7, 10, 0, 0, 4218, 4219, 7, 13, 0, 0, 4219, 670, 1, 0, 0, 0, 4220, 4221, 7, 9, 0, 0, 4221, 4222, 7, 10, 0, 0, 4222, 4223, 7, 9, 0, 0, 4223, 4224, 7, 9, 0, 0, 4224, 4225, 7, 17, 0, 0, 4225, 4226, 7, 19, 0, 0, 4226, 4227, 7, 7, 0, 0, 4227, 672, 1, 0, 0, 0, 4228, 4229, 7, 9, 0, 0, 4229, 4230, 7, 10, 0, 0, 4230, 4231, 7, 16, 0, 0, 4231, 674, 1, 0, 0, 0, 4232, 4233, 7, 9, 0, 0, 4233, 4234, 7, 20, 0, 0, 4234, 4235, 7, 5, 0, 0, 4235, 4236, 7, 13, 0, 0, 4236, 4237, 7, 10, 0, 0, 4237, 676, 1, 0, 0, 0, 4238, 4239, 7, 9, 0, 0, 4239, 4240, 7, 20, 0, 0, 4240, 4241, 7, 19, 0, 0, 4241, 4242, 7, 29, 0, 0, 4242, 678, 1, 0, 0, 0, 4243, 4244, 7, 9, 0, 0, 4244, 4245, 7, 17, 0, 0, 4245, 4246, 7, 15, 0, 0, 4246, 4247, 7, 24, 0, 0, 4247, 4248, 7, 6, 0, 0, 4248, 4249, 7, 10, 0, 0, 4249, 680, 1, 0, 0, 0, 4250, 4251, 7, 9, 0, 0, 4251, 4252, 7, 7, 0, 0, 4252, 4253, 7, 5, 0, 0, 4253, 4254, 7, 24, 0, 0, 4254, 4255, 7, 9, 0, 0, 4255, 4256, 7, 20, 0, 0, 4256, 4257, 7, 19, 0, 0, 4257, 4258, 7, 16, 0, 0, 4258, 682, 1, 0, 0, 0, 4259, 4260, 7, 9, 0, 0, 4260, 4261, 7, 16, 0, 0, 4261, 4262, 7, 5, 0, 0, 4262, 4263, 7, 18, 0, 0, 4263, 4264, 7, 6, 0, 0, 4264, 4265, 7, 10, 0, 0, 4265, 684, 1, 0, 0, 0, 4266, 4267, 7, 9, 0, 0, 4267, 4268, 7, 16, 0, 0, 4268, 4269, 7, 5, 0, 0, 4269, 4270, 7, 7, 0, 0, 4270, 4271, 7, 12, 0, 0, 4271, 4272, 7, 5, 0, 0, 4272, 4273, 7, 6, 0, 0, 4273, 4274, 7, 19, 0, 0, 4274, 4275, 7, 7, 0, 0, 4275, 4276, 7, 10, 0, 0, 4276, 686, 1, 0, 0, 0, 4277, 4278, 7, 9, 0, 0, 4278, 4279, 7, 16, 0, 0, 4279, 4280, 7, 5, 0, 0, 4280, 4281, 7, 13, 0, 0, 4281, 4282, 7, 16, 0, 0, 4282, 688, 1, 0, 0, 0, 4283, 4284, 7, 9, 0, 0, 4284, 4285, 7, 16, 0, 0, 4285, 4286, 7, 5, 0, 0, 4286, 4287, 7, 16, 0, 0, 4287, 4288, 7, 10, 0, 0, 4288, 4289, 7, 15, 0, 0, 4289, 4290, 7, 10, 0, 0, 4290, 4291, 7, 7, 0, 0, 4291, 4292, 7, 16, 0, 0, 4292, 690, 1, 0, 0, 0, 4293, 4294, 7, 9, 0, 0, 4294, 4295, 7, 16, 0, 0, 4295, 4296, 7, 5, 0, 0, 4296, 4297, 7, 16, 0, 0, 4297, 4298, 7, 17, 0, 0, 4298, 4299, 7, 9, 0, 0, 4299, 4300, 7, 16, 0, 0, 4300, 4301, 7, 17, 0, 0, 4301, 4302, 7, 14, 0, 0, 4302, 4303, 7, 9, 0, 0, 4303, 692, 1, 0, 0, 0, 4304, 4305, 7, 9, 0, 0, 4305, 4306, 7, 16, 0, 0, 4306, 4307, 7, 12, 0, 0, 4307, 4308, 7, 17, 0, 0, 4308, 4309, 7, 7, 0, 0, 4309, 694, 1, 0, 0, 0, 4310, 4311, 7, 9, 0, 0, 4311, 4312, 7, 16, 0, 0, 4312, 4313, 7, 12, 0, 0, 4313, 4314, 7, 19, 0, 0, 4314, 4315, 7, 22, 0, 0, 4315, 4316, 7, 16, 0, 0, 4316, 696, 1, 0, 0, 0, 4317, 4318, 7, 9, 0, 0, 4318, 4319, 7, 16, 0, 0, 4319, 4320, 7, 19, 0, 0, 4320, 4321, 7, 13, 0, 0, 4321, 4322, 7, 5, 0, 0, 4322, 4323, 7, 23, 0, 0, 4323, 4324, 7, 10, 0, 0, 4324, 698, 1, 0, 0, 0, 4325, 4326, 7, 9, 0, 0, 4326, 4327, 7, 16, 0, 0, 4327, 4328, 7, 13, 0, 0, 4328, 4329, 7, 17, 0, 0, 4329, 4330, 7, 14, 0, 0, 4330, 4331, 7, 16, 0, 0, 4331, 700, 1, 0, 0, 0, 4332, 4333, 7, 9, 0, 0, 4333, 4334, 7, 16, 0, 0, 4334, 4335, 7, 13, 0, 0, 4335, 4336, 7, 17, 0, 0, 4336, 4337, 7, 24, 0, 0, 4337, 702, 1, 0, 0, 0, 4338, 4339, 7, 9, 0, 0, 4339, 4340, 7, 8, 0, 0, 4340, 4341, 7, 9, 0, 0, 4341, 4342, 7, 17, 0, 0, 4342, 4343, 7, 12, 0, 0, 4343, 704, 1, 0, 0, 0, 4344, 4345, 7, 9, 0, 0, 4345, 4346, 7, 8, 0, 0, 4346, 4347, 7, 9, 0, 0, 4347, 4348, 7, 16, 0, 0, 4348, 4349, 7, 10, 0, 0, 4349, 4350, 7, 15, 0, 0, 4350, 706, 1, 0, 0, 0, 4351, 4352, 7, 16, 0, 0, 4352, 4353, 7, 5, 0, 0, 4353, 4354, 7, 18, 0, 0, 4354, 4355, 7, 6, 0, 0, 4355, 4356, 7, 10, 0, 0, 4356, 4357, 7, 9, 0, 0, 4357, 708, 1, 0, 0, 0, 4358, 4359, 7, 16, 0, 0, 4359, 4360, 7, 5, 0, 0, 4360, 4361, 7, 18, 0, 0, 4361, 4362, 7, 6, 0, 0, 4362, 4363, 7, 10, 0, 0, 4363, 4364, 7, 9, 0, 0, 4364, 4365, 7, 24, 0, 0, 4365, 4366, 7, 5, 0, 0, 4366, 4367, 7, 14, 0, 0, 4367, 4368, 7, 10, 0, 0, 4368, 710, 1, 0, 0, 0, 4369, 4370, 7, 16, 0, 0, 4370, 4371, 7, 10, 0, 0, 4371, 4372, 7, 15, 0, 0, 4372, 4373, 7, 24, 0, 0, 4373, 712, 1, 0, 0, 0, 4374, 4375, 7, 16, 0, 0, 4375, 4376, 7, 10, 0, 0, 4376, 4377, 7, 15, 0, 0, 4377, 4378, 7, 24, 0, 0, 4378, 4379, 7, 6, 0, 0, 4379, 4380, 7, 5, 0, 0, 4380, 4381, 7, 16, 0, 0, 4381, 4382, 7, 10, 0, 0, 4382, 714, 1, 0, 0, 0, 4383, 4384, 7, 16, 0, 0, 4384, 4385, 7, 10, 0, 0, 4385, 4386, 7, 15, 0, 0, 4386, 4387, 7, 24, 0, 0, 4387, 4388, 7, 19, 0, 0, 4388, 4389, 7, 13, 0, 0, 4389, 4390, 7, 5, 0, 0, 4390, 4391, 7, 13, 0, 0, 4391, 4392, 7, 8, 0, 0, 4392, 716, 1, 0, 0, 0, 4393, 4394, 7, 16, 0, 0, 4394, 4395, 7, 10, 0, 0, 4395, 4396, 7, 26, 0, 0, 4396, 4397, 7, 16, 0, 0, 4397, 718, 1, 0, 0, 0, 4398, 4399, 7, 16, 0, 0, 4399, 4400, 7, 13, 0, 0, 4400, 4401, 7, 5, 0, 0, 4401, 4402, 7, 7, 0, 0, 4402, 4403, 7, 9, 0, 0, 4403, 4404, 7, 5, 0, 0, 4404, 4405, 7, 14, 0, 0, 4405, 4406, 7, 16, 0, 0, 4406, 4407, 7, 17, 0, 0, 4407, 4408, 7, 19, 0, 0, 4408, 4409, 7, 7, 0, 0, 4409, 720, 1, 0, 0, 0, 4410, 4411, 7, 16, 0, 0, 4411, 4412, 7, 13, 0, 0, 4412, 4413, 7, 17, 0, 0, 4413, 4414, 7, 23, 0, 0, 4414, 4415, 7, 23, 0, 0, 4415, 4416, 7, 10, 0, 0, 4416, 4417, 7, 13, 0, 0, 4417, 722, 1, 0, 0, 0, 4418, 4419, 7, 16, 0, 0, 4419, 4420, 7, 13, 0, 0, 4420, 4421, 7, 22, 0, 0, 4421, 4422, 7, 7, 0, 0, 4422, 4423, 7, 14, 0, 0, 4423, 4424, 7, 5, 0, 0, 4424, 4425, 7, 16, 0, 0, 4425, 4426, 7, 10, 0, 0, 4426, 724, 1, 0, 0, 0, 4427, 4428, 7, 16, 0, 0, 4428, 4429, 7, 13, 0, 0, 4429, 4430, 7, 22, 0, 0, 4430, 4431, 7, 9, 0, 0, 4431, 4432, 7, 16, 0, 0, 4432, 4433, 7, 10, 0, 0, 4433, 4434, 7, 12, 0, 0, 4434, 726, 1, 0, 0, 0, 4435, 4436, 7, 16, 0, 0, 4436, 4437, 7, 8, 0, 0, 4437, 4438, 7, 24, 0, 0, 4438, 4439, 7, 10, 0, 0, 4439, 728, 1, 0, 0, 0, 4440, 4441, 7, 16, 0, 0, 4441, 4442, 7, 8, 0, 0, 4442, 4443, 7, 24, 0, 0, 4443, 4444, 7, 10, 0, 0, 4444, 4445, 7, 9, 0, 0, 4445, 730, 1, 0, 0, 0, 4446, 4447, 7, 22, 0, 0, 4447, 4448, 7, 7, 0, 0, 4448, 4449, 7, 18, 0, 0, 4449, 4450, 7, 19, 0, 0, 4450, 4451, 7, 22, 0, 0, 4451, 4452, 7, 7, 0, 0, 4452, 4453, 7, 12, 0, 0, 4453, 4454, 7, 10, 0, 0, 4454, 4455, 7, 12, 0, 0, 4455, 732, 1, 0, 0, 0, 4456, 4457, 7, 22, 0, 0, 4457, 4458, 7, 7, 0, 0, 4458, 4459, 7, 14, 0, 0, 4459, 4460, 7, 19, 0, 0, 4460, 4461, 7, 15, 0, 0, 4461, 4462, 7, 15, 0, 0, 4462, 4463, 7, 17, 0, 0, 4463, 4464, 7, 16, 0, 0, 4464, 4465, 7, 16, 0, 0, 4465, 4466, 7, 10, 0, 0, 4466, 4467, 7, 12, 0, 0, 4467, 734, 1, 0, 0, 0, 4468, 4469, 7, 22, 0, 0, 4469, 4470, 7, 7, 0, 0, 4470, 4471, 7, 10, 0, 0, 4471, 4472, 7, 7, 0, 0, 4472, 4473, 7, 14, 0, 0, 4473, 4474, 7, 13, 0, 0, 4474, 4475, 7, 8, 0, 0, 4475, 4476, 7, 24, 0, 0, 4476, 4477, 7, 16, 0, 0, 4477, 4478, 7, 10, 0, 0, 4478, 4479, 7, 12, 0, 0, 4479, 736, 1, 0, 0, 0, 4480, 4481, 7, 22, 0, 0, 4481, 4482, 7, 7, 0, 0, 4482, 4483, 7, 21, 0, 0, 4483, 4484, 7, 7, 0, 0, 4484, 4485, 7, 19, 0, 0, 4485, 4486, 7, 29, 0, 0, 4486, 4487, 7, 7, 0, 0, 4487, 738, 1, 0, 0, 0, 4488, 4489, 7, 22, 0, 0, 4489, 4490, 7, 7, 0, 0, 4490, 4491, 7, 6, 0, 0, 4491, 4492, 7, 17, 0, 0, 4492, 4493, 7, 9, 0, 0, 4493, 4494, 7, 16, 0, 0, 4494, 4495, 7, 10, 0, 0, 4495, 4496, 7, 7, 0, 0, 4496, 740, 1, 0, 0, 0, 4497, 4498, 7, 22, 0, 0, 4498, 4499, 7, 7, 0, 0, 4499, 4500, 7, 6, 0, 0, 4500, 4501, 7, 19, 0, 0, 4501, 4502, 7, 23, 0, 0, 4502, 4503, 7, 23, 0, 0, 4503, 4504, 7, 10, 0, 0, 4504, 4505, 7, 12, 0, 0, 4505, 742, 1, 0, 0, 0, 4506, 4507, 7, 22, 0, 0, 4507, 4508, 7, 7, 0, 0, 4508, 4509, 7, 16, 0, 0, 4509, 4510, 7, 17, 0, 0, 4510, 4511, 7, 6, 0, 0, 4511, 744, 1, 0, 0, 0, 4512, 4513, 7, 22, 0, 0, 4513, 4514, 7, 24, 0, 0, 4514, 4515, 7, 12, 0, 0, 4515, 4516, 7, 5, 0, 0, 4516, 4517, 7, 16, 0, 0, 4517, 4518, 7, 10, 0, 0, 4518, 746, 1, 0, 0, 0, 4519, 4520, 7, 27, 0, 0, 4520, 4521, 7, 5, 0, 0, 4521, 4522, 7, 14, 0, 0, 4522, 4523, 7, 22, 0, 0, 4523, 4524, 7, 22, 0, 0, 4524, 4525, 7, 15, 0, 0, 4525, 748, 1, 0, 0, 0, 4526, 4527, 7, 27, 0, 0, 4527, 4528, 7, 5, 0, 0, 4528, 4529, 7, 6, 0, 0, 4529, 4530, 7, 17, 0, 0, 4530, 4531, 7, 12, 0, 0, 4531, 750, 1, 0, 0, 0, 4532, 4533, 7, 27, 0, 0, 4533, 4534, 7, 5, 0, 0, 4534, 4535, 7, 6, 0, 0, 4535, 4536, 7, 17, 0, 0, 4536, 4537, 7, 12, 0, 0, 4537, 4538, 7, 5, 0, 0, 4538, 4539, 7, 16, 0, 0, 4539, 4540, 7, 10, 0, 0, 4540, 752, 1, 0, 0, 0, 4541, 4542, 7, 27, 0, 0, 4542, 4543, 7, 5, 0, 0, 4543, 4544, 7, 6, 0, 0, 4544, 4545, 7, 17, 0, 0, 4545, 4546, 7, 12, 0, 0, 4546, 4547, 7, 5, 0, 0, 4547, 4548, 7, 16, 0, 0, 4548, 4549, 7, 19, 0, 0, 4549, 4550, 7, 13, 0, 0, 4550, 754, 1, 0, 0, 0, 4551, 4552, 7, 27, 0, 0, 4552, 4553, 7, 5, 0, 0, 4553, 4554, 7, 13, 0, 0, 4554, 4555, 7, 8, 0, 0, 4555, 4556, 7, 17, 0, 0, 4556, 4557, 7, 7, 0, 0, 4557, 4558, 7, 23, 0, 0, 4558, 756, 1, 0, 0, 0, 4559, 4560, 7, 27, 0, 0, 4560, 4561, 7, 10, 0, 0, 4561, 4562, 7, 13, 0, 0, 4562, 4563, 7, 9, 0, 0, 4563, 4564, 7, 17, 0, 0, 4564, 4565, 7, 19, 0, 0, 4565, 4566, 7, 7, 0, 0, 4566, 758, 1, 0, 0, 0, 4567, 4568, 7, 27, 0, 0, 4568, 4569, 7, 17, 0, 0, 4569, 4570, 7, 10, 0, 0, 4570, 4571, 7, 29, 0, 0, 4571, 760, 1, 0, 0, 0, 4572, 4573, 7, 27, 0, 0, 4573, 4574, 7, 19, 0, 0, 4574, 4575, 7, 6, 0, 0, 4575, 4576, 7, 5, 0, 0, 4576, 4577, 7, 16, 0, 0, 4577, 4578, 7, 17, 0, 0, 4578, 4579, 7, 6, 0, 0, 4579, 4580, 7, 10, 0, 0, 4580, 762, 1, 0, 0, 0, 4581, 4582, 7, 29, 0, 0, 4582, 4583, 7, 20, 0, 0, 4583, 4584, 7, 17, 0, 0, 4584, 4585, 7, 16, 0, 0, 4585, 4586, 7, 10, 0, 0, 4586, 4587, 7, 9, 0, 0, 4587, 4588, 7, 24, 0, 0, 4588, 4589, 7, 5, 0, 0, 4589, 4590, 7, 14, 0, 0, 4590, 4591, 7, 10, 0, 0, 4591, 764, 1, 0, 0, 0, 4592, 4593, 7, 29, 0, 0, 4593, 4594, 7, 17, 0, 0, 4594, 4595, 7, 16, 0, 0, 4595, 4596, 7, 20, 0, 0, 4596, 4597, 7, 19, 0, 0, 4597, 4598, 7, 22, 0, 0, 4598, 4599, 7, 16, 0, 0, 4599, 766, 1, 0, 0, 0, 4600, 4601, 7, 29, 0, 0, 4601, 4602, 7, 19, 0, 0, 4602, 4603, 7, 13, 0, 0, 4603, 4604, 7, 21, 0, 0, 4604, 768, 1, 0, 0, 0, 4605, 4606, 7, 29, 0, 0, 4606, 4607, 7, 13, 0, 0, 4607, 4608, 7, 5, 0, 0, 4608, 4609, 7, 24, 0, 0, 4609, 4610, 7, 24, 0, 0, 4610, 4611, 7, 10, 0, 0, 4611, 4612, 7, 13, 0, 0, 4612, 770, 1, 0, 0, 0, 4613, 4614, 7, 29, 0, 0, 4614, 4615, 7, 13, 0, 0, 4615, 4616, 7, 17, 0, 0, 4616, 4617, 7, 16, 0, 0, 4617, 4618, 7, 10, 0, 0, 4618, 772, 1, 0, 0, 0, 4619, 4620, 7, 26, 0, 0, 4620, 4621, 7, 15, 0, 0, 4621, 4622, 7, 6, 0, 0, 4622, 774, 1, 0, 0, 0, 4623, 4624, 7, 8, 0, 0, 4624, 4625, 7, 10, 0, 0, 4625, 4626, 7, 5, 0, 0, 4626, 4627, 7, 13, 0, 0, 4627, 776, 1, 0, 0, 0, 4628, 4629, 7, 8, 0, 0, 4629, 4630, 7, 10, 0, 0, 4630, 4631, 7, 9, 0, 0, 4631, 778, 1, 0, 0, 0, 4632, 4633, 7, 11, 0, 0, 4633, 4634, 7, 19, 0, 0, 4634, 4635, 7, 7, 0, 0, 4635, 4636, 7, 10, 0, 0, 4636, 780, 1, 0, 0, 0, 4637, 4638, 7, 28, 0, 0, 4638, 4639, 7, 22, 0, 0, 4639, 4640, 7, 5, 0, 0, 4640, 4641, 7, 6, 0, 0, 4641, 4642, 7, 17, 0, 0, 4642, 4643, 7, 25, 0, 0, 4643, 4644, 7, 8, 0, 0, 4644, 782, 1, 0, 0, 0, 4645, 4646, 7, 14, 0, 0, 4646, 4647, 7, 19, 0, 0, 4647, 4648, 7, 7, 0, 0, 4648, 4649, 7, 7, 0, 0, 4649, 4650, 7, 10, 0, 0, 4650, 4651, 7, 14, 0, 0, 4651, 4652, 7, 16, 0, 0, 4652, 784, 1, 0, 0, 0, 4653, 4654, 7, 16, 0, 0, 4654, 4655, 7, 19, 0, 0, 4655, 4656, 7, 24, 0, 0, 4656, 786, 1, 0, 0, 0, 4657, 4658, 7, 27, 0, 0, 4658, 4659, 7, 5, 0, 0, 4659, 4660, 7, 13, 0, 0, 4660, 4661, 7, 18, 0, 0, 4661, 4662, 7, 8, 0, 0, 4662, 4663, 7, 16, 0, 0, 4663, 4664, 7, 10, 0, 0, 4664, 788, 1, 0, 0, 0, 4665, 4666, 7, 27, 0, 0, 4666, 4667, 7, 5, 0, 0, 4667, 4668, 7, 13, 0, 0, 4668, 4669, 7, 18, 0, 0, 4669, 4670, 7, 17, 0, 0, 4670, 4671, 7, 7, 0, 0, 4671, 4672, 7, 5, 0, 0, 4672, 4673, 7, 13, 0, 0, 4673, 4674, 7, 8, 0, 0, 4674, 790, 1, 0, 0, 0, 4675, 4676, 7, 14, 0, 0, 4676, 4677, 7, 19, 0, 0, 4677, 4678, 7, 7, 0, 0, 4678, 4679, 7, 30, 0, 0, 4679, 4680, 7, 22, 0, 0, 4680, 4681, 7, 7, 0, 0, 4681, 4682, 7, 14, 0, 0, 4682, 4683, 7, 16, 0, 0, 4683, 4684, 7, 17, 0, 0, 4684, 4685, 7, 19, 0, 0, 4685, 4686, 7, 7, 0, 0, 4686, 792, 1, 0, 0, 0, 4687, 4688, 7, 12, 0, 0, 4688, 4689, 7, 10, 0, 0, 4689, 4690, 7, 25, 0, 0, 4690, 4691, 7, 17, 0, 0, 4691, 4692, 7, 7, 0, 0, 4692, 4693, 7, 17, 0, 0, 4693, 4694, 7, 16, 0, 0, 4694, 4695, 7, 17, 0, 0, 4695, 4696, 7, 19, 0, 0, 4696, 4697, 7, 7, 0, 0, 4697, 794, 1, 0, 0, 0, 4698, 4699, 7, 12, 0, 0, 4699, 4700, 7, 5, 0, 0, 4700, 4701, 7, 16, 0, 0, 4701, 4702, 7, 5, 0, 0, 4702, 4703, 7, 9, 0, 0, 4703, 4704, 7, 20, 0, 0, 4704, 4705, 7, 5, 0, 0, 4705, 4706, 7, 13, 0, 0, 4706, 4707, 7, 10, 0, 0, 4707, 796, 1, 0, 0, 0, 4708, 4709, 7, 25, 0, 0, 4709, 4710, 7, 17, 0, 0, 4710, 4711, 7, 6, 0, 0, 4711, 4712, 7, 10, 0, 0, 4712, 798, 1, 0, 0, 0, 4713, 4714, 7, 24, 0, 0, 4714, 4715, 7, 22, 0, 0, 4715, 4716, 7, 18, 0, 0, 4716, 4717, 7, 6, 0, 0, 4717, 4718, 7, 17, 0, 0, 4718, 4719, 7, 14, 0, 0, 4719, 4720, 7, 5, 0, 0, 4720, 4721, 7, 14, 0, 0, 4721, 4722, 7, 14, 0, 0, 4722, 4723, 7, 10, 0, 0, 4723, 4724, 7, 9, 0, 0, 4724, 4725, 7, 9, 0, 0, 4725, 4726, 7, 17, 0, 0, 4726, 4727, 7, 18, 0, 0, 4727, 4728, 7, 6, 0, 0, 4728, 4729, 7, 10, 0, 0, 4729, 800, 1, 0, 0, 0, 4730, 4731, 7, 17, 0, 0, 4731, 4732, 7, 7, 0, 0, 4732, 4733, 7, 14, 0, 0, 4733, 4734, 7, 6, 0, 0, 4734, 4735, 7, 22, 0, 0, 4735, 4736, 7, 12, 0, 0, 4736, 4737, 7, 10, 0, 0, 4737, 4738, 7, 7, 0, 0, 4738, 4739, 7, 10, 0, 0, 4739, 4740, 7, 29, 0, 0, 4740, 802, 1, 0, 0, 0, 4741, 4742, 7, 17, 0, 0, 4742, 4743, 7, 5, 0, 0, 4743, 4744, 7, 15, 0, 0, 4744, 4745, 5, 95, 0, 0, 4745, 4746, 7, 13, 0, 0, 4746, 4747, 7, 19, 0, 0, 4747, 4748, 7, 6, 0, 0, 4748, 4749, 7, 10, 0, 0, 4749, 804, 1, 0, 0, 0, 4750, 4751, 7, 14, 0, 0, 4751, 4752, 7, 5, 0, 0, 4752, 4753, 7, 16, 0, 0, 4753, 4754, 7, 5, 0, 0, 4754, 4755, 7, 6, 0, 0, 4755, 4756, 7, 19, 0, 0, 4756, 4757, 7, 23, 0, 0, 4757, 4758, 5, 95, 0, 0, 4758, 4759, 7, 13, 0, 0, 4759, 4760, 7, 19, 0, 0, 4760, 4761, 7, 6, 0, 0, 4761, 4762, 7, 10, 0, 0, 4762, 806, 1, 0, 0, 0, 4763, 4764, 7, 14, 0, 0, 4764, 4765, 7, 5, 0, 0, 4765, 4766, 7, 16, 0, 0, 4766, 4767, 7, 5, 0, 0, 4767, 4768, 7, 6, 0, 0, 4768, 4769, 7, 19, 0, 0, 4769, 4770, 7, 23, 0, 0, 4770, 4771, 5, 95, 0, 0, 4771, 4772, 7, 17, 0, 0, 4772, 4773, 7, 12, 0, 0, 4773, 808, 1, 0, 0, 0, 4774, 4775, 7, 20, 0, 0, 4775, 4776, 7, 17, 0, 0, 4776, 4777, 7, 27, 0, 0, 4777, 4778, 7, 10, 0, 0, 4778, 810, 1, 0, 0, 0, 4779, 4780, 7, 15, 0, 0, 4780, 4781, 7, 10, 0, 0, 4781, 4782, 7, 16, 0, 0, 4782, 4783, 7, 5, 0, 0, 4783, 4784, 7, 9, 0, 0, 4784, 4785, 7, 16, 0, 0, 4785, 4786, 7, 19, 0, 0, 4786, 4787, 7, 13, 0, 0, 4787, 4788, 7, 10, 0, 0, 4788, 812, 1, 0, 0, 0, 4789, 4790, 7, 22, 0, 0, 4790, 4791, 7, 13, 0, 0, 4791, 4792, 7, 17, 0, 0, 4792, 814, 1, 0, 0, 0, 4793, 4794, 7, 24, 0, 0, 4794, 4795, 7, 19, 0, 0, 4795, 4796, 7, 9, 0, 0, 4796, 4797, 7, 16, 0, 0, 4797, 4798, 7, 23, 0, 0, 4798, 4799, 7, 13, 0, 0, 4799, 4800, 7, 10, 0, 0, 4800, 4801, 7, 9, 0, 0, 4801, 816, 1, 0, 0, 0, 4802, 4803, 7, 15, 0, 0, 4803, 4804, 7, 8, 0, 0, 4804, 4805, 7, 9, 0, 0, 4805, 4806, 7, 28, 0, 0, 4806, 4807, 7, 6, 0, 0, 4807, 818, 1, 0, 0, 0, 4808, 4809, 7, 9, 0, 0, 4809, 4810, 7, 10, 0, 0, 4810, 4811, 7, 14, 0, 0, 4811, 4812, 7, 13, 0, 0, 4812, 4813, 7, 10, 0, 0, 4813, 4814, 7, 16, 0, 0, 4814, 4815, 5, 95, 0, 0, 4815, 4816, 7, 5, 0, 0, 4816, 4817, 7, 13, 0, 0, 4817, 4818, 7, 7, 0, 0, 4818, 820, 1, 0, 0, 0, 4819, 4820, 7, 21, 0, 0, 4820, 4821, 7, 17, 0, 0, 4821, 4822, 7, 7, 0, 0, 4822, 4823, 7, 10, 0, 0, 4823, 4824, 7, 9, 0, 0, 4824, 4825, 7, 17, 0, 0, 4825, 4826, 7, 9, 0, 0, 4826, 822, 1, 0, 0, 0, 4827, 4828, 7, 21, 0, 0, 4828, 4829, 7, 5, 0, 0, 4829, 4830, 7, 25, 0, 0, 4830, 4831, 7, 21, 0, 0, 4831, 4832, 7, 5, 0, 0, 4832, 824, 1, 0, 0, 0, 4833, 4834, 7, 15, 0, 0, 4834, 4835, 7, 9, 0, 0, 4835, 4836, 7, 21, 0, 0, 4836, 826, 1, 0, 0, 0, 4837, 4838, 7, 5, 0, 0, 4838, 4839, 7, 22, 0, 0, 4839, 4840, 7, 16, 0, 0, 4840, 4841, 7, 20, 0, 0, 4841, 4842, 7, 10, 0, 0, 4842, 4843, 7, 7, 0, 0, 4843, 4844, 7, 16, 0, 0, 4844, 4845, 7, 17, 0, 0, 4845, 4846, 7, 14, 0, 0, 4846, 4847, 7, 5, 0, 0, 4847, 4848, 7, 16, 0, 0, 4848, 4849, 7, 17, 0, 0, 4849, 4850, 7, 19, 0, 0, 4850, 4851, 7, 7, 0, 0, 4851, 828, 1, 0, 0, 0, 4852, 4853, 7, 5, 0, 0, 4853, 4854, 7, 22, 0, 0, 4854, 4855, 7, 16, 0, 0, 4855, 4856, 7, 20, 0, 0, 4856, 4857, 7, 10, 0, 0, 4857, 4858, 7, 7, 0, 0, 4858, 4859, 7, 16, 0, 0, 4859, 4860, 7, 17, 0, 0, 4860, 4861, 7, 14, 0, 0, 4861, 4862, 7, 5, 0, 0, 4862, 4863, 7, 16, 0, 0, 4863, 4864, 7, 17, 0, 0, 4864, 4865, 7, 19, 0, 0, 4865, 4866, 7, 7, 0, 0, 4866, 4867, 5, 95, 0, 0, 4867, 4868, 7, 5, 0, 0, 4868, 4869, 7, 13, 0, 0, 4869, 4870, 7, 7, 0, 0, 4870, 830, 1, 0, 0, 0, 4871, 4872, 7, 9, 0, 0, 4872, 4873, 7, 10, 0, 0, 4873, 4874, 7, 9, 0, 0, 4874, 4875, 7, 9, 0, 0, 4875, 4876, 7, 17, 0, 0, 4876, 4877, 7, 19, 0, 0, 4877, 4878, 7, 7, 0, 0, 4878, 832, 1, 0, 0, 0, 4879, 4880, 7, 15, 0, 0, 4880, 4881, 7, 16, 0, 0, 4881, 4882, 7, 6, 0, 0, 4882, 4883, 7, 9, 0, 0, 4883, 834, 1, 0, 0, 0, 4884, 4885, 7, 15, 0, 0, 4885, 4886, 7, 5, 0, 0, 4886, 4887, 7, 9, 0, 0, 4887, 4888, 7, 21, 0, 0, 4888, 4889, 7, 17, 0, 0, 4889, 4890, 7, 7, 0, 0, 4890, 4891, 7, 23, 0, 0, 4891, 836, 1, 0, 0, 0, 4892, 4893, 7, 13, 0, 0, 4893, 4894, 7, 6, 0, 0, 4894, 4895, 7, 9, 0, 0, 4895, 838, 1, 0, 0, 0, 4896, 4897, 7, 17, 0, 0, 4897, 4898, 7, 12, 0, 0, 4898, 4899, 7, 10, 0, 0, 4899, 4900, 7, 7, 0, 0, 4900, 4901, 7, 16, 0, 0, 4901, 4902, 7, 17, 0, 0, 4902, 4903, 7, 16, 0, 0, 4903, 4904, 7, 8, 0, 0, 4904, 840, 1, 0, 0, 0, 4905, 4906, 7, 24, 0, 0, 4906, 4907, 7, 13, 0, 0, 4907, 4908, 7, 19, 0, 0, 4908, 4909, 7, 27, 0, 0, 4909, 4910, 7, 17, 0, 0, 4910, 4911, 7, 12, 0, 0, 4911, 4912, 7, 10, 0, 0, 4912, 4913, 7, 13, 0, 0, 4913, 842, 1, 0, 0, 0, 4914, 4915, 7, 24, 0, 0, 4915, 4916, 7, 13, 0, 0, 4916, 4917, 7, 19, 0, 0, 4917, 4918, 7, 16, 0, 0, 4918, 4919, 7, 10, 0, 0, 4919, 4920, 7, 14, 0, 0, 4920, 4921, 7, 16, 0, 0, 4921, 4922, 7, 10, 0, 0, 4922, 4923, 7, 12, 0, 0, 4923, 844, 1, 0, 0, 0, 4924, 4925, 7, 15, 0, 0, 4925, 4926, 7, 19, 0, 0, 4926, 4927, 7, 12, 0, 0, 4927, 4928, 7, 10, 0, 0, 4928, 4929, 7, 6, 0, 0, 4929, 846, 1, 0, 0, 0, 4930, 4931, 7, 16, 0, 0, 4931, 4932, 7, 5, 0, 0, 4932, 4933, 7, 13, 0, 0, 4933, 4934, 7, 23, 0, 0, 4934, 4935, 7, 10, 0, 0, 4935, 4936, 7, 16, 0, 0, 4936, 848, 1, 0, 0, 0, 4937, 4938, 7, 9, 0, 0, 4938, 4939, 7, 5, 0, 0, 4939, 4940, 7, 23, 0, 0, 4940, 4941, 7, 10, 0, 0, 4941, 4942, 7, 15, 0, 0, 4942, 4943, 7, 5, 0, 0, 4943, 4944, 7, 21, 0, 0, 4944, 4945, 7, 10, 0, 0, 4945, 4946, 7, 13, 0, 0, 4946, 850, 1, 0, 0, 0, 4947, 4948, 7, 5, 0, 0, 4948, 4949, 7, 22, 0, 0, 4949, 4950, 7, 16, 0, 0, 4950, 4951, 7, 19, 0, 0, 4951, 852, 1, 0, 0, 0, 4952, 4953, 7, 15, 0, 0, 4953, 4954, 7, 19, 0, 0, 4954, 4955, 7, 12, 0, 0, 4955, 4956, 7, 10, 0, 0, 4956, 4957, 7, 6, 0, 0, 4957, 4958, 5, 95, 0, 0, 4958, 4959, 7, 16, 0, 0, 4959, 4960, 7, 8, 0, 0, 4960, 4961, 7, 24, 0, 0, 4961, 4962, 7, 10, 0, 0, 4962, 854, 1, 0, 0, 0, 4963, 4964, 7, 24, 0, 0, 4964, 4965, 7, 13, 0, 0, 4965, 4966, 7, 19, 0, 0, 4966, 4967, 7, 18, 0, 0, 4967, 4968, 7, 6, 0, 0, 4968, 4969, 7, 10, 0, 0, 4969, 4970, 7, 15, 0, 0, 4970, 4971, 5, 95, 0, 0, 4971, 4972, 7, 16, 0, 0, 4972, 4973, 7, 8, 0, 0, 4973, 4974, 7, 24, 0, 0, 4974, 4975, 7, 10, 0, 0, 4975, 856, 1, 0, 0, 0, 4976, 4977, 7, 19, 0, 0, 4977, 4978, 7, 18, 0, 0, 4978, 4979, 7, 30, 0, 0, 4979, 4980, 7, 10, 0, 0, 4980, 4981, 7, 14, 0, 0, 4981, 4982, 7, 16, 0, 0, 4982, 4983, 7, 17, 0, 0, 4983, 4984, 7, 27, 0, 0, 4984, 4985, 7, 10, 0, 0, 4985, 858, 1, 0, 0, 0, 4986, 4987, 7, 24, 0, 0, 4987, 4988, 7, 13, 0, 0, 4988, 4989, 7, 10, 0, 0, 4989, 4990, 7, 24, 0, 0, 4990, 4991, 7, 13, 0, 0, 4991, 4992, 7, 19, 0, 0, 4992, 4993, 7, 14, 0, 0, 4993, 4994, 7, 10, 0, 0, 4994, 4995, 7, 9, 0, 0, 4995, 4996, 7, 9, 0, 0, 4996, 4997, 7, 19, 0, 0, 4997, 4998, 7, 13, 0, 0, 4998, 4999, 7, 9, 0, 0, 4999, 860, 1, 0, 0, 0, 5000, 5001, 7, 20, 0, 0, 5001, 5002, 7, 8, 0, 0, 5002, 5003, 7, 24, 0, 0, 5003, 5004, 7, 10, 0, 0, 5004, 5005, 7, 13, 0, 0, 5005, 5006, 7, 24, 0, 0, 5006, 5007, 7, 5, 0, 0, 5007, 5008, 7, 13, 0, 0, 5008, 5009, 7, 5, 0, 0, 5009, 5010, 7, 15, 0, 0, 5010, 5011, 7, 10, 0, 0, 5011, 5012, 7, 16, 0, 0, 5012, 5013, 7, 10, 0, 0, 5013, 5014, 7, 13, 0, 0, 5014, 5015, 7, 9, 0, 0, 5015, 862, 1, 0, 0, 0, 5016, 5017, 7, 26, 0, 0, 5017, 5018, 7, 23, 0, 0, 5018, 5019, 7, 18, 0, 0, 5019, 5020, 7, 19, 0, 0, 5020, 5021, 7, 19, 0, 0, 5021, 5022, 7, 9, 0, 0, 5022, 5023, 7, 16, 0, 0, 5023, 864, 1, 0, 0, 0, 5024, 5025, 7, 15, 0, 0, 5025, 5026, 7, 6, 0, 0, 5026, 5027, 7, 24, 0, 0, 5027, 866, 1, 0, 0, 0, 5028, 5029, 7, 6, 0, 0, 5029, 5030, 7, 17, 0, 0, 5030, 5031, 7, 7, 0, 0, 5031, 5032, 7, 10, 0, 0, 5032, 5033, 7, 5, 0, 0, 5033, 5034, 7, 13, 0, 0, 5034, 5035, 5, 95, 0, 0, 5035, 5036, 7, 6, 0, 0, 5036, 5037, 7, 10, 0, 0, 5037, 5038, 7, 5, 0, 0, 5038, 5039, 7, 13, 0, 0, 5039, 5040, 7, 7, 0, 0, 5040, 5041, 7, 10, 0, 0, 5041, 5042, 7, 13, 0, 0, 5042, 868, 1, 0, 0, 0, 5043, 5044, 7, 21, 0, 0, 5044, 5045, 7, 15, 0, 0, 5045, 5046, 7, 10, 0, 0, 5046, 5047, 7, 5, 0, 0, 5047, 5048, 7, 7, 0, 0, 5048, 5049, 7, 9, 0, 0, 5049, 870, 1, 0, 0, 0, 5050, 5051, 7, 25, 0, 0, 5051, 5052, 7, 19, 0, 0, 5052, 5053, 7, 13, 0, 0, 5053, 5054, 7, 10, 0, 0, 5054, 5055, 7, 14, 0, 0, 5055, 5056, 7, 5, 0, 0, 5056, 5057, 7, 9, 0, 0, 5057, 5058, 7, 16, 0, 0, 5058, 872, 1, 0, 0, 0, 5059, 5060, 7, 13, 0, 0, 5060, 5061, 7, 10, 0, 0, 5061, 5062, 7, 23, 0, 0, 5062, 5063, 7, 13, 0, 0, 5063, 5064, 7, 10, 0, 0, 5064, 5065, 7, 9, 0, 0, 5065, 5066, 7, 9, 0, 0, 5066, 5067, 7, 17, 0, 0, 5067, 5068, 7, 19, 0, 0, 5068, 5069, 7, 7, 0, 0, 5069, 874, 1, 0, 0, 0, 5070, 5071, 7, 18, 0, 0, 5071, 5072, 7, 17, 0, 0, 5072, 5073, 7, 7, 0, 0, 5073, 5074, 7, 5, 0, 0, 5074, 5075, 7, 13, 0, 0, 5075, 5076, 7, 8, 0, 0, 5076, 5077, 5, 95, 0, 0, 5077, 5078, 7, 14, 0, 0, 5078, 5079, 7, 6, 0, 0, 5079, 5080, 7, 5, 0, 0, 5080, 5081, 7, 9, 0, 0, 5081, 5082, 7, 9, 0, 0, 5082, 5083, 7, 17, 0, 0, 5083, 5084, 7, 25, 0, 0, 5084, 5085, 7, 17, 0, 0, 5085, 5086, 7, 14, 0, 0, 5086, 5087, 7, 5, 0, 0, 5087, 5088, 7, 16, 0, 0, 5088, 5089, 7, 17, 0, 0, 5089, 5090, 7, 19, 0, 0, 5090, 5091, 7, 7, 0, 0, 5091, 876, 1, 0, 0, 0, 5092, 5093, 7, 15, 0, 0, 5093, 5094, 7, 22, 0, 0, 5094, 5095, 7, 6, 0, 0, 5095, 5096, 7, 16, 0, 0, 5096, 5097, 7, 17, 0, 0, 5097, 5098, 7, 14, 0, 0, 5098, 5099, 7, 6, 0, 0, 5099, 5100, 7, 5, 0, 0, 5100, 5101, 7, 9, 0, 0, 5101, 5102, 7, 9, 0, 0, 5102, 5103, 5, 95, 0, 0, 5103, 5104, 7, 14, 0, 0, 5104, 5105, 7, 6, 0, 0, 5105, 5106, 7, 5, 0, 0, 5106, 5107, 7, 9, 0, 0, 5107, 5108, 7, 9, 0, 0, 5108, 5109, 7, 17, 0, 0, 5109, 5110, 7, 25, 0, 0, 5110, 5111, 7, 17, 0, 0, 5111, 5112, 7, 14, 0, 0, 5112, 5113, 7, 5, 0, 0, 5113, 5114, 7, 16, 0, 0, 5114, 5115, 7, 17, 0, 0, 5115, 5116, 7, 19, 0, 0, 5116, 5117, 7, 7, 0, 0, 5117, 878, 1, 0, 0, 0, 5118, 5119, 7, 9, 0, 0, 5119, 5120, 5, 51, 0, 0, 5120, 5121, 5, 95, 0, 0, 5121, 5122, 7, 18, 0, 0, 5122, 5123, 7, 22, 0, 0, 5123, 5124, 7, 14, 0, 0, 5124, 5125, 7, 21, 0, 0, 5125, 5126, 7, 10, 0, 0, 5126, 5127, 7, 16, 0, 0, 5127, 880, 1, 0, 0, 0, 5128, 5129, 7, 16, 0, 0, 5129, 5130, 7, 5, 0, 0, 5130, 5131, 7, 23, 0, 0, 5131, 5132, 7, 9, 0, 0, 5132, 882, 1, 0, 0, 0, 5133, 5134, 7, 21, 0, 0, 5134, 5135, 7, 15, 0, 0, 5135, 5136, 7, 9, 0, 0, 5136, 5137, 5, 95, 0, 0, 5137, 5138, 7, 21, 0, 0, 5138, 5139, 7, 10, 0, 0, 5139, 5140, 7, 8, 0, 0, 5140, 5141, 5, 95, 0, 0, 5141, 5142, 7, 17, 0, 0, 5142, 5143, 7, 12, 0, 0, 5143, 884, 1, 0, 0, 0, 5144, 5145, 7, 9, 0, 0, 5145, 5146, 5, 51, 0, 0, 5146, 5147, 5, 95, 0, 0, 5147, 5148, 7, 23, 0, 0, 5148, 5149, 7, 5, 0, 0, 5149, 5150, 7, 13, 0, 0, 5150, 5151, 7, 18, 0, 0, 5151, 5152, 7, 5, 0, 0, 5152, 5153, 7, 23, 0, 0, 5153, 5154, 7, 10, 0, 0, 5154, 5155, 5, 95, 0, 0, 5155, 5156, 7, 14, 0, 0, 5156, 5157, 7, 19, 0, 0, 5157, 5158, 7, 6, 0, 0, 5158, 5159, 7, 6, 0, 0, 5159, 5160, 7, 10, 0, 0, 5160, 5161, 7, 14, 0, 0, 5161, 5162, 7, 16, 0, 0, 5162, 886, 1, 0, 0, 0, 5163, 5164, 7, 15, 0, 0, 5164, 5165, 7, 5, 0, 0, 5165, 5166, 7, 26, 0, 0, 5166, 5167, 5, 95, 0, 0, 5167, 5168, 7, 14, 0, 0, 5168, 5169, 7, 10, 0, 0, 5169, 5170, 7, 6, 0, 0, 5170, 5171, 7, 6, 0, 0, 5171, 5172, 7, 9, 0, 0, 5172, 888, 1, 0, 0, 0, 5173, 5174, 7, 15, 0, 0, 5174, 5175, 7, 5, 0, 0, 5175, 5176, 7, 26, 0, 0, 5176, 5177, 5, 95, 0, 0, 5177, 5178, 7, 13, 0, 0, 5178, 5179, 7, 22, 0, 0, 5179, 5180, 7, 7, 0, 0, 5180, 5181, 7, 16, 0, 0, 5181, 5182, 7, 17, 0, 0, 5182, 5183, 7, 15, 0, 0, 5183, 5184, 7, 10, 0, 0, 5184, 890, 1, 0, 0, 0, 5185, 5186, 7, 20, 0, 0, 5186, 5187, 7, 19, 0, 0, 5187, 5188, 7, 13, 0, 0, 5188, 5189, 7, 17, 0, 0, 5189, 5190, 7, 11, 0, 0, 5190, 5191, 7, 19, 0, 0, 5191, 5192, 7, 7, 0, 0, 5192, 892, 1, 0, 0, 0, 5193, 5194, 7, 25, 0, 0, 5194, 5195, 7, 13, 0, 0, 5195, 5196, 7, 10, 0, 0, 5196, 5197, 7, 28, 0, 0, 5197, 5198, 7, 22, 0, 0, 5198, 5199, 7, 10, 0, 0, 5199, 5200, 7, 7, 0, 0, 5200, 5201, 7, 14, 0, 0, 5201, 5202, 7, 8, 0, 0, 5202, 894, 1, 0, 0, 0, 5203, 5204, 7, 24, 0, 0, 5204, 5205, 7, 10, 0, 0, 5205, 5206, 7, 13, 0, 0, 5206, 5207, 7, 14, 0, 0, 5207, 5208, 7, 10, 0, 0, 5208, 5209, 7, 7, 0, 0, 5209, 5210, 7, 16, 0, 0, 5210, 5211, 7, 17, 0, 0, 5211, 5212, 7, 6, 0, 0, 5212, 5213, 7, 10, 0, 0, 5213, 5214, 7, 9, 0, 0, 5214, 896, 1, 0, 0, 0, 5215, 5216, 7, 15, 0, 0, 5216, 5217, 7, 5, 0, 0, 5217, 5218, 7, 26, 0, 0, 5218, 5219, 5, 95, 0, 0, 5219, 5220, 7, 18, 0, 0, 5220, 5221, 7, 5, 0, 0, 5221, 5222, 7, 16, 0, 0, 5222, 5223, 7, 14, 0, 0, 5223, 5224, 7, 20, 0, 0, 5224, 5225, 5, 95, 0, 0, 5225, 5226, 7, 13, 0, 0, 5226, 5227, 7, 19, 0, 0, 5227, 5228, 7, 29, 0, 0, 5228, 5229, 7, 9, 0, 0, 5229, 898, 1, 0, 0, 0, 5230, 5231, 7, 22, 0, 0, 5231, 5232, 7, 7, 0, 0, 5232, 5233, 7, 6, 0, 0, 5233, 5234, 7, 19, 0, 0, 5234, 5235, 7, 5, 0, 0, 5235, 5236, 7, 12, 0, 0, 5236, 900, 1, 0, 0, 0, 5237, 5238, 7, 15, 0, 0, 5238, 5239, 7, 5, 0, 0, 5239, 5240, 7, 7, 0, 0, 5240, 5241, 7, 17, 0, 0, 5241, 5242, 7, 25, 0, 0, 5242, 5243, 7, 10, 0, 0, 5243, 5244, 7, 9, 0, 0, 5244, 5245, 7, 16, 0, 0, 5245, 902, 1, 0, 0, 0, 5246, 5247, 7, 5, 0, 0, 5247, 5248, 7, 12, 0, 0, 5248, 5249, 7, 12, 0, 0, 5249, 5250, 7, 28, 0, 0, 5250, 5251, 7, 22, 0, 0, 5251, 5252, 7, 19, 0, 0, 5252, 5253, 7, 16, 0, 0, 5253, 5254, 7, 10, 0, 0, 5254, 5255, 7, 9, 0, 0, 5255, 904, 1, 0, 0, 0, 5256, 5257, 7, 5, 0, 0, 5257, 5258, 7, 6, 0, 0, 5258, 5259, 7, 6, 0, 0, 5259, 5260, 7, 19, 0, 0, 5260, 5261, 7, 29, 0, 0, 5261, 5262, 7, 19, 0, 0, 5262, 5263, 7, 27, 0, 0, 5263, 5264, 7, 10, 0, 0, 5264, 5265, 7, 13, 0, 0, 5265, 5266, 7, 29, 0, 0, 5266, 5267, 7, 13, 0, 0, 5267, 5268, 7, 17, 0, 0, 5268, 5269, 7, 16, 0, 0, 5269, 5270, 7, 10, 0, 0, 5270, 906, 1, 0, 0, 0, 5271, 5272, 7, 14, 0, 0, 5272, 5273, 7, 6, 0, 0, 5273, 5274, 7, 10, 0, 0, 5274, 5275, 7, 5, 0, 0, 5275, 5276, 7, 7, 0, 0, 5276, 5277, 7, 24, 0, 0, 5277, 5278, 7, 5, 0, 0, 5278, 5279, 7, 16, 0, 0, 5279, 5280, 7, 20, 0, 0, 5280, 908, 1, 0, 0, 0, 5281, 5282, 7, 15, 0, 0, 5282, 5283, 7, 5, 0, 0, 5283, 5284, 7, 26, 0, 0, 5284, 5285, 7, 25, 0, 0, 5285, 5286, 7, 17, 0, 0, 5286, 5287, 7, 6, 0, 0, 5287, 5288, 7, 10, 0, 0, 5288, 5289, 7, 9, 0, 0, 5289, 5290, 7, 17, 0, 0, 5290, 5291, 7, 11, 0, 0, 5291, 5292, 7, 10, 0, 0, 5292, 910, 1, 0, 0, 0, 5293, 5294, 7, 13, 0, 0, 5294, 5295, 7, 19, 0, 0, 5295, 5296, 7, 29, 0, 0, 5296, 5297, 7, 23, 0, 0, 5297, 5298, 7, 13, 0, 0, 5298, 5299, 7, 19, 0, 0, 5299, 5300, 7, 22, 0, 0, 5300, 5301, 7, 24, 0, 0, 5301, 5302, 7, 9, 0, 0, 5302, 5303, 7, 17, 0, 0, 5303, 5304, 7, 11, 0, 0, 5304, 5305, 7, 10, 0, 0, 5305, 912, 1, 0, 0, 0, 5306, 5307, 7, 18, 0, 0, 5307, 5308, 7, 11, 0, 0, 5308, 5309, 7, 17, 0, 0, 5309, 5310, 7, 24, 0, 0, 5310, 5311, 5, 50, 0, 0, 5311, 914, 1, 0, 0, 0, 5312, 5313, 7, 23, 0, 0, 5313, 5314, 7, 11, 0, 0, 5314, 5315, 7, 17, 0, 0, 5315, 5316, 7, 24, 0, 0, 5316, 916, 1, 0, 0, 0, 5317, 5318, 7, 11, 0, 0, 5318, 5319, 7, 9, 0, 0, 5319, 5320, 7, 16, 0, 0, 5320, 5321, 7, 12, 0, 0, 5321, 918, 1, 0, 0, 0, 5322, 5323, 7, 12, 0, 0, 5323, 5324, 7, 5, 0, 0, 5324, 5325, 7, 16, 0, 0, 5325, 5326, 7, 5, 0, 0, 5326, 5327, 7, 18, 0, 0, 5327, 5328, 7, 5, 0, 0, 5328, 5329, 7, 9, 0, 0, 5329, 5330, 7, 10, 0, 0, 5330, 5331, 7, 9, 0, 0, 5331, 920, 1, 0, 0, 0, 5332, 5333, 7, 12, 0, 0, 5333, 5334, 7, 5, 0, 0, 5334, 5335, 7, 16, 0, 0, 5335, 5336, 7, 5, 0, 0, 5336, 5337, 7, 9, 0, 0, 5337, 5338, 7, 20, 0, 0, 5338, 5339, 7, 5, 0, 0, 5339, 5340, 7, 13, 0, 0, 5340, 5341, 7, 10, 0, 0, 5341, 5342, 7, 9, 0, 0, 5342, 922, 1, 0, 0, 0, 5343, 5344, 7, 23, 0, 0, 5344, 5345, 7, 13, 0, 0, 5345, 5346, 7, 5, 0, 0, 5346, 5347, 7, 7, 0, 0, 5347, 5348, 7, 16, 0, 0, 5348, 5349, 7, 9, 0, 0, 5349, 924, 1, 0, 0, 0, 5350, 5351, 7, 22, 0, 0, 5351, 5352, 7, 9, 0, 0, 5352, 5353, 7, 10, 0, 0, 5353, 926, 1, 0, 0, 0, 5354, 5355, 7, 14, 0, 0, 5355, 5356, 7, 5, 0, 0, 5356, 5357, 7, 7, 0, 0, 5357, 5358, 7, 14, 0, 0, 5358, 5359, 7, 10, 0, 0, 5359, 5360, 7, 6, 0, 0, 5360, 928, 1, 0, 0, 0, 5361, 5362, 7, 9, 0, 0, 5362, 5363, 7, 10, 0, 0, 5363, 5364, 7, 9, 0, 0, 5364, 5365, 7, 9, 0, 0, 5365, 5366, 7, 17, 0, 0, 5366, 5367, 7, 19, 0, 0, 5367, 5368, 7, 7, 0, 0, 5368, 5369, 5, 95, 0, 0, 5369, 5370, 7, 5, 0, 0, 5370, 5371, 7, 22, 0, 0, 5371, 5372, 7, 16, 0, 0, 5372, 5373, 7, 20, 0, 0, 5373, 5374, 7, 19, 0, 0, 5374, 5375, 7, 13, 0, 0, 5375, 5376, 7, 17, 0, 0, 5376, 5377, 7, 11, 0, 0, 5377, 5378, 7, 5, 0, 0, 5378, 5379, 7, 16, 0, 0, 5379, 5380, 7, 17, 0, 0, 5380, 5381, 7, 19, 0, 0, 5381, 5382, 7, 7, 0, 0, 5382, 930, 1, 0, 0, 0, 5383, 5384, 7, 9, 0, 0, 5384, 5385, 7, 10, 0, 0, 5385, 5386, 7, 9, 0, 0, 5386, 5387, 7, 9, 0, 0, 5387, 5388, 7, 17, 0, 0, 5388, 5389, 7, 19, 0, 0, 5389, 5390, 7, 7, 0, 0, 5390, 5391, 5, 95, 0, 0, 5391, 5392, 7, 14, 0, 0, 5392, 5393, 7, 20, 0, 0, 5393, 5394, 7, 5, 0, 0, 5394, 5395, 7, 13, 0, 0, 5395, 5396, 7, 5, 0, 0, 5396, 5397, 7, 14, 0, 0, 5397, 5398, 7, 16, 0, 0, 5398, 5399, 7, 10, 0, 0, 5399, 5400, 7, 13, 0, 0, 5400, 5401, 7, 17, 0, 0, 5401, 5402, 7, 9, 0, 0, 5402, 5403, 7, 16, 0, 0, 5403, 5404, 7, 17, 0, 0, 5404, 5405, 7, 14, 0, 0, 5405, 5406, 7, 9, 0, 0, 5406, 932, 1, 0, 0, 0, 5407, 5408, 7, 14, 0, 0, 5408, 5409, 7, 19, 0, 0, 5409, 5410, 7, 15, 0, 0, 5410, 5411, 7, 24, 0, 0, 5411, 5412, 7, 13, 0, 0, 5412, 5413, 7, 10, 0, 0, 5413, 5414, 7, 9, 0, 0, 5414, 5415, 7, 9, 0, 0, 5415, 5416, 7, 17, 0, 0, 5416, 5417, 7, 19, 0, 0, 5417, 5418, 7, 7, 0, 0, 5418, 934, 1, 0, 0, 0, 5419, 5420, 7, 6, 0, 0, 5420, 5421, 7, 17, 0, 0, 5421, 5422, 7, 18, 0, 0, 5422, 5423, 7, 13, 0, 0, 5423, 5424, 7, 5, 0, 0, 5424, 5425, 7, 13, 0, 0, 5425, 5426, 7, 8, 0, 0, 5426, 936, 1, 0, 0, 0, 5427, 5428, 7, 5, 0, 0, 5428, 5429, 7, 24, 0, 0, 5429, 5430, 7, 24, 0, 0, 5430, 5431, 7, 10, 0, 0, 5431, 5432, 7, 7, 0, 0, 5432, 5433, 7, 12, 0, 0, 5433, 938, 1, 0, 0, 0, 5434, 5435, 7, 15, 0, 0, 5435, 5436, 7, 18, 0, 0, 5436, 940, 1, 0, 0, 0, 5437, 5438, 7, 23, 0, 0, 5438, 5439, 7, 18, 0, 0, 5439, 942, 1, 0, 0, 0, 5440, 5441, 7, 5, 0, 0, 5441, 5442, 7, 14, 0, 0, 5442, 5443, 7, 14, 0, 0, 5443, 5444, 7, 19, 0, 0, 5444, 5445, 7, 22, 0, 0, 5445, 5446, 7, 7, 0, 0, 5446, 5447, 7, 16, 0, 0, 5447, 944, 1, 0, 0, 0, 5448, 5449, 7, 7, 0, 0, 5449, 5450, 7, 5, 0, 0, 5450, 5451, 7, 15, 0, 0, 5451, 5452, 7, 10, 0, 0, 5452, 5453, 7, 9, 0, 0, 5453, 5454, 7, 24, 0, 0, 5454, 5455, 7, 5, 0, 0, 5455, 5456, 7, 14, 0, 0, 5456, 5457, 7, 10, 0, 0, 5457, 946, 1, 0, 0, 0, 5458, 5459, 7, 12, 0, 0, 5459, 5460, 7, 10, 0, 0, 5460, 5461, 7, 9, 0, 0, 5461, 5462, 7, 14, 0, 0, 5462, 5463, 7, 13, 0, 0, 5463, 5464, 7, 17, 0, 0, 5464, 5465, 7, 18, 0, 0, 5465, 5466, 7, 10, 0, 0, 5466, 948, 1, 0, 0, 0, 5467, 5468, 7, 7, 0, 0, 5468, 5469, 7, 19, 0, 0, 5469, 5470, 7, 7, 0, 0, 5470, 5471, 7, 5, 0, 0, 5471, 5472, 7, 16, 0, 0, 5472, 5473, 7, 19, 0, 0, 5473, 5474, 7, 15, 0, 0, 5474, 5475, 7, 17, 0, 0, 5475, 5476, 7, 14, 0, 0, 5476, 950, 1, 0, 0, 0, 5477, 5478, 7, 15, 0, 0, 5478, 5479, 7, 5, 0, 0, 5479, 5480, 7, 7, 0, 0, 5480, 5481, 7, 5, 0, 0, 5481, 5482, 7, 23, 0, 0, 5482, 5483, 7, 10, 0, 0, 5483, 5484, 7, 12, 0, 0, 5484, 5485, 7, 18, 0, 0, 5485, 5486, 7, 8, 0, 0, 5486, 952, 1, 0, 0, 0, 5487, 5488, 7, 5, 0, 0, 5488, 5489, 7, 12, 0, 0, 5489, 5490, 7, 26, 0, 0, 5490, 954, 1, 0, 0, 0, 5491, 5492, 7, 13, 0, 0, 5492, 5493, 7, 10, 0, 0, 5493, 5494, 7, 15, 0, 0, 5494, 5495, 7, 19, 0, 0, 5495, 5496, 7, 27, 0, 0, 5496, 5497, 7, 10, 0, 0, 5497, 956, 1, 0, 0, 0, 5498, 5499, 7, 12, 0, 0, 5499, 5500, 7, 22, 0, 0, 5500, 5501, 7, 24, 0, 0, 5501, 5502, 7, 6, 0, 0, 5502, 5503, 7, 17, 0, 0, 5503, 5504, 7, 14, 0, 0, 5504, 5505, 7, 5, 0, 0, 5505, 5506, 7, 16, 0, 0, 5506, 5507, 7, 10, 0, 0, 5507, 5508, 7, 9, 0, 0, 5508, 958, 1, 0, 0, 0, 5509, 5510, 7, 18, 0, 0, 5510, 5511, 7, 10, 0, 0, 5511, 5512, 7, 12, 0, 0, 5512, 5513, 7, 13, 0, 0, 5513, 5514, 7, 19, 0, 0, 5514, 5515, 7, 14, 0, 0, 5515, 5516, 7, 21, 0, 0, 5516, 960, 1, 0, 0, 0, 5517, 5518, 7, 15, 0, 0, 5518, 5519, 7, 19, 0, 0, 5519, 5520, 7, 12, 0, 0, 5520, 5521, 7, 10, 0, 0, 5521, 5522, 7, 6, 0, 0, 5522, 5523, 5, 95, 0, 0, 5523, 5524, 7, 17, 0, 0, 5524, 5525, 7, 12, 0, 0, 5525, 962, 1, 0, 0, 0, 5526, 5527, 7, 24, 0, 0, 5527, 5528, 7, 13, 0, 0, 5528, 5529, 7, 19, 0, 0, 5529, 5530, 7, 15, 0, 0, 5530, 5531, 7, 24, 0, 0, 5531, 5532, 7, 16, 0, 0, 5532, 964, 1, 0, 0, 0, 5533, 5534, 7, 9, 0, 0, 5534, 5535, 7, 22, 0, 0, 5535, 5536, 7, 25, 0, 0, 5536, 5537, 7, 25, 0, 0, 5537, 5538, 7, 17, 0, 0, 5538, 5539, 7, 26, 0, 0, 5539, 966, 1, 0, 0, 0, 5540, 5541, 7, 13, 0, 0, 5541, 5542, 7, 10, 0, 0, 5542, 5543, 7, 28, 0, 0, 5543, 5544, 7, 22, 0, 0, 5544, 5545, 7, 10, 0, 0, 5545, 5546, 7, 9, 0, 0, 5546, 5547, 7, 16, 0, 0, 5547, 5548, 5, 95, 0, 0, 5548, 5549, 7, 16, 0, 0, 5549, 5550, 7, 8, 0, 0, 5550, 5551, 7, 24, 0, 0, 5551, 5552, 7, 10, 0, 0, 5552, 968, 1, 0, 0, 0, 5553, 5554, 7, 13, 0, 0, 5554, 5555, 7, 10, 0, 0, 5555, 5556, 7, 9, 0, 0, 5556, 5557, 7, 24, 0, 0, 5557, 5558, 7, 19, 0, 0, 5558, 5559, 7, 7, 0, 0, 5559, 5560, 7, 9, 0, 0, 5560, 5561, 7, 10, 0, 0, 5561, 5562, 5, 95, 0, 0, 5562, 5563, 7, 16, 0, 0, 5563, 5564, 7, 8, 0, 0, 5564, 5565, 7, 24, 0, 0, 5565, 5566, 7, 10, 0, 0, 5566, 970, 1, 0, 0, 0, 5567, 5568, 7, 13, 0, 0, 5568, 5569, 7, 5, 0, 0, 5569, 5570, 7, 29, 0, 0, 5570, 972, 1, 0, 0, 0, 5571, 5572, 7, 22, 0, 0, 5572, 5573, 7, 7, 0, 0, 5573, 5574, 7, 17, 0, 0, 5574, 5575, 7, 25, 0, 0, 5575, 5576, 7, 17, 0, 0, 5576, 5577, 7, 10, 0, 0, 5577, 5578, 7, 12, 0, 0, 5578, 974, 1, 0, 0, 0, 5579, 5580, 7, 9, 0, 0, 5580, 5581, 7, 22, 0, 0, 5581, 5582, 7, 24, 0, 0, 5582, 5583, 7, 10, 0, 0, 5583, 5584, 7, 13, 0, 0, 5584, 976, 1, 0, 0, 0, 5585, 5586, 7, 14, 0, 0, 5586, 5587, 7, 17, 0, 0, 5587, 978, 1, 0, 0, 0, 5588, 5589, 7, 14, 0, 0, 5589, 5590, 7, 9, 0, 0, 5590, 980, 1, 0, 0, 0, 5591, 5592, 7, 24, 0, 0, 5592, 5593, 7, 6, 0, 0, 5593, 5594, 7, 24, 0, 0, 5594, 5595, 7, 8, 0, 0, 5595, 5596, 7, 16, 0, 0, 5596, 5597, 7, 20, 0, 0, 5597, 5598, 7, 19, 0, 0, 5598, 5599, 7, 7, 0, 0, 5599, 5600, 7, 22, 0, 0, 5600, 982, 1, 0, 0, 0, 5601, 5602, 7, 25, 0, 0, 5602, 5603, 7, 17, 0, 0, 5603, 5604, 7, 6, 0, 0, 5604, 5605, 7, 6, 0, 0, 5605, 5606, 7, 16, 0, 0, 5606, 5607, 7, 5, 0, 0, 5607, 5608, 7, 13, 0, 0, 5608, 5609, 7, 23, 0, 0, 5609, 5610, 7, 10, 0, 0, 5610, 5611, 7, 16, 0, 0, 5611, 984, 1, 0, 0, 0, 5612, 5613, 7, 17, 0, 0, 5613, 5614, 7, 23, 0, 0, 5614, 5615, 7, 7, 0, 0, 5615, 5616, 7, 19, 0, 0, 5616, 5617, 7, 13, 0, 0, 5617, 5618, 7, 10, 0, 0, 5618, 5619, 7, 10, 0, 0, 5619, 5620, 7, 26, 0, 0, 5620, 5621, 7, 16, 0, 0, 5621, 5622, 7, 13, 0, 0, 5622, 5623, 7, 5, 0, 0, 5623, 986, 1, 0, 0, 0, 5624, 5625, 7, 14, 0, 0, 5625, 5626, 7, 13, 0, 0, 5626, 5627, 7, 10, 0, 0, 5627, 5628, 7, 5, 0, 0, 5628, 5629, 7, 16, 0, 0, 5629, 5630, 7, 10, 0, 0, 5630, 5631, 7, 22, 0, 0, 5631, 5632, 7, 9, 0, 0, 5632, 5633, 7, 10, 0, 0, 5633, 5634, 7, 13, 0, 0, 5634, 988, 1, 0, 0, 0, 5635, 5636, 7, 7, 0, 0, 5636, 5637, 7, 19, 0, 0, 5637, 5638, 7, 14, 0, 0, 5638, 5639, 7, 13, 0, 0, 5639, 5640, 7, 10, 0, 0, 5640, 5641, 7, 5, 0, 0, 5641, 5642, 7, 16, 0, 0, 5642, 5643, 7, 10, 0, 0, 5643, 5644, 7, 22, 0, 0, 5644, 5645, 7, 9, 0, 0, 5645, 5646, 7, 10, 0, 0, 5646, 5647, 7, 13, 0, 0, 5647, 990, 1, 0, 0, 0, 5648, 5649, 7, 13, 0, 0, 5649, 5650, 7, 10, 0, 0, 5650, 5651, 7, 23, 0, 0, 5651, 5652, 7, 17, 0, 0, 5652, 5653, 7, 19, 0, 0, 5653, 5654, 7, 7, 0, 0, 5654, 992, 1, 0, 0, 0, 5655, 5656, 7, 24, 0, 0, 5656, 5657, 7, 19, 0, 0, 5657, 5658, 7, 13, 0, 0, 5658, 5659, 7, 16, 0, 0, 5659, 994, 1, 0, 0, 0, 5660, 5661, 7, 13, 0, 0, 5661, 5662, 7, 10, 0, 0, 5662, 5663, 7, 12, 0, 0, 5663, 5664, 7, 9, 0, 0, 5664, 5665, 7, 20, 0, 0, 5665, 5666, 7, 17, 0, 0, 5666, 5667, 7, 25, 0, 0, 5667, 5668, 7, 16, 0, 0, 5668, 996, 1, 0, 0, 0, 5669, 5670, 7, 17, 0, 0, 5670, 5671, 7, 5, 0, 0, 5671, 5672, 7, 15, 0, 0, 5672, 998, 1, 0, 0, 0, 5673, 5674, 7, 14, 0, 0, 5674, 5675, 7, 13, 0, 0, 5675, 5676, 7, 10, 0, 0, 5676, 5677, 7, 5, 0, 0, 5677, 5678, 7, 16, 0, 0, 5678, 5679, 7, 10, 0, 0, 5679, 5680, 7, 12, 0, 0, 5680, 5681, 7, 18, 0, 0, 5681, 1000, 1, 0, 0, 0, 5682, 5683, 7, 7, 0, 0, 5683, 5684, 7, 19, 0, 0, 5684, 5685, 7, 14, 0, 0, 5685, 5686, 7, 13, 0, 0, 5686, 5687, 7, 10, 0, 0, 5687, 5688, 7, 5, 0, 0, 5688, 5689, 7, 16, 0, 0, 5689, 5690, 7, 10, 0, 0, 5690, 5691, 7, 12, 0, 0, 5691, 5692, 7, 18, 0, 0, 5692, 1002, 1, 0, 0, 0, 5693, 5694, 7, 13, 0, 0, 5694, 5695, 7, 10, 0, 0, 5695, 5696, 7, 9, 0, 0, 5696, 5697, 7, 16, 0, 0, 5697, 5698, 7, 13, 0, 0, 5698, 5699, 7, 17, 0, 0, 5699, 5700, 7, 14, 0, 0, 5700, 5701, 7, 16, 0, 0, 5701, 5702, 7, 10, 0, 0, 5702, 5703, 7, 12, 0, 0, 5703, 1004, 1, 0, 0, 0, 5704, 5705, 7, 22, 0, 0, 5705, 5706, 7, 7, 0, 0, 5706, 5707, 7, 6, 0, 0, 5707, 5708, 7, 17, 0, 0, 5708, 5709, 7, 15, 0, 0, 5709, 5710, 7, 17, 0, 0, 5710, 5711, 7, 16, 0, 0, 5711, 5712, 7, 10, 0, 0, 5712, 5713, 7, 12, 0, 0, 5713, 1006, 1, 0, 0, 0, 5714, 5715, 7, 10, 0, 0, 5715, 5716, 7, 26, 0, 0, 5716, 5717, 7, 16, 0, 0, 5717, 5718, 7, 10, 0, 0, 5718, 5719, 7, 13, 0, 0, 5719, 5720, 7, 7, 0, 0, 5720, 5721, 7, 5, 0, 0, 5721, 5722, 7, 6, 0, 0, 5722, 5723, 7, 17, 0, 0, 5723, 5724, 7, 12, 0, 0, 5724, 1008, 1, 0, 0, 0, 5725, 5726, 7, 16, 0, 0, 5726, 5727, 7, 17, 0, 0, 5727, 5728, 7, 15, 0, 0, 5728, 5729, 7, 10, 0, 0, 5729, 5730, 7, 19, 0, 0, 5730, 5731, 7, 22, 0, 0, 5731, 5732, 7, 16, 0, 0, 5732, 1010, 1, 0, 0, 0, 5733, 5734, 7, 9, 0, 0, 5734, 5735, 7, 8, 0, 0, 5735, 5736, 7, 9, 0, 0, 5736, 5737, 7, 6, 0, 0, 5737, 5738, 7, 19, 0, 0, 5738, 5739, 7, 23, 0, 0, 5739, 1012, 1, 0, 0, 0, 5740, 5741, 7, 14, 0, 0, 5741, 5742, 7, 13, 0, 0, 5742, 5743, 7, 10, 0, 0, 5743, 5744, 7, 12, 0, 0, 5744, 5745, 7, 10, 0, 0, 5745, 5746, 7, 7, 0, 0, 5746, 5747, 7, 16, 0, 0, 5747, 5748, 7, 17, 0, 0, 5748, 5749, 7, 5, 0, 0, 5749, 5750, 7, 6, 0, 0, 5750, 5751, 7, 9, 0, 0, 5751, 1014, 1, 0, 0, 0, 5752, 5753, 7, 22, 0, 0, 5753, 5754, 7, 7, 0, 0, 5754, 5755, 7, 13, 0, 0, 5755, 5756, 7, 10, 0, 0, 5756, 5757, 7, 9, 0, 0, 5757, 5758, 7, 16, 0, 0, 5758, 5759, 7, 13, 0, 0, 5759, 5760, 7, 17, 0, 0, 5760, 5761, 7, 14, 0, 0, 5761, 5762, 7, 16, 0, 0, 5762, 5763, 7, 10, 0, 0, 5763, 5764, 7, 12, 0, 0, 5764, 1016, 1, 0, 0, 0, 5765, 5766, 7, 24, 0, 0, 5766, 5767, 7, 5, 0, 0, 5767, 5768, 7, 13, 0, 0, 5768, 5769, 7, 5, 0, 0, 5769, 5770, 7, 15, 0, 0, 5770, 5771, 7, 10, 0, 0, 5771, 5772, 7, 16, 0, 0, 5772, 5773, 7, 10, 0, 0, 5773, 5774, 7, 13, 0, 0, 5774, 5775, 7, 9, 0, 0, 5775, 1018, 1, 0, 0, 0, 5776, 5777, 7, 5, 0, 0, 5777, 5778, 7, 24, 0, 0, 5778, 5779, 7, 24, 0, 0, 5779, 5780, 7, 6, 0, 0, 5780, 5781, 7, 17, 0, 0, 5781, 5782, 7, 14, 0, 0, 5782, 5783, 7, 5, 0, 0, 5783, 5784, 7, 16, 0, 0, 5784, 5785, 7, 17, 0, 0, 5785, 5786, 7, 19, 0, 0, 5786, 5787, 7, 7, 0, 0, 5787, 5788, 5, 95, 0, 0, 5788, 5789, 7, 5, 0, 0, 5789, 5790, 7, 13, 0, 0, 5790, 5791, 7, 7, 0, 0, 5791, 1020, 1, 0, 0, 0, 5792, 5793, 7, 5, 0, 0, 5793, 5794, 7, 22, 0, 0, 5794, 5795, 7, 16, 0, 0, 5795, 5796, 7, 19, 0, 0, 5796, 5797, 5, 95, 0, 0, 5797, 5798, 7, 14, 0, 0, 5798, 5799, 7, 13, 0, 0, 5799, 5800, 7, 10, 0, 0, 5800, 5801, 7, 5, 0, 0, 5801, 5802, 7, 16, 0, 0, 5802, 5803, 7, 10, 0, 0, 5803, 5804, 5, 95, 0, 0, 5804, 5805, 7, 13, 0, 0, 5805, 5806, 7, 19, 0, 0, 5806, 5807, 7, 6, 0, 0, 5807, 5808, 7, 10, 0, 0, 5808, 5809, 7, 9, 0, 0, 5809, 1022, 1, 0, 0, 0, 5810, 5811, 7, 14, 0, 0, 5811, 5812, 7, 19, 0, 0, 5812, 5813, 7, 15, 0, 0, 5813, 5814, 7, 24, 0, 0, 5814, 5815, 7, 13, 0, 0, 5815, 5816, 7, 19, 0, 0, 5816, 5817, 7, 29, 0, 0, 5817, 5818, 7, 9, 0, 0, 5818, 1024, 1, 0, 0, 0, 5819, 5820, 7, 24, 0, 0, 5820, 5821, 7, 13, 0, 0, 5821, 5822, 7, 19, 0, 0, 5822, 5823, 7, 27, 0, 0, 5823, 5824, 7, 17, 0, 0, 5824, 5825, 7, 12, 0, 0, 5825, 5826, 7, 10, 0, 0, 5826, 5827, 7, 13, 0, 0, 5827, 5828, 5, 95, 0, 0, 5828, 5829, 7, 22, 0, 0, 5829, 5830, 7, 13, 0, 0, 5830, 5831, 7, 6, 0, 0, 5831, 1026, 1, 0, 0, 0, 5832, 5833, 7, 24, 0, 0, 5833, 5834, 7, 13, 0, 0, 5834, 5835, 7, 19, 0, 0, 5835, 5836, 7, 27, 0, 0, 5836, 5837, 7, 17, 0, 0, 5837, 5838, 7, 12, 0, 0, 5838, 5839, 7, 10, 0, 0, 5839, 5840, 7, 13, 0, 0, 5840, 5841, 5, 95, 0, 0, 5841, 5842, 7, 22, 0, 0, 5842, 5843, 7, 13, 0, 0, 5843, 5844, 7, 6, 0, 0, 5844, 5845, 5, 95, 0, 0, 5845, 5846, 7, 24, 0, 0, 5846, 5847, 7, 19, 0, 0, 5847, 5848, 7, 13, 0, 0, 5848, 5849, 7, 16, 0, 0, 5849, 1028, 1, 0, 0, 0, 5850, 5851, 7, 5, 0, 0, 5851, 5852, 7, 16, 0, 0, 5852, 5853, 7, 16, 0, 0, 5853, 5854, 7, 13, 0, 0, 5854, 5855, 7, 17, 0, 0, 5855, 5856, 7, 18, 0, 0, 5856, 5857, 7, 22, 0, 0, 5857, 5858, 7, 16, 0, 0, 5858, 5859, 7, 10, 0, 0, 5859, 5860, 5, 95, 0, 0, 5860, 5861, 7, 15, 0, 0, 5861, 5862, 7, 5, 0, 0, 5862, 5863, 7, 24, 0, 0, 5863, 1030, 1, 0, 0, 0, 5864, 5865, 7, 24, 0, 0, 5865, 5866, 7, 13, 0, 0, 5866, 5867, 7, 19, 0, 0, 5867, 5868, 7, 27, 0, 0, 5868, 5869, 7, 17, 0, 0, 5869, 5870, 7, 12, 0, 0, 5870, 5871, 7, 10, 0, 0, 5871, 5872, 7, 13, 0, 0, 5872, 5873, 5, 95, 0, 0, 5873, 5874, 7, 5, 0, 0, 5874, 5875, 7, 13, 0, 0, 5875, 5876, 7, 7, 0, 0, 5876, 1032, 1, 0, 0, 0, 5877, 5878, 7, 5, 0, 0, 5878, 5879, 7, 9, 0, 0, 5879, 5880, 7, 9, 0, 0, 5880, 5881, 7, 22, 0, 0, 5881, 5882, 7, 15, 0, 0, 5882, 5883, 7, 10, 0, 0, 5883, 5884, 5, 95, 0, 0, 5884, 5885, 7, 13, 0, 0, 5885, 5886, 7, 19, 0, 0, 5886, 5887, 7, 6, 0, 0, 5887, 5888, 7, 10, 0, 0, 5888, 5889, 5, 95, 0, 0, 5889, 5890, 7, 5, 0, 0, 5890, 5891, 7, 13, 0, 0, 5891, 5892, 7, 7, 0, 0, 5892, 1034, 1, 0, 0, 0, 5893, 5894, 7, 24, 0, 0, 5894, 5895, 7, 13, 0, 0, 5895, 5896, 7, 19, 0, 0, 5896, 5897, 7, 24, 0, 0, 5897, 5898, 7, 10, 0, 0, 5898, 5899, 7, 13, 0, 0, 5899, 5900, 7, 16, 0, 0, 5900, 5901, 7, 17, 0, 0, 5901, 5902, 7, 10, 0, 0, 5902, 5903, 7, 9, 0, 0, 5903, 1036, 1, 0, 0, 0, 5904, 5905, 7, 5, 0, 0, 5905, 5906, 7, 27, 0, 0, 5906, 5907, 7, 13, 0, 0, 5907, 5908, 7, 19, 0, 0, 5908, 1038, 1, 0, 0, 0, 5909, 5910, 7, 13, 0, 0, 5910, 5911, 7, 14, 0, 0, 5911, 5912, 7, 25, 0, 0, 5912, 5913, 7, 17, 0, 0, 5913, 5914, 7, 6, 0, 0, 5914, 5915, 7, 10, 0, 0, 5915, 1040, 1, 0, 0, 0, 5916, 5917, 7, 9, 0, 0, 5917, 5918, 7, 10, 0, 0, 5918, 5919, 7, 28, 0, 0, 5919, 5920, 7, 22, 0, 0, 5920, 5921, 7, 10, 0, 0, 5921, 5922, 7, 7, 0, 0, 5922, 5923, 7, 14, 0, 0, 5923, 5924, 7, 10, 0, 0, 5924, 5925, 7, 25, 0, 0, 5925, 5926, 7, 17, 0, 0, 5926, 5927, 7, 6, 0, 0, 5927, 5928, 7, 10, 0, 0, 5928, 1042, 1, 0, 0, 0, 5929, 5930, 7, 16, 0, 0, 5930, 5931, 7, 10, 0, 0, 5931, 5932, 7, 26, 0, 0, 5932, 5933, 7, 16, 0, 0, 5933, 5934, 7, 25, 0, 0, 5934, 5935, 7, 17, 0, 0, 5935, 5936, 7, 6, 0, 0, 5936, 5937, 7, 10, 0, 0, 5937, 1044, 1, 0, 0, 0, 5938, 5939, 7, 19, 0, 0, 5939, 5940, 7, 13, 0, 0, 5940, 5941, 7, 14, 0, 0, 5941, 1046, 1, 0, 0, 0, 5942, 5943, 7, 17, 0, 0, 5943, 5944, 7, 19, 0, 0, 5944, 5945, 7, 7, 0, 0, 5945, 1048, 1, 0, 0, 0, 5946, 5947, 7, 6, 0, 0, 5947, 5948, 7, 5, 0, 0, 5948, 5949, 7, 15, 0, 0, 5949, 5950, 7, 18, 0, 0, 5950, 5951, 7, 12, 0, 0, 5951, 5952, 7, 5, 0, 0, 5952, 1050, 1, 0, 0, 0, 5953, 5954, 7, 25, 0, 0, 5954, 5955, 7, 17, 0, 0, 5955, 5956, 7, 26, 0, 0, 5956, 5957, 7, 10, 0, 0, 5957, 5958, 7, 12, 0, 0, 5958, 5959, 7, 29, 0, 0, 5959, 5960, 7, 17, 0, 0, 5960, 5961, 7, 12, 0, 0, 5961, 5962, 7, 16, 0, 0, 5962, 5963, 7, 20, 0, 0, 5963, 1052, 1, 0, 0, 0, 5964, 5965, 7, 24, 0, 0, 5965, 5966, 7, 5, 0, 0, 5966, 5967, 7, 13, 0, 0, 5967, 5968, 7, 28, 0, 0, 5968, 5969, 7, 22, 0, 0, 5969, 5970, 7, 10, 0, 0, 5970, 5971, 7, 16, 0, 0, 5971, 1054, 1, 0, 0, 0, 5972, 5973, 7, 6, 0, 0, 5973, 5974, 7, 11, 0, 0, 5974, 5975, 7, 19, 0, 0, 5975, 5976, 7, 24, 0, 0, 5976, 1056, 1, 0, 0, 0, 5977, 5978, 7, 13, 0, 0, 5978, 5979, 7, 10, 0, 0, 5979, 5980, 7, 15, 0, 0, 5980, 5981, 7, 19, 0, 0, 5981, 5982, 7, 27, 0, 0, 5982, 5983, 7, 10, 0, 0, 5983, 5984, 7, 28, 0, 0, 5984, 5985, 7, 22, 0, 0, 5985, 5986, 7, 19, 0, 0, 5986, 5987, 7, 16, 0, 0, 5987, 5988, 7, 10, 0, 0, 5988, 5989, 7, 9, 0, 0, 5989, 1058, 1, 0, 0, 0, 5990, 5991, 7, 16, 0, 0, 5991, 5992, 7, 13, 0, 0, 5992, 5993, 7, 22, 0, 0, 5993, 5994, 7, 7, 0, 0, 5994, 5995, 7, 14, 0, 0, 5995, 5996, 7, 5, 0, 0, 5996, 5997, 7, 16, 0, 0, 5997, 5998, 7, 10, 0, 0, 5998, 5999, 7, 14, 0, 0, 5999, 6000, 7, 19, 0, 0, 6000, 6001, 7, 6, 0, 0, 6001, 6002, 7, 22, 0, 0, 6002, 6003, 7, 15, 0, 0, 6003, 6004, 7, 7, 0, 0, 6004, 6005, 7, 9, 0, 0, 6005, 1060, 1, 0, 0, 0, 6006, 6007, 7, 25, 0, 0, 6007, 6008, 7, 17, 0, 0, 6008, 6009, 7, 6, 0, 0, 6009, 6010, 7, 6, 0, 0, 6010, 6011, 7, 13, 0, 0, 6011, 6012, 7, 10, 0, 0, 6012, 6013, 7, 14, 0, 0, 6013, 6014, 7, 19, 0, 0, 6014, 6015, 7, 13, 0, 0, 6015, 6016, 7, 12, 0, 0, 6016, 1062, 1, 0, 0, 0, 6017, 6018, 7, 18, 0, 0, 6018, 6019, 7, 6, 0, 0, 6019, 6020, 7, 5, 0, 0, 6020, 6021, 7, 7, 0, 0, 6021, 6022, 7, 21, 0, 0, 6022, 6023, 7, 9, 0, 0, 6023, 6024, 7, 5, 0, 0, 6024, 6025, 7, 9, 0, 0, 6025, 6026, 7, 7, 0, 0, 6026, 6027, 7, 22, 0, 0, 6027, 6028, 7, 6, 0, 0, 6028, 6029, 7, 6, 0, 0, 6029, 1064, 1, 0, 0, 0, 6030, 6031, 7, 10, 0, 0, 6031, 6032, 7, 15, 0, 0, 6032, 6033, 7, 24, 0, 0, 6033, 6034, 7, 16, 0, 0, 6034, 6035, 7, 8, 0, 0, 6035, 6036, 7, 5, 0, 0, 6036, 6037, 7, 9, 0, 0, 6037, 6038, 7, 7, 0, 0, 6038, 6039, 7, 22, 0, 0, 6039, 6040, 7, 6, 0, 0, 6040, 6041, 7, 6, 0, 0, 6041, 1066, 1, 0, 0, 0, 6042, 6043, 7, 15, 0, 0, 6043, 6044, 7, 5, 0, 0, 6044, 6045, 7, 26, 0, 0, 6045, 6046, 7, 10, 0, 0, 6046, 6047, 7, 13, 0, 0, 6047, 6048, 7, 13, 0, 0, 6048, 6049, 7, 19, 0, 0, 6049, 6050, 7, 13, 0, 0, 6050, 1068, 1, 0, 0, 0, 6051, 6052, 7, 12, 0, 0, 6052, 6053, 7, 5, 0, 0, 6053, 6054, 7, 16, 0, 0, 6054, 6055, 7, 10, 0, 0, 6055, 6056, 7, 25, 0, 0, 6056, 6057, 7, 19, 0, 0, 6057, 6058, 7, 13, 0, 0, 6058, 6059, 7, 15, 0, 0, 6059, 6060, 7, 5, 0, 0, 6060, 6061, 7, 16, 0, 0, 6061, 1070, 1, 0, 0, 0, 6062, 6063, 7, 16, 0, 0, 6063, 6064, 7, 17, 0, 0, 6064, 6065, 7, 15, 0, 0, 6065, 6066, 7, 10, 0, 0, 6066, 6067, 7, 25, 0, 0, 6067, 6068, 7, 19, 0, 0, 6068, 6069, 7, 13, 0, 0, 6069, 6070, 7, 15, 0, 0, 6070, 6071, 7, 5, 0, 0, 6071, 6072, 7, 16, 0, 0, 6072, 1072, 1, 0, 0, 0, 6073, 6074, 7, 5, 0, 0, 6074, 6075, 7, 14, 0, 0, 6075, 6076, 7, 14, 0, 0, 6076, 6077, 7, 10, 0, 0, 6077, 6078, 7, 24, 0, 0, 6078, 6079, 7, 16, 0, 0, 6079, 6080, 7, 17, 0, 0, 6080, 6081, 7, 7, 0, 0, 6081, 6082, 7, 27, 0, 0, 6082, 6083, 7, 14, 0, 0, 6083, 6084, 7, 20, 0, 0, 6084, 6085, 7, 5, 0, 0, 6085, 6086, 7, 13, 0, 0, 6086, 6087, 7, 9, 0, 0, 6087, 1074, 1, 0, 0, 0, 6088, 6089, 7, 5, 0, 0, 6089, 6090, 7, 14, 0, 0, 6090, 6091, 7, 14, 0, 0, 6091, 6092, 7, 10, 0, 0, 6092, 6093, 7, 24, 0, 0, 6093, 6094, 7, 16, 0, 0, 6094, 6095, 7, 5, 0, 0, 6095, 6096, 7, 7, 0, 0, 6096, 6097, 7, 8, 0, 0, 6097, 6098, 7, 12, 0, 0, 6098, 6099, 7, 5, 0, 0, 6099, 6100, 7, 16, 0, 0, 6100, 6101, 7, 10, 0, 0, 6101, 1076, 1, 0, 0, 0, 6102, 6103, 7, 17, 0, 0, 6103, 6104, 7, 23, 0, 0, 6104, 6105, 7, 7, 0, 0, 6105, 6106, 7, 19, 0, 0, 6106, 6107, 7, 13, 0, 0, 6107, 6108, 7, 10, 0, 0, 6108, 6109, 7, 20, 0, 0, 6109, 6110, 7, 10, 0, 0, 6110, 6111, 7, 5, 0, 0, 6111, 6112, 7, 12, 0, 0, 6112, 6113, 7, 10, 0, 0, 6113, 6114, 7, 13, 0, 0, 6114, 1078, 1, 0, 0, 0, 6115, 6116, 7, 17, 0, 0, 6116, 6117, 7, 23, 0, 0, 6117, 6118, 7, 7, 0, 0, 6118, 6119, 7, 19, 0, 0, 6119, 6120, 7, 13, 0, 0, 6120, 6121, 7, 10, 0, 0, 6121, 6122, 7, 18, 0, 0, 6122, 6123, 7, 6, 0, 0, 6123, 6124, 7, 5, 0, 0, 6124, 6125, 7, 7, 0, 0, 6125, 6126, 7, 21, 0, 0, 6126, 6127, 7, 6, 0, 0, 6127, 6128, 7, 17, 0, 0, 6128, 6129, 7, 7, 0, 0, 6129, 6130, 7, 10, 0, 0, 6130, 6131, 7, 9, 0, 0, 6131, 1080, 1, 0, 0, 0, 6132, 6133, 7, 14, 0, 0, 6133, 6134, 7, 19, 0, 0, 6134, 6135, 7, 15, 0, 0, 6135, 6136, 7, 24, 0, 0, 6136, 6137, 7, 22, 0, 0, 6137, 6138, 7, 24, 0, 0, 6138, 6139, 7, 12, 0, 0, 6139, 6140, 7, 5, 0, 0, 6140, 6141, 7, 16, 0, 0, 6141, 6142, 7, 10, 0, 0, 6142, 1082, 1, 0, 0, 0, 6143, 6144, 7, 9, 0, 0, 6144, 6145, 7, 16, 0, 0, 6145, 6146, 7, 5, 0, 0, 6146, 6147, 7, 16, 0, 0, 6147, 6148, 7, 22, 0, 0, 6148, 6149, 7, 24, 0, 0, 6149, 6150, 7, 12, 0, 0, 6150, 6151, 7, 5, 0, 0, 6151, 6152, 7, 16, 0, 0, 6152, 6153, 7, 10, 0, 0, 6153, 1084, 1, 0, 0, 0, 6154, 6155, 7, 10, 0, 0, 6155, 6156, 7, 26, 0, 0, 6156, 6157, 7, 24, 0, 0, 6157, 6158, 7, 6, 0, 0, 6158, 6159, 7, 17, 0, 0, 6159, 6160, 7, 14, 0, 0, 6160, 6161, 7, 17, 0, 0, 6161, 6162, 7, 16, 0, 0, 6162, 6163, 5, 95, 0, 0, 6163, 6164, 7, 17, 0, 0, 6164, 6165, 7, 12, 0, 0, 6165, 6166, 7, 9, 0, 0, 6166, 1086, 1, 0, 0, 0, 6167, 6168, 7, 13, 0, 0, 6168, 6169, 7, 10, 0, 0, 6169, 6170, 7, 5, 0, 0, 6170, 6171, 7, 12, 0, 0, 6171, 6172, 7, 13, 0, 0, 6172, 6173, 7, 5, 0, 0, 6173, 6174, 7, 16, 0, 0, 6174, 6175, 7, 17, 0, 0, 6175, 6176, 7, 19, 0, 0, 6176, 1088, 1, 0, 0, 0, 6177, 6178, 7, 13, 0, 0, 6178, 6179, 7, 19, 0, 0, 6179, 6180, 7, 22, 0, 0, 6180, 6181, 7, 7, 0, 0, 6181, 6182, 7, 12, 0, 0, 6182, 6183, 7, 10, 0, 0, 6183, 6184, 7, 14, 0, 0, 6184, 1090, 1, 0, 0, 0, 6185, 6186, 7, 16, 0, 0, 6186, 6187, 7, 13, 0, 0, 6187, 6188, 7, 17, 0, 0, 6188, 6189, 7, 15, 0, 0, 6189, 6190, 7, 18, 0, 0, 6190, 6191, 7, 6, 0, 0, 6191, 6192, 7, 5, 0, 0, 6192, 6193, 7, 7, 0, 0, 6193, 6194, 7, 21, 0, 0, 6194, 6195, 7, 9, 0, 0, 6195, 1092, 1, 0, 0, 0, 6196, 6197, 7, 24, 0, 0, 6197, 6198, 7, 13, 0, 0, 6198, 6199, 7, 10, 0, 0, 6199, 6200, 7, 9, 0, 0, 6200, 6201, 7, 10, 0, 0, 6201, 6202, 7, 16, 0, 0, 6202, 1094, 1, 0, 0, 0, 6203, 6204, 7, 5, 0, 0, 6204, 6205, 7, 14, 0, 0, 6205, 6206, 7, 14, 0, 0, 6206, 6207, 7, 10, 0, 0, 6207, 6208, 7, 9, 0, 0, 6208, 6209, 7, 9, 0, 0, 6209, 6210, 5, 95, 0, 0, 6210, 6211, 7, 21, 0, 0, 6211, 6212, 7, 10, 0, 0, 6212, 6213, 7, 8, 0, 0, 6213, 6214, 5, 95, 0, 0, 6214, 6215, 7, 17, 0, 0, 6215, 6216, 7, 12, 0, 0, 6216, 1096, 1, 0, 0, 0, 6217, 6218, 7, 9, 0, 0, 6218, 6219, 7, 10, 0, 0, 6219, 6220, 7, 14, 0, 0, 6220, 6221, 7, 13, 0, 0, 6221, 6222, 7, 10, 0, 0, 6222, 6223, 7, 16, 0, 0, 6223, 6224, 5, 95, 0, 0, 6224, 6225, 7, 5, 0, 0, 6225, 6226, 7, 14, 0, 0, 6226, 6227, 7, 14, 0, 0, 6227, 6228, 7, 10, 0, 0, 6228, 6229, 7, 9, 0, 0, 6229, 6230, 7, 9, 0, 0, 6230, 6231, 5, 95, 0, 0, 6231, 6232, 7, 21, 0, 0, 6232, 6233, 7, 10, 0, 0, 6233, 6234, 7, 8, 0, 0, 6234, 1098, 1, 0, 0, 0, 6235, 6236, 7, 9, 0, 0, 6236, 6237, 7, 10, 0, 0, 6237, 6238, 7, 9, 0, 0, 6238, 6239, 7, 9, 0, 0, 6239, 6240, 7, 17, 0, 0, 6240, 6241, 7, 19, 0, 0, 6241, 6242, 7, 7, 0, 0, 6242, 6243, 5, 95, 0, 0, 6243, 6244, 7, 16, 0, 0, 6244, 6245, 7, 19, 0, 0, 6245, 6246, 7, 21, 0, 0, 6246, 6247, 7, 10, 0, 0, 6247, 6248, 7, 7, 0, 0, 6248, 1100, 1, 0, 0, 0, 6249, 6250, 7, 20, 0, 0, 6250, 6251, 7, 10, 0, 0, 6251, 6252, 7, 5, 0, 0, 6252, 6253, 7, 12, 0, 0, 6253, 6254, 7, 10, 0, 0, 6254, 6255, 7, 13, 0, 0, 6255, 1102, 1, 0, 0, 0, 6256, 6257, 7, 9, 0, 0, 6257, 6258, 7, 10, 0, 0, 6258, 6259, 7, 16, 0, 0, 6259, 6260, 7, 16, 0, 0, 6260, 6261, 7, 17, 0, 0, 6261, 6262, 7, 7, 0, 0, 6262, 6263, 7, 23, 0, 0, 6263, 6264, 7, 9, 0, 0, 6264, 1104, 1, 0, 0, 0, 6265, 6266, 7, 25, 0, 0, 6266, 6267, 7, 22, 0, 0, 6267, 6268, 7, 7, 0, 0, 6268, 6269, 7, 14, 0, 0, 6269, 6270, 7, 16, 0, 0, 6270, 6271, 7, 17, 0, 0, 6271, 6272, 7, 19, 0, 0, 6272, 6273, 7, 7, 0, 0, 6273, 6274, 5, 95, 0, 0, 6274, 6275, 7, 7, 0, 0, 6275, 6276, 7, 5, 0, 0, 6276, 6277, 7, 15, 0, 0, 6277, 6278, 7, 10, 0, 0, 6278, 1106, 1, 0, 0, 0, 6279, 6280, 7, 5, 0, 0, 6280, 6281, 7, 16, 0, 0, 6281, 6282, 7, 19, 0, 0, 6282, 6283, 7, 15, 0, 0, 6283, 6284, 7, 17, 0, 0, 6284, 6285, 7, 14, 0, 0, 6285, 1108, 1, 0, 0, 0, 6286, 6287, 7, 18, 0, 0, 6287, 6288, 7, 10, 0, 0, 6288, 6289, 7, 16, 0, 0, 6289, 6290, 7, 29, 0, 0, 6290, 6291, 7, 10, 0, 0, 6291, 6292, 7, 10, 0, 0, 6292, 6293, 7, 7, 0, 0, 6293, 1110, 1, 0, 0, 0, 6294, 6295, 7, 18, 0, 0, 6295, 6296, 7, 17, 0, 0, 6296, 6297, 7, 23, 0, 0, 6297, 6298, 7, 17, 0, 0, 6298, 6299, 7, 7, 0, 0, 6299, 6300, 7, 16, 0, 0, 6300, 1112, 1, 0, 0, 0, 6301, 6302, 7, 18, 0, 0, 6302, 6303, 7, 17, 0, 0, 6303, 6304, 7, 16, 0, 0, 6304, 1114, 1, 0, 0, 0, 6305, 6306, 7, 18, 0, 0, 6306, 6307, 7, 19, 0, 0, 6307, 6308, 7, 19, 0, 0, 6308, 6309, 7, 6, 0, 0, 6309, 6310, 7, 10, 0, 0, 6310, 6311, 7, 5, 0, 0, 6311, 6312, 7, 7, 0, 0, 6312, 1116, 1, 0, 0, 0, 6313, 6314, 7, 14, 0, 0, 6314, 6315, 7, 20, 0, 0, 6315, 6316, 7, 5, 0, 0, 6316, 6317, 7, 13, 0, 0, 6317, 1118, 1, 0, 0, 0, 6318, 6319, 7, 14, 0, 0, 6319, 6320, 7, 20, 0, 0, 6320, 6321, 7, 5, 0, 0, 6321, 6322, 7, 13, 0, 0, 6322, 6323, 7, 5, 0, 0, 6323, 6324, 7, 14, 0, 0, 6324, 6325, 7, 16, 0, 0, 6325, 6326, 7, 10, 0, 0, 6326, 6327, 7, 13, 0, 0, 6327, 1120, 1, 0, 0, 0, 6328, 6329, 7, 14, 0, 0, 6329, 6330, 7, 19, 0, 0, 6330, 6331, 7, 5, 0, 0, 6331, 6332, 7, 6, 0, 0, 6332, 6333, 7, 10, 0, 0, 6333, 6334, 7, 9, 0, 0, 6334, 6335, 7, 14, 0, 0, 6335, 6336, 7, 10, 0, 0, 6336, 1122, 1, 0, 0, 0, 6337, 6338, 7, 12, 0, 0, 6338, 6339, 7, 10, 0, 0, 6339, 6340, 7, 14, 0, 0, 6340, 1124, 1, 0, 0, 0, 6341, 6342, 7, 12, 0, 0, 6342, 6343, 7, 10, 0, 0, 6343, 6344, 7, 14, 0, 0, 6344, 6345, 7, 17, 0, 0, 6345, 6346, 7, 15, 0, 0, 6346, 6347, 7, 5, 0, 0, 6347, 6348, 7, 6, 0, 0, 6348, 1126, 1, 0, 0, 0, 6349, 6350, 7, 10, 0, 0, 6350, 6351, 7, 26, 0, 0, 6351, 6352, 7, 17, 0, 0, 6352, 6353, 7, 9, 0, 0, 6353, 6354, 7, 16, 0, 0, 6354, 6355, 7, 9, 0, 0, 6355, 1128, 1, 0, 0, 0, 6356, 6357, 7, 10, 0, 0, 6357, 6358, 7, 26, 0, 0, 6358, 6359, 7, 16, 0, 0, 6359, 6360, 7, 13, 0, 0, 6360, 6361, 7, 5, 0, 0, 6361, 6362, 7, 14, 0, 0, 6362, 6363, 7, 16, 0, 0, 6363, 1130, 1, 0, 0, 0, 6364, 6365, 7, 25, 0, 0, 6365, 6366, 7, 6, 0, 0, 6366, 6367, 7, 19, 0, 0, 6367, 6368, 7, 5, 0, 0, 6368, 6369, 7, 16, 0, 0, 6369, 1132, 1, 0, 0, 0, 6370, 6371, 7, 23, 0, 0, 6371, 6372, 7, 13, 0, 0, 6372, 6373, 7, 10, 0, 0, 6373, 6374, 7, 5, 0, 0, 6374, 6375, 7, 16, 0, 0, 6375, 6376, 7, 10, 0, 0, 6376, 6377, 7, 9, 0, 0, 6377, 6378, 7, 16, 0, 0, 6378, 1134, 1, 0, 0, 0, 6379, 6380, 7, 17, 0, 0, 6380, 6381, 7, 7, 0, 0, 6381, 6382, 7, 19, 0, 0, 6382, 6383, 7, 22, 0, 0, 6383, 6384, 7, 16, 0, 0, 6384, 1136, 1, 0, 0, 0, 6385, 6386, 7, 17, 0, 0, 6386, 6387, 7, 7, 0, 0, 6387, 6388, 7, 16, 0, 0, 6388, 1138, 1, 0, 0, 0, 6389, 6390, 7, 17, 0, 0, 6390, 6391, 7, 7, 0, 0, 6391, 6392, 7, 16, 0, 0, 6392, 6393, 7, 10, 0, 0, 6393, 6394, 7, 23, 0, 0, 6394, 6395, 7, 10, 0, 0, 6395, 6396, 7, 13, 0, 0, 6396, 1140, 1, 0, 0, 0, 6397, 6398, 7, 17, 0, 0, 6398, 6399, 7, 7, 0, 0, 6399, 6400, 7, 16, 0, 0, 6400, 6401, 7, 10, 0, 0, 6401, 6402, 7, 13, 0, 0, 6402, 6403, 7, 27, 0, 0, 6403, 6404, 7, 5, 0, 0, 6404, 6405, 7, 6, 0, 0, 6405, 1142, 1, 0, 0, 0, 6406, 6407, 7, 6, 0, 0, 6407, 6408, 7, 10, 0, 0, 6408, 6409, 7, 5, 0, 0, 6409, 6410, 7, 9, 0, 0, 6410, 6411, 7, 16, 0, 0, 6411, 1144, 1, 0, 0, 0, 6412, 6413, 7, 7, 0, 0, 6413, 6414, 7, 5, 0, 0, 6414, 6415, 7, 16, 0, 0, 6415, 6416, 7, 17, 0, 0, 6416, 6417, 7, 19, 0, 0, 6417, 6418, 7, 7, 0, 0, 6418, 6419, 7, 5, 0, 0, 6419, 6420, 7, 6, 0, 0, 6420, 1146, 1, 0, 0, 0, 6421, 6422, 7, 7, 0, 0, 6422, 6423, 7, 14, 0, 0, 6423, 6424, 7, 20, 0, 0, 6424, 6425, 7, 5, 0, 0, 6425, 6426, 7, 13, 0, 0, 6426, 1148, 1, 0, 0, 0, 6427, 6428, 7, 7, 0, 0, 6428, 6429, 7, 19, 0, 0, 6429, 6430, 7, 7, 0, 0, 6430, 6431, 7, 10, 0, 0, 6431, 1150, 1, 0, 0, 0, 6432, 6433, 7, 7, 0, 0, 6433, 6434, 7, 22, 0, 0, 6434, 6435, 7, 6, 0, 0, 6435, 6436, 7, 6, 0, 0, 6436, 6437, 7, 17, 0, 0, 6437, 6438, 7, 25, 0, 0, 6438, 1152, 1, 0, 0, 0, 6439, 6440, 7, 7, 0, 0, 6440, 6441, 7, 22, 0, 0, 6441, 6442, 7, 15, 0, 0, 6442, 6443, 7, 10, 0, 0, 6443, 6444, 7, 13, 0, 0, 6444, 6445, 7, 17, 0, 0, 6445, 6446, 7, 14, 0, 0, 6446, 1154, 1, 0, 0, 0, 6447, 6448, 7, 19, 0, 0, 6448, 6449, 7, 27, 0, 0, 6449, 6450, 7, 10, 0, 0, 6450, 6451, 7, 13, 0, 0, 6451, 6452, 7, 6, 0, 0, 6452, 6453, 7, 5, 0, 0, 6453, 6454, 7, 8, 0, 0, 6454, 1156, 1, 0, 0, 0, 6455, 6456, 7, 24, 0, 0, 6456, 6457, 7, 5, 0, 0, 6457, 6458, 7, 13, 0, 0, 6458, 6459, 7, 5, 0, 0, 6459, 6460, 7, 15, 0, 0, 6460, 6461, 7, 10, 0, 0, 6461, 6462, 7, 16, 0, 0, 6462, 6463, 7, 10, 0, 0, 6463, 6464, 7, 13, 0, 0, 6464, 1158, 1, 0, 0, 0, 6465, 6466, 7, 24, 0, 0, 6466, 6467, 7, 19, 0, 0, 6467, 6468, 7, 9, 0, 0, 6468, 6469, 7, 17, 0, 0, 6469, 6470, 7, 16, 0, 0, 6470, 6471, 7, 17, 0, 0, 6471, 6472, 7, 19, 0, 0, 6472, 6473, 7, 7, 0, 0, 6473, 1160, 1, 0, 0, 0, 6474, 6475, 7, 24, 0, 0, 6475, 6476, 7, 13, 0, 0, 6476, 6477, 7, 10, 0, 0, 6477, 6478, 7, 14, 0, 0, 6478, 6479, 7, 17, 0, 0, 6479, 6480, 7, 9, 0, 0, 6480, 6481, 7, 17, 0, 0, 6481, 6482, 7, 19, 0, 0, 6482, 6483, 7, 7, 0, 0, 6483, 1162, 1, 0, 0, 0, 6484, 6485, 7, 13, 0, 0, 6485, 6486, 7, 10, 0, 0, 6486, 6487, 7, 5, 0, 0, 6487, 6488, 7, 6, 0, 0, 6488, 1164, 1, 0, 0, 0, 6489, 6490, 7, 13, 0, 0, 6490, 6491, 7, 19, 0, 0, 6491, 6492, 7, 29, 0, 0, 6492, 1166, 1, 0, 0, 0, 6493, 6494, 7, 9, 0, 0, 6494, 6495, 7, 10, 0, 0, 6495, 6496, 7, 16, 0, 0, 6496, 6497, 7, 19, 0, 0, 6497, 6498, 7, 25, 0, 0, 6498, 1168, 1, 0, 0, 0, 6499, 6500, 7, 9, 0, 0, 6500, 6501, 7, 15, 0, 0, 6501, 6502, 7, 5, 0, 0, 6502, 6503, 7, 6, 0, 0, 6503, 6504, 7, 6, 0, 0, 6504, 6505, 7, 17, 0, 0, 6505, 6506, 7, 7, 0, 0, 6506, 6507, 7, 16, 0, 0, 6507, 1170, 1, 0, 0, 0, 6508, 6509, 7, 9, 0, 0, 6509, 6510, 7, 22, 0, 0, 6510, 6511, 7, 18, 0, 0, 6511, 6512, 7, 9, 0, 0, 6512, 6513, 7, 16, 0, 0, 6513, 6514, 7, 13, 0, 0, 6514, 6515, 7, 17, 0, 0, 6515, 6516, 7, 7, 0, 0, 6516, 6517, 7, 23, 0, 0, 6517, 1172, 1, 0, 0, 0, 6518, 6519, 7, 16, 0, 0, 6519, 6520, 7, 17, 0, 0, 6520, 6521, 7, 15, 0, 0, 6521, 6522, 7, 10, 0, 0, 6522, 1174, 1, 0, 0, 0, 6523, 6524, 7, 16, 0, 0, 6524, 6525, 7, 17, 0, 0, 6525, 6526, 7, 15, 0, 0, 6526, 6527, 7, 10, 0, 0, 6527, 6528, 7, 9, 0, 0, 6528, 6529, 7, 16, 0, 0, 6529, 6530, 7, 5, 0, 0, 6530, 6531, 7, 15, 0, 0, 6531, 6532, 7, 24, 0, 0, 6532, 1176, 1, 0, 0, 0, 6533, 6534, 7, 16, 0, 0, 6534, 6535, 7, 13, 0, 0, 6535, 6536, 7, 10, 0, 0, 6536, 6537, 7, 5, 0, 0, 6537, 6538, 7, 16, 0, 0, 6538, 1178, 1, 0, 0, 0, 6539, 6540, 7, 16, 0, 0, 6540, 6541, 7, 13, 0, 0, 6541, 6542, 7, 17, 0, 0, 6542, 6543, 7, 15, 0, 0, 6543, 1180, 1, 0, 0, 0, 6544, 6545, 7, 27, 0, 0, 6545, 6546, 7, 5, 0, 0, 6546, 6547, 7, 6, 0, 0, 6547, 6548, 7, 22, 0, 0, 6548, 6549, 7, 10, 0, 0, 6549, 6550, 7, 9, 0, 0, 6550, 1182, 1, 0, 0, 0, 6551, 6552, 7, 27, 0, 0, 6552, 6553, 7, 5, 0, 0, 6553, 6554, 7, 13, 0, 0, 6554, 6555, 7, 14, 0, 0, 6555, 6556, 7, 20, 0, 0, 6556, 6557, 7, 5, 0, 0, 6557, 6558, 7, 13, 0, 0, 6558, 1184, 1, 0, 0, 0, 6559, 6560, 7, 26, 0, 0, 6560, 6561, 7, 15, 0, 0, 6561, 6562, 7, 6, 0, 0, 6562, 6563, 7, 5, 0, 0, 6563, 6564, 7, 16, 0, 0, 6564, 6565, 7, 16, 0, 0, 6565, 6566, 7, 13, 0, 0, 6566, 6567, 7, 17, 0, 0, 6567, 6568, 7, 18, 0, 0, 6568, 6569, 7, 22, 0, 0, 6569, 6570, 7, 16, 0, 0, 6570, 6571, 7, 10, 0, 0, 6571, 6572, 7, 9, 0, 0, 6572, 1186, 1, 0, 0, 0, 6573, 6574, 7, 26, 0, 0, 6574, 6575, 7, 15, 0, 0, 6575, 6576, 7, 6, 0, 0, 6576, 6577, 7, 14, 0, 0, 6577, 6578, 7, 19, 0, 0, 6578, 6579, 7, 15, 0, 0, 6579, 6580, 7, 15, 0, 0, 6580, 6581, 7, 10, 0, 0, 6581, 6582, 7, 7, 0, 0, 6582, 6583, 7, 16, 0, 0, 6583, 1188, 1, 0, 0, 0, 6584, 6585, 7, 26, 0, 0, 6585, 6586, 7, 15, 0, 0, 6586, 6587, 7, 6, 0, 0, 6587, 6588, 7, 5, 0, 0, 6588, 6589, 7, 23, 0, 0, 6589, 6590, 7, 23, 0, 0, 6590, 1190, 1, 0, 0, 0, 6591, 6592, 7, 26, 0, 0, 6592, 6593, 7, 15, 0, 0, 6593, 6594, 7, 6, 0, 0, 6594, 6595, 5, 95, 0, 0, 6595, 6596, 7, 17, 0, 0, 6596, 6597, 7, 9, 0, 0, 6597, 6598, 5, 95, 0, 0, 6598, 6599, 7, 29, 0, 0, 6599, 6600, 7, 10, 0, 0, 6600, 6601, 7, 6, 0, 0, 6601, 6602, 7, 6, 0, 0, 6602, 6603, 5, 95, 0, 0, 6603, 6604, 7, 25, 0, 0, 6604, 6605, 7, 19, 0, 0, 6605, 6606, 7, 13, 0, 0, 6606, 6607, 7, 15, 0, 0, 6607, 6608, 7, 10, 0, 0, 6608, 6609, 7, 12, 0, 0, 6609, 1192, 1, 0, 0, 0, 6610, 6611, 7, 26, 0, 0, 6611, 6612, 7, 15, 0, 0, 6612, 6613, 7, 6, 0, 0, 6613, 6614, 5, 95, 0, 0, 6614, 6615, 7, 17, 0, 0, 6615, 6616, 7, 9, 0, 0, 6616, 6617, 5, 95, 0, 0, 6617, 6618, 7, 29, 0, 0, 6618, 6619, 7, 10, 0, 0, 6619, 6620, 7, 6, 0, 0, 6620, 6621, 7, 6, 0, 0, 6621, 6622, 5, 95, 0, 0, 6622, 6623, 7, 25, 0, 0, 6623, 6624, 7, 19, 0, 0, 6624, 6625, 7, 13, 0, 0, 6625, 6626, 7, 15, 0, 0, 6626, 6627, 7, 10, 0, 0, 6627, 6628, 7, 12, 0, 0, 6628, 6629, 5, 95, 0, 0, 6629, 6630, 7, 12, 0, 0, 6630, 6631, 7, 19, 0, 0, 6631, 6632, 7, 14, 0, 0, 6632, 6633, 7, 22, 0, 0, 6633, 6634, 7, 15, 0, 0, 6634, 6635, 7, 10, 0, 0, 6635, 6636, 7, 7, 0, 0, 6636, 6637, 7, 16, 0, 0, 6637, 1194, 1, 0, 0, 0, 6638, 6639, 7, 26, 0, 0, 6639, 6640, 7, 15, 0, 0, 6640, 6641, 7, 6, 0, 0, 6641, 6642, 5, 95, 0, 0, 6642, 6643, 7, 17, 0, 0, 6643, 6644, 7, 9, 0, 0, 6644, 6645, 5, 95, 0, 0, 6645, 6646, 7, 29, 0, 0, 6646, 6647, 7, 10, 0, 0, 6647, 6648, 7, 6, 0, 0, 6648, 6649, 7, 6, 0, 0, 6649, 6650, 5, 95, 0, 0, 6650, 6651, 7, 25, 0, 0, 6651, 6652, 7, 19, 0, 0, 6652, 6653, 7, 13, 0, 0, 6653, 6654, 7, 15, 0, 0, 6654, 6655, 7, 10, 0, 0, 6655, 6656, 7, 12, 0, 0, 6656, 6657, 5, 95, 0, 0, 6657, 6658, 7, 14, 0, 0, 6658, 6659, 7, 19, 0, 0, 6659, 6660, 7, 7, 0, 0, 6660, 6661, 7, 16, 0, 0, 6661, 6662, 7, 10, 0, 0, 6662, 6663, 7, 7, 0, 0, 6663, 6664, 7, 16, 0, 0, 6664, 1196, 1, 0, 0, 0, 6665, 6666, 7, 26, 0, 0, 6666, 6667, 7, 24, 0, 0, 6667, 6668, 7, 5, 0, 0, 6668, 6669, 7, 16, 0, 0, 6669, 6670, 7, 20, 0, 0, 6670, 1198, 1, 0, 0, 0, 6671, 6672, 7, 26, 0, 0, 6672, 6673, 7, 24, 0, 0, 6673, 6674, 7, 5, 0, 0, 6674, 6675, 7, 16, 0, 0, 6675, 6676, 7, 20, 0, 0, 6676, 6677, 5, 95, 0, 0, 6677, 6678, 7, 10, 0, 0, 6678, 6679, 7, 26, 0, 0, 6679, 6680, 7, 17, 0, 0, 6680, 6681, 7, 9, 0, 0, 6681, 6682, 7, 16, 0, 0, 6682, 6683, 7, 9, 0, 0, 6683, 1200, 1, 0, 0, 0, 6684, 6685, 7, 26, 0, 0, 6685, 6686, 7, 15, 0, 0, 6686, 6687, 7, 6, 0, 0, 6687, 6688, 7, 14, 0, 0, 6688, 6689, 7, 19, 0, 0, 6689, 6690, 7, 7, 0, 0, 6690, 6691, 7, 14, 0, 0, 6691, 6692, 7, 5, 0, 0, 6692, 6693, 7, 16, 0, 0, 6693, 1202, 1, 0, 0, 0, 6694, 6695, 7, 26, 0, 0, 6695, 6696, 7, 15, 0, 0, 6696, 6697, 7, 6, 0, 0, 6697, 6698, 7, 10, 0, 0, 6698, 6699, 7, 6, 0, 0, 6699, 6700, 7, 10, 0, 0, 6700, 6701, 7, 15, 0, 0, 6701, 6702, 7, 10, 0, 0, 6702, 6703, 7, 7, 0, 0, 6703, 6704, 7, 16, 0, 0, 6704, 1204, 1, 0, 0, 0, 6705, 6706, 7, 26, 0, 0, 6706, 6707, 7, 15, 0, 0, 6707, 6708, 7, 6, 0, 0, 6708, 6709, 7, 10, 0, 0, 6709, 6710, 7, 26, 0, 0, 6710, 6711, 7, 17, 0, 0, 6711, 6712, 7, 9, 0, 0, 6712, 6713, 7, 16, 0, 0, 6713, 6714, 7, 9, 0, 0, 6714, 1206, 1, 0, 0, 0, 6715, 6716, 7, 26, 0, 0, 6716, 6717, 7, 15, 0, 0, 6717, 6718, 7, 6, 0, 0, 6718, 6719, 7, 25, 0, 0, 6719, 6720, 7, 19, 0, 0, 6720, 6721, 7, 13, 0, 0, 6721, 6722, 7, 10, 0, 0, 6722, 6723, 7, 9, 0, 0, 6723, 6724, 7, 16, 0, 0, 6724, 1208, 1, 0, 0, 0, 6725, 6726, 7, 26, 0, 0, 6726, 6727, 7, 15, 0, 0, 6727, 6728, 7, 6, 0, 0, 6728, 6729, 7, 24, 0, 0, 6729, 6730, 7, 5, 0, 0, 6730, 6731, 7, 13, 0, 0, 6731, 6732, 7, 9, 0, 0, 6732, 6733, 7, 10, 0, 0, 6733, 1210, 1, 0, 0, 0, 6734, 6735, 7, 26, 0, 0, 6735, 6736, 7, 15, 0, 0, 6736, 6737, 7, 6, 0, 0, 6737, 6738, 7, 24, 0, 0, 6738, 6739, 7, 17, 0, 0, 6739, 1212, 1, 0, 0, 0, 6740, 6741, 7, 26, 0, 0, 6741, 6742, 7, 15, 0, 0, 6742, 6743, 7, 6, 0, 0, 6743, 6744, 7, 13, 0, 0, 6744, 6745, 7, 19, 0, 0, 6745, 6746, 7, 19, 0, 0, 6746, 6747, 7, 16, 0, 0, 6747, 1214, 1, 0, 0, 0, 6748, 6749, 7, 26, 0, 0, 6749, 6750, 7, 15, 0, 0, 6750, 6751, 7, 6, 0, 0, 6751, 6752, 7, 9, 0, 0, 6752, 6753, 7, 10, 0, 0, 6753, 6754, 7, 13, 0, 0, 6754, 6755, 7, 17, 0, 0, 6755, 6756, 7, 5, 0, 0, 6756, 6757, 7, 6, 0, 0, 6757, 6758, 7, 17, 0, 0, 6758, 6759, 7, 11, 0, 0, 6759, 6760, 7, 10, 0, 0, 6760, 1216, 1, 0, 0, 0, 6761, 6762, 7, 14, 0, 0, 6762, 6763, 7, 5, 0, 0, 6763, 6764, 7, 6, 0, 0, 6764, 6765, 7, 6, 0, 0, 6765, 1218, 1, 0, 0, 0, 6766, 6767, 7, 14, 0, 0, 6767, 6768, 7, 22, 0, 0, 6768, 6769, 7, 13, 0, 0, 6769, 6770, 7, 13, 0, 0, 6770, 6771, 7, 10, 0, 0, 6771, 6772, 7, 7, 0, 0, 6772, 6773, 7, 16, 0, 0, 6773, 1220, 1, 0, 0, 0, 6774, 6775, 7, 5, 0, 0, 6775, 6776, 7, 16, 0, 0, 6776, 6777, 7, 16, 0, 0, 6777, 6778, 7, 5, 0, 0, 6778, 6779, 7, 14, 0, 0, 6779, 6780, 7, 20, 0, 0, 6780, 1222, 1, 0, 0, 0, 6781, 6782, 7, 12, 0, 0, 6782, 6783, 7, 10, 0, 0, 6783, 6784, 7, 16, 0, 0, 6784, 6785, 7, 5, 0, 0, 6785, 6786, 7, 14, 0, 0, 6786, 6787, 7, 20, 0, 0, 6787, 1224, 1, 0, 0, 0, 6788, 6789, 7, 10, 0, 0, 6789, 6790, 7, 26, 0, 0, 6790, 6791, 7, 24, 0, 0, 6791, 6792, 7, 13, 0, 0, 6792, 6793, 7, 10, 0, 0, 6793, 6794, 7, 9, 0, 0, 6794, 6795, 7, 9, 0, 0, 6795, 6796, 7, 17, 0, 0, 6796, 6797, 7, 19, 0, 0, 6797, 6798, 7, 7, 0, 0, 6798, 1226, 1, 0, 0, 0, 6799, 6800, 7, 23, 0, 0, 6800, 6801, 7, 10, 0, 0, 6801, 6802, 7, 7, 0, 0, 6802, 6803, 7, 10, 0, 0, 6803, 6804, 7, 13, 0, 0, 6804, 6805, 7, 5, 0, 0, 6805, 6806, 7, 16, 0, 0, 6806, 6807, 7, 10, 0, 0, 6807, 6808, 7, 12, 0, 0, 6808, 1228, 1, 0, 0, 0, 6809, 6810, 7, 6, 0, 0, 6810, 6811, 7, 19, 0, 0, 6811, 6812, 7, 23, 0, 0, 6812, 6813, 7, 23, 0, 0, 6813, 6814, 7, 10, 0, 0, 6814, 6815, 7, 12, 0, 0, 6815, 1230, 1, 0, 0, 0, 6816, 6817, 7, 9, 0, 0, 6817, 6818, 7, 16, 0, 0, 6818, 6819, 7, 19, 0, 0, 6819, 6820, 7, 13, 0, 0, 6820, 6821, 7, 10, 0, 0, 6821, 6822, 7, 12, 0, 0, 6822, 1232, 1, 0, 0, 0, 6823, 6824, 7, 9, 0, 0, 6824, 6825, 7, 10, 0, 0, 6825, 6826, 7, 13, 0, 0, 6826, 6827, 7, 12, 0, 0, 6827, 6828, 7, 10, 0, 0, 6828, 1234, 1, 0, 0, 0, 6829, 6830, 7, 9, 0, 0, 6830, 6831, 7, 10, 0, 0, 6831, 6832, 7, 13, 0, 0, 6832, 6833, 7, 12, 0, 0, 6833, 6834, 7, 10, 0, 0, 6834, 6835, 7, 24, 0, 0, 6835, 6836, 7, 13, 0, 0, 6836, 6837, 7, 19, 0, 0, 6837, 6838, 7, 24, 0, 0, 6838, 6839, 7, 10, 0, 0, 6839, 6840, 7, 13, 0, 0, 6840, 6841, 7, 16, 0, 0, 6841, 6842, 7, 17, 0, 0, 6842, 6843, 7, 10, 0, 0, 6843, 6844, 7, 9, 0, 0, 6844, 1236, 1, 0, 0, 0, 6845, 6846, 7, 17, 0, 0, 6846, 6847, 7, 7, 0, 0, 6847, 6848, 7, 24, 0, 0, 6848, 6849, 7, 22, 0, 0, 6849, 6850, 7, 16, 0, 0, 6850, 6851, 7, 25, 0, 0, 6851, 6852, 7, 19, 0, 0, 6852, 6853, 7, 13, 0, 0, 6853, 6854, 7, 15, 0, 0, 6854, 6855, 7, 5, 0, 0, 6855, 6856, 7, 16, 0, 0, 6856, 1238, 1, 0, 0, 0, 6857, 6858, 7, 19, 0, 0, 6858, 6859, 7, 22, 0, 0, 6859, 6860, 7, 16, 0, 0, 6860, 6861, 7, 24, 0, 0, 6861, 6862, 7, 22, 0, 0, 6862, 6863, 7, 16, 0, 0, 6863, 6864, 7, 25, 0, 0, 6864, 6865, 7, 19, 0, 0, 6865, 6866, 7, 13, 0, 0, 6866, 6867, 7, 15, 0, 0, 6867, 6868, 7, 5, 0, 0, 6868, 6869, 7, 16, 0, 0, 6869, 1240, 1, 0, 0, 0, 6870, 6871, 7, 25, 0, 0, 6871, 6872, 7, 17, 0, 0, 6872, 6873, 7, 10, 0, 0, 6873, 6874, 7, 6, 0, 0, 6874, 6875, 7, 12, 0, 0, 6875, 6876, 7, 9, 0, 0, 6876, 1242, 1, 0, 0, 0, 6877, 6878, 7, 14, 0, 0, 6878, 6879, 7, 19, 0, 0, 6879, 6880, 7, 6, 0, 0, 6880, 6881, 7, 6, 0, 0, 6881, 6882, 7, 10, 0, 0, 6882, 6883, 7, 14, 0, 0, 6883, 6884, 7, 16, 0, 0, 6884, 6885, 7, 17, 0, 0, 6885, 6886, 7, 19, 0, 0, 6886, 6887, 7, 7, 0, 0, 6887, 1244, 1, 0, 0, 0, 6888, 6889, 7, 17, 0, 0, 6889, 6890, 7, 16, 0, 0, 6890, 6891, 7, 10, 0, 0, 6891, 6892, 7, 15, 0, 0, 6892, 6893, 7, 9, 0, 0, 6893, 1246, 1, 0, 0, 0, 6894, 6895, 7, 16, 0, 0, 6895, 6896, 7, 10, 0, 0, 6896, 6897, 7, 13, 0, 0, 6897, 6898, 7, 15, 0, 0, 6898, 6899, 7, 17, 0, 0, 6899, 6900, 7, 7, 0, 0, 6900, 6901, 7, 5, 0, 0, 6901, 6902, 7, 16, 0, 0, 6902, 6903, 7, 10, 0, 0, 6903, 6904, 7, 12, 0, 0, 6904, 1248, 1, 0, 0, 0, 6905, 6906, 7, 10, 0, 0, 6906, 6907, 7, 9, 0, 0, 6907, 6908, 7, 14, 0, 0, 6908, 6909, 7, 5, 0, 0, 6909, 6910, 7, 24, 0, 0, 6910, 6911, 7, 10, 0, 0, 6911, 6912, 7, 12, 0, 0, 6912, 1250, 1, 0, 0, 0, 6913, 6914, 7, 12, 0, 0, 6914, 6915, 7, 10, 0, 0, 6915, 6916, 7, 25, 0, 0, 6916, 6917, 7, 17, 0, 0, 6917, 6918, 7, 7, 0, 0, 6918, 6919, 7, 10, 0, 0, 6919, 6920, 7, 12, 0, 0, 6920, 1252, 1, 0, 0, 0, 6921, 6922, 7, 6, 0, 0, 6922, 6923, 7, 17, 0, 0, 6923, 6924, 7, 7, 0, 0, 6924, 6925, 7, 10, 0, 0, 6925, 6926, 7, 9, 0, 0, 6926, 1254, 1, 0, 0, 0, 6927, 6928, 7, 21, 0, 0, 6928, 6929, 7, 10, 0, 0, 6929, 6930, 7, 8, 0, 0, 6930, 6931, 7, 9, 0, 0, 6931, 1256, 1, 0, 0, 0, 6932, 6933, 7, 24, 0, 0, 6933, 6934, 7, 5, 0, 0, 6934, 6935, 7, 13, 0, 0, 6935, 6936, 7, 16, 0, 0, 6936, 6937, 7, 17, 0, 0, 6937, 6938, 7, 16, 0, 0, 6938, 6939, 7, 17, 0, 0, 6939, 6940, 7, 19, 0, 0, 6940, 6941, 7, 7, 0, 0, 6941, 6942, 7, 10, 0, 0, 6942, 6943, 7, 12, 0, 0, 6943, 1258, 1, 0, 0, 0, 6944, 6945, 7, 9, 0, 0, 6945, 6946, 7, 16, 0, 0, 6946, 6947, 7, 13, 0, 0, 6947, 6948, 7, 22, 0, 0, 6948, 6949, 7, 14, 0, 0, 6949, 6950, 7, 16, 0, 0, 6950, 1260, 1, 0, 0, 0, 6951, 6952, 7, 15, 0, 0, 6952, 6953, 7, 5, 0, 0, 6953, 6954, 7, 24, 0, 0, 6954, 1262, 1, 0, 0, 0, 6955, 6956, 7, 9, 0, 0, 6956, 6957, 7, 16, 0, 0, 6957, 6958, 7, 13, 0, 0, 6958, 6959, 7, 17, 0, 0, 6959, 6960, 7, 7, 0, 0, 6960, 6961, 7, 23, 0, 0, 6961, 1264, 1, 0, 0, 0, 6962, 6963, 7, 12, 0, 0, 6963, 6964, 7, 10, 0, 0, 6964, 6965, 7, 6, 0, 0, 6965, 6966, 7, 17, 0, 0, 6966, 6967, 7, 15, 0, 0, 6967, 6968, 7, 17, 0, 0, 6968, 6969, 7, 16, 0, 0, 6969, 6970, 7, 10, 0, 0, 6970, 6971, 7, 12, 0, 0, 6971, 1266, 1, 0, 0, 0, 6972, 6973, 7, 22, 0, 0, 6973, 6974, 7, 9, 0, 0, 6974, 6975, 7, 5, 0, 0, 6975, 6976, 7, 23, 0, 0, 6976, 6977, 7, 10, 0, 0, 6977, 1268, 1, 0, 0, 0, 6978, 6979, 7, 17, 0, 0, 6979, 6980, 7, 23, 0, 0, 6980, 6981, 7, 7, 0, 0, 6981, 6982, 7, 19, 0, 0, 6982, 6983, 7, 13, 0, 0, 6983, 6984, 7, 10, 0, 0, 6984, 1270, 1, 0, 0, 0, 6985, 6986, 7, 6, 0, 0, 6986, 6987, 7, 5, 0, 0, 6987, 6988, 7, 7, 0, 0, 6988, 6989, 7, 23, 0, 0, 6989, 6990, 7, 22, 0, 0, 6990, 6991, 7, 5, 0, 0, 6991, 6992, 7, 23, 0, 0, 6992, 6993, 7, 10, 0, 0, 6993, 6994, 7, 9, 0, 0, 6994, 1272, 1, 0, 0, 0, 6995, 6996, 7, 30, 0, 0, 6996, 6997, 7, 19, 0, 0, 6997, 6998, 7, 18, 0, 0, 6998, 1274, 1, 0, 0, 0, 6999, 7000, 7, 30, 0, 0, 7000, 7001, 7, 19, 0, 0, 7001, 7002, 7, 18, 0, 0, 7002, 7003, 7, 9, 0, 0, 7003, 1276, 1, 0, 0, 0, 7004, 7005, 7, 27, 0, 0, 7005, 7006, 7, 17, 0, 0, 7006, 7007, 7, 5, 0, 0, 7007, 1278, 1, 0, 0, 0, 7008, 7009, 7, 5, 0, 0, 7009, 7010, 7, 9, 0, 0, 7010, 7011, 7, 9, 0, 0, 7011, 7012, 7, 22, 0, 0, 7012, 7013, 7, 15, 0, 0, 7013, 7014, 7, 10, 0, 0, 7014, 7015, 7, 13, 0, 0, 7015, 7016, 7, 19, 0, 0, 7016, 7017, 7, 6, 0, 0, 7017, 7018, 7, 10, 0, 0, 7018, 1280, 1, 0, 0, 0, 7019, 7020, 7, 13, 0, 0, 7020, 7021, 7, 10, 0, 0, 7021, 7022, 7, 16, 0, 0, 7022, 7023, 7, 13, 0, 0, 7023, 7024, 7, 8, 0, 0, 7024, 7025, 5, 95, 0, 0, 7025, 7026, 7, 16, 0, 0, 7026, 7027, 7, 17, 0, 0, 7027, 7028, 7, 15, 0, 0, 7028, 7029, 7, 10, 0, 0, 7029, 7030, 7, 19, 0, 0, 7030, 7031, 7, 22, 0, 0, 7031, 7032, 7, 16, 0, 0, 7032, 1282, 1, 0, 0, 0, 7033, 7034, 7, 15, 0, 0, 7034, 7035, 7, 5, 0, 0, 7035, 7036, 7, 26, 0, 0, 7036, 7037, 5, 95, 0, 0, 7037, 7038, 7, 18, 0, 0, 7038, 7039, 7, 5, 0, 0, 7039, 7040, 7, 16, 0, 0, 7040, 7041, 7, 14, 0, 0, 7041, 7042, 7, 20, 0, 0, 7042, 7043, 5, 95, 0, 0, 7043, 7044, 7, 9, 0, 0, 7044, 7045, 7, 17, 0, 0, 7045, 7046, 7, 11, 0, 0, 7046, 7047, 7, 10, 0, 0, 7047, 1284, 1, 0, 0, 0, 7048, 7049, 7, 15, 0, 0, 7049, 7050, 7, 5, 0, 0, 7050, 7051, 7, 26, 0, 0, 7051, 7052, 5, 95, 0, 0, 7052, 7053, 7, 24, 0, 0, 7053, 7054, 7, 5, 0, 0, 7054, 7055, 7, 8, 0, 0, 7055, 7056, 7, 6, 0, 0, 7056, 7057, 7, 19, 0, 0, 7057, 7058, 7, 5, 0, 0, 7058, 7059, 7, 12, 0, 0, 7059, 7060, 5, 95, 0, 0, 7060, 7061, 7, 17, 0, 0, 7061, 7062, 7, 7, 0, 0, 7062, 7063, 5, 95, 0, 0, 7063, 7064, 7, 15, 0, 0, 7064, 7065, 7, 18, 0, 0, 7065, 1286, 1, 0, 0, 0, 7066, 7067, 7, 21, 0, 0, 7067, 7068, 7, 18, 0, 0, 7068, 1288, 1, 0, 0, 0, 7069, 7070, 7, 17, 0, 0, 7070, 7071, 7, 7, 0, 0, 7071, 7072, 7, 14, 0, 0, 7072, 7073, 7, 6, 0, 0, 7073, 7074, 7, 22, 0, 0, 7074, 7075, 7, 12, 0, 0, 7075, 7076, 7, 10, 0, 0, 7076, 1290, 1, 0, 0, 0, 7077, 7078, 7, 13, 0, 0, 7078, 7079, 7, 19, 0, 0, 7079, 7080, 7, 22, 0, 0, 7080, 7081, 7, 16, 0, 0, 7081, 7082, 7, 17, 0, 0, 7082, 7083, 7, 7, 0, 0, 7083, 7084, 7, 10, 0, 0, 7084, 1292, 1, 0, 0, 0, 7085, 7086, 7, 16, 0, 0, 7086, 7087, 7, 13, 0, 0, 7087, 7088, 7, 5, 0, 0, 7088, 7089, 7, 7, 0, 0, 7089, 7090, 7, 9, 0, 0, 7090, 7091, 7, 25, 0, 0, 7091, 7092, 7, 19, 0, 0, 7092, 7093, 7, 13, 0, 0, 7093, 7094, 7, 15, 0, 0, 7094, 1294, 1, 0, 0, 0, 7095, 7096, 7, 17, 0, 0, 7096, 7097, 7, 15, 0, 0, 7097, 7098, 7, 24, 0, 0, 7098, 7099, 7, 19, 0, 0, 7099, 7100, 7, 13, 0, 0, 7100, 7101, 7, 16, 0, 0, 7101, 1296, 1, 0, 0, 0, 7102, 7103, 7, 24, 0, 0, 7103, 7104, 7, 19, 0, 0, 7104, 7105, 7, 6, 0, 0, 7105, 7106, 7, 17, 0, 0, 7106, 7107, 7, 14, 0, 0, 7107, 7108, 7, 8, 0, 0, 7108, 1298, 1, 0, 0, 0, 7109, 7110, 7, 24, 0, 0, 7110, 7111, 7, 13, 0, 0, 7111, 7112, 7, 17, 0, 0, 7112, 7113, 7, 19, 0, 0, 7113, 7114, 7, 13, 0, 0, 7114, 7115, 7, 17, 0, 0, 7115, 7116, 7, 16, 0, 0, 7116, 7117, 7, 8, 0, 0, 7117, 1300, 1, 0, 0, 0, 7118, 7119, 7, 15, 0, 0, 7119, 7120, 7, 10, 0, 0, 7120, 7121, 7, 16, 0, 0, 7121, 7122, 7, 20, 0, 0, 7122, 7123, 7, 19, 0, 0, 7123, 7124, 7, 12, 0, 0, 7124, 1302, 1, 0, 0, 0, 7125, 7126, 7, 13, 0, 0, 7126, 7127, 7, 10, 0, 0, 7127, 7128, 7, 25, 0, 0, 7128, 7129, 7, 10, 0, 0, 7129, 7130, 7, 13, 0, 0, 7130, 7131, 7, 10, 0, 0, 7131, 7132, 7, 7, 0, 0, 7132, 7133, 7, 14, 0, 0, 7133, 7134, 7, 17, 0, 0, 7134, 7135, 7, 7, 0, 0, 7135, 7136, 7, 23, 0, 0, 7136, 1304, 1, 0, 0, 0, 7137, 7138, 7, 7, 0, 0, 7138, 7139, 7, 10, 0, 0, 7139, 7140, 7, 29, 0, 0, 7140, 1306, 1, 0, 0, 0, 7141, 7142, 7, 19, 0, 0, 7142, 7143, 7, 6, 0, 0, 7143, 7144, 7, 12, 0, 0, 7144, 1308, 1, 0, 0, 0, 7145, 7146, 7, 27, 0, 0, 7146, 7147, 7, 5, 0, 0, 7147, 7148, 7, 6, 0, 0, 7148, 7149, 7, 22, 0, 0, 7149, 7150, 7, 10, 0, 0, 7150, 1310, 1, 0, 0, 0, 7151, 7152, 7, 9, 0, 0, 7152, 7153, 7, 22, 0, 0, 7153, 7154, 7, 18, 0, 0, 7154, 7155, 7, 9, 0, 0, 7155, 7156, 7, 14, 0, 0, 7156, 7157, 7, 13, 0, 0, 7157, 7158, 7, 17, 0, 0, 7158, 7159, 7, 24, 0, 0, 7159, 7160, 7, 16, 0, 0, 7160, 7161, 7, 17, 0, 0, 7161, 7162, 7, 19, 0, 0, 7162, 7163, 7, 7, 0, 0, 7163, 1312, 1, 0, 0, 0, 7164, 7165, 7, 24, 0, 0, 7165, 7166, 7, 22, 0, 0, 7166, 7167, 7, 18, 0, 0, 7167, 7168, 7, 6, 0, 0, 7168, 7169, 7, 17, 0, 0, 7169, 7170, 7, 14, 0, 0, 7170, 7171, 7, 5, 0, 0, 7171, 7172, 7, 16, 0, 0, 7172, 7173, 7, 17, 0, 0, 7173, 7174, 7, 19, 0, 0, 7174, 7175, 7, 7, 0, 0, 7175, 1314, 1, 0, 0, 0, 7176, 7177, 7, 19, 0, 0, 7177, 7178, 7, 22, 0, 0, 7178, 7179, 7, 16, 0, 0, 7179, 1316, 1, 0, 0, 0, 7180, 7181, 7, 10, 0, 0, 7181, 7182, 7, 7, 0, 0, 7182, 7183, 7, 12, 0, 0, 7183, 1318, 1, 0, 0, 0, 7184, 7185, 7, 13, 0, 0, 7185, 7186, 7, 19, 0, 0, 7186, 7187, 7, 22, 0, 0, 7187, 7188, 7, 16, 0, 0, 7188, 7189, 7, 17, 0, 0, 7189, 7190, 7, 7, 0, 0, 7190, 7191, 7, 10, 0, 0, 7191, 7192, 7, 9, 0, 0, 7192, 1320, 1, 0, 0, 0, 7193, 7194, 7, 9, 0, 0, 7194, 7195, 7, 14, 0, 0, 7195, 7196, 7, 20, 0, 0, 7196, 7197, 7, 10, 0, 0, 7197, 7198, 7, 15, 0, 0, 7198, 7199, 7, 5, 0, 0, 7199, 7200, 7, 9, 0, 0, 7200, 1322, 1, 0, 0, 0, 7201, 7202, 7, 24, 0, 0, 7202, 7203, 7, 13, 0, 0, 7203, 7204, 7, 19, 0, 0, 7204, 7205, 7, 14, 0, 0, 7205, 7206, 7, 10, 0, 0, 7206, 7207, 7, 12, 0, 0, 7207, 7208, 7, 22, 0, 0, 7208, 7209, 7, 13, 0, 0, 7209, 7210, 7, 10, 0, 0, 7210, 7211, 7, 9, 0, 0, 7211, 1324, 1, 0, 0, 0, 7212, 7213, 7, 17, 0, 0, 7213, 7214, 7, 7, 0, 0, 7214, 7215, 7, 24, 0, 0, 7215, 7216, 7, 22, 0, 0, 7216, 7217, 7, 16, 0, 0, 7217, 1326, 1, 0, 0, 0, 7218, 7219, 7, 9, 0, 0, 7219, 7220, 7, 22, 0, 0, 7220, 7221, 7, 24, 0, 0, 7221, 7222, 7, 24, 0, 0, 7222, 7223, 7, 19, 0, 0, 7223, 7224, 7, 13, 0, 0, 7224, 7225, 7, 16, 0, 0, 7225, 1328, 1, 0, 0, 0, 7226, 7227, 7, 24, 0, 0, 7227, 7228, 7, 5, 0, 0, 7228, 7229, 7, 13, 0, 0, 7229, 7230, 7, 5, 0, 0, 7230, 7231, 7, 6, 0, 0, 7231, 7232, 7, 6, 0, 0, 7232, 7233, 7, 10, 0, 0, 7233, 7234, 7, 6, 0, 0, 7234, 1330, 1, 0, 0, 0, 7235, 7236, 7, 9, 0, 0, 7236, 7237, 7, 28, 0, 0, 7237, 7238, 7, 6, 0, 0, 7238, 1332, 1, 0, 0, 0, 7239, 7240, 7, 12, 0, 0, 7240, 7241, 7, 10, 0, 0, 7241, 7242, 7, 24, 0, 0, 7242, 7243, 7, 10, 0, 0, 7243, 7244, 7, 7, 0, 0, 7244, 7245, 7, 12, 0, 0, 7245, 7246, 7, 9, 0, 0, 7246, 1334, 1, 0, 0, 0, 7247, 7248, 7, 19, 0, 0, 7248, 7249, 7, 27, 0, 0, 7249, 7250, 7, 10, 0, 0, 7250, 7251, 7, 13, 0, 0, 7251, 7252, 7, 13, 0, 0, 7252, 7253, 7, 17, 0, 0, 7253, 7254, 7, 12, 0, 0, 7254, 7255, 7, 17, 0, 0, 7255, 7256, 7, 7, 0, 0, 7256, 7257, 7, 23, 0, 0, 7257, 1336, 1, 0, 0, 0, 7258, 7259, 7, 14, 0, 0, 7259, 7260, 7, 19, 0, 0, 7260, 7261, 7, 7, 0, 0, 7261, 7262, 7, 25, 0, 0, 7262, 7263, 7, 6, 0, 0, 7263, 7264, 7, 17, 0, 0, 7264, 7265, 7, 14, 0, 0, 7265, 7266, 7, 16, 0, 0, 7266, 1338, 1, 0, 0, 0, 7267, 7268, 7, 9, 0, 0, 7268, 7269, 7, 21, 0, 0, 7269, 7270, 7, 17, 0, 0, 7270, 7271, 7, 24, 0, 0, 7271, 1340, 1, 0, 0, 0, 7272, 7273, 7, 6, 0, 0, 7273, 7274, 7, 19, 0, 0, 7274, 7275, 7, 14, 0, 0, 7275, 7276, 7, 21, 0, 0, 7276, 7277, 7, 10, 0, 0, 7277, 7278, 7, 12, 0, 0, 7278, 1342, 1, 0, 0, 0, 7279, 7280, 7, 16, 0, 0, 7280, 7281, 7, 17, 0, 0, 7281, 7282, 7, 10, 0, 0, 7282, 7283, 7, 9, 0, 0, 7283, 1344, 1, 0, 0, 0, 7284, 7285, 7, 13, 0, 0, 7285, 7286, 7, 19, 0, 0, 7286, 7287, 7, 6, 0, 0, 7287, 7288, 7, 6, 0, 0, 7288, 7289, 7, 22, 0, 0, 7289, 7290, 7, 24, 0, 0, 7290, 1346, 1, 0, 0, 0, 7291, 7292, 7, 14, 0, 0, 7292, 7293, 7, 22, 0, 0, 7293, 7294, 7, 18, 0, 0, 7294, 7295, 7, 10, 0, 0, 7295, 1348, 1, 0, 0, 0, 7296, 7297, 7, 23, 0, 0, 7297, 7298, 7, 13, 0, 0, 7298, 7299, 7, 19, 0, 0, 7299, 7300, 7, 22, 0, 0, 7300, 7301, 7, 24, 0, 0, 7301, 7302, 7, 17, 0, 0, 7302, 7303, 7, 7, 0, 0, 7303, 7304, 7, 23, 0, 0, 7304, 1350, 1, 0, 0, 0, 7305, 7306, 7, 9, 0, 0, 7306, 7307, 7, 10, 0, 0, 7307, 7308, 7, 16, 0, 0, 7308, 7309, 7, 9, 0, 0, 7309, 1352, 1, 0, 0, 0, 7310, 7311, 7, 16, 0, 0, 7311, 7312, 7, 5, 0, 0, 7312, 7313, 7, 18, 0, 0, 7313, 7314, 7, 6, 0, 0, 7314, 7315, 7, 10, 0, 0, 7315, 7316, 7, 9, 0, 0, 7316, 7317, 7, 5, 0, 0, 7317, 7318, 7, 15, 0, 0, 7318, 7319, 7, 24, 0, 0, 7319, 7320, 7, 6, 0, 0, 7320, 7321, 7, 10, 0, 0, 7321, 1354, 1, 0, 0, 0, 7322, 7323, 7, 19, 0, 0, 7323, 7324, 7, 13, 0, 0, 7324, 7325, 7, 12, 0, 0, 7325, 7326, 7, 17, 0, 0, 7326, 7327, 7, 7, 0, 0, 7327, 7328, 7, 5, 0, 0, 7328, 7329, 7, 6, 0, 0, 7329, 7330, 7, 17, 0, 0, 7330, 7331, 7, 16, 0, 0, 7331, 7332, 7, 8, 0, 0, 7332, 1356, 1, 0, 0, 0, 7333, 7334, 7, 26, 0, 0, 7334, 7335, 7, 15, 0, 0, 7335, 7336, 7, 6, 0, 0, 7336, 7337, 7, 16, 0, 0, 7337, 7338, 7, 5, 0, 0, 7338, 7339, 7, 18, 0, 0, 7339, 7340, 7, 6, 0, 0, 7340, 7341, 7, 10, 0, 0, 7341, 1358, 1, 0, 0, 0, 7342, 7343, 7, 14, 0, 0, 7343, 7344, 7, 19, 0, 0, 7344, 7345, 7, 6, 0, 0, 7345, 7346, 7, 22, 0, 0, 7346, 7347, 7, 15, 0, 0, 7347, 7348, 7, 7, 0, 0, 7348, 7349, 7, 9, 0, 0, 7349, 1360, 1, 0, 0, 0, 7350, 7351, 7, 26, 0, 0, 7351, 7352, 7, 15, 0, 0, 7352, 7353, 7, 6, 0, 0, 7353, 7354, 7, 7, 0, 0, 7354, 7355, 7, 5, 0, 0, 7355, 7356, 7, 15, 0, 0, 7356, 7357, 7, 10, 0, 0, 7357, 7358, 7, 9, 0, 0, 7358, 7359, 7, 24, 0, 0, 7359, 7360, 7, 5, 0, 0, 7360, 7361, 7, 14, 0, 0, 7361, 7362, 7, 10, 0, 0, 7362, 7363, 7, 9, 0, 0, 7363, 1362, 1, 0, 0, 0, 7364, 7365, 7, 13, 0, 0, 7365, 7366, 7, 19, 0, 0, 7366, 7367, 7, 29, 0, 0, 7367, 7368, 7, 16, 0, 0, 7368, 7369, 7, 8, 0, 0, 7369, 7370, 7, 24, 0, 0, 7370, 7371, 7, 10, 0, 0, 7371, 1364, 1, 0, 0, 0, 7372, 7373, 7, 7, 0, 0, 7373, 7374, 7, 19, 0, 0, 7374, 7375, 7, 13, 0, 0, 7375, 7376, 7, 15, 0, 0, 7376, 7377, 7, 5, 0, 0, 7377, 7378, 7, 6, 0, 0, 7378, 7379, 7, 17, 0, 0, 7379, 7380, 7, 11, 0, 0, 7380, 7381, 7, 10, 0, 0, 7381, 7382, 7, 12, 0, 0, 7382, 1366, 1, 0, 0, 0, 7383, 7384, 7, 29, 0, 0, 7384, 7385, 7, 17, 0, 0, 7385, 7386, 7, 16, 0, 0, 7386, 7387, 7, 20, 0, 0, 7387, 7388, 7, 17, 0, 0, 7388, 7389, 7, 7, 0, 0, 7389, 1368, 1, 0, 0, 0, 7390, 7391, 7, 25, 0, 0, 7391, 7392, 7, 17, 0, 0, 7392, 7393, 7, 6, 0, 0, 7393, 7394, 7, 16, 0, 0, 7394, 7395, 7, 10, 0, 0, 7395, 7396, 7, 13, 0, 0, 7396, 1370, 1, 0, 0, 0, 7397, 7398, 7, 23, 0, 0, 7398, 7399, 7, 13, 0, 0, 7399, 7400, 7, 19, 0, 0, 7400, 7401, 7, 22, 0, 0, 7401, 7402, 7, 24, 0, 0, 7402, 7403, 7, 9, 0, 0, 7403, 1372, 1, 0, 0, 0, 7404, 7405, 7, 19, 0, 0, 7405, 7406, 7, 16, 0, 0, 7406, 7407, 7, 20, 0, 0, 7407, 7408, 7, 10, 0, 0, 7408, 7409, 7, 13, 0, 0, 7409, 7410, 7, 9, 0, 0, 7410, 1374, 1, 0, 0, 0, 7411, 7412, 7, 7, 0, 0, 7412, 7413, 7, 25, 0, 0, 7413, 7414, 7, 14, 0, 0, 7414, 1376, 1, 0, 0, 0, 7415, 7416, 7, 7, 0, 0, 7416, 7417, 7, 25, 0, 0, 7417, 7418, 7, 12, 0, 0, 7418, 1378, 1, 0, 0, 0, 7419, 7420, 7, 7, 0, 0, 7420, 7421, 7, 25, 0, 0, 7421, 7422, 7, 21, 0, 0, 7422, 7423, 7, 14, 0, 0, 7423, 1380, 1, 0, 0, 0, 7424, 7425, 7, 7, 0, 0, 7425, 7426, 7, 25, 0, 0, 7426, 7427, 7, 21, 0, 0, 7427, 7428, 7, 12, 0, 0, 7428, 1382, 1, 0, 0, 0, 7429, 7430, 7, 22, 0, 0, 7430, 7431, 7, 10, 0, 0, 7431, 7432, 7, 9, 0, 0, 7432, 7433, 7, 14, 0, 0, 7433, 7434, 7, 5, 0, 0, 7434, 7435, 7, 24, 0, 0, 7435, 7436, 7, 10, 0, 0, 7436, 1384, 1, 0, 0, 0, 7437, 7438, 7, 27, 0, 0, 7438, 7439, 7, 17, 0, 0, 7439, 7440, 7, 10, 0, 0, 7440, 7441, 7, 29, 0, 0, 7441, 7442, 7, 9, 0, 0, 7442, 1386, 1, 0, 0, 0, 7443, 7444, 7, 7, 0, 0, 7444, 7445, 7, 19, 0, 0, 7445, 7446, 7, 13, 0, 0, 7446, 7447, 7, 15, 0, 0, 7447, 7448, 7, 5, 0, 0, 7448, 7449, 7, 6, 0, 0, 7449, 7450, 7, 17, 0, 0, 7450, 7451, 7, 11, 0, 0, 7451, 7452, 7, 10, 0, 0, 7452, 1388, 1, 0, 0, 0, 7453, 7454, 7, 12, 0, 0, 7454, 7455, 7, 22, 0, 0, 7455, 7456, 7, 15, 0, 0, 7456, 7457, 7, 24, 0, 0, 7457, 1390, 1, 0, 0, 0, 7458, 7459, 7, 24, 0, 0, 7459, 7460, 7, 13, 0, 0, 7460, 7461, 7, 17, 0, 0, 7461, 7462, 7, 7, 0, 0, 7462, 7463, 7, 16, 0, 0, 7463, 7464, 5, 95, 0, 0, 7464, 7465, 7, 9, 0, 0, 7465, 7466, 7, 16, 0, 0, 7466, 7467, 7, 13, 0, 0, 7467, 7468, 7, 17, 0, 0, 7468, 7469, 7, 14, 0, 0, 7469, 7470, 7, 16, 0, 0, 7470, 7471, 5, 95, 0, 0, 7471, 7472, 7, 24, 0, 0, 7472, 7473, 7, 5, 0, 0, 7473, 7474, 7, 13, 0, 0, 7474, 7475, 7, 5, 0, 0, 7475, 7476, 7, 15, 0, 0, 7476, 7477, 7, 9, 0, 0, 7477, 1392, 1, 0, 0, 0, 7478, 7479, 7, 27, 0, 0, 7479, 7480, 7, 5, 0, 0, 7480, 7481, 7, 13, 0, 0, 7481, 7482, 7, 17, 0, 0, 7482, 7483, 7, 5, 0, 0, 7483, 7484, 7, 18, 0, 0, 7484, 7485, 7, 6, 0, 0, 7485, 7486, 7, 10, 0, 0, 7486, 7487, 5, 95, 0, 0, 7487, 7488, 7, 14, 0, 0, 7488, 7489, 7, 19, 0, 0, 7489, 7490, 7, 7, 0, 0, 7490, 7491, 7, 25, 0, 0, 7491, 7492, 7, 6, 0, 0, 7492, 7493, 7, 17, 0, 0, 7493, 7494, 7, 14, 0, 0, 7494, 7495, 7, 16, 0, 0, 7495, 1394, 1, 0, 0, 0, 7496, 7497, 7, 10, 0, 0, 7497, 7498, 7, 13, 0, 0, 7498, 7499, 7, 13, 0, 0, 7499, 7500, 7, 19, 0, 0, 7500, 7501, 7, 13, 0, 0, 7501, 1396, 1, 0, 0, 0, 7502, 7503, 7, 22, 0, 0, 7503, 7504, 7, 9, 0, 0, 7504, 7505, 7, 10, 0, 0, 7505, 7506, 5, 95, 0, 0, 7506, 7507, 7, 27, 0, 0, 7507, 7508, 7, 5, 0, 0, 7508, 7509, 7, 13, 0, 0, 7509, 7510, 7, 17, 0, 0, 7510, 7511, 7, 5, 0, 0, 7511, 7512, 7, 18, 0, 0, 7512, 7513, 7, 6, 0, 0, 7513, 7514, 7, 10, 0, 0, 7514, 1398, 1, 0, 0, 0, 7515, 7516, 7, 22, 0, 0, 7516, 7517, 7, 9, 0, 0, 7517, 7518, 7, 10, 0, 0, 7518, 7519, 5, 95, 0, 0, 7519, 7520, 7, 14, 0, 0, 7520, 7521, 7, 19, 0, 0, 7521, 7522, 7, 6, 0, 0, 7522, 7523, 7, 22, 0, 0, 7523, 7524, 7, 15, 0, 0, 7524, 7525, 7, 7, 0, 0, 7525, 1400, 1, 0, 0, 0, 7526, 7527, 7, 5, 0, 0, 7527, 7528, 7, 6, 0, 0, 7528, 7529, 7, 17, 0, 0, 7529, 7530, 7, 5, 0, 0, 7530, 7531, 7, 9, 0, 0, 7531, 1402, 1, 0, 0, 0, 7532, 7533, 7, 14, 0, 0, 7533, 7534, 7, 19, 0, 0, 7534, 7535, 7, 7, 0, 0, 7535, 7536, 7, 9, 0, 0, 7536, 7537, 7, 16, 0, 0, 7537, 7538, 7, 5, 0, 0, 7538, 7539, 7, 7, 0, 0, 7539, 7540, 7, 16, 0, 0, 7540, 1404, 1, 0, 0, 0, 7541, 7542, 7, 24, 0, 0, 7542, 7543, 7, 10, 0, 0, 7543, 7544, 7, 13, 0, 0, 7544, 7545, 7, 25, 0, 0, 7545, 7546, 7, 19, 0, 0, 7546, 7547, 7, 13, 0, 0, 7547, 7548, 7, 15, 0, 0, 7548, 1406, 1, 0, 0, 0, 7549, 7550, 7, 23, 0, 0, 7550, 7551, 7, 10, 0, 0, 7551, 7552, 7, 16, 0, 0, 7552, 1408, 1, 0, 0, 0, 7553, 7554, 7, 12, 0, 0, 7554, 7555, 7, 17, 0, 0, 7555, 7556, 7, 5, 0, 0, 7556, 7557, 7, 23, 0, 0, 7557, 7558, 7, 7, 0, 0, 7558, 7559, 7, 19, 0, 0, 7559, 7560, 7, 9, 0, 0, 7560, 7561, 7, 16, 0, 0, 7561, 7562, 7, 17, 0, 0, 7562, 7563, 7, 14, 0, 0, 7563, 7564, 7, 9, 0, 0, 7564, 1410, 1, 0, 0, 0, 7565, 7566, 7, 9, 0, 0, 7566, 7567, 7, 16, 0, 0, 7567, 7568, 7, 5, 0, 0, 7568, 7569, 7, 14, 0, 0, 7569, 7570, 7, 21, 0, 0, 7570, 7571, 7, 10, 0, 0, 7571, 7572, 7, 12, 0, 0, 7572, 1412, 1, 0, 0, 0, 7573, 7574, 7, 10, 0, 0, 7574, 7575, 7, 6, 0, 0, 7575, 7576, 7, 9, 0, 0, 7576, 7577, 7, 17, 0, 0, 7577, 7578, 7, 25, 0, 0, 7578, 1414, 1, 0, 0, 0, 7579, 7580, 7, 29, 0, 0, 7580, 7581, 7, 20, 0, 0, 7581, 7582, 7, 17, 0, 0, 7582, 7583, 7, 6, 0, 0, 7583, 7584, 7, 10, 0, 0, 7584, 1416, 1, 0, 0, 0, 7585, 7586, 7, 13, 0, 0, 7586, 7587, 7, 10, 0, 0, 7587, 7588, 7, 27, 0, 0, 7588, 7589, 7, 10, 0, 0, 7589, 7590, 7, 13, 0, 0, 7590, 7591, 7, 9, 0, 0, 7591, 7592, 7, 10, 0, 0, 7592, 1418, 1, 0, 0, 0, 7593, 7594, 7, 25, 0, 0, 7594, 7595, 7, 19, 0, 0, 7595, 7596, 7, 13, 0, 0, 7596, 7597, 7, 10, 0, 0, 7597, 7598, 7, 5, 0, 0, 7598, 7599, 7, 14, 0, 0, 7599, 7600, 7, 20, 0, 0, 7600, 1420, 1, 0, 0, 0, 7601, 7602, 7, 9, 0, 0, 7602, 7603, 7, 6, 0, 0, 7603, 7604, 7, 17, 0, 0, 7604, 7605, 7, 14, 0, 0, 7605, 7606, 7, 10, 0, 0, 7606, 1422, 1, 0, 0, 0, 7607, 7608, 7, 10, 0, 0, 7608, 7609, 7, 26, 0, 0, 7609, 7610, 7, 17, 0, 0, 7610, 7611, 7, 16, 0, 0, 7611, 1424, 1, 0, 0, 0, 7612, 7613, 7, 13, 0, 0, 7613, 7614, 7, 10, 0, 0, 7614, 7615, 7, 16, 0, 0, 7615, 7616, 7, 22, 0, 0, 7616, 7617, 7, 13, 0, 0, 7617, 7618, 7, 7, 0, 0, 7618, 1426, 1, 0, 0, 0, 7619, 7620, 7, 28, 0, 0, 7620, 7621, 7, 22, 0, 0, 7621, 7622, 7, 10, 0, 0, 7622, 7623, 7, 13, 0, 0, 7623, 7624, 7, 8, 0, 0, 7624, 1428, 1, 0, 0, 0, 7625, 7626, 7, 13, 0, 0, 7626, 7627, 7, 5, 0, 0, 7627, 7628, 7, 17, 0, 0, 7628, 7629, 7, 9, 0, 0, 7629, 7630, 7, 10, 0, 0, 7630, 1430, 1, 0, 0, 0, 7631, 7632, 7, 9, 0, 0, 7632, 7633, 7, 28, 0, 0, 7633, 7634, 7, 6, 0, 0, 7634, 7635, 7, 9, 0, 0, 7635, 7636, 7, 16, 0, 0, 7636, 7637, 7, 5, 0, 0, 7637, 7638, 7, 16, 0, 0, 7638, 7639, 7, 10, 0, 0, 7639, 1432, 1, 0, 0, 0, 7640, 7641, 7, 12, 0, 0, 7641, 7642, 7, 10, 0, 0, 7642, 7643, 7, 18, 0, 0, 7643, 7644, 7, 22, 0, 0, 7644, 7645, 7, 23, 0, 0, 7645, 1434, 1, 0, 0, 0, 7646, 7647, 7, 6, 0, 0, 7647, 7648, 7, 19, 0, 0, 7648, 7649, 7, 23, 0, 0, 7649, 1436, 1, 0, 0, 0, 7650, 7651, 7, 17, 0, 0, 7651, 7652, 7, 7, 0, 0, 7652, 7653, 7, 25, 0, 0, 7653, 7654, 7, 19, 0, 0, 7654, 1438, 1, 0, 0, 0, 7655, 7656, 7, 7, 0, 0, 7656, 7657, 7, 19, 0, 0, 7657, 7658, 7, 16, 0, 0, 7658, 7659, 7, 17, 0, 0, 7659, 7660, 7, 14, 0, 0, 7660, 7661, 7, 10, 0, 0, 7661, 1440, 1, 0, 0, 0, 7662, 7663, 7, 29, 0, 0, 7663, 7664, 7, 5, 0, 0, 7664, 7665, 7, 13, 0, 0, 7665, 7666, 7, 7, 0, 0, 7666, 7667, 7, 17, 0, 0, 7667, 7668, 7, 7, 0, 0, 7668, 7669, 7, 23, 0, 0, 7669, 1442, 1, 0, 0, 0, 7670, 7671, 7, 10, 0, 0, 7671, 7672, 7, 26, 0, 0, 7672, 7673, 7, 14, 0, 0, 7673, 7674, 7, 10, 0, 0, 7674, 7675, 7, 24, 0, 0, 7675, 7676, 7, 16, 0, 0, 7676, 7677, 7, 17, 0, 0, 7677, 7678, 7, 19, 0, 0, 7678, 7679, 7, 7, 0, 0, 7679, 1444, 1, 0, 0, 0, 7680, 7681, 7, 5, 0, 0, 7681, 7682, 7, 9, 0, 0, 7682, 7683, 7, 9, 0, 0, 7683, 7684, 7, 10, 0, 0, 7684, 7685, 7, 13, 0, 0, 7685, 7686, 7, 16, 0, 0, 7686, 1446, 1, 0, 0, 0, 7687, 7688, 7, 6, 0, 0, 7688, 7689, 7, 19, 0, 0, 7689, 7690, 7, 19, 0, 0, 7690, 7691, 7, 24, 0, 0, 7691, 1448, 1, 0, 0, 0, 7692, 7693, 7, 19, 0, 0, 7693, 7694, 7, 24, 0, 0, 7694, 7695, 7, 10, 0, 0, 7695, 7696, 7, 7, 0, 0, 7696, 1450, 1, 0, 0, 0, 7697, 7698, 7, 5, 0, 0, 7698, 7699, 7, 18, 0, 0, 7699, 7700, 7, 9, 0, 0, 7700, 1452, 1, 0, 0, 0, 7701, 7702, 7, 14, 0, 0, 7702, 7703, 7, 18, 0, 0, 7703, 7704, 7, 13, 0, 0, 7704, 7705, 7, 16, 0, 0, 7705, 1454, 1, 0, 0, 0, 7706, 7707, 7, 14, 0, 0, 7707, 7708, 7, 10, 0, 0, 7708, 7709, 7, 17, 0, 0, 7709, 7710, 7, 6, 0, 0, 7710, 1456, 1, 0, 0, 0, 7711, 7712, 7, 14, 0, 0, 7712, 7713, 7, 10, 0, 0, 7713, 7714, 7, 17, 0, 0, 7714, 7715, 7, 6, 0, 0, 7715, 7716, 7, 17, 0, 0, 7716, 7717, 7, 7, 0, 0, 7717, 7718, 7, 23, 0, 0, 7718, 1458, 1, 0, 0, 0, 7719, 7720, 7, 12, 0, 0, 7720, 7721, 7, 10, 0, 0, 7721, 7722, 7, 23, 0, 0, 7722, 7723, 7, 13, 0, 0, 7723, 7724, 7, 10, 0, 0, 7724, 7725, 7, 10, 0, 0, 7725, 7726, 7, 9, 0, 0, 7726, 1460, 1, 0, 0, 0, 7727, 7728, 7, 12, 0, 0, 7728, 7729, 7, 17, 0, 0, 7729, 7730, 7, 27, 0, 0, 7730, 1462, 1, 0, 0, 0, 7731, 7732, 7, 10, 0, 0, 7732, 7733, 7, 26, 0, 0, 7733, 7734, 7, 24, 0, 0, 7734, 1464, 1, 0, 0, 0, 7735, 7736, 7, 25, 0, 0, 7736, 7737, 7, 5, 0, 0, 7737, 7738, 7, 14, 0, 0, 7738, 7739, 7, 16, 0, 0, 7739, 7740, 7, 19, 0, 0, 7740, 7741, 7, 13, 0, 0, 7741, 7742, 7, 17, 0, 0, 7742, 7743, 7, 5, 0, 0, 7743, 7744, 7, 6, 0, 0, 7744, 1466, 1, 0, 0, 0, 7745, 7746, 7, 25, 0, 0, 7746, 7747, 7, 6, 0, 0, 7747, 7748, 7, 19, 0, 0, 7748, 7749, 7, 19, 0, 0, 7749, 7750, 7, 13, 0, 0, 7750, 1468, 1, 0, 0, 0, 7751, 7752, 7, 23, 0, 0, 7752, 7753, 7, 14, 0, 0, 7753, 7754, 7, 12, 0, 0, 7754, 1470, 1, 0, 0, 0, 7755, 7756, 7, 6, 0, 0, 7756, 7757, 7, 14, 0, 0, 7757, 7758, 7, 15, 0, 0, 7758, 1472, 1, 0, 0, 0, 7759, 7760, 7, 6, 0, 0, 7760, 7761, 7, 7, 0, 0, 7761, 1474, 1, 0, 0, 0, 7762, 7763, 7, 6, 0, 0, 7763, 7764, 7, 19, 0, 0, 7764, 7765, 7, 23, 0, 0, 7765, 7766, 5, 49, 0, 0, 7766, 7767, 5, 48, 0, 0, 7767, 1476, 1, 0, 0, 0, 7768, 7769, 7, 15, 0, 0, 7769, 7770, 7, 17, 0, 0, 7770, 7771, 7, 7, 0, 0, 7771, 7772, 5, 95, 0, 0, 7772, 7773, 7, 9, 0, 0, 7773, 7774, 7, 14, 0, 0, 7774, 7775, 7, 5, 0, 0, 7775, 7776, 7, 6, 0, 0, 7776, 7777, 7, 10, 0, 0, 7777, 1478, 1, 0, 0, 0, 7778, 7779, 7, 15, 0, 0, 7779, 7780, 7, 19, 0, 0, 7780, 7781, 7, 12, 0, 0, 7781, 1480, 1, 0, 0, 0, 7782, 7783, 7, 24, 0, 0, 7783, 7784, 7, 17, 0, 0, 7784, 1482, 1, 0, 0, 0, 7785, 7786, 7, 24, 0, 0, 7786, 7787, 7, 19, 0, 0, 7787, 7788, 7, 29, 0, 0, 7788, 7789, 7, 10, 0, 0, 7789, 7790, 7, 13, 0, 0, 7790, 1484, 1, 0, 0, 0, 7791, 7792, 7, 13, 0, 0, 7792, 7793, 7, 5, 0, 0, 7793, 7794, 7, 12, 0, 0, 7794, 7795, 7, 17, 0, 0, 7795, 7796, 7, 5, 0, 0, 7796, 7797, 7, 7, 0, 0, 7797, 7798, 7, 9, 0, 0, 7798, 1486, 1, 0, 0, 0, 7799, 7800, 7, 13, 0, 0, 7800, 7801, 7, 19, 0, 0, 7801, 7802, 7, 22, 0, 0, 7802, 7803, 7, 7, 0, 0, 7803, 7804, 7, 12, 0, 0, 7804, 1488, 1, 0, 0, 0, 7805, 7806, 7, 9, 0, 0, 7806, 7807, 7, 14, 0, 0, 7807, 7808, 7, 5, 0, 0, 7808, 7809, 7, 6, 0, 0, 7809, 7810, 7, 10, 0, 0, 7810, 1490, 1, 0, 0, 0, 7811, 7812, 7, 9, 0, 0, 7812, 7813, 7, 17, 0, 0, 7813, 7814, 7, 23, 0, 0, 7814, 7815, 7, 7, 0, 0, 7815, 1492, 1, 0, 0, 0, 7816, 7817, 7, 9, 0, 0, 7817, 7818, 7, 28, 0, 0, 7818, 7819, 7, 13, 0, 0, 7819, 7820, 7, 16, 0, 0, 7820, 1494, 1, 0, 0, 0, 7821, 7822, 7, 16, 0, 0, 7822, 7823, 7, 13, 0, 0, 7823, 7824, 7, 17, 0, 0, 7824, 7825, 7, 15, 0, 0, 7825, 7826, 5, 95, 0, 0, 7826, 7827, 7, 9, 0, 0, 7827, 7828, 7, 14, 0, 0, 7828, 7829, 7, 5, 0, 0, 7829, 7830, 7, 6, 0, 0, 7830, 7831, 7, 10, 0, 0, 7831, 1496, 1, 0, 0, 0, 7832, 7833, 7, 16, 0, 0, 7833, 7834, 7, 13, 0, 0, 7834, 7835, 7, 22, 0, 0, 7835, 7836, 7, 7, 0, 0, 7836, 7837, 7, 14, 0, 0, 7837, 1498, 1, 0, 0, 0, 7838, 7839, 7, 29, 0, 0, 7839, 7840, 7, 17, 0, 0, 7840, 7841, 7, 12, 0, 0, 7841, 7842, 7, 16, 0, 0, 7842, 7843, 7, 20, 0, 0, 7843, 7844, 5, 95, 0, 0, 7844, 7845, 7, 18, 0, 0, 7845, 7846, 7, 22, 0, 0, 7846, 7847, 7, 14, 0, 0, 7847, 7848, 7, 21, 0, 0, 7848, 7849, 7, 10, 0, 0, 7849, 7850, 7, 16, 0, 0, 7850, 1500, 1, 0, 0, 0, 7851, 7852, 7, 13, 0, 0, 7852, 7853, 7, 5, 0, 0, 7853, 7854, 7, 7, 0, 0, 7854, 7855, 7, 12, 0, 0, 7855, 7856, 7, 19, 0, 0, 7856, 7857, 7, 15, 0, 0, 7857, 1502, 1, 0, 0, 0, 7858, 7859, 7, 9, 0, 0, 7859, 7860, 7, 10, 0, 0, 7860, 7861, 7, 16, 0, 0, 7861, 7862, 7, 9, 0, 0, 7862, 7863, 7, 10, 0, 0, 7863, 7864, 7, 10, 0, 0, 7864, 7865, 7, 12, 0, 0, 7865, 1504, 1, 0, 0, 0, 7866, 7867, 7, 5, 0, 0, 7867, 7868, 7, 14, 0, 0, 7868, 7869, 7, 19, 0, 0, 7869, 7870, 7, 9, 0, 0, 7870, 1506, 1, 0, 0, 0, 7871, 7872, 7, 5, 0, 0, 7872, 7873, 7, 14, 0, 0, 7873, 7874, 7, 19, 0, 0, 7874, 7875, 7, 9, 0, 0, 7875, 7876, 7, 12, 0, 0, 7876, 1508, 1, 0, 0, 0, 7877, 7878, 7, 5, 0, 0, 7878, 7879, 7, 9, 0, 0, 7879, 7880, 7, 17, 0, 0, 7880, 7881, 7, 7, 0, 0, 7881, 1510, 1, 0, 0, 0, 7882, 7883, 7, 5, 0, 0, 7883, 7884, 7, 9, 0, 0, 7884, 7885, 7, 17, 0, 0, 7885, 7886, 7, 7, 0, 0, 7886, 7887, 7, 12, 0, 0, 7887, 1512, 1, 0, 0, 0, 7888, 7889, 7, 5, 0, 0, 7889, 7890, 7, 16, 0, 0, 7890, 7891, 7, 5, 0, 0, 7891, 7892, 7, 7, 0, 0, 7892, 1514, 1, 0, 0, 0, 7893, 7894, 7, 5, 0, 0, 7894, 7895, 7, 16, 0, 0, 7895, 7896, 7, 5, 0, 0, 7896, 7897, 7, 7, 0, 0, 7897, 7898, 7, 12, 0, 0, 7898, 1516, 1, 0, 0, 0, 7899, 7900, 7, 5, 0, 0, 7900, 7901, 7, 16, 0, 0, 7901, 7902, 7, 5, 0, 0, 7902, 7903, 7, 7, 0, 0, 7903, 7904, 5, 50, 0, 0, 7904, 1518, 1, 0, 0, 0, 7905, 7906, 7, 5, 0, 0, 7906, 7907, 7, 16, 0, 0, 7907, 7908, 7, 5, 0, 0, 7908, 7909, 7, 7, 0, 0, 7909, 7910, 5, 50, 0, 0, 7910, 7911, 7, 12, 0, 0, 7911, 1520, 1, 0, 0, 0, 7912, 7913, 7, 14, 0, 0, 7913, 7914, 7, 19, 0, 0, 7914, 7915, 7, 9, 0, 0, 7915, 1522, 1, 0, 0, 0, 7916, 7917, 7, 14, 0, 0, 7917, 7918, 7, 19, 0, 0, 7918, 7919, 7, 9, 0, 0, 7919, 7920, 7, 12, 0, 0, 7920, 1524, 1, 0, 0, 0, 7921, 7922, 7, 14, 0, 0, 7922, 7923, 7, 19, 0, 0, 7923, 7924, 7, 16, 0, 0, 7924, 1526, 1, 0, 0, 0, 7925, 7926, 7, 14, 0, 0, 7926, 7927, 7, 19, 0, 0, 7927, 7928, 7, 16, 0, 0, 7928, 7929, 7, 12, 0, 0, 7929, 1528, 1, 0, 0, 0, 7930, 7931, 7, 9, 0, 0, 7931, 7932, 7, 17, 0, 0, 7932, 7933, 7, 7, 0, 0, 7933, 1530, 1, 0, 0, 0, 7934, 7935, 7, 9, 0, 0, 7935, 7936, 7, 17, 0, 0, 7936, 7937, 7, 7, 0, 0, 7937, 7938, 7, 12, 0, 0, 7938, 1532, 1, 0, 0, 0, 7939, 7940, 7, 16, 0, 0, 7940, 7941, 7, 5, 0, 0, 7941, 7942, 7, 7, 0, 0, 7942, 1534, 1, 0, 0, 0, 7943, 7944, 7, 16, 0, 0, 7944, 7945, 7, 5, 0, 0, 7945, 7946, 7, 7, 0, 0, 7946, 7947, 7, 12, 0, 0, 7947, 1536, 1, 0, 0, 0, 7948, 7949, 7, 9, 0, 0, 7949, 7950, 7, 17, 0, 0, 7950, 7951, 7, 7, 0, 0, 7951, 7952, 7, 20, 0, 0, 7952, 1538, 1, 0, 0, 0, 7953, 7954, 7, 14, 0, 0, 7954, 7955, 7, 19, 0, 0, 7955, 7956, 7, 9, 0, 0, 7956, 7957, 7, 20, 0, 0, 7957, 1540, 1, 0, 0, 0, 7958, 7959, 7, 16, 0, 0, 7959, 7960, 7, 5, 0, 0, 7960, 7961, 7, 7, 0, 0, 7961, 7962, 7, 20, 0, 0, 7962, 1542, 1, 0, 0, 0, 7963, 7964, 7, 5, 0, 0, 7964, 7965, 7, 9, 0, 0, 7965, 7966, 7, 17, 0, 0, 7966, 7967, 7, 7, 0, 0, 7967, 7968, 7, 20, 0, 0, 7968, 1544, 1, 0, 0, 0, 7969, 7970, 7, 5, 0, 0, 7970, 7971, 7, 14, 0, 0, 7971, 7972, 7, 19, 0, 0, 7972, 7973, 7, 9, 0, 0, 7973, 7974, 7, 20, 0, 0, 7974, 1546, 1, 0, 0, 0, 7975, 7976, 7, 5, 0, 0, 7976, 7977, 7, 16, 0, 0, 7977, 7978, 7, 5, 0, 0, 7978, 7979, 7, 7, 0, 0, 7979, 7980, 7, 20, 0, 0, 7980, 1548, 1, 0, 0, 0, 7981, 7982, 7, 18, 0, 0, 7982, 7983, 7, 17, 0, 0, 7983, 7984, 7, 16, 0, 0, 7984, 7985, 5, 95, 0, 0, 7985, 7986, 7, 6, 0, 0, 7986, 7987, 7, 10, 0, 0, 7987, 7988, 7, 7, 0, 0, 7988, 7989, 7, 23, 0, 0, 7989, 7990, 7, 16, 0, 0, 7990, 7991, 7, 20, 0, 0, 7991, 1550, 1, 0, 0, 0, 7992, 7993, 7, 14, 0, 0, 7993, 7994, 7, 20, 0, 0, 7994, 7995, 7, 5, 0, 0, 7995, 7996, 7, 13, 0, 0, 7996, 7997, 5, 95, 0, 0, 7997, 7998, 7, 6, 0, 0, 7998, 7999, 7, 10, 0, 0, 7999, 8000, 7, 7, 0, 0, 8000, 8001, 7, 23, 0, 0, 8001, 8002, 7, 16, 0, 0, 8002, 8003, 7, 20, 0, 0, 8003, 1552, 1, 0, 0, 0, 8004, 8005, 7, 14, 0, 0, 8005, 8006, 7, 20, 0, 0, 8006, 8007, 7, 5, 0, 0, 8007, 8008, 7, 13, 0, 0, 8008, 8009, 7, 5, 0, 0, 8009, 8010, 7, 14, 0, 0, 8010, 8011, 7, 16, 0, 0, 8011, 8012, 7, 10, 0, 0, 8012, 8013, 7, 13, 0, 0, 8013, 8014, 5, 95, 0, 0, 8014, 8015, 7, 6, 0, 0, 8015, 8016, 7, 10, 0, 0, 8016, 8017, 7, 7, 0, 0, 8017, 8018, 7, 23, 0, 0, 8018, 8019, 7, 16, 0, 0, 8019, 8020, 7, 20, 0, 0, 8020, 1554, 1, 0, 0, 0, 8021, 8022, 7, 6, 0, 0, 8022, 8023, 7, 19, 0, 0, 8023, 8024, 7, 29, 0, 0, 8024, 8025, 7, 10, 0, 0, 8025, 8026, 7, 13, 0, 0, 8026, 1556, 1, 0, 0, 0, 8027, 8028, 7, 19, 0, 0, 8028, 8029, 7, 14, 0, 0, 8029, 8030, 7, 16, 0, 0, 8030, 8031, 7, 10, 0, 0, 8031, 8032, 7, 16, 0, 0, 8032, 8033, 5, 95, 0, 0, 8033, 8034, 7, 6, 0, 0, 8034, 8035, 7, 10, 0, 0, 8035, 8036, 7, 7, 0, 0, 8036, 8037, 7, 23, 0, 0, 8037, 8038, 7, 16, 0, 0, 8038, 8039, 7, 20, 0, 0, 8039, 1558, 1, 0, 0, 0, 8040, 8041, 7, 22, 0, 0, 8041, 8042, 7, 24, 0, 0, 8042, 8043, 7, 24, 0, 0, 8043, 8044, 7, 10, 0, 0, 8044, 8045, 7, 13, 0, 0, 8045, 1560, 1, 0, 0, 0, 8046, 8047, 7, 5, 0, 0, 8047, 8048, 7, 9, 0, 0, 8048, 8049, 7, 14, 0, 0, 8049, 8050, 7, 17, 0, 0, 8050, 8051, 7, 17, 0, 0, 8051, 1562, 1, 0, 0, 0, 8052, 8053, 7, 18, 0, 0, 8053, 8054, 7, 16, 0, 0, 8054, 8055, 7, 13, 0, 0, 8055, 8056, 7, 17, 0, 0, 8056, 8057, 7, 15, 0, 0, 8057, 1564, 1, 0, 0, 0, 8058, 8059, 7, 14, 0, 0, 8059, 8060, 7, 20, 0, 0, 8060, 8061, 7, 13, 0, 0, 8061, 1566, 1, 0, 0, 0, 8062, 8063, 7, 14, 0, 0, 8063, 8064, 7, 19, 0, 0, 8064, 8065, 7, 7, 0, 0, 8065, 8066, 7, 14, 0, 0, 8066, 8067, 7, 5, 0, 0, 8067, 8068, 7, 16, 0, 0, 8068, 1568, 1, 0, 0, 0, 8069, 8070, 7, 14, 0, 0, 8070, 8071, 7, 19, 0, 0, 8071, 8072, 7, 7, 0, 0, 8072, 8073, 7, 14, 0, 0, 8073, 8074, 7, 5, 0, 0, 8074, 8075, 7, 16, 0, 0, 8075, 8076, 5, 95, 0, 0, 8076, 8077, 7, 29, 0, 0, 8077, 8078, 7, 9, 0, 0, 8078, 1570, 1, 0, 0, 0, 8079, 8080, 7, 25, 0, 0, 8080, 8081, 7, 19, 0, 0, 8081, 8082, 7, 13, 0, 0, 8082, 8083, 7, 15, 0, 0, 8083, 8084, 7, 5, 0, 0, 8084, 8085, 7, 16, 0, 0, 8085, 1572, 1, 0, 0, 0, 8086, 8087, 7, 17, 0, 0, 8087, 8088, 7, 7, 0, 0, 8088, 8089, 7, 17, 0, 0, 8089, 8090, 7, 16, 0, 0, 8090, 8091, 7, 14, 0, 0, 8091, 8092, 7, 5, 0, 0, 8092, 8093, 7, 24, 0, 0, 8093, 1574, 1, 0, 0, 0, 8094, 8095, 7, 6, 0, 0, 8095, 8096, 7, 10, 0, 0, 8096, 8097, 7, 7, 0, 0, 8097, 8098, 7, 23, 0, 0, 8098, 8099, 7, 16, 0, 0, 8099, 8100, 7, 20, 0, 0, 8100, 1576, 1, 0, 0, 0, 8101, 8102, 7, 6, 0, 0, 8102, 8103, 7, 24, 0, 0, 8103, 8104, 7, 5, 0, 0, 8104, 8105, 7, 12, 0, 0, 8105, 1578, 1, 0, 0, 0, 8106, 8107, 7, 6, 0, 0, 8107, 8108, 7, 16, 0, 0, 8108, 8109, 7, 13, 0, 0, 8109, 8110, 7, 17, 0, 0, 8110, 8111, 7, 15, 0, 0, 8111, 1580, 1, 0, 0, 0, 8112, 8113, 7, 15, 0, 0, 8113, 8114, 7, 12, 0, 0, 8114, 8115, 5, 53, 0, 0, 8115, 1582, 1, 0, 0, 0, 8116, 8117, 7, 24, 0, 0, 8117, 8118, 7, 5, 0, 0, 8118, 8119, 7, 13, 0, 0, 8119, 8120, 7, 9, 0, 0, 8120, 8121, 7, 10, 0, 0, 8121, 8122, 5, 95, 0, 0, 8122, 8123, 7, 17, 0, 0, 8123, 8124, 7, 12, 0, 0, 8124, 8125, 7, 10, 0, 0, 8125, 8126, 7, 7, 0, 0, 8126, 8127, 7, 16, 0, 0, 8127, 1584, 1, 0, 0, 0, 8128, 8129, 7, 24, 0, 0, 8129, 8130, 7, 23, 0, 0, 8130, 8131, 5, 95, 0, 0, 8131, 8132, 7, 14, 0, 0, 8132, 8133, 7, 6, 0, 0, 8133, 8134, 7, 17, 0, 0, 8134, 8135, 7, 10, 0, 0, 8135, 8136, 7, 7, 0, 0, 8136, 8137, 7, 16, 0, 0, 8137, 8138, 5, 95, 0, 0, 8138, 8139, 7, 10, 0, 0, 8139, 8140, 7, 7, 0, 0, 8140, 8141, 7, 14, 0, 0, 8141, 8142, 7, 19, 0, 0, 8142, 8143, 7, 12, 0, 0, 8143, 8144, 7, 17, 0, 0, 8144, 8145, 7, 7, 0, 0, 8145, 8146, 7, 23, 0, 0, 8146, 1586, 1, 0, 0, 0, 8147, 8148, 7, 28, 0, 0, 8148, 8149, 7, 22, 0, 0, 8149, 8150, 7, 19, 0, 0, 8150, 8151, 7, 16, 0, 0, 8151, 8152, 7, 10, 0, 0, 8152, 8153, 5, 95, 0, 0, 8153, 8154, 7, 17, 0, 0, 8154, 8155, 7, 12, 0, 0, 8155, 8156, 7, 10, 0, 0, 8156, 8157, 7, 7, 0, 0, 8157, 8158, 7, 16, 0, 0, 8158, 1588, 1, 0, 0, 0, 8159, 8160, 7, 28, 0, 0, 8160, 8161, 7, 22, 0, 0, 8161, 8162, 7, 19, 0, 0, 8162, 8163, 7, 16, 0, 0, 8163, 8164, 7, 10, 0, 0, 8164, 8165, 5, 95, 0, 0, 8165, 8166, 7, 6, 0, 0, 8166, 8167, 7, 17, 0, 0, 8167, 8168, 7, 16, 0, 0, 8168, 8169, 7, 10, 0, 0, 8169, 8170, 7, 13, 0, 0, 8170, 8171, 7, 5, 0, 0, 8171, 8172, 7, 6, 0, 0, 8172, 1590, 1, 0, 0, 0, 8173, 8174, 7, 28, 0, 0, 8174, 8175, 7, 22, 0, 0, 8175, 8176, 7, 19, 0, 0, 8176, 8177, 7, 16, 0, 0, 8177, 8178, 7, 10, 0, 0, 8178, 8179, 5, 95, 0, 0, 8179, 8180, 7, 7, 0, 0, 8180, 8181, 7, 22, 0, 0, 8181, 8182, 7, 6, 0, 0, 8182, 8183, 7, 6, 0, 0, 8183, 8184, 7, 5, 0, 0, 8184, 8185, 7, 18, 0, 0, 8185, 8186, 7, 6, 0, 0, 8186, 8187, 7, 10, 0, 0, 8187, 1592, 1, 0, 0, 0, 8188, 8189, 7, 13, 0, 0, 8189, 8190, 7, 10, 0, 0, 8190, 8191, 7, 23, 0, 0, 8191, 8192, 7, 10, 0, 0, 8192, 8193, 7, 26, 0, 0, 8193, 8194, 7, 24, 0, 0, 8194, 8195, 5, 95, 0, 0, 8195, 8196, 7, 14, 0, 0, 8196, 8197, 7, 19, 0, 0, 8197, 8198, 7, 22, 0, 0, 8198, 8199, 7, 7, 0, 0, 8199, 8200, 7, 16, 0, 0, 8200, 1594, 1, 0, 0, 0, 8201, 8202, 7, 13, 0, 0, 8202, 8203, 7, 10, 0, 0, 8203, 8204, 7, 23, 0, 0, 8204, 8205, 7, 10, 0, 0, 8205, 8206, 7, 26, 0, 0, 8206, 8207, 7, 24, 0, 0, 8207, 8208, 5, 95, 0, 0, 8208, 8209, 7, 17, 0, 0, 8209, 8210, 7, 7, 0, 0, 8210, 8211, 7, 9, 0, 0, 8211, 8212, 7, 16, 0, 0, 8212, 8213, 7, 13, 0, 0, 8213, 1596, 1, 0, 0, 0, 8214, 8215, 7, 13, 0, 0, 8215, 8216, 7, 10, 0, 0, 8216, 8217, 7, 23, 0, 0, 8217, 8218, 7, 10, 0, 0, 8218, 8219, 7, 26, 0, 0, 8219, 8220, 7, 24, 0, 0, 8220, 8221, 5, 95, 0, 0, 8221, 8222, 7, 6, 0, 0, 8222, 8223, 7, 17, 0, 0, 8223, 8224, 7, 21, 0, 0, 8224, 8225, 7, 10, 0, 0, 8225, 1598, 1, 0, 0, 0, 8226, 8227, 7, 13, 0, 0, 8227, 8228, 7, 10, 0, 0, 8228, 8229, 7, 23, 0, 0, 8229, 8230, 7, 10, 0, 0, 8230, 8231, 7, 26, 0, 0, 8231, 8232, 7, 24, 0, 0, 8232, 8233, 5, 95, 0, 0, 8233, 8234, 7, 15, 0, 0, 8234, 8235, 7, 5, 0, 0, 8235, 8236, 7, 16, 0, 0, 8236, 8237, 7, 14, 0, 0, 8237, 8238, 7, 20, 0, 0, 8238, 1600, 1, 0, 0, 0, 8239, 8240, 7, 13, 0, 0, 8240, 8241, 7, 10, 0, 0, 8241, 8242, 7, 23, 0, 0, 8242, 8243, 7, 10, 0, 0, 8243, 8244, 7, 26, 0, 0, 8244, 8245, 7, 24, 0, 0, 8245, 8246, 5, 95, 0, 0, 8246, 8247, 7, 15, 0, 0, 8247, 8248, 7, 5, 0, 0, 8248, 8249, 7, 16, 0, 0, 8249, 8250, 7, 14, 0, 0, 8250, 8251, 7, 20, 0, 0, 8251, 8252, 7, 10, 0, 0, 8252, 8253, 7, 9, 0, 0, 8253, 1602, 1, 0, 0, 0, 8254, 8255, 7, 13, 0, 0, 8255, 8256, 7, 10, 0, 0, 8256, 8257, 7, 23, 0, 0, 8257, 8258, 7, 10, 0, 0, 8258, 8259, 7, 26, 0, 0, 8259, 8260, 7, 24, 0, 0, 8260, 8261, 5, 95, 0, 0, 8261, 8262, 7, 13, 0, 0, 8262, 8263, 7, 10, 0, 0, 8263, 8264, 7, 24, 0, 0, 8264, 8265, 7, 6, 0, 0, 8265, 8266, 7, 5, 0, 0, 8266, 8267, 7, 14, 0, 0, 8267, 8268, 7, 10, 0, 0, 8268, 1604, 1, 0, 0, 0, 8269, 8270, 7, 13, 0, 0, 8270, 8271, 7, 10, 0, 0, 8271, 8272, 7, 23, 0, 0, 8272, 8273, 7, 10, 0, 0, 8273, 8274, 7, 26, 0, 0, 8274, 8275, 7, 24, 0, 0, 8275, 8276, 5, 95, 0, 0, 8276, 8277, 7, 9, 0, 0, 8277, 8278, 7, 24, 0, 0, 8278, 8279, 7, 6, 0, 0, 8279, 8280, 7, 17, 0, 0, 8280, 8281, 7, 16, 0, 0, 8281, 8282, 5, 95, 0, 0, 8282, 8283, 7, 16, 0, 0, 8283, 8284, 7, 19, 0, 0, 8284, 8285, 5, 95, 0, 0, 8285, 8286, 7, 5, 0, 0, 8286, 8287, 7, 13, 0, 0, 8287, 8288, 7, 13, 0, 0, 8288, 8289, 7, 5, 0, 0, 8289, 8290, 7, 8, 0, 0, 8290, 1606, 1, 0, 0, 0, 8291, 8292, 7, 13, 0, 0, 8292, 8293, 7, 10, 0, 0, 8293, 8294, 7, 23, 0, 0, 8294, 8295, 7, 10, 0, 0, 8295, 8296, 7, 26, 0, 0, 8296, 8297, 7, 24, 0, 0, 8297, 8298, 5, 95, 0, 0, 8298, 8299, 7, 9, 0, 0, 8299, 8300, 7, 24, 0, 0, 8300, 8301, 7, 6, 0, 0, 8301, 8302, 7, 17, 0, 0, 8302, 8303, 7, 16, 0, 0, 8303, 8304, 5, 95, 0, 0, 8304, 8305, 7, 16, 0, 0, 8305, 8306, 7, 19, 0, 0, 8306, 8307, 5, 95, 0, 0, 8307, 8308, 7, 16, 0, 0, 8308, 8309, 7, 5, 0, 0, 8309, 8310, 7, 18, 0, 0, 8310, 8311, 7, 6, 0, 0, 8311, 8312, 7, 10, 0, 0, 8312, 1608, 1, 0, 0, 0, 8313, 8314, 7, 13, 0, 0, 8314, 8315, 7, 10, 0, 0, 8315, 8316, 7, 23, 0, 0, 8316, 8317, 7, 10, 0, 0, 8317, 8318, 7, 26, 0, 0, 8318, 8319, 7, 24, 0, 0, 8319, 8320, 5, 95, 0, 0, 8320, 8321, 7, 9, 0, 0, 8321, 8322, 7, 22, 0, 0, 8322, 8323, 7, 18, 0, 0, 8323, 8324, 7, 9, 0, 0, 8324, 8325, 7, 16, 0, 0, 8325, 8326, 7, 13, 0, 0, 8326, 1610, 1, 0, 0, 0, 8327, 8328, 7, 13, 0, 0, 8328, 8329, 7, 10, 0, 0, 8329, 8330, 7, 24, 0, 0, 8330, 8331, 7, 10, 0, 0, 8331, 8332, 7, 5, 0, 0, 8332, 8333, 7, 16, 0, 0, 8333, 1612, 1, 0, 0, 0, 8334, 8335, 7, 13, 0, 0, 8335, 8336, 7, 24, 0, 0, 8336, 8337, 7, 5, 0, 0, 8337, 8338, 7, 12, 0, 0, 8338, 1614, 1, 0, 0, 0, 8339, 8340, 7, 13, 0, 0, 8340, 8341, 7, 16, 0, 0, 8341, 8342, 7, 13, 0, 0, 8342, 8343, 7, 17, 0, 0, 8343, 8344, 7, 15, 0, 0, 8344, 1616, 1, 0, 0, 0, 8345, 8346, 7, 9, 0, 0, 8346, 8347, 7, 24, 0, 0, 8347, 8348, 7, 6, 0, 0, 8348, 8349, 7, 17, 0, 0, 8349, 8350, 7, 16, 0, 0, 8350, 8351, 5, 95, 0, 0, 8351, 8352, 7, 24, 0, 0, 8352, 8353, 7, 5, 0, 0, 8353, 8354, 7, 13, 0, 0, 8354, 8355, 7, 16, 0, 0, 8355, 1618, 1, 0, 0, 0, 8356, 8357, 7, 9, 0, 0, 8357, 8358, 7, 16, 0, 0, 8358, 8359, 7, 5, 0, 0, 8359, 8360, 7, 13, 0, 0, 8360, 8361, 7, 16, 0, 0, 8361, 8362, 7, 9, 0, 0, 8362, 8363, 5, 95, 0, 0, 8363, 8364, 7, 29, 0, 0, 8364, 8365, 7, 17, 0, 0, 8365, 8366, 7, 16, 0, 0, 8366, 8367, 7, 20, 0, 0, 8367, 1620, 1, 0, 0, 0, 8368, 8369, 7, 9, 0, 0, 8369, 8370, 7, 16, 0, 0, 8370, 8371, 7, 13, 0, 0, 8371, 8372, 7, 17, 0, 0, 8372, 8373, 7, 7, 0, 0, 8373, 8374, 7, 23, 0, 0, 8374, 8375, 5, 95, 0, 0, 8375, 8376, 7, 16, 0, 0, 8376, 8377, 7, 19, 0, 0, 8377, 8378, 5, 95, 0, 0, 8378, 8379, 7, 5, 0, 0, 8379, 8380, 7, 13, 0, 0, 8380, 8381, 7, 13, 0, 0, 8381, 8382, 7, 5, 0, 0, 8382, 8383, 7, 8, 0, 0, 8383, 1622, 1, 0, 0, 0, 8384, 8385, 7, 9, 0, 0, 8385, 8386, 7, 16, 0, 0, 8386, 8387, 7, 13, 0, 0, 8387, 8388, 7, 17, 0, 0, 8388, 8389, 7, 7, 0, 0, 8389, 8390, 7, 23, 0, 0, 8390, 8391, 5, 95, 0, 0, 8391, 8392, 7, 16, 0, 0, 8392, 8393, 7, 19, 0, 0, 8393, 8394, 5, 95, 0, 0, 8394, 8395, 7, 16, 0, 0, 8395, 8396, 7, 5, 0, 0, 8396, 8397, 7, 18, 0, 0, 8397, 8398, 7, 6, 0, 0, 8398, 8399, 7, 10, 0, 0, 8399, 1624, 1, 0, 0, 0, 8400, 8401, 7, 9, 0, 0, 8401, 8402, 7, 16, 0, 0, 8402, 8403, 7, 13, 0, 0, 8403, 8404, 7, 24, 0, 0, 8404, 8405, 7, 19, 0, 0, 8405, 8406, 7, 9, 0, 0, 8406, 1626, 1, 0, 0, 0, 8407, 8408, 7, 9, 0, 0, 8408, 8409, 7, 22, 0, 0, 8409, 8410, 7, 18, 0, 0, 8410, 8411, 7, 9, 0, 0, 8411, 8412, 7, 16, 0, 0, 8412, 8413, 7, 13, 0, 0, 8413, 1628, 1, 0, 0, 0, 8414, 8415, 7, 16, 0, 0, 8415, 8416, 7, 19, 0, 0, 8416, 8417, 5, 95, 0, 0, 8417, 8418, 7, 5, 0, 0, 8418, 8419, 7, 9, 0, 0, 8419, 8420, 7, 14, 0, 0, 8420, 8421, 7, 17, 0, 0, 8421, 8422, 7, 17, 0, 0, 8422, 1630, 1, 0, 0, 0, 8423, 8424, 7, 16, 0, 0, 8424, 8425, 7, 19, 0, 0, 8425, 8426, 5, 95, 0, 0, 8426, 8427, 7, 20, 0, 0, 8427, 8428, 7, 10, 0, 0, 8428, 8429, 7, 26, 0, 0, 8429, 1632, 1, 0, 0, 0, 8430, 8431, 7, 16, 0, 0, 8431, 8432, 7, 13, 0, 0, 8432, 8433, 7, 5, 0, 0, 8433, 8434, 7, 7, 0, 0, 8434, 8435, 7, 9, 0, 0, 8435, 8436, 7, 6, 0, 0, 8436, 8437, 7, 5, 0, 0, 8437, 8438, 7, 16, 0, 0, 8438, 8439, 7, 10, 0, 0, 8439, 1634, 1, 0, 0, 0, 8440, 8441, 7, 22, 0, 0, 8441, 8442, 7, 7, 0, 0, 8442, 8443, 7, 17, 0, 0, 8443, 8444, 7, 9, 0, 0, 8444, 8445, 7, 16, 0, 0, 8445, 8446, 7, 13, 0, 0, 8446, 1636, 1, 0, 0, 0, 8447, 8448, 7, 5, 0, 0, 8448, 8449, 7, 23, 0, 0, 8449, 8450, 7, 10, 0, 0, 8450, 1638, 1, 0, 0, 0, 8451, 8452, 7, 14, 0, 0, 8452, 8453, 7, 6, 0, 0, 8453, 8454, 7, 19, 0, 0, 8454, 8455, 7, 14, 0, 0, 8455, 8456, 7, 21, 0, 0, 8456, 8457, 5, 95, 0, 0, 8457, 8458, 7, 16, 0, 0, 8458, 8459, 7, 17, 0, 0, 8459, 8460, 7, 15, 0, 0, 8460, 8461, 7, 10, 0, 0, 8461, 8462, 7, 9, 0, 0, 8462, 8463, 7, 16, 0, 0, 8463, 8464, 7, 5, 0, 0, 8464, 8465, 7, 15, 0, 0, 8465, 8466, 7, 24, 0, 0, 8466, 1640, 1, 0, 0, 0, 8467, 8468, 7, 12, 0, 0, 8468, 8469, 7, 5, 0, 0, 8469, 8470, 7, 16, 0, 0, 8470, 8471, 7, 10, 0, 0, 8471, 8472, 5, 95, 0, 0, 8472, 8473, 7, 18, 0, 0, 8473, 8474, 7, 17, 0, 0, 8474, 8475, 7, 7, 0, 0, 8475, 1642, 1, 0, 0, 0, 8476, 8477, 7, 12, 0, 0, 8477, 8478, 7, 5, 0, 0, 8478, 8479, 7, 16, 0, 0, 8479, 8480, 7, 10, 0, 0, 8480, 8481, 5, 95, 0, 0, 8481, 8482, 7, 24, 0, 0, 8482, 8483, 7, 5, 0, 0, 8483, 8484, 7, 13, 0, 0, 8484, 8485, 7, 16, 0, 0, 8485, 1644, 1, 0, 0, 0, 8486, 8487, 7, 12, 0, 0, 8487, 8488, 7, 5, 0, 0, 8488, 8489, 7, 16, 0, 0, 8489, 8490, 7, 10, 0, 0, 8490, 8491, 5, 95, 0, 0, 8491, 8492, 7, 16, 0, 0, 8492, 8493, 7, 13, 0, 0, 8493, 8494, 7, 22, 0, 0, 8494, 8495, 7, 7, 0, 0, 8495, 8496, 7, 14, 0, 0, 8496, 1646, 1, 0, 0, 0, 8497, 8498, 7, 17, 0, 0, 8498, 8499, 7, 9, 0, 0, 8499, 8500, 7, 25, 0, 0, 8500, 8501, 7, 17, 0, 0, 8501, 8502, 7, 7, 0, 0, 8502, 8503, 7, 17, 0, 0, 8503, 8504, 7, 16, 0, 0, 8504, 8505, 7, 10, 0, 0, 8505, 1648, 1, 0, 0, 0, 8506, 8507, 7, 30, 0, 0, 8507, 8508, 7, 22, 0, 0, 8508, 8509, 7, 9, 0, 0, 8509, 8510, 7, 16, 0, 0, 8510, 8511, 7, 17, 0, 0, 8511, 8512, 7, 25, 0, 0, 8512, 8513, 7, 8, 0, 0, 8513, 8514, 5, 95, 0, 0, 8514, 8515, 7, 12, 0, 0, 8515, 8516, 7, 5, 0, 0, 8516, 8517, 7, 8, 0, 0, 8517, 8518, 7, 9, 0, 0, 8518, 1650, 1, 0, 0, 0, 8519, 8520, 7, 30, 0, 0, 8520, 8521, 7, 22, 0, 0, 8521, 8522, 7, 9, 0, 0, 8522, 8523, 7, 16, 0, 0, 8523, 8524, 7, 17, 0, 0, 8524, 8525, 7, 25, 0, 0, 8525, 8526, 7, 8, 0, 0, 8526, 8527, 5, 95, 0, 0, 8527, 8528, 7, 20, 0, 0, 8528, 8529, 7, 19, 0, 0, 8529, 8530, 7, 22, 0, 0, 8530, 8531, 7, 13, 0, 0, 8531, 8532, 7, 9, 0, 0, 8532, 1652, 1, 0, 0, 0, 8533, 8534, 7, 30, 0, 0, 8534, 8535, 7, 22, 0, 0, 8535, 8536, 7, 9, 0, 0, 8536, 8537, 7, 16, 0, 0, 8537, 8538, 7, 17, 0, 0, 8538, 8539, 7, 25, 0, 0, 8539, 8540, 7, 8, 0, 0, 8540, 8541, 5, 95, 0, 0, 8541, 8542, 7, 17, 0, 0, 8542, 8543, 7, 7, 0, 0, 8543, 8544, 7, 16, 0, 0, 8544, 8545, 7, 10, 0, 0, 8545, 8546, 7, 13, 0, 0, 8546, 8547, 7, 27, 0, 0, 8547, 8548, 7, 5, 0, 0, 8548, 8549, 7, 6, 0, 0, 8549, 1654, 1, 0, 0, 0, 8550, 8551, 7, 15, 0, 0, 8551, 8552, 7, 5, 0, 0, 8552, 8553, 7, 21, 0, 0, 8553, 8554, 7, 10, 0, 0, 8554, 8555, 5, 95, 0, 0, 8555, 8556, 7, 12, 0, 0, 8556, 8557, 7, 5, 0, 0, 8557, 8558, 7, 16, 0, 0, 8558, 8559, 7, 10, 0, 0, 8559, 1656, 1, 0, 0, 0, 8560, 8561, 7, 15, 0, 0, 8561, 8562, 7, 5, 0, 0, 8562, 8563, 7, 21, 0, 0, 8563, 8564, 7, 10, 0, 0, 8564, 8565, 5, 95, 0, 0, 8565, 8566, 7, 17, 0, 0, 8566, 8567, 7, 7, 0, 0, 8567, 8568, 7, 16, 0, 0, 8568, 8569, 7, 10, 0, 0, 8569, 8570, 7, 13, 0, 0, 8570, 8571, 7, 27, 0, 0, 8571, 8572, 7, 5, 0, 0, 8572, 8573, 7, 6, 0, 0, 8573, 1658, 1, 0, 0, 0, 8574, 8575, 7, 15, 0, 0, 8575, 8576, 7, 5, 0, 0, 8576, 8577, 7, 21, 0, 0, 8577, 8578, 7, 10, 0, 0, 8578, 8579, 5, 95, 0, 0, 8579, 8580, 7, 16, 0, 0, 8580, 8581, 7, 17, 0, 0, 8581, 8582, 7, 15, 0, 0, 8582, 8583, 7, 10, 0, 0, 8583, 1660, 1, 0, 0, 0, 8584, 8585, 7, 15, 0, 0, 8585, 8586, 7, 5, 0, 0, 8586, 8587, 7, 21, 0, 0, 8587, 8588, 7, 10, 0, 0, 8588, 8589, 5, 95, 0, 0, 8589, 8590, 7, 16, 0, 0, 8590, 8591, 7, 17, 0, 0, 8591, 8592, 7, 15, 0, 0, 8592, 8593, 7, 10, 0, 0, 8593, 8594, 7, 9, 0, 0, 8594, 8595, 7, 16, 0, 0, 8595, 8596, 7, 5, 0, 0, 8596, 8597, 7, 15, 0, 0, 8597, 8598, 7, 24, 0, 0, 8598, 1662, 1, 0, 0, 0, 8599, 8600, 7, 15, 0, 0, 8600, 8601, 7, 5, 0, 0, 8601, 8602, 7, 21, 0, 0, 8602, 8603, 7, 10, 0, 0, 8603, 8604, 5, 95, 0, 0, 8604, 8605, 7, 16, 0, 0, 8605, 8606, 7, 17, 0, 0, 8606, 8607, 7, 15, 0, 0, 8607, 8608, 7, 10, 0, 0, 8608, 8609, 7, 9, 0, 0, 8609, 8610, 7, 16, 0, 0, 8610, 8611, 7, 5, 0, 0, 8611, 8612, 7, 15, 0, 0, 8612, 8613, 7, 24, 0, 0, 8613, 8614, 7, 16, 0, 0, 8614, 8615, 7, 11, 0, 0, 8615, 1664, 1, 0, 0, 0, 8616, 8617, 7, 7, 0, 0, 8617, 8618, 7, 19, 0, 0, 8618, 8619, 7, 29, 0, 0, 8619, 1666, 1, 0, 0, 0, 8620, 8621, 7, 9, 0, 0, 8621, 8622, 7, 16, 0, 0, 8622, 8623, 7, 5, 0, 0, 8623, 8624, 7, 16, 0, 0, 8624, 8625, 7, 10, 0, 0, 8625, 8626, 7, 15, 0, 0, 8626, 8627, 7, 10, 0, 0, 8627, 8628, 7, 7, 0, 0, 8628, 8629, 7, 16, 0, 0, 8629, 8630, 5, 95, 0, 0, 8630, 8631, 7, 16, 0, 0, 8631, 8632, 7, 17, 0, 0, 8632, 8633, 7, 15, 0, 0, 8633, 8634, 7, 10, 0, 0, 8634, 8635, 7, 9, 0, 0, 8635, 8636, 7, 16, 0, 0, 8636, 8637, 7, 5, 0, 0, 8637, 8638, 7, 15, 0, 0, 8638, 8639, 7, 24, 0, 0, 8639, 1668, 1, 0, 0, 0, 8640, 8641, 7, 16, 0, 0, 8641, 8642, 7, 17, 0, 0, 8642, 8643, 7, 15, 0, 0, 8643, 8644, 7, 10, 0, 0, 8644, 8645, 7, 19, 0, 0, 8645, 8646, 7, 25, 0, 0, 8646, 8647, 7, 12, 0, 0, 8647, 8648, 7, 5, 0, 0, 8648, 8649, 7, 8, 0, 0, 8649, 1670, 1, 0, 0, 0, 8650, 8651, 7, 16, 0, 0, 8651, 8652, 7, 13, 0, 0, 8652, 8653, 7, 5, 0, 0, 8653, 8654, 7, 7, 0, 0, 8654, 8655, 7, 9, 0, 0, 8655, 8656, 7, 5, 0, 0, 8656, 8657, 7, 14, 0, 0, 8657, 8658, 7, 16, 0, 0, 8658, 8659, 7, 17, 0, 0, 8659, 8660, 7, 19, 0, 0, 8660, 8661, 7, 7, 0, 0, 8661, 8662, 5, 95, 0, 0, 8662, 8663, 7, 16, 0, 0, 8663, 8664, 7, 17, 0, 0, 8664, 8665, 7, 15, 0, 0, 8665, 8666, 7, 10, 0, 0, 8666, 8667, 7, 9, 0, 0, 8667, 8668, 7, 16, 0, 0, 8668, 8669, 7, 5, 0, 0, 8669, 8670, 7, 15, 0, 0, 8670, 8671, 7, 24, 0, 0, 8671, 1672, 1, 0, 0, 0, 8672, 8673, 7, 16, 0, 0, 8673, 8674, 7, 19, 0, 0, 8674, 8675, 5, 95, 0, 0, 8675, 8676, 7, 16, 0, 0, 8676, 8677, 7, 17, 0, 0, 8677, 8678, 7, 15, 0, 0, 8678, 8679, 7, 10, 0, 0, 8679, 8680, 7, 9, 0, 0, 8680, 8681, 7, 16, 0, 0, 8681, 8682, 7, 5, 0, 0, 8682, 8683, 7, 15, 0, 0, 8683, 8684, 7, 24, 0, 0, 8684, 1674, 1, 0, 0, 0, 8685, 8686, 7, 16, 0, 0, 8686, 8687, 7, 19, 0, 0, 8687, 8688, 5, 95, 0, 0, 8688, 8689, 7, 14, 0, 0, 8689, 8690, 7, 20, 0, 0, 8690, 8691, 7, 5, 0, 0, 8691, 8692, 7, 13, 0, 0, 8692, 1676, 1, 0, 0, 0, 8693, 8694, 7, 16, 0, 0, 8694, 8695, 7, 19, 0, 0, 8695, 8696, 5, 95, 0, 0, 8696, 8697, 7, 12, 0, 0, 8697, 8698, 7, 5, 0, 0, 8698, 8699, 7, 16, 0, 0, 8699, 8700, 7, 10, 0, 0, 8700, 1678, 1, 0, 0, 0, 8701, 8702, 7, 16, 0, 0, 8702, 8703, 7, 19, 0, 0, 8703, 8704, 5, 95, 0, 0, 8704, 8705, 7, 7, 0, 0, 8705, 8706, 7, 22, 0, 0, 8706, 8707, 7, 15, 0, 0, 8707, 8708, 7, 18, 0, 0, 8708, 8709, 7, 10, 0, 0, 8709, 8710, 7, 13, 0, 0, 8710, 1680, 1, 0, 0, 0, 8711, 8712, 7, 10, 0, 0, 8712, 8713, 7, 7, 0, 0, 8713, 8714, 7, 14, 0, 0, 8714, 8715, 7, 19, 0, 0, 8715, 8716, 7, 12, 0, 0, 8716, 8717, 7, 10, 0, 0, 8717, 1682, 1, 0, 0, 0, 8718, 8719, 7, 12, 0, 0, 8719, 8720, 7, 17, 0, 0, 8720, 8721, 7, 9, 0, 0, 8721, 8722, 7, 16, 0, 0, 8722, 8723, 7, 21, 0, 0, 8723, 8724, 7, 10, 0, 0, 8724, 8725, 7, 8, 0, 0, 8725, 1684, 1, 0, 0, 0, 8726, 8727, 7, 9, 0, 0, 8727, 8728, 7, 19, 0, 0, 8728, 8729, 7, 13, 0, 0, 8729, 8730, 7, 16, 0, 0, 8730, 8731, 7, 21, 0, 0, 8731, 8732, 7, 10, 0, 0, 8732, 8733, 7, 8, 0, 0, 8733, 1686, 1, 0, 0, 0, 8734, 8735, 7, 12, 0, 0, 8735, 8736, 7, 17, 0, 0, 8736, 8737, 7, 9, 0, 0, 8737, 8738, 7, 16, 0, 0, 8738, 8739, 7, 9, 0, 0, 8739, 8740, 7, 16, 0, 0, 8740, 8741, 7, 8, 0, 0, 8741, 8742, 7, 6, 0, 0, 8742, 8743, 7, 10, 0, 0, 8743, 1688, 1, 0, 0, 0, 8744, 8745, 7, 18, 0, 0, 8745, 8746, 7, 5, 0, 0, 8746, 8747, 7, 14, 0, 0, 8747, 8748, 7, 21, 0, 0, 8748, 8749, 7, 22, 0, 0, 8749, 8750, 7, 24, 0, 0, 8750, 1690, 1, 0, 0, 0, 8751, 8752, 7, 14, 0, 0, 8752, 8753, 7, 19, 0, 0, 8753, 8754, 7, 15, 0, 0, 8754, 8755, 7, 24, 0, 0, 8755, 8756, 7, 19, 0, 0, 8756, 8757, 7, 22, 0, 0, 8757, 8758, 7, 7, 0, 0, 8758, 8759, 7, 12, 0, 0, 8759, 1692, 1, 0, 0, 0, 8760, 8761, 7, 17, 0, 0, 8761, 8762, 7, 7, 0, 0, 8762, 8763, 7, 16, 0, 0, 8763, 8764, 7, 10, 0, 0, 8764, 8765, 7, 13, 0, 0, 8765, 8766, 7, 6, 0, 0, 8766, 8767, 7, 10, 0, 0, 8767, 8768, 7, 5, 0, 0, 8768, 8769, 7, 27, 0, 0, 8769, 8770, 7, 10, 0, 0, 8770, 8771, 7, 12, 0, 0, 8771, 1694, 1, 0, 0, 0, 8772, 8773, 7, 10, 0, 0, 8773, 8774, 7, 27, 0, 0, 8774, 8775, 7, 10, 0, 0, 8775, 8776, 7, 7, 0, 0, 8776, 1696, 1, 0, 0, 0, 8777, 8778, 7, 14, 0, 0, 8778, 8779, 7, 5, 0, 0, 8779, 8780, 7, 9, 0, 0, 8780, 8781, 7, 10, 0, 0, 8781, 8782, 5, 95, 0, 0, 8782, 8783, 7, 9, 0, 0, 8783, 8784, 7, 10, 0, 0, 8784, 8785, 7, 7, 0, 0, 8785, 8786, 7, 9, 0, 0, 8786, 8787, 7, 17, 0, 0, 8787, 8788, 7, 16, 0, 0, 8788, 8789, 7, 17, 0, 0, 8789, 8790, 7, 27, 0, 0, 8790, 8791, 7, 10, 0, 0, 8791, 1698, 1, 0, 0, 0, 8792, 8793, 7, 28, 0, 0, 8793, 8794, 7, 22, 0, 0, 8794, 8795, 7, 19, 0, 0, 8795, 8796, 7, 16, 0, 0, 8796, 8797, 7, 5, 0, 0, 8797, 1700, 1, 0, 0, 0, 8798, 8799, 7, 16, 0, 0, 8799, 8800, 7, 18, 0, 0, 8800, 1702, 1, 0, 0, 0, 8801, 8802, 7, 18, 0, 0, 8802, 8803, 7, 19, 0, 0, 8803, 8804, 7, 19, 0, 0, 8804, 8805, 7, 9, 0, 0, 8805, 8806, 7, 16, 0, 0, 8806, 1704, 1, 0, 0, 0, 8807, 8808, 7, 13, 0, 0, 8808, 8809, 7, 10, 0, 0, 8809, 8810, 7, 14, 0, 0, 8810, 8811, 7, 6, 0, 0, 8811, 8812, 7, 22, 0, 0, 8812, 8813, 7, 9, 0, 0, 8813, 8814, 7, 16, 0, 0, 8814, 8815, 7, 10, 0, 0, 8815, 8816, 7, 13, 0, 0, 8816, 1706, 1, 0, 0, 0, 8817, 8818, 7, 9, 0, 0, 8818, 8819, 7, 19, 0, 0, 8819, 8820, 7, 13, 0, 0, 8820, 8821, 7, 16, 0, 0, 8821, 1708, 1, 0, 0, 0, 8822, 8823, 7, 24, 0, 0, 8823, 8824, 7, 10, 0, 0, 8824, 8825, 7, 13, 0, 0, 8825, 8826, 7, 14, 0, 0, 8826, 8827, 7, 10, 0, 0, 8827, 8828, 7, 7, 0, 0, 8828, 8829, 7, 16, 0, 0, 8829, 1710, 1, 0, 0, 0, 8830, 8831, 7, 14, 0, 0, 8831, 8832, 7, 5, 0, 0, 8832, 8833, 7, 9, 0, 0, 8833, 8834, 7, 10, 0, 0, 8834, 8835, 5, 95, 0, 0, 8835, 8836, 7, 17, 0, 0, 8836, 8837, 7, 7, 0, 0, 8837, 8838, 7, 9, 0, 0, 8838, 8839, 7, 10, 0, 0, 8839, 8840, 7, 7, 0, 0, 8840, 8841, 7, 9, 0, 0, 8841, 8842, 7, 17, 0, 0, 8842, 8843, 7, 16, 0, 0, 8843, 8844, 7, 17, 0, 0, 8844, 8845, 7, 27, 0, 0, 8845, 8846, 7, 10, 0, 0, 8846, 1712, 1, 0, 0, 0, 8847, 8851, 3, 1719, 857, 0, 8848, 8850, 3, 1721, 858, 0, 8849, 8848, 1, 0, 0, 0, 8850, 8853, 1, 0, 0, 0, 8851, 8849, 1, 0, 0, 0, 8851, 8852, 1, 0, 0, 0, 8852, 1714, 1, 0, 0, 0, 8853, 8851, 1, 0, 0, 0, 8854, 8855, 5, 35, 0, 0, 8855, 8856, 3, 1713, 854, 0, 8856, 1716, 1, 0, 0, 0, 8857, 8858, 3, 1713, 854, 0, 8858, 8859, 5, 58, 0, 0, 8859, 8860, 3, 1713, 854, 0, 8860, 1718, 1, 0, 0, 0, 8861, 8868, 7, 31, 0, 0, 8862, 8863, 7, 32, 0, 0, 8863, 8868, 4, 857, 6, 0, 8864, 8865, 7, 33, 0, 0, 8865, 8866, 7, 34, 0, 0, 8866, 8868, 4, 857, 7, 0, 8867, 8861, 1, 0, 0, 0, 8867, 8862, 1, 0, 0, 0, 8867, 8864, 1, 0, 0, 0, 8868, 1720, 1, 0, 0, 0, 8869, 8872, 3, 1723, 859, 0, 8870, 8872, 5, 36, 0, 0, 8871, 8869, 1, 0, 0, 0, 8871, 8870, 1, 0, 0, 0, 8872, 1722, 1, 0, 0, 0, 8873, 8876, 3, 1719, 857, 0, 8874, 8876, 7, 0, 0, 0, 8875, 8873, 1, 0, 0, 0, 8875, 8874, 1, 0, 0, 0, 8876, 1724, 1, 0, 0, 0, 8877, 8878, 3, 1727, 861, 0, 8878, 8879, 5, 34, 0, 0, 8879, 1726, 1, 0, 0, 0, 8880, 8886, 5, 34, 0, 0, 8881, 8882, 5, 34, 0, 0, 8882, 8885, 5, 34, 0, 0, 8883, 8885, 8, 35, 0, 0, 8884, 8881, 1, 0, 0, 0, 8884, 8883, 1, 0, 0, 0, 8885, 8888, 1, 0, 0, 0, 8886, 8884, 1, 0, 0, 0, 8886, 8887, 1, 0, 0, 0, 8887, 1728, 1, 0, 0, 0, 8888, 8886, 1, 0, 0, 0, 8889, 8890, 3, 1731, 863, 0, 8890, 8891, 5, 34, 0, 0, 8891, 1730, 1, 0, 0, 0, 8892, 8898, 5, 34, 0, 0, 8893, 8894, 5, 34, 0, 0, 8894, 8897, 5, 34, 0, 0, 8895, 8897, 8, 36, 0, 0, 8896, 8893, 1, 0, 0, 0, 8896, 8895, 1, 0, 0, 0, 8897, 8900, 1, 0, 0, 0, 8898, 8896, 1, 0, 0, 0, 8898, 8899, 1, 0, 0, 0, 8899, 1732, 1, 0, 0, 0, 8900, 8898, 1, 0, 0, 0, 8901, 8902, 7, 22, 0, 0, 8902, 8903, 5, 38, 0, 0, 8903, 8904, 3, 1725, 860, 0, 8904, 1734, 1, 0, 0, 0, 8905, 8906, 7, 22, 0, 0, 8906, 8907, 5, 38, 0, 0, 8907, 8908, 3, 1727, 861, 0, 8908, 1736, 1, 0, 0, 0, 8909, 8910, 7, 22, 0, 0, 8910, 8911, 5, 38, 0, 0, 8911, 8912, 3, 1729, 862, 0, 8912, 1738, 1, 0, 0, 0, 8913, 8914, 7, 22, 0, 0, 8914, 8915, 5, 38, 0, 0, 8915, 8916, 3, 1731, 863, 0, 8916, 1740, 1, 0, 0, 0, 8917, 8918, 3, 1743, 869, 0, 8918, 8919, 5, 39, 0, 0, 8919, 1742, 1, 0, 0, 0, 8920, 8926, 5, 39, 0, 0, 8921, 8922, 5, 39, 0, 0, 8922, 8925, 5, 39, 0, 0, 8923, 8925, 8, 37, 0, 0, 8924, 8921, 1, 0, 0, 0, 8924, 8923, 1, 0, 0, 0, 8925, 8928, 1, 0, 0, 0, 8926, 8924, 1, 0, 0, 0, 8926, 8927, 1, 0, 0, 0, 8927, 1744, 1, 0, 0, 0, 8928, 8926, 1, 0, 0, 0, 8929, 8930, 7, 10, 0, 0, 8930, 8931, 5, 39, 0, 0, 8931, 8932, 1, 0, 0, 0, 8932, 8933, 6, 870, 2, 0, 8933, 8934, 6, 870, 3, 0, 8934, 1746, 1, 0, 0, 0, 8935, 8936, 3, 1749, 872, 0, 8936, 8937, 5, 39, 0, 0, 8937, 1748, 1, 0, 0, 0, 8938, 8939, 7, 22, 0, 0, 8939, 8940, 5, 38, 0, 0, 8940, 8941, 3, 1743, 869, 0, 8941, 1750, 1, 0, 0, 0, 8942, 8944, 5, 36, 0, 0, 8943, 8945, 3, 1753, 874, 0, 8944, 8943, 1, 0, 0, 0, 8944, 8945, 1, 0, 0, 0, 8945, 8946, 1, 0, 0, 0, 8946, 8947, 5, 36, 0, 0, 8947, 8948, 6, 873, 4, 0, 8948, 8949, 1, 0, 0, 0, 8949, 8950, 6, 873, 5, 0, 8950, 1752, 1, 0, 0, 0, 8951, 8955, 3, 1719, 857, 0, 8952, 8954, 3, 1723, 859, 0, 8953, 8952, 1, 0, 0, 0, 8954, 8957, 1, 0, 0, 0, 8955, 8953, 1, 0, 0, 0, 8955, 8956, 1, 0, 0, 0, 8956, 1754, 1, 0, 0, 0, 8957, 8955, 1, 0, 0, 0, 8958, 8959, 3, 1757, 876, 0, 8959, 8960, 5, 39, 0, 0, 8960, 1756, 1, 0, 0, 0, 8961, 8962, 7, 18, 0, 0, 8962, 8966, 5, 39, 0, 0, 8963, 8965, 7, 38, 0, 0, 8964, 8963, 1, 0, 0, 0, 8965, 8968, 1, 0, 0, 0, 8966, 8964, 1, 0, 0, 0, 8966, 8967, 1, 0, 0, 0, 8967, 1758, 1, 0, 0, 0, 8968, 8966, 1, 0, 0, 0, 8969, 8970, 3, 1761, 878, 0, 8970, 8971, 5, 39, 0, 0, 8971, 1760, 1, 0, 0, 0, 8972, 8973, 7, 18, 0, 0, 8973, 8974, 3, 1743, 869, 0, 8974, 1762, 1, 0, 0, 0, 8975, 8976, 3, 1765, 880, 0, 8976, 8977, 5, 39, 0, 0, 8977, 1764, 1, 0, 0, 0, 8978, 8979, 7, 26, 0, 0, 8979, 8983, 5, 39, 0, 0, 8980, 8982, 7, 39, 0, 0, 8981, 8980, 1, 0, 0, 0, 8982, 8985, 1, 0, 0, 0, 8983, 8981, 1, 0, 0, 0, 8983, 8984, 1, 0, 0, 0, 8984, 1766, 1, 0, 0, 0, 8985, 8983, 1, 0, 0, 0, 8986, 8987, 3, 1769, 882, 0, 8987, 8988, 5, 39, 0, 0, 8988, 1768, 1, 0, 0, 0, 8989, 8990, 7, 26, 0, 0, 8990, 8991, 3, 1743, 869, 0, 8991, 1770, 1, 0, 0, 0, 8992, 8993, 3, 1777, 886, 0, 8993, 1772, 1, 0, 0, 0, 8994, 8995, 3, 1777, 886, 0, 8995, 8996, 5, 46, 0, 0, 8996, 8997, 5, 46, 0, 0, 8997, 8998, 1, 0, 0, 0, 8998, 8999, 6, 884, 6, 0, 8999, 1774, 1, 0, 0, 0, 9000, 9001, 3, 1777, 886, 0, 9001, 9003, 5, 46, 0, 0, 9002, 9004, 3, 1777, 886, 0, 9003, 9002, 1, 0, 0, 0, 9003, 9004, 1, 0, 0, 0, 9004, 9010, 1, 0, 0, 0, 9005, 9007, 7, 10, 0, 0, 9006, 9008, 7, 1, 0, 0, 9007, 9006, 1, 0, 0, 0, 9007, 9008, 1, 0, 0, 0, 9008, 9009, 1, 0, 0, 0, 9009, 9011, 3, 1777, 886, 0, 9010, 9005, 1, 0, 0, 0, 9010, 9011, 1, 0, 0, 0, 9011, 9029, 1, 0, 0, 0, 9012, 9013, 5, 46, 0, 0, 9013, 9019, 3, 1777, 886, 0, 9014, 9016, 7, 10, 0, 0, 9015, 9017, 7, 1, 0, 0, 9016, 9015, 1, 0, 0, 0, 9016, 9017, 1, 0, 0, 0, 9017, 9018, 1, 0, 0, 0, 9018, 9020, 3, 1777, 886, 0, 9019, 9014, 1, 0, 0, 0, 9019, 9020, 1, 0, 0, 0, 9020, 9029, 1, 0, 0, 0, 9021, 9022, 3, 1777, 886, 0, 9022, 9024, 7, 10, 0, 0, 9023, 9025, 7, 1, 0, 0, 9024, 9023, 1, 0, 0, 0, 9024, 9025, 1, 0, 0, 0, 9025, 9026, 1, 0, 0, 0, 9026, 9027, 3, 1777, 886, 0, 9027, 9029, 1, 0, 0, 0, 9028, 9000, 1, 0, 0, 0, 9028, 9012, 1, 0, 0, 0, 9028, 9021, 1, 0, 0, 0, 9029, 1776, 1, 0, 0, 0, 9030, 9032, 7, 0, 0, 0, 9031, 9030, 1, 0, 0, 0, 9032, 9033, 1, 0, 0, 0, 9033, 9031, 1, 0, 0, 0, 9033, 9034, 1, 0, 0, 0, 9034, 1778, 1, 0, 0, 0, 9035, 9036, 5, 58, 0, 0, 9036, 9040, 7, 40, 0, 0, 9037, 9039, 7, 41, 0, 0, 9038, 9037, 1, 0, 0, 0, 9039, 9042, 1, 0, 0, 0, 9040, 9038, 1, 0, 0, 0, 9040, 9041, 1, 0, 0, 0, 9041, 1780, 1, 0, 0, 0, 9042, 9040, 1, 0, 0, 0, 9043, 9044, 5, 58, 0, 0, 9044, 9045, 5, 34, 0, 0, 9045, 9053, 1, 0, 0, 0, 9046, 9047, 5, 92, 0, 0, 9047, 9052, 9, 0, 0, 0, 9048, 9049, 5, 34, 0, 0, 9049, 9052, 5, 34, 0, 0, 9050, 9052, 8, 42, 0, 0, 9051, 9046, 1, 0, 0, 0, 9051, 9048, 1, 0, 0, 0, 9051, 9050, 1, 0, 0, 0, 9052, 9055, 1, 0, 0, 0, 9053, 9051, 1, 0, 0, 0, 9053, 9054, 1, 0, 0, 0, 9054, 9056, 1, 0, 0, 0, 9055, 9053, 1, 0, 0, 0, 9056, 9057, 5, 34, 0, 0, 9057, 1782, 1, 0, 0, 0, 9058, 9059, 7, 43, 0, 0, 9059, 9060, 1, 0, 0, 0, 9060, 9061, 6, 889, 7, 0, 9061, 1784, 1, 0, 0, 0, 9062, 9064, 5, 13, 0, 0, 9063, 9065, 5, 10, 0, 0, 9064, 9063, 1, 0, 0, 0, 9064, 9065, 1, 0, 0, 0, 9065, 9068, 1, 0, 0, 0, 9066, 9068, 5, 10, 0, 0, 9067, 9062, 1, 0, 0, 0, 9067, 9066, 1, 0, 0, 0, 9068, 9069, 1, 0, 0, 0, 9069, 9070, 6, 890, 7, 0, 9070, 1786, 1, 0, 0, 0, 9071, 9072, 5, 45, 0, 0, 9072, 9073, 5, 45, 0, 0, 9073, 9077, 1, 0, 0, 0, 9074, 9076, 8, 44, 0, 0, 9075, 9074, 1, 0, 0, 0, 9076, 9079, 1, 0, 0, 0, 9077, 9075, 1, 0, 0, 0, 9077, 9078, 1, 0, 0, 0, 9078, 9080, 1, 0, 0, 0, 9079, 9077, 1, 0, 0, 0, 9080, 9081, 6, 891, 7, 0, 9081, 1788, 1, 0, 0, 0, 9082, 9083, 5, 47, 0, 0, 9083, 9084, 5, 42, 0, 0, 9084, 9107, 1, 0, 0, 0, 9085, 9087, 5, 47, 0, 0, 9086, 9085, 1, 0, 0, 0, 9087, 9090, 1, 0, 0, 0, 9088, 9086, 1, 0, 0, 0, 9088, 9089, 1, 0, 0, 0, 9089, 9091, 1, 0, 0, 0, 9090, 9088, 1, 0, 0, 0, 9091, 9106, 3, 1789, 892, 0, 9092, 9106, 8, 45, 0, 0, 9093, 9095, 5, 47, 0, 0, 9094, 9093, 1, 0, 0, 0, 9095, 9096, 1, 0, 0, 0, 9096, 9094, 1, 0, 0, 0, 9096, 9097, 1, 0, 0, 0, 9097, 9098, 1, 0, 0, 0, 9098, 9106, 8, 45, 0, 0, 9099, 9101, 5, 42, 0, 0, 9100, 9099, 1, 0, 0, 0, 9101, 9102, 1, 0, 0, 0, 9102, 9100, 1, 0, 0, 0, 9102, 9103, 1, 0, 0, 0, 9103, 9104, 1, 0, 0, 0, 9104, 9106, 8, 45, 0, 0, 9105, 9088, 1, 0, 0, 0, 9105, 9092, 1, 0, 0, 0, 9105, 9094, 1, 0, 0, 0, 9105, 9100, 1, 0, 0, 0, 9106, 9109, 1, 0, 0, 0, 9107, 9105, 1, 0, 0, 0, 9107, 9108, 1, 0, 0, 0, 9108, 9113, 1, 0, 0, 0, 9109, 9107, 1, 0, 0, 0, 9110, 9112, 5, 42, 0, 0, 9111, 9110, 1, 0, 0, 0, 9112, 9115, 1, 0, 0, 0, 9113, 9111, 1, 0, 0, 0, 9113, 9114, 1, 0, 0, 0, 9114, 9116, 1, 0, 0, 0, 9115, 9113, 1, 0, 0, 0, 9116, 9117, 5, 42, 0, 0, 9117, 9118, 5, 47, 0, 0, 9118, 9119, 1, 0, 0, 0, 9119, 9120, 6, 892, 7, 0, 9120, 1790, 1, 0, 0, 0, 9121, 9122, 5, 47, 0, 0, 9122, 9123, 5, 42, 0, 0, 9123, 9148, 1, 0, 0, 0, 9124, 9126, 5, 47, 0, 0, 9125, 9124, 1, 0, 0, 0, 9126, 9129, 1, 0, 0, 0, 9127, 9125, 1, 0, 0, 0, 9127, 9128, 1, 0, 0, 0, 9128, 9130, 1, 0, 0, 0, 9129, 9127, 1, 0, 0, 0, 9130, 9147, 3, 1789, 892, 0, 9131, 9147, 8, 45, 0, 0, 9132, 9134, 5, 47, 0, 0, 9133, 9132, 1, 0, 0, 0, 9134, 9135, 1, 0, 0, 0, 9135, 9133, 1, 0, 0, 0, 9135, 9136, 1, 0, 0, 0, 9136, 9137, 1, 0, 0, 0, 9137, 9145, 8, 45, 0, 0, 9138, 9140, 5, 42, 0, 0, 9139, 9138, 1, 0, 0, 0, 9140, 9141, 1, 0, 0, 0, 9141, 9139, 1, 0, 0, 0, 9141, 9142, 1, 0, 0, 0, 9142, 9143, 1, 0, 0, 0, 9143, 9145, 8, 45, 0, 0, 9144, 9133, 1, 0, 0, 0, 9144, 9139, 1, 0, 0, 0, 9145, 9147, 1, 0, 0, 0, 9146, 9127, 1, 0, 0, 0, 9146, 9131, 1, 0, 0, 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, 9168, 1, 0, 0, 0, 9150, 9148, 1, 0, 0, 0, 9151, 9153, 5, 47, 0, 0, 9152, 9151, 1, 0, 0, 0, 9153, 9154, 1, 0, 0, 0, 9154, 9152, 1, 0, 0, 0, 9154, 9155, 1, 0, 0, 0, 9155, 9169, 1, 0, 0, 0, 9156, 9158, 5, 42, 0, 0, 9157, 9156, 1, 0, 0, 0, 9158, 9159, 1, 0, 0, 0, 9159, 9157, 1, 0, 0, 0, 9159, 9160, 1, 0, 0, 0, 9160, 9169, 1, 0, 0, 0, 9161, 9163, 5, 47, 0, 0, 9162, 9161, 1, 0, 0, 0, 9163, 9166, 1, 0, 0, 0, 9164, 9162, 1, 0, 0, 0, 9164, 9165, 1, 0, 0, 0, 9165, 9167, 1, 0, 0, 0, 9166, 9164, 1, 0, 0, 0, 9167, 9169, 3, 1791, 893, 0, 9168, 9152, 1, 0, 0, 0, 9168, 9157, 1, 0, 0, 0, 9168, 9164, 1, 0, 0, 0, 9168, 9169, 1, 0, 0, 0, 9169, 9170, 1, 0, 0, 0, 9170, 9171, 6, 893, 8, 0, 9171, 1792, 1, 0, 0, 0, 9172, 9184, 5, 92, 0, 0, 9173, 9183, 8, 46, 0, 0, 9174, 9178, 5, 34, 0, 0, 9175, 9177, 8, 47, 0, 0, 9176, 9175, 1, 0, 0, 0, 9177, 9180, 1, 0, 0, 0, 9178, 9176, 1, 0, 0, 0, 9178, 9179, 1, 0, 0, 0, 9179, 9181, 1, 0, 0, 0, 9180, 9178, 1, 0, 0, 0, 9181, 9183, 5, 34, 0, 0, 9182, 9173, 1, 0, 0, 0, 9182, 9174, 1, 0, 0, 0, 9183, 9186, 1, 0, 0, 0, 9184, 9182, 1, 0, 0, 0, 9184, 9185, 1, 0, 0, 0, 9185, 9194, 1, 0, 0, 0, 9186, 9184, 1, 0, 0, 0, 9187, 9191, 5, 34, 0, 0, 9188, 9190, 8, 47, 0, 0, 9189, 9188, 1, 0, 0, 0, 9190, 9193, 1, 0, 0, 0, 9191, 9189, 1, 0, 0, 0, 9191, 9192, 1, 0, 0, 0, 9192, 9195, 1, 0, 0, 0, 9193, 9191, 1, 0, 0, 0, 9194, 9187, 1, 0, 0, 0, 9194, 9195, 1, 0, 0, 0, 9195, 1794, 1, 0, 0, 0, 9196, 9197, 5, 92, 0, 0, 9197, 9198, 5, 92, 0, 0, 9198, 1796, 1, 0, 0, 0, 9199, 9200, 9, 0, 0, 0, 9200, 1798, 1, 0, 0, 0, 9201, 9202, 3, 1803, 899, 0, 9202, 9203, 5, 39, 0, 0, 9203, 9204, 1, 0, 0, 0, 9204, 9205, 6, 897, 9, 0, 9205, 1800, 1, 0, 0, 0, 9206, 9208, 3, 1803, 899, 0, 9207, 9209, 5, 92, 0, 0, 9208, 9207, 1, 0, 0, 0, 9208, 9209, 1, 0, 0, 0, 9209, 9210, 1, 0, 0, 0, 9210, 9211, 5, 0, 0, 1, 9211, 1802, 1, 0, 0, 0, 9212, 9213, 5, 39, 0, 0, 9213, 9236, 5, 39, 0, 0, 9214, 9232, 5, 92, 0, 0, 9215, 9216, 5, 120, 0, 0, 9216, 9233, 7, 39, 0, 0, 9217, 9218, 5, 117, 0, 0, 9218, 9219, 7, 39, 0, 0, 9219, 9220, 7, 39, 0, 0, 9220, 9221, 7, 39, 0, 0, 9221, 9233, 7, 39, 0, 0, 9222, 9223, 5, 85, 0, 0, 9223, 9224, 7, 39, 0, 0, 9224, 9225, 7, 39, 0, 0, 9225, 9226, 7, 39, 0, 0, 9226, 9227, 7, 39, 0, 0, 9227, 9228, 7, 39, 0, 0, 9228, 9229, 7, 39, 0, 0, 9229, 9230, 7, 39, 0, 0, 9230, 9233, 7, 39, 0, 0, 9231, 9233, 8, 48, 0, 0, 9232, 9215, 1, 0, 0, 0, 9232, 9217, 1, 0, 0, 0, 9232, 9222, 1, 0, 0, 0, 9232, 9231, 1, 0, 0, 0, 9233, 9236, 1, 0, 0, 0, 9234, 9236, 8, 49, 0, 0, 9235, 9212, 1, 0, 0, 0, 9235, 9214, 1, 0, 0, 0, 9235, 9234, 1, 0, 0, 0, 9236, 9239, 1, 0, 0, 0, 9237, 9235, 1, 0, 0, 0, 9237, 9238, 1, 0, 0, 0, 9238, 1804, 1, 0, 0, 0, 9239, 9237, 1, 0, 0, 0, 9240, 9241, 3, 1809, 902, 0, 9241, 9242, 5, 39, 0, 0, 9242, 9243, 1, 0, 0, 0, 9243, 9244, 6, 900, 9, 0, 9244, 1806, 1, 0, 0, 0, 9245, 9247, 3, 1809, 902, 0, 9246, 9248, 5, 92, 0, 0, 9247, 9246, 1, 0, 0, 0, 9247, 9248, 1, 0, 0, 0, 9248, 9249, 1, 0, 0, 0, 9249, 9250, 5, 0, 0, 1, 9250, 1808, 1, 0, 0, 0, 9251, 9252, 5, 39, 0, 0, 9252, 9257, 5, 39, 0, 0, 9253, 9254, 5, 92, 0, 0, 9254, 9257, 9, 0, 0, 0, 9255, 9257, 8, 49, 0, 0, 9256, 9251, 1, 0, 0, 0, 9256, 9253, 1, 0, 0, 0, 9256, 9255, 1, 0, 0, 0, 9257, 9260, 1, 0, 0, 0, 9258, 9256, 1, 0, 0, 0, 9258, 9259, 1, 0, 0, 0, 9259, 1810, 1, 0, 0, 0, 9260, 9258, 1, 0, 0, 0, 9261, 9262, 3, 1783, 889, 0, 9262, 9263, 1, 0, 0, 0, 9263, 9264, 6, 903, 10, 0, 9264, 9265, 6, 903, 7, 0, 9265, 1812, 1, 0, 0, 0, 9266, 9267, 3, 1785, 890, 0, 9267, 9268, 1, 0, 0, 0, 9268, 9269, 6, 904, 11, 0, 9269, 9270, 6, 904, 7, 0, 9270, 9271, 6, 904, 12, 0, 9271, 1814, 1, 0, 0, 0, 9272, 9273, 6, 905, 13, 0, 9273, 9274, 1, 0, 0, 0, 9274, 9275, 6, 905, 14, 0, 9275, 9276, 6, 905, 15, 0, 9276, 1816, 1, 0, 0, 0, 9277, 9278, 3, 1783, 889, 0, 9278, 9279, 1, 0, 0, 0, 9279, 9280, 6, 906, 10, 0, 9280, 9281, 6, 906, 7, 0, 9281, 1818, 1, 0, 0, 0, 9282, 9283, 3, 1785, 890, 0, 9283, 9284, 1, 0, 0, 0, 9284, 9285, 6, 907, 11, 0, 9285, 9286, 6, 907, 7, 0, 9286, 1820, 1, 0, 0, 0, 9287, 9288, 5, 39, 0, 0, 9288, 9289, 1, 0, 0, 0, 9289, 9290, 6, 908, 2, 0, 9290, 9291, 6, 908, 16, 0, 9291, 1822, 1, 0, 0, 0, 9292, 9293, 6, 909, 17, 0, 9293, 9294, 1, 0, 0, 0, 9294, 9295, 6, 909, 14, 0, 9295, 9296, 6, 909, 15, 0, 9296, 1824, 1, 0, 0, 0, 9297, 9299, 8, 50, 0, 0, 9298, 9297, 1, 0, 0, 0, 9299, 9300, 1, 0, 0, 0, 9300, 9298, 1, 0, 0, 0, 9300, 9301, 1, 0, 0, 0, 9301, 9310, 1, 0, 0, 0, 9302, 9306, 5, 36, 0, 0, 9303, 9305, 8, 50, 0, 0, 9304, 9303, 1, 0, 0, 0, 9305, 9308, 1, 0, 0, 0, 9306, 9304, 1, 0, 0, 0, 9306, 9307, 1, 0, 0, 0, 9307, 9310, 1, 0, 0, 0, 9308, 9306, 1, 0, 0, 0, 9309, 9298, 1, 0, 0, 0, 9309, 9302, 1, 0, 0, 0, 9310, 1826, 1, 0, 0, 0, 9311, 9313, 5, 36, 0, 0, 9312, 9314, 3, 1753, 874, 0, 9313, 9312, 1, 0, 0, 0, 9313, 9314, 1, 0, 0, 0, 9314, 9315, 1, 0, 0, 0, 9315, 9316, 5, 36, 0, 0, 9316, 9317, 1, 0, 0, 0, 9317, 9318, 4, 911, 8, 0, 9318, 9319, 6, 911, 18, 0, 9319, 9320, 1, 0, 0, 0, 9320, 9321, 6, 911, 15, 0, 9321, 1828, 1, 0, 0, 0, 77, 0, 1, 2, 3, 4, 1896, 1902, 1904, 1909, 1913, 1915, 1918, 1927, 1929, 1934, 1939, 1941, 8851, 8867, 8871, 8875, 8884, 8886, 8896, 8898, 8924, 8926, 8944, 8955, 8966, 8983, 9003, 9007, 9010, 9016, 9019, 9024, 9028, 9033, 9040, 9051, 9053, 9064, 9067, 9077, 9088, 9096, 9102, 9105, 9107, 9113, 9127, 9135, 9141, 9144, 9146, 9148, 9154, 9159, 9164, 9168, 9178, 9182, 9184, 9191, 9194, 9208, 9232, 9235, 9237, 9247, 9256, 9258, 9300, 9306, 9309, 9313, 19, 1, 28, 0, 7, 29, 0, 3, 0, 0, 5, 1, 0, 1, 873, 1, 5, 4, 0, 1, 884, 2, 0, 1, 0, 1, 893, 3, 2, 2, 0, 7, 880, 0, 7, 881, 0, 2, 3, 0, 1, 905, 4, 6, 0, 0, 4, 0, 0, 2, 1, 0, 1, 909, 5, 1, 911, 6] \ No newline at end of file diff --git a/redshift/RedshiftLexer.tokens b/redshift/RedshiftLexer.tokens new file mode 100644 index 0000000..2931e67 --- /dev/null +++ b/redshift/RedshiftLexer.tokens @@ -0,0 +1,1740 @@ +Dollar=1 +OPEN_PAREN=2 +CLOSE_PAREN=3 +OPEN_BRACKET=4 +CLOSE_BRACKET=5 +COMMA=6 +SEMI=7 +COLON=8 +STAR=9 +EQUAL=10 +DOT=11 +PLUS=12 +MINUS=13 +SLASH=14 +CARET=15 +LT=16 +GT=17 +LESS_LESS=18 +GREATER_GREATER=19 +COLON_EQUALS=20 +LESS_EQUALS=21 +EQUALS_GREATER=22 +GREATER_EQUALS=23 +DOT_DOT=24 +NOT_EQUALS=25 +TYPECAST=26 +PERCENT=27 +PARAM=28 +Operator=29 +ALL=30 +ANALYSE=31 +ANALYZE=32 +AND=33 +ANY=34 +ARRAY=35 +AS=36 +ASC=37 +ASYMMETRIC=38 +BOTH=39 +CASE=40 +CAST=41 +CHECK=42 +COLLATE=43 +COLUMN=44 +CONSTRAINT=45 +CREATE=46 +CURRENT_CATALOG=47 +CURRENT_DATE=48 +CURRENT_ROLE=49 +CURRENT_TIME=50 +CURRENT_TIMESTAMP=51 +CURRENT_USER=52 +DEFAULT=53 +DEFERRABLE=54 +DESC=55 +DISTINCT=56 +DO=57 +ELSE=58 +EXCEPT=59 +FALSE_P=60 +FETCH=61 +FOR=62 +FOREIGN=63 +FROM=64 +GRANT=65 +GROUP_P=66 +HAVING=67 +IN_P=68 +INITIALLY=69 +INTERSECT=70 +INTO=71 +LATERAL_P=72 +LEADING=73 +LIMIT=74 +LOCALTIME=75 +LOCALTIMESTAMP=76 +NOT=77 +NULL_P=78 +OFFSET=79 +ON=80 +ONLY=81 +OR=82 +ORDER=83 +PLACING=84 +PRIMARY=85 +PUBLIC=86 +REFERENCES=87 +RETURNING=88 +SELECT=89 +SESSION_USER=90 +SOME=91 +SYMMETRIC=92 +TABLE=93 +THEN=94 +TO=95 +TRAILING=96 +TRUE_P=97 +UNION=98 +UNIQUE=99 +USER=100 +USING=101 +VARIADIC=102 +WHEN=103 +WHERE=104 +WINDOW=105 +WITH=106 +AUTHORIZATION=107 +BINARY=108 +BINDING=109 +COLLATION=110 +CONCURRENTLY=111 +CROSS=112 +CURRENT_SCHEMA=113 +FREEZE=114 +FULL=115 +ILIKE=116 +INNER_P=117 +IS=118 +ISNULL=119 +JOIN=120 +LEFT=121 +LIKE=122 +NATURAL=123 +NOTNULL=124 +OUTER_P=125 +OVER=126 +OVERLAPS=127 +RIGHT=128 +SIMILAR=129 +VERBOSE=130 +ABORT_P=131 +ABSOLUTE_P=132 +ACCESS=133 +ACTION=134 +ADD_P=135 +ADMIN=136 +AFTER=137 +AGGREGATE=138 +ALSO=139 +ALTER=140 +ALWAYS=141 +ASSERTION=142 +ASSIGNMENT=143 +AT=144 +ATTRIBUTE=145 +BACKWARD=146 +BEFORE=147 +BEGIN_P=148 +BY=149 +CACHE=150 +CALLED=151 +CASCADE=152 +CASCADED=153 +CATALOG=154 +CHAIN=155 +CHARACTERISTICS=156 +CHECKPOINT=157 +CLASS=158 +CLOSE=159 +CLUSTER=160 +COMMENT=161 +COMMENTS=162 +COMMIT=163 +COMMITTED=164 +CONFIGURATION=165 +CONNECTION=166 +CONSTRAINTS=167 +CONTENT_P=168 +CONTINUE_P=169 +CONVERSION_P=170 +COPY=171 +COST=172 +CSV=173 +JSON=174 +CURSOR=175 +CYCLE=176 +DATA_P=177 +DATA_CATALOG=178 +DATABASE=179 +DAY_P=180 +DEALLOCATE=181 +DECLARE=182 +DEFAULTS=183 +DEFERRED=184 +DEFINER=185 +DELETE_P=186 +DELIMITER=187 +DELIMITERS=188 +DICTIONARY=189 +DISABLE_P=190 +DISCARD=191 +DOCUMENT_P=192 +DOMAIN_P=193 +DOUBLE_P=194 +DROP=195 +EACH=196 +ENABLE_P=197 +ENCODING=198 +ENCRYPTED=199 +ENUM_P=200 +ESCAPE=201 +EVENT=202 +EXCLUDE=203 +EXCLUDING=204 +EXCLUSIVE=205 +EXECUTE=206 +EXPLAIN=207 +EXTENSION=208 +EXTERNAL=209 +FAMILY=210 +FIRST_P=211 +FOLLOWING=212 +FORCE=213 +FORWARD=214 +FUNCTION=215 +FUNCTIONS=216 +GLOBAL=217 +GRANTED=218 +HANDLER=219 +HEADER_P=220 +HOLD=221 +HOUR_P=222 +IDENTITY_P=223 +IF_P=224 +IMMEDIATE=225 +IMMUTABLE=226 +IMPLICIT_P=227 +INCLUDING=228 +INCREMENT=229 +INDEX=230 +INDEXES=231 +INHERIT=232 +INHERITS=233 +INLINE_P=234 +INSENSITIVE=235 +INSERT=236 +INSTEAD=237 +INVOKER=238 +ISOLATION=239 +KEY=240 +LABEL=241 +LANGUAGE=242 +LARGE_P=243 +LAST_P=244 +LEAKPROOF=245 +LEVEL=246 +LISTEN=247 +LOAD=248 +LOCAL=249 +LOCATION=250 +LOCK_P=251 +MAPPING=252 +MATCH=253 +MATCHED=254 +MATERIALIZED=255 +MAXVALUE=256 +MERGE=257 +MINUTE_P=258 +MINVALUE=259 +MODE=260 +MONTH_P=261 +MOVE=262 +NAME_P=263 +NAMES=264 +NEXT=265 +NO=266 +NOTHING=267 +NOTIFY=268 +NOWAIT=269 +NULLS_P=270 +OBJECT_P=271 +OF=272 +OFF=273 +OIDS=274 +OPERATOR=275 +OPTION=276 +OPTIONS=277 +OWNED=278 +OWNER=279 +PARSER=280 +PARTIAL=281 +PARTITION=282 +PASSING=283 +PASSWORD=284 +PLANS=285 +PRECEDING=286 +PREDICATE=287 +PREPARE=288 +PREPARED=289 +PRESERVE=290 +PRIOR=291 +PRIVILEGES=292 +PROCEDURAL=293 +PROCEDURE=294 +PROGRAM=295 +QUOTE=296 +RANGE=297 +READ=298 +REASSIGN=299 +RECHECK=300 +RECURSIVE=301 +REF=302 +REFRESH=303 +REINDEX=304 +RELATIVE_P=305 +RELEASE=306 +RENAME=307 +REPEATABLE=308 +REPLACE=309 +REPLICA=310 +RESET=311 +RESTART=312 +RESTRICT=313 +RETURNS=314 +REVOKE=315 +ROLE=316 +ROLLBACK=317 +ROWS=318 +RULE=319 +SAVEPOINT=320 +SCHEMA=321 +SCROLL=322 +SEARCH=323 +SECOND_P=324 +SECURITY=325 +SEQUENCE=326 +SEQUENCES=327 +SERIALIZABLE=328 +SERVER=329 +SESSION=330 +SET=331 +SHARE=332 +SHOW=333 +SIMPLE=334 +SNAPSHOT=335 +STABLE=336 +STANDALONE_P=337 +START=338 +STATEMENT=339 +STATISTICS=340 +STDIN=341 +STDOUT=342 +STORAGE=343 +STRICT_P=344 +STRIP_P=345 +SYSID=346 +SYSTEM_P=347 +TABLES=348 +TABLESPACE=349 +TEMP=350 +TEMPLATE=351 +TEMPORARY=352 +TEXT_P=353 +TRANSACTION=354 +TRIGGER=355 +TRUNCATE=356 +TRUSTED=357 +TYPE_P=358 +TYPES_P=359 +UNBOUNDED=360 +UNCOMMITTED=361 +UNENCRYPTED=362 +UNKNOWN=363 +UNLISTEN=364 +UNLOGGED=365 +UNTIL=366 +UPDATE=367 +VACUUM=368 +VALID=369 +VALIDATE=370 +VALIDATOR=371 +VARYING=372 +VERSION_P=373 +VIEW=374 +VOLATILE=375 +WHITESPACE_P=376 +WITHOUT=377 +WORK=378 +WRAPPER=379 +WRITE=380 +XML_P=381 +YEAR_P=382 +YES_P=383 +ZONE=384 +QUALIFY=385 +CONNECT=386 +TOP=387 +VARBYTE=388 +VARBINARY=389 +CONJUNCTION=390 +DEFINITION=391 +DATASHARE=392 +FILE=393 +PUBLICACCESSIBLE=394 +INCLUDENEW=395 +IAM_ROLE=396 +CATALOG_ROLE=397 +CATALOG_ID=398 +HIVE=399 +METASTORE=400 +URI=401 +POSTGRES=402 +MYSQL=403 +SECRET_ARN=404 +KINESIS=405 +KAFKA=406 +MSK=407 +AUTHENTICATION=408 +AUTHENTICATION_ARN=409 +SESSION_TOKEN=410 +MTLS=411 +MASKING=412 +RLS=413 +IDENTITY=414 +PROVIDER=415 +PROTECTED=416 +MODEL=417 +TARGET=418 +SAGEMAKER=419 +AUTO=420 +MODEL_TYPE=421 +PROBLEM_TYPE=422 +OBJECTIVE=423 +PREPROCESSORS=424 +HYPERPARAMETERS=425 +XGBOOST=426 +MLP=427 +LINEAR_LEARNER=428 +KMEANS=429 +FORECAST=430 +REGRESSION=431 +BINARY_CLASSIFICATION=432 +MULTICLASS_CLASSIFICATION=433 +S3_BUCKET=434 +TAGS=435 +KMS_KEY_ID=436 +S3_GARBAGE_COLLECT=437 +MAX_CELLS=438 +MAX_RUNTIME=439 +HORIZON=440 +FREQUENCY=441 +PERCENTILES=442 +MAX_BATCH_ROWS=443 +UNLOAD=444 +MANIFEST=445 +ADDQUOTES=446 +ALLOWOVERWRITE=447 +CLEANPATH=448 +MAXFILESIZE=449 +ROWGROUPSIZE=450 +BZIP2=451 +GZIP=452 +ZSTD=453 +DATABASES=454 +DATASHARES=455 +GRANTS=456 +USE=457 +CANCEL=458 +SESSION_AUTHORIZATION=459 +SESSION_CHARACTERISTICS=460 +COMPRESSION=461 +LIBRARY=462 +APPEND=463 +MB=464 +GB=465 +ACCOUNT=466 +NAMESPACE=467 +DESCRIBE=468 +NONATOMIC=469 +MANAGEDBY=470 +ADX=471 +REMOVE=472 +DUPLICATES=473 +BEDROCK=474 +MODEL_ID=475 +PROMPT=476 +SUFFIX=477 +REQUEST_TYPE=478 +RESPONSE_TYPE=479 +RAW=480 +UNIFIED=481 +SUPER=482 +CI=483 +CS=484 +PLPYTHONU=485 +FILLTARGET=486 +IGNOREEXTRA=487 +CREATEUSER=488 +NOCREATEUSER=489 +REGION=490 +PORT=491 +REDSHIFT=492 +IAM=493 +CREATEDB=494 +NOCREATEDB=495 +RESTRICTED=496 +UNLIMITED=497 +EXTERNALID=498 +TIMEOUT=499 +SYSLOG=500 +CREDENTIALS=501 +UNRESTRICTED=502 +PARAMETERS=503 +APPLICATION_ARN=504 +AUTO_CREATE_ROLES=505 +COMPROWS=506 +PROVIDER_URL=507 +PROVIDER_URL_PORT=508 +ATTRIBUTE_MAP=509 +PROVIDER_ARN=510 +ASSUME_ROLE_ARN=511 +PROPERTIES=512 +AVRO=513 +RCFILE=514 +SEQUENCEFILE=515 +TEXTFILE=516 +ORC=517 +ION=518 +LAMBDA=519 +FIXEDWIDTH=520 +PARQUET=521 +LZOP=522 +REMOVEQUOTES=523 +TRUNCATECOLUMNS=524 +FILLRECORD=525 +BLANKSASNULL=526 +EMPTYASNULL=527 +MAXERROR=528 +DATEFORMAT=529 +TIMEFORMAT=530 +ACCEPTINVCHARS=531 +ACCEPTANYDATE=532 +IGNOREHEADER=533 +IGNOREBLANKLINES=534 +COMPUPDATE=535 +STATUPDATE=536 +EXPLICIT_IDS=537 +READRATIO=538 +ROUNDEC=539 +TRIMBLANKS=540 +PRESET=541 +ACCESS_KEY_ID=542 +SECRET_ACCESS_KEY=543 +SESSION_TOKEN_KW=544 +HEADER=545 +SETTINGS=546 +FUNCTION_NAME=547 +ATOMIC_P=548 +BETWEEN=549 +BIGINT=550 +BIT=551 +BOOLEAN_P=552 +CHAR_P=553 +CHARACTER=554 +COALESCE=555 +DEC=556 +DECIMAL_P=557 +EXISTS=558 +EXTRACT=559 +FLOAT_P=560 +GREATEST=561 +INOUT=562 +INT_P=563 +INTEGER=564 +INTERVAL=565 +LEAST=566 +NATIONAL=567 +NCHAR=568 +NONE=569 +NULLIF=570 +NUMERIC=571 +OVERLAY=572 +PARAMETER=573 +POSITION=574 +PRECISION=575 +REAL=576 +ROW=577 +SETOF=578 +SMALLINT=579 +SUBSTRING=580 +TIME=581 +TIMESTAMP=582 +TREAT=583 +TRIM=584 +VALUES=585 +VARCHAR=586 +XMLATTRIBUTES=587 +XMLCOMMENT=588 +XMLAGG=589 +XML_IS_WELL_FORMED=590 +XML_IS_WELL_FORMED_DOCUMENT=591 +XML_IS_WELL_FORMED_CONTENT=592 +XPATH=593 +XPATH_EXISTS=594 +XMLCONCAT=595 +XMLELEMENT=596 +XMLEXISTS=597 +XMLFOREST=598 +XMLPARSE=599 +XMLPI=600 +XMLROOT=601 +XMLSERIALIZE=602 +CALL=603 +CURRENT_P=604 +ATTACH=605 +DETACH=606 +EXPRESSION=607 +GENERATED=608 +LOGGED=609 +STORED=610 +SERDE=611 +SERDEPROPERTIES=612 +INPUTFORMAT=613 +OUTPUTFORMAT=614 +FIELDS=615 +COLLECTION=616 +ITEMS=617 +TERMINATED=618 +ESCAPED=619 +DEFINED=620 +LINES=621 +KEYS=622 +PARTITIONED=623 +STRUCT=624 +MAP=625 +STRING=626 +DELIMITED=627 +USAGE=628 +IGNORE=629 +LANGUAGES=630 +JOB=631 +JOBS=632 +VIA=633 +ASSUMEROLE=634 +RETRY_TIMEOUT=635 +MAX_BATCH_SIZE=636 +MAX_PAYLOAD_IN_MB=637 +KB=638 +INCLUDE=639 +ROUTINE=640 +TRANSFORM=641 +IMPORT_P=642 +POLICY=643 +PRIORITY=644 +METHOD=645 +REFERENCING=646 +NEW=647 +OLD=648 +VALUE_P=649 +SUBSCRIPTION=650 +PUBLICATION=651 +OUT_P=652 +END_P=653 +ROUTINES=654 +SCHEMAS=655 +PROCEDURES=656 +INPUT_P=657 +SUPPORT=658 +PARALLEL=659 +SQL_P=660 +DEPENDS=661 +OVERRIDING=662 +CONFLICT=663 +SKIP_P=664 +LOCKED=665 +TIES=666 +ROLLUP=667 +CUBE=668 +GROUPING=669 +SETS=670 +TABLESAMPLE=671 +ORDINALITY=672 +XMLTABLE=673 +COLUMNS=674 +XMLNAMESPACES=675 +ROWTYPE=676 +NORMALIZED=677 +WITHIN=678 +FILTER=679 +GROUPS=680 +OTHERS=681 +NFC=682 +NFD=683 +NFKC=684 +NFKD=685 +UESCAPE=686 +VIEWS=687 +NORMALIZE=688 +DUMP=689 +PRINT_STRICT_PARAMS=690 +VARIABLE_CONFLICT=691 +ERROR=692 +USE_VARIABLE=693 +USE_COLUMN=694 +ALIAS=695 +CONSTANT=696 +PERFORM=697 +GET=698 +DIAGNOSTICS=699 +STACKED=700 +ELSIF=701 +WHILE=702 +REVERSE=703 +FOREACH=704 +SLICE=705 +EXIT=706 +RETURN=707 +QUERY=708 +RAISE=709 +SQLSTATE=710 +DEBUG=711 +LOG=712 +INFO=713 +NOTICE=714 +WARNING=715 +EXCEPTION=716 +ASSERT=717 +LOOP=718 +OPEN=719 +ABS=720 +CBRT=721 +CEIL=722 +CEILING=723 +DEGREES=724 +DIV=725 +EXP=726 +FACTORIAL=727 +FLOOR=728 +GCD=729 +LCM=730 +LN=731 +LOG10=732 +MIN_SCALE=733 +MOD=734 +PI=735 +POWER=736 +RADIANS=737 +ROUND=738 +SCALE=739 +SIGN=740 +SQRT=741 +TRIM_SCALE=742 +TRUNC=743 +WIDTH_BUCKET=744 +RANDOM=745 +SETSEED=746 +ACOS=747 +ACOSD=748 +ASIN=749 +ASIND=750 +ATAN=751 +ATAND=752 +ATAN2=753 +ATAN2D=754 +COS=755 +COSD=756 +COT=757 +COTD=758 +SIN=759 +SIND=760 +TAN=761 +TAND=762 +SINH=763 +COSH=764 +TANH=765 +ASINH=766 +ACOSH=767 +ATANH=768 +BIT_LENGTH=769 +CHAR_LENGTH=770 +CHARACTER_LENGTH=771 +LOWER=772 +OCTET_LENGTH=773 +UPPER=774 +ASCII=775 +BTRIM=776 +CHR=777 +CONCAT=778 +CONCAT_WS=779 +FORMAT=780 +INITCAP=781 +LENGTH=782 +LPAD=783 +LTRIM=784 +MD5=785 +PARSE_IDENT=786 +PG_CLIENT_ENCODING=787 +QUOTE_IDENT=788 +QUOTE_LITERAL=789 +QUOTE_NULLABLE=790 +REGEXP_COUNT=791 +REGEXP_INSTR=792 +REGEXP_LIKE=793 +REGEXP_MATCH=794 +REGEXP_MATCHES=795 +REGEXP_REPLACE=796 +REGEXP_SPLIT_TO_ARRAY=797 +REGEXP_SPLIT_TO_TABLE=798 +REGEXP_SUBSTR=799 +REPEAT=800 +RPAD=801 +RTRIM=802 +SPLIT_PART=803 +STARTS_WITH=804 +STRING_TO_ARRAY=805 +STRING_TO_TABLE=806 +STRPOS=807 +SUBSTR=808 +TO_ASCII=809 +TO_HEX=810 +TRANSLATE=811 +UNISTR=812 +AGE=813 +CLOCK_TIMESTAMP=814 +DATE_BIN=815 +DATE_PART=816 +DATE_TRUNC=817 +ISFINITE=818 +JUSTIFY_DAYS=819 +JUSTIFY_HOURS=820 +JUSTIFY_INTERVAL=821 +MAKE_DATE=822 +MAKE_INTERVAL=823 +MAKE_TIME=824 +MAKE_TIMESTAMP=825 +MAKE_TIMESTAMPTZ=826 +NOW=827 +STATEMENT_TIMESTAMP=828 +TIMEOFDAY=829 +TRANSACTION_TIMESTAMP=830 +TO_TIMESTAMP=831 +TO_CHAR=832 +TO_DATE=833 +TO_NUMBER=834 +ENCODE=835 +DISTKEY=836 +SORTKEY=837 +DISTSTYLE=838 +BACKUP=839 +COMPOUND=840 +INTERLEAVED=841 +EVEN=842 +CASE_SENSITIVE=843 +QUOTA=844 +TB=845 +BOOST=846 +RECLUSTER=847 +SORT=848 +PERCENT_WORD=849 +CASE_INSENSITIVE=850 +Identifier=851 +TemporaryIdentifier=852 +NamespaceUser=853 +QuotedIdentifier=854 +UnterminatedQuotedIdentifier=855 +InvalidQuotedIdentifier=856 +InvalidUnterminatedQuotedIdentifier=857 +UnicodeQuotedIdentifier=858 +UnterminatedUnicodeQuotedIdentifier=859 +InvalidUnicodeQuotedIdentifier=860 +InvalidUnterminatedUnicodeQuotedIdentifier=861 +StringConstant=862 +UnterminatedStringConstant=863 +UnicodeEscapeStringConstant=864 +UnterminatedUnicodeEscapeStringConstant=865 +BeginDollarStringConstant=866 +BinaryStringConstant=867 +UnterminatedBinaryStringConstant=868 +InvalidBinaryStringConstant=869 +InvalidUnterminatedBinaryStringConstant=870 +HexadecimalStringConstant=871 +UnterminatedHexadecimalStringConstant=872 +InvalidHexadecimalStringConstant=873 +InvalidUnterminatedHexadecimalStringConstant=874 +Integral=875 +NumericFail=876 +Numeric=877 +PLSQLVARIABLENAME=878 +PLSQLIDENTIFIER=879 +Whitespace=880 +Newline=881 +LineComment=882 +BlockComment=883 +UnterminatedBlockComment=884 +MetaCommand=885 +EndMetaCommand=886 +ErrorCharacter=887 +EscapeStringConstant=888 +UnterminatedEscapeStringConstant=889 +InvalidEscapeStringConstant=890 +InvalidUnterminatedEscapeStringConstant=891 +AfterEscapeStringConstantMode_NotContinued=892 +AfterEscapeStringConstantWithNewlineMode_NotContinued=893 +DollarText=894 +EndDollarStringConstant=895 +AfterEscapeStringConstantWithNewlineMode_Continued=896 +'$'=1 +'('=2 +')'=3 +'['=4 +']'=5 +','=6 +';'=7 +':'=8 +'*'=9 +'='=10 +'.'=11 +'+'=12 +'-'=13 +'/'=14 +'^'=15 +'<'=16 +'>'=17 +'<<'=18 +'>>'=19 +':='=20 +'<='=21 +'=>'=22 +'>='=23 +'..'=24 +'<>'=25 +'::'=26 +'%'=27 +'ALL'=30 +'ANALYSE'=31 +'ANALYZE'=32 +'AND'=33 +'ANY'=34 +'ARRAY'=35 +'AS'=36 +'ASC'=37 +'ASYMMETRIC'=38 +'BOTH'=39 +'CASE'=40 +'CAST'=41 +'CHECK'=42 +'COLLATE'=43 +'COLUMN'=44 +'CONSTRAINT'=45 +'CREATE'=46 +'CURRENT_CATALOG'=47 +'CURRENT_DATE'=48 +'CURRENT_ROLE'=49 +'CURRENT_TIME'=50 +'CURRENT_TIMESTAMP'=51 +'CURRENT_USER'=52 +'DEFAULT'=53 +'DEFERRABLE'=54 +'DESC'=55 +'DISTINCT'=56 +'DO'=57 +'ELSE'=58 +'EXCEPT'=59 +'FALSE'=60 +'FETCH'=61 +'FOR'=62 +'FOREIGN'=63 +'FROM'=64 +'GRANT'=65 +'GROUP'=66 +'HAVING'=67 +'IN'=68 +'INITIALLY'=69 +'INTERSECT'=70 +'INTO'=71 +'LATERAL'=72 +'LEADING'=73 +'LIMIT'=74 +'LOCALTIME'=75 +'LOCALTIMESTAMP'=76 +'NOT'=77 +'NULL'=78 +'OFFSET'=79 +'ON'=80 +'ONLY'=81 +'OR'=82 +'ORDER'=83 +'PLACING'=84 +'PRIMARY'=85 +'PUBLIC'=86 +'REFERENCES'=87 +'RETURNING'=88 +'SELECT'=89 +'SESSION_USER'=90 +'SOME'=91 +'SYMMETRIC'=92 +'TABLE'=93 +'THEN'=94 +'TO'=95 +'TRAILING'=96 +'TRUE'=97 +'UNION'=98 +'UNIQUE'=99 +'USER'=100 +'USING'=101 +'VARIADIC'=102 +'WHEN'=103 +'WHERE'=104 +'WINDOW'=105 +'WITH'=106 +'AUTHORIZATION'=107 +'BINARY'=108 +'BINDING'=109 +'COLLATION'=110 +'CONCURRENTLY'=111 +'CROSS'=112 +'CURRENT_SCHEMA'=113 +'FREEZE'=114 +'FULL'=115 +'ILIKE'=116 +'INNER'=117 +'IS'=118 +'ISNULL'=119 +'JOIN'=120 +'LEFT'=121 +'LIKE'=122 +'NATURAL'=123 +'NOTNULL'=124 +'OUTER'=125 +'OVER'=126 +'OVERLAPS'=127 +'RIGHT'=128 +'SIMILAR'=129 +'VERBOSE'=130 +'ABORT'=131 +'ABSOLUTE'=132 +'ACCESS'=133 +'ACTION'=134 +'ADD'=135 +'ADMIN'=136 +'AFTER'=137 +'AGGREGATE'=138 +'ALSO'=139 +'ALTER'=140 +'ALWAYS'=141 +'ASSERTION'=142 +'ASSIGNMENT'=143 +'AT'=144 +'ATTRIBUTE'=145 +'BACKWARD'=146 +'BEFORE'=147 +'BEGIN'=148 +'BY'=149 +'CACHE'=150 +'CALLED'=151 +'CASCADE'=152 +'CASCADED'=153 +'CATALOG'=154 +'CHAIN'=155 +'CHARACTERISTICS'=156 +'CHECKPOINT'=157 +'CLASS'=158 +'CLOSE'=159 +'CLUSTER'=160 +'COMMENT'=161 +'COMMENTS'=162 +'COMMIT'=163 +'COMMITTED'=164 +'CONFIGURATION'=165 +'CONNECTION'=166 +'CONSTRAINTS'=167 +'CONTENT'=168 +'CONTINUE'=169 +'CONVERSION'=170 +'COPY'=171 +'COST'=172 +'CSV'=173 +'JSON'=174 +'CURSOR'=175 +'CYCLE'=176 +'DATA'=177 +'DATA_CATALOG'=178 +'DATABASE'=179 +'DAY'=180 +'DEALLOCATE'=181 +'DECLARE'=182 +'DEFAULTS'=183 +'DEFERRED'=184 +'DEFINER'=185 +'DELETE'=186 +'DELIMITER'=187 +'DELIMITERS'=188 +'DICTIONARY'=189 +'DISABLE'=190 +'DISCARD'=191 +'DOCUMENT'=192 +'DOMAIN'=193 +'DOUBLE'=194 +'DROP'=195 +'EACH'=196 +'ENABLE'=197 +'ENCODING'=198 +'ENCRYPTED'=199 +'ENUM'=200 +'ESCAPE'=201 +'EVENT'=202 +'EXCLUDE'=203 +'EXCLUDING'=204 +'EXCLUSIVE'=205 +'EXECUTE'=206 +'EXPLAIN'=207 +'EXTENSION'=208 +'EXTERNAL'=209 +'FAMILY'=210 +'FIRST'=211 +'FOLLOWING'=212 +'FORCE'=213 +'FORWARD'=214 +'FUNCTION'=215 +'FUNCTIONS'=216 +'GLOBAL'=217 +'GRANTED'=218 +'HANDLER'=219 +'HOLD'=221 +'HOUR'=222 +'IF'=224 +'IMMEDIATE'=225 +'IMMUTABLE'=226 +'IMPLICIT'=227 +'INCLUDING'=228 +'INCREMENT'=229 +'INDEX'=230 +'INDEXES'=231 +'INHERIT'=232 +'INHERITS'=233 +'INLINE'=234 +'INSENSITIVE'=235 +'INSERT'=236 +'INSTEAD'=237 +'INVOKER'=238 +'ISOLATION'=239 +'KEY'=240 +'LABEL'=241 +'LANGUAGE'=242 +'LARGE'=243 +'LAST'=244 +'LEAKPROOF'=245 +'LEVEL'=246 +'LISTEN'=247 +'LOAD'=248 +'LOCAL'=249 +'LOCATION'=250 +'LOCK'=251 +'MAPPING'=252 +'MATCH'=253 +'MATCHED'=254 +'MATERIALIZED'=255 +'MAXVALUE'=256 +'MERGE'=257 +'MINUTE'=258 +'MINVALUE'=259 +'MODE'=260 +'MONTH'=261 +'MOVE'=262 +'NAME'=263 +'NAMES'=264 +'NEXT'=265 +'NO'=266 +'NOTHING'=267 +'NOTIFY'=268 +'NOWAIT'=269 +'NULLS'=270 +'OBJECT'=271 +'OF'=272 +'OFF'=273 +'OIDS'=274 +'OPERATOR'=275 +'OPTION'=276 +'OPTIONS'=277 +'OWNED'=278 +'OWNER'=279 +'PARSER'=280 +'PARTIAL'=281 +'PARTITION'=282 +'PASSING'=283 +'PASSWORD'=284 +'PLANS'=285 +'PRECEDING'=286 +'PREDICATE'=287 +'PREPARE'=288 +'PREPARED'=289 +'PRESERVE'=290 +'PRIOR'=291 +'PRIVILEGES'=292 +'PROCEDURAL'=293 +'PROCEDURE'=294 +'PROGRAM'=295 +'QUOTE'=296 +'RANGE'=297 +'READ'=298 +'REASSIGN'=299 +'RECHECK'=300 +'RECURSIVE'=301 +'REF'=302 +'REFRESH'=303 +'REINDEX'=304 +'RELATIVE'=305 +'RELEASE'=306 +'RENAME'=307 +'REPEATABLE'=308 +'REPLACE'=309 +'REPLICA'=310 +'RESET'=311 +'RESTART'=312 +'RESTRICT'=313 +'RETURNS'=314 +'REVOKE'=315 +'ROLE'=316 +'ROLLBACK'=317 +'ROWS'=318 +'RULE'=319 +'SAVEPOINT'=320 +'SCHEMA'=321 +'SCROLL'=322 +'SEARCH'=323 +'SECOND'=324 +'SECURITY'=325 +'SEQUENCE'=326 +'SEQUENCES'=327 +'SERIALIZABLE'=328 +'SERVER'=329 +'SET'=331 +'SHARE'=332 +'SHOW'=333 +'SIMPLE'=334 +'SNAPSHOT'=335 +'STABLE'=336 +'STANDALONE'=337 +'START'=338 +'STATEMENT'=339 +'STATISTICS'=340 +'STDIN'=341 +'STDOUT'=342 +'STORAGE'=343 +'STRICT'=344 +'STRIP'=345 +'SYSID'=346 +'SYSTEM'=347 +'TABLES'=348 +'TABLESPACE'=349 +'TEMP'=350 +'TEMPLATE'=351 +'TEMPORARY'=352 +'TEXT'=353 +'TRANSACTION'=354 +'TRIGGER'=355 +'TRUNCATE'=356 +'TRUSTED'=357 +'TYPE'=358 +'TYPES'=359 +'UNBOUNDED'=360 +'UNCOMMITTED'=361 +'UNENCRYPTED'=362 +'UNKNOWN'=363 +'UNLISTEN'=364 +'UNLOGGED'=365 +'UNTIL'=366 +'UPDATE'=367 +'VACUUM'=368 +'VALID'=369 +'VALIDATE'=370 +'VALIDATOR'=371 +'VARYING'=372 +'VERSION'=373 +'VIEW'=374 +'VOLATILE'=375 +'WHITESPACE'=376 +'WITHOUT'=377 +'WORK'=378 +'WRAPPER'=379 +'WRITE'=380 +'XML'=381 +'YEAR'=382 +'YES'=383 +'ZONE'=384 +'QUALIFY'=385 +'CONNECT'=386 +'TOP'=387 +'VARBYTE'=388 +'VARBINARY'=389 +'CONJUNCTION'=390 +'DEFINITION'=391 +'DATASHARE'=392 +'FILE'=393 +'PUBLICACCESSIBLE'=394 +'INCLUDENEW'=395 +'IAM_ROLE'=396 +'CATALOG_ROLE'=397 +'CATALOG_ID'=398 +'HIVE'=399 +'METASTORE'=400 +'URI'=401 +'POSTGRES'=402 +'MYSQL'=403 +'SECRET_ARN'=404 +'KINESIS'=405 +'KAFKA'=406 +'MSK'=407 +'AUTHENTICATION'=408 +'AUTHENTICATION_ARN'=409 +'MTLS'=411 +'MASKING'=412 +'RLS'=413 +'PROVIDER'=415 +'PROTECTED'=416 +'MODEL'=417 +'TARGET'=418 +'SAGEMAKER'=419 +'AUTO'=420 +'MODEL_TYPE'=421 +'PROBLEM_TYPE'=422 +'OBJECTIVE'=423 +'PREPROCESSORS'=424 +'HYPERPARAMETERS'=425 +'XGBOOST'=426 +'MLP'=427 +'LINEAR_LEARNER'=428 +'KMEANS'=429 +'FORECAST'=430 +'REGRESSION'=431 +'BINARY_CLASSIFICATION'=432 +'MULTICLASS_CLASSIFICATION'=433 +'S3_BUCKET'=434 +'TAGS'=435 +'KMS_KEY_ID'=436 +'S3_GARBAGE_COLLECT'=437 +'MAX_CELLS'=438 +'MAX_RUNTIME'=439 +'HORIZON'=440 +'FREQUENCY'=441 +'PERCENTILES'=442 +'MAX_BATCH_ROWS'=443 +'UNLOAD'=444 +'MANIFEST'=445 +'ADDQUOTES'=446 +'ALLOWOVERWRITE'=447 +'CLEANPATH'=448 +'MAXFILESIZE'=449 +'ROWGROUPSIZE'=450 +'BZIP2'=451 +'GZIP'=452 +'ZSTD'=453 +'DATABASES'=454 +'DATASHARES'=455 +'GRANTS'=456 +'USE'=457 +'CANCEL'=458 +'SESSION_AUTHORIZATION'=459 +'SESSION_CHARACTERISTICS'=460 +'COMPRESSION'=461 +'LIBRARY'=462 +'APPEND'=463 +'MB'=464 +'GB'=465 +'ACCOUNT'=466 +'NAMESPACE'=467 +'DESCRIBE'=468 +'NONATOMIC'=469 +'MANAGEDBY'=470 +'ADX'=471 +'REMOVE'=472 +'DUPLICATES'=473 +'BEDROCK'=474 +'MODEL_ID'=475 +'PROMPT'=476 +'SUFFIX'=477 +'REQUEST_TYPE'=478 +'RESPONSE_TYPE'=479 +'RAW'=480 +'UNIFIED'=481 +'SUPER'=482 +'CI'=483 +'CS'=484 +'PLPYTHONU'=485 +'FILLTARGET'=486 +'IGNOREEXTRA'=487 +'CREATEUSER'=488 +'NOCREATEUSER'=489 +'REGION'=490 +'PORT'=491 +'REDSHIFT'=492 +'IAM'=493 +'CREATEDB'=494 +'NOCREATEDB'=495 +'RESTRICTED'=496 +'UNLIMITED'=497 +'EXTERNALID'=498 +'TIMEOUT'=499 +'SYSLOG'=500 +'CREDENTIALS'=501 +'UNRESTRICTED'=502 +'PARAMETERS'=503 +'APPLICATION_ARN'=504 +'AUTO_CREATE_ROLES'=505 +'COMPROWS'=506 +'PROVIDER_URL'=507 +'PROVIDER_URL_PORT'=508 +'ATTRIBUTE_MAP'=509 +'PROVIDER_ARN'=510 +'ASSUME_ROLE_ARN'=511 +'PROPERTIES'=512 +'AVRO'=513 +'RCFILE'=514 +'SEQUENCEFILE'=515 +'TEXTFILE'=516 +'ORC'=517 +'ION'=518 +'LAMBDA'=519 +'FIXEDWIDTH'=520 +'PARQUET'=521 +'LZOP'=522 +'REMOVEQUOTES'=523 +'TRUNCATECOLUMNS'=524 +'FILLRECORD'=525 +'BLANKSASNULL'=526 +'EMPTYASNULL'=527 +'MAXERROR'=528 +'DATEFORMAT'=529 +'TIMEFORMAT'=530 +'ACCEPTINVCHARS'=531 +'ACCEPTANYDATE'=532 +'IGNOREHEADER'=533 +'IGNOREBLANKLINES'=534 +'COMPUPDATE'=535 +'STATUPDATE'=536 +'EXPLICIT_IDS'=537 +'READRATIO'=538 +'ROUNDEC'=539 +'TRIMBLANKS'=540 +'PRESET'=541 +'ACCESS_KEY_ID'=542 +'SECRET_ACCESS_KEY'=543 +'SESSION_TOKEN'=544 +'SETTINGS'=546 +'FUNCTION_NAME'=547 +'ATOMIC'=548 +'BETWEEN'=549 +'BIGINT'=550 +'BIT'=551 +'BOOLEAN'=552 +'CHAR'=553 +'CHARACTER'=554 +'COALESCE'=555 +'DEC'=556 +'DECIMAL'=557 +'EXISTS'=558 +'EXTRACT'=559 +'FLOAT'=560 +'GREATEST'=561 +'INOUT'=562 +'INT'=563 +'INTEGER'=564 +'INTERVAL'=565 +'LEAST'=566 +'NATIONAL'=567 +'NCHAR'=568 +'NONE'=569 +'NULLIF'=570 +'NUMERIC'=571 +'OVERLAY'=572 +'PARAMETER'=573 +'POSITION'=574 +'PRECISION'=575 +'REAL'=576 +'ROW'=577 +'SETOF'=578 +'SMALLINT'=579 +'SUBSTRING'=580 +'TIME'=581 +'TIMESTAMP'=582 +'TREAT'=583 +'TRIM'=584 +'VALUES'=585 +'VARCHAR'=586 +'XMLATTRIBUTES'=587 +'XMLCOMMENT'=588 +'XMLAGG'=589 +'XML_IS_WELL_FORMED'=590 +'XML_IS_WELL_FORMED_DOCUMENT'=591 +'XML_IS_WELL_FORMED_CONTENT'=592 +'XPATH'=593 +'XPATH_EXISTS'=594 +'XMLCONCAT'=595 +'XMLELEMENT'=596 +'XMLEXISTS'=597 +'XMLFOREST'=598 +'XMLPARSE'=599 +'XMLPI'=600 +'XMLROOT'=601 +'XMLSERIALIZE'=602 +'CALL'=603 +'CURRENT'=604 +'ATTACH'=605 +'DETACH'=606 +'EXPRESSION'=607 +'GENERATED'=608 +'LOGGED'=609 +'STORED'=610 +'SERDE'=611 +'SERDEPROPERTIES'=612 +'INPUTFORMAT'=613 +'OUTPUTFORMAT'=614 +'FIELDS'=615 +'COLLECTION'=616 +'ITEMS'=617 +'TERMINATED'=618 +'ESCAPED'=619 +'DEFINED'=620 +'LINES'=621 +'KEYS'=622 +'PARTITIONED'=623 +'STRUCT'=624 +'MAP'=625 +'STRING'=626 +'DELIMITED'=627 +'USAGE'=628 +'IGNORE'=629 +'LANGUAGES'=630 +'JOB'=631 +'JOBS'=632 +'VIA'=633 +'ASSUMEROLE'=634 +'RETRY_TIMEOUT'=635 +'MAX_BATCH_SIZE'=636 +'MAX_PAYLOAD_IN_MB'=637 +'KB'=638 +'INCLUDE'=639 +'ROUTINE'=640 +'TRANSFORM'=641 +'IMPORT'=642 +'POLICY'=643 +'PRIORITY'=644 +'METHOD'=645 +'REFERENCING'=646 +'NEW'=647 +'OLD'=648 +'VALUE'=649 +'SUBSCRIPTION'=650 +'PUBLICATION'=651 +'OUT'=652 +'END'=653 +'ROUTINES'=654 +'SCHEMAS'=655 +'PROCEDURES'=656 +'INPUT'=657 +'SUPPORT'=658 +'PARALLEL'=659 +'SQL'=660 +'DEPENDS'=661 +'OVERRIDING'=662 +'CONFLICT'=663 +'SKIP'=664 +'LOCKED'=665 +'TIES'=666 +'ROLLUP'=667 +'CUBE'=668 +'GROUPING'=669 +'SETS'=670 +'TABLESAMPLE'=671 +'ORDINALITY'=672 +'XMLTABLE'=673 +'COLUMNS'=674 +'XMLNAMESPACES'=675 +'ROWTYPE'=676 +'NORMALIZED'=677 +'WITHIN'=678 +'FILTER'=679 +'GROUPS'=680 +'OTHERS'=681 +'NFC'=682 +'NFD'=683 +'NFKC'=684 +'NFKD'=685 +'UESCAPE'=686 +'VIEWS'=687 +'NORMALIZE'=688 +'DUMP'=689 +'PRINT_STRICT_PARAMS'=690 +'VARIABLE_CONFLICT'=691 +'ERROR'=692 +'USE_VARIABLE'=693 +'USE_COLUMN'=694 +'ALIAS'=695 +'CONSTANT'=696 +'PERFORM'=697 +'GET'=698 +'DIAGNOSTICS'=699 +'STACKED'=700 +'ELSIF'=701 +'WHILE'=702 +'REVERSE'=703 +'FOREACH'=704 +'SLICE'=705 +'EXIT'=706 +'RETURN'=707 +'QUERY'=708 +'RAISE'=709 +'SQLSTATE'=710 +'DEBUG'=711 +'LOG'=712 +'INFO'=713 +'NOTICE'=714 +'WARNING'=715 +'EXCEPTION'=716 +'ASSERT'=717 +'LOOP'=718 +'OPEN'=719 +'ABS'=720 +'CBRT'=721 +'CEIL'=722 +'CEILING'=723 +'DEGREES'=724 +'DIV'=725 +'EXP'=726 +'FACTORIAL'=727 +'FLOOR'=728 +'GCD'=729 +'LCM'=730 +'LN'=731 +'LOG10'=732 +'MIN_SCALE'=733 +'MOD'=734 +'PI'=735 +'POWER'=736 +'RADIANS'=737 +'ROUND'=738 +'SCALE'=739 +'SIGN'=740 +'SQRT'=741 +'TRIM_SCALE'=742 +'TRUNC'=743 +'WIDTH_BUCKET'=744 +'RANDOM'=745 +'SETSEED'=746 +'ACOS'=747 +'ACOSD'=748 +'ASIN'=749 +'ASIND'=750 +'ATAN'=751 +'ATAND'=752 +'ATAN2'=753 +'ATAN2D'=754 +'COS'=755 +'COSD'=756 +'COT'=757 +'COTD'=758 +'SIN'=759 +'SIND'=760 +'TAN'=761 +'TAND'=762 +'SINH'=763 +'COSH'=764 +'TANH'=765 +'ASINH'=766 +'ACOSH'=767 +'ATANH'=768 +'BIT_LENGTH'=769 +'CHAR_LENGTH'=770 +'CHARACTER_LENGTH'=771 +'LOWER'=772 +'OCTET_LENGTH'=773 +'UPPER'=774 +'ASCII'=775 +'BTRIM'=776 +'CHR'=777 +'CONCAT'=778 +'CONCAT_WS'=779 +'FORMAT'=780 +'INITCAP'=781 +'LENGTH'=782 +'LPAD'=783 +'LTRIM'=784 +'MD5'=785 +'PARSE_IDENT'=786 +'PG_CLIENT_ENCODING'=787 +'QUOTE_IDENT'=788 +'QUOTE_LITERAL'=789 +'QUOTE_NULLABLE'=790 +'REGEXP_COUNT'=791 +'REGEXP_INSTR'=792 +'REGEXP_LIKE'=793 +'REGEXP_MATCH'=794 +'REGEXP_MATCHES'=795 +'REGEXP_REPLACE'=796 +'REGEXP_SPLIT_TO_ARRAY'=797 +'REGEXP_SPLIT_TO_TABLE'=798 +'REGEXP_SUBSTR'=799 +'REPEAT'=800 +'RPAD'=801 +'RTRIM'=802 +'SPLIT_PART'=803 +'STARTS_WITH'=804 +'STRING_TO_ARRAY'=805 +'STRING_TO_TABLE'=806 +'STRPOS'=807 +'SUBSTR'=808 +'TO_ASCII'=809 +'TO_HEX'=810 +'TRANSLATE'=811 +'UNISTR'=812 +'AGE'=813 +'CLOCK_TIMESTAMP'=814 +'DATE_BIN'=815 +'DATE_PART'=816 +'DATE_TRUNC'=817 +'ISFINITE'=818 +'JUSTIFY_DAYS'=819 +'JUSTIFY_HOURS'=820 +'JUSTIFY_INTERVAL'=821 +'MAKE_DATE'=822 +'MAKE_INTERVAL'=823 +'MAKE_TIME'=824 +'MAKE_TIMESTAMP'=825 +'MAKE_TIMESTAMPTZ'=826 +'NOW'=827 +'STATEMENT_TIMESTAMP'=828 +'TIMEOFDAY'=829 +'TRANSACTION_TIMESTAMP'=830 +'TO_TIMESTAMP'=831 +'TO_CHAR'=832 +'TO_DATE'=833 +'TO_NUMBER'=834 +'ENCODE'=835 +'DISTKEY'=836 +'SORTKEY'=837 +'DISTSTYLE'=838 +'BACKUP'=839 +'COMPOUND'=840 +'INTERLEAVED'=841 +'EVEN'=842 +'CASE_SENSITIVE'=843 +'QUOTA'=844 +'TB'=845 +'BOOST'=846 +'RECLUSTER'=847 +'SORT'=848 +'PERCENT'=849 +'CASE_INSENSITIVE'=850 +'\\\\'=886 +'\''=896 diff --git a/redshift/RedshiftParser.g4 b/redshift/RedshiftParser.g4 new file mode 100755 index 0000000..c776663 --- /dev/null +++ b/redshift/RedshiftParser.g4 @@ -0,0 +1,6976 @@ +parser grammar RedshiftParser; + + +options { tokenVocab = RedshiftLexer; +superClass = RedshiftParserBase; +} + + +@header +{ +} +@members +{ +} +root + : stmtblock EOF + ; + +plsqlroot + : pl_function + ; + +stmtblock + : stmtmulti + ; + +stmtmulti + : (stmt SEMI?)* + ; + +stmt + : altereventtrigstmt + | altercollationstmt + | alterdatabasestmt + | alterdatabasesetstmt + | alterdefaultprivilegesstmt + | alterdomainstmt + | alterenumstmt + | alterextensionstmt + | alterextensioncontentsstmt + | alterfdwstmt + | alterforeignserverstmt + | alterfunctionstmt + | alterprocedurestmt + | altergroupstmt + | alterobjectdependsstmt + | alterobjectschemastmt + | alterownerstmt + | alteroperatorstmt + | altertypestmt + | alterpolicystmt + | alterseqstmt + | altersystemstmt + | altertablestmt + | altertblspcstmt + | altercompositetypestmt + | alterpublicationstmt + | alterrolesetstmt + | alterrolestmt + | alteruserstmt + | alterschemastmt + | altersubscriptionstmt + | alterstatsstmt + | altertsconfigurationstmt + | altertsdictionarystmt + | alterusermappingstmt + | analyzestmt + | callstmt + | checkpointstmt + | closeportalstmt + | clusterstmt + | commentstmt + | constraintssetstmt + | copystmt + | createamstmt + | createasstmt + | createassertionstmt + | createcaststmt + | createconversionstmt + | createdomainstmt + | createextensionstmt + | createfdwstmt + | createforeignserverstmt + | createforeigntablestmt + | createfunctionstmt + | createprocedurestmt + | creategroupstmt + | creatematviewstmt + | createopclassstmt + | createopfamilystmt + | createpublicationstmt + | alteropfamilystmt + | createpolicystmt + | createplangstmt + | createschemastmt + | createseqstmt + | createstmt + | createsubscriptionstmt + | createstatsstmt + | createtablespacestmt + | createtransformstmt + | createtrigstmt + | createeventtrigstmt + | createrolestmt + | createuserstmt + | createusermappingstmt + | createdbstmt + | deallocatestmt + | declarecursorstmt + | definestmt + | deletestmt + | discardstmt + | dostmt + | dropcaststmt + | dropopclassstmt + | dropopfamilystmt + | dropownedstmt + | dropschemastmt + | dropstmt + | dropsubscriptionstmt + | droptablespacestmt + | droptransformstmt + | droprolestmt + | dropuserstmt + | dropgroupstmt + | dropusermappingstmt + | dropdbstmt + | executestmt + | explainstmt + | fetchstmt + | grantstmt + | importforeignschemastmt + | indexstmt + | insertstmt + | mergestmt + | listenstmt + | refreshmatviewstmt + | loadstmt + | lockstmt + | notifystmt + | preparestmt + | reassignownedstmt + | reindexstmt + | removeaggrstmt + | removefuncstmt + | removeoperstmt + | renamestmt + | revokestmt + | revokerolestmt + | rulestmt + | seclabelstmt + | selectstmt + | transactionstmt + | truncatestmt + | unlistenstmt + | updatestmt + | vacuumstmt + | variableresetstmt + | variablesetstmt + | variableshowstmt + | viewstmt + // REDSHIFT-SPECIFIC STATEMENTS + | alterdatasharestmt + | alterexternalschemastmt + | alterexternalviewstmt + | alteridentityproviderstmt + | altermaskingpolicystmt + | altermaterializedviewstmt + | alterrlspolicystmt + | altertableappendstmt + | analyzecompressionstmt + | attachmaskingpolicystmt + | attachrlspolicystmt + | cancelstmt + | closestmt + | createdatasharestmt + | createexternalfunctionstmt + | createexternalmodelstmt + | createexternalschemastmt + | createexternaltablestmt + | createexternalviewstmt + | createidentityproviderstmt + | createlibrarystmt + | createmaskingpolicystmt + | createmodelstmt + | createrlspolicystmt + | descdatasharestmt + | descidentityproviderstmt + | detachmaskingpolicystmt + | detachrlspolicystmt + | dropdatasharestmt + | dropexternalviewstmt + | dropidentityproviderstmt + | droplibrarystmt + | dropmaskingpolicystmt + | dropmodelstmt + | droprlspolicystmt + | insertexternaltablestmt + | selectintostmt + | setsessionauthorizationstmt + | setsessioncharacteristicsstmt + | showcolumnsstmt + | showdatabasesstmt + | showdatasharesstmt + | showexternaltablestmt + | showgrantsstmt + | showmodelstmt + | showprocedurestmt + | showschemasstmt + | showtablestmt + | showtablesstmt + | showviewstmt + | unloadstmt + | usestmt + | plsqlconsolecommand + ; + +plsqlconsolecommand + : MetaCommand EndMetaCommand? + ; + +callstmt + : CALL func_application + ; + +createrolestmt + : CREATE ROLE roleid opt_with? optrolelist + ; + +opt_with + : WITH + //| WITH_LA + ; + +optrolelist + : createoptroleelem* + ; + +alteroptrolelist + : alteroptroleelem (',' alteroptroleelem)* + | alteroptroleelem* + ; + +alteroptroleelem + : PASSWORD (sconst | NULL_P | DISABLE_P) + | (ENCRYPTED | UNENCRYPTED) PASSWORD sconst + | INHERIT + | CONNECTION LIMIT (signediconst | UNLIMITED) + | VALID UNTIL sconst + | USER role_list + | EXTERNALID (sconst | identifier) + | CREATEDB + | NOCREATEDB + | CREATEUSER + | NOCREATEUSER + | SYSLOG ACCESS (RESTRICTED | UNRESTRICTED) + | SESSION TIMEOUT iconst + | RESET SESSION TIMEOUT + | RESET ALL + | SET var_name (TO | EQUAL)? var_list + | RESET var_name + | identifier + ; + +createoptroleelem + : alteroptroleelem + | SYSID iconst + | ADMIN role_list + | ROLE role_list + | IN_P (ROLE | GROUP_P) role_list + ; + +createuserstmt + : CREATE USER roleid opt_with? optrolelist + ; + +alterrolestmt + : ALTER ROLE rolespec opt_with? alterroleaction; + +alterroleaction + : RENAME TO colid + | OWNER TO colid + | EXTERNALID TO colid + ; + +opt_in_database + : IN_P DATABASE name + ; + +alterrolesetstmt + : ALTER (ROLE | USER) ALL? rolespec opt_in_database? setresetclause + ; + +alterschemastmt + : ALTER SCHEMA name QUOTA (iconst (MB | GB | TB)? | UNLIMITED) + ; + +droprolestmt + : DROP ROLE rolespec (FORCE | RESTRICT)? + ; + +dropuserstmt + : DROP USER opt_if_exists? role_list + ; + +dropgroupstmt + : DROP GROUP_P rolespec + ; + + +creategroupstmt + : CREATE GROUP_P roleid opt_with? optrolelist + ; + +altergroupstmt + : ALTER GROUP_P rolespec add_drop USER role_list + ; + +add_drop + : ADD_P + | DROP + ; + +createschemastmt + : CREATE SCHEMA opt_if_not_exists? schemaname=colid opt_auth_clause? opt_quota? optschemaeltlist? + | CREATE SCHEMA opt_auth_clause opt_quota? optschemaeltlist? + ; + +opt_auth_clause + : AUTHORIZATION rolespec + ; + +opt_quota + : QUOTA ((fconst | iconst) (MB | GB | TB)? | UNLIMITED) + ; + +optschemaeltlist + : schema_stmt+ + ; + +schema_stmt + : createstmt + | indexstmt + | createseqstmt + | createtrigstmt + | grantstmt + | viewstmt + ; + +variablesetstmt + : SET (LOCAL | SESSION)? set_rest + ; + +set_rest + : TRANSACTION transaction_mode_list + | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list + | set_rest_more + ; + +generic_set + : var_name (TO | EQUAL) var_list + ; + +set_rest_more + : generic_set + | var_name FROM CURRENT_P + | TIME ZONE zone_value + | CATALOG sconst + | SCHEMA sconst + | NAMES opt_encoding? + | ROLE nonreservedword_or_sconst + | SESSION AUTHORIZATION nonreservedword_or_sconst + | XML_P OPTION document_or_content + | TRANSACTION SNAPSHOT sconst + ; + +var_name + : colid (DOT colid)* + ; + +var_list + : var_value (COMMA var_value)* + ; + +var_value + : opt_boolean_or_string + | numericonly + ; + +iso_level + : READ (UNCOMMITTED | COMMITTED) + | REPEATABLE READ + | SERIALIZABLE + ; + +opt_boolean_or_string + : TRUE_P + | FALSE_P + | ON + | nonreservedword_or_sconst + ; + +zone_value + : sconst + | identifier + | constinterval sconst opt_interval? + | constinterval OPEN_PAREN iconst CLOSE_PAREN sconst + | numericonly + | DEFAULT + | LOCAL + ; + +opt_encoding + : sconst + | DEFAULT + ; + +nonreservedword_or_sconst + : nonreservedword + | sconst + ; + +variableresetstmt + : RESET reset_rest + ; + +reset_rest + : generic_reset + | TIME ZONE + | TRANSACTION ISOLATION LEVEL + | SESSION AUTHORIZATION + ; + +generic_reset + : var_name + | ALL + ; + +setresetclause + : SET set_rest + | variableresetstmt + ; + +functionsetresetclause + : SET set_rest_more + | variableresetstmt + ; + +variableshowstmt + : SHOW (var_name | TIME ZONE | TRANSACTION ISOLATION LEVEL | SESSION AUTHORIZATION | CURRENT_SCHEMA | SESSION_USER | CURRENT_USER | ALL) + ; + +constraintssetstmt + : SET CONSTRAINTS constraints_set_list constraints_set_mode + ; + +constraints_set_list + : ALL + | qualified_name_list + ; + +constraints_set_mode + : DEFERRED + | IMMEDIATE + ; + +checkpointstmt + : CHECKPOINT + ; + +discardstmt + : DISCARD (ALL | TEMP | TEMPORARY | PLANS | SEQUENCES) + ; + +altertablestmt + : ALTER TABLE qualified_name alter_table_cmds (COMMA alter_table_cmds)* + ; + +alter_table_cmds + : ADD_P table_constraint + | DROP CONSTRAINT colid (RESTRICT | CASCADE)? + | OWNER TO rolespec + | RENAME TO colid + | RENAME COLUMN colid TO colid + | ALTER COLUMN colid TYPE_P typename + | ALTER COLUMN colid ENCODE colid + | ALTER DISTKEY colid + | ALTER DISTSTYLE ALL + | ALTER DISTSTYLE EVEN + | ALTER DISTSTYLE KEY DISTKEY colid + | ALTER DISTSTYLE AUTO + | ALTER COMPOUND? SORTKEY OPEN_PAREN columnlist CLOSE_PAREN + | ALTER SORTKEY AUTO + | ALTER SORTKEY NONE + | ALTER ENCODE AUTO + | ADD_P COLUMN? colid typename (DEFAULT a_expr)? (ENCODE colid)? (NOT? NULL_P)? (COLLATE (CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI))? + | DROP COLUMN? colid (RESTRICT | CASCADE)? + | ROW LEVEL SECURITY (ON | OFF) (CONJUNCTION TYPE_P (AND | OR))? (FOR DATASHARES)? + | MASKING (ON | OFF) FOR DATASHARES + // ALTER TABLE APPEND + | APPEND FROM qualified_name (IGNOREEXTRA | FILLTARGET)? + // The following options apply only to external tables + | SET LOCATION StringConstant + | SET FILE FORMAT colid + | SET TABLE PROPERTIES OPEN_PAREN table_properties_list CLOSE_PAREN + | PARTITION OPEN_PAREN ((colid EQUAL a_expr) (COMMA colid EQUAL a_expr)*) CLOSE_PAREN SET LOCATION StringConstant + | ADD_P opt_if_not_exists? PARTITION OPEN_PAREN ((colid EQUAL a_expr) (COMMA colid EQUAL a_expr)*) CLOSE_PAREN LOCATION StringConstant + | DROP PARTITION OPEN_PAREN ((colid EQUAL a_expr) (COMMA colid EQUAL a_expr)*) CLOSE_PAREN + ; + +table_constraint + : (CONSTRAINT colid)? ( + (UNIQUE OPEN_PAREN columnlist CLOSE_PAREN) + | (PRIMARY KEY OPEN_PAREN columnlist CLOSE_PAREN) + | (FOREIGN KEY OPEN_PAREN columnlist CLOSE_PAREN REFERENCES qualified_name OPEN_PAREN columnlist CLOSE_PAREN) + ); + +partition_cmd + : ATTACH PARTITION qualified_name partitionboundspec + | DETACH PARTITION qualified_name + ; + +index_partition_cmd + : ATTACH PARTITION qualified_name + ; + +alter_table_cmd + : ADD_P columnDef + | ADD_P IF_P NOT EXISTS columnDef + | ADD_P COLUMN columnDef + | ADD_P COLUMN IF_P NOT EXISTS columnDef + | ALTER opt_column? colid alter_column_default + | ALTER opt_column? colid DROP NOT NULL_P + | ALTER opt_column? colid SET NOT NULL_P + | ALTER opt_column? colid DROP EXPRESSION + | ALTER opt_column? colid DROP EXPRESSION IF_P EXISTS + | ALTER opt_column? colid SET STATISTICS signediconst + | ALTER opt_column? iconst SET STATISTICS signediconst + | ALTER opt_column? colid SET reloptions + | ALTER opt_column? colid RESET reloptions + | ALTER opt_column? colid SET STORAGE colid + | ALTER opt_column? colid ADD_P GENERATED generated_when AS IDENTITY_P optparenthesizedseqoptlist? + | ALTER opt_column? colid alter_identity_column_option_list + | ALTER opt_column? colid DROP IDENTITY_P + | ALTER opt_column? colid DROP IDENTITY_P IF_P EXISTS + | DROP opt_column? IF_P EXISTS colid opt_drop_behavior? + | DROP opt_column? colid opt_drop_behavior? + | ALTER opt_column? colid opt_set_data? TYPE_P typename opt_collate_clause? alter_using? + | ALTER opt_column? colid alter_generic_options + | ADD_P tableconstraint + | ALTER CONSTRAINT name constraintattributespec + | VALIDATE CONSTRAINT name + | DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior? + | DROP CONSTRAINT name opt_drop_behavior? + | SET WITHOUT OIDS + | CLUSTER ON name + | SET WITHOUT CLUSTER + | SET LOGGED + | SET UNLOGGED + | ENABLE_P TRIGGER name + | ENABLE_P ALWAYS TRIGGER name + | ENABLE_P REPLICA TRIGGER name + | ENABLE_P TRIGGER ALL + | ENABLE_P TRIGGER USER + | DISABLE_P TRIGGER name + | DISABLE_P TRIGGER ALL + | DISABLE_P TRIGGER USER + | ENABLE_P RULE name + | ENABLE_P ALWAYS RULE name + | ENABLE_P REPLICA RULE name + | DISABLE_P RULE name + | INHERIT qualified_name + | NO INHERIT qualified_name + | OF any_name + | NOT OF + | OWNER TO rolespec + | SET ACCESS METHOD name + | SET TABLESPACE name + | SET reloptions + | RESET reloptions + | REPLICA IDENTITY_P replica_identity + | ENABLE_P ROW LEVEL SECURITY + | DISABLE_P ROW LEVEL SECURITY + | FORCE ROW LEVEL SECURITY + | NO FORCE ROW LEVEL SECURITY + | alter_generic_options + ; + +alter_column_default + : SET DEFAULT a_expr + | DROP DEFAULT + ; + +opt_drop_behavior + : CASCADE + | RESTRICT + ; + +opt_collate_clause + : COLLATE any_name + ; + +alter_using + : USING a_expr + ; + +replica_identity + : NOTHING + | FULL + | DEFAULT + | USING INDEX name + ; + +reloptions + : OPEN_PAREN reloption_list CLOSE_PAREN + ; + +opt_reloptions + : WITH reloptions + ; + +reloption_list + : reloption_elem (COMMA reloption_elem)* + ; + +reloption_elem + : collabel (EQUAL def_arg | DOT collabel (EQUAL def_arg)?)? + ; + +alter_identity_column_option_list + : alter_identity_column_option+ + ; + +alter_identity_column_option + : RESTART (opt_with? numericonly)? + | SET (seqoptelem | GENERATED generated_when) + ; + +partitionboundspec + : FOR VALUES WITH OPEN_PAREN hash_partbound CLOSE_PAREN + | FOR VALUES IN_P OPEN_PAREN expr_list CLOSE_PAREN + | FOR VALUES FROM OPEN_PAREN expr_list CLOSE_PAREN TO OPEN_PAREN expr_list CLOSE_PAREN + | DEFAULT + ; + +hash_partbound_elem + : nonreservedword iconst + ; + +hash_partbound + : hash_partbound_elem (COMMA hash_partbound_elem)* + ; + +altercompositetypestmt + : ALTER TYPE_P any_name alter_type_cmds + ; + +alter_type_cmds + : alter_type_cmd (COMMA alter_type_cmd)* + ; + +alter_type_cmd + : ADD_P ATTRIBUTE tablefuncelement opt_drop_behavior? + | DROP ATTRIBUTE (IF_P EXISTS)? colid opt_drop_behavior? + | ALTER ATTRIBUTE colid opt_set_data? TYPE_P typename opt_collate_clause? opt_drop_behavior? + ; + +closeportalstmt + : CLOSE (cursor_name | ALL) + ; + +copystmt + : COPY opt_binary? qualified_name opt_column_list? copy_from opt_program? copy_file_name copy_delimiter? opt_with? copy_options where_clause? + | COPY OPEN_PAREN preparablestmt CLOSE_PAREN TO opt_program? copy_file_name opt_with? copy_options + | COPY qualified_name opt_column_list? FROM sconst redshift_copy_authorization redshift_copy_format? redshift_copy_parameter* + ; + +redshift_copy_authorization + : IAM_ROLE (DEFAULT | sconst) + | CREDENTIALS sconst + | ACCESS_KEY_ID sconst SECRET_ACCESS_KEY sconst (SESSION_TOKEN_KW sconst)? + ; + +redshift_copy_format + : FORMAT? AS? (CSV | PARQUET | ORC | JSON | AVRO) sconst? + ; + +redshift_copy_parameter + : copy_param_name (AS? copy_param_value)? + ; + +copy_param_name + : colid + | NULL_P + ; + +copy_param_value + : sconst | iconst | colid + | ON | OFF | TRUE_P | FALSE_P | PRESET + | AUTO | DEFAULT | NONE + ; + +copy_from + : FROM + | TO + ; + +opt_program + : PROGRAM + ; + +copy_file_name + : sconst + | STDIN + | STDOUT + ; + +copy_options + : copy_opt_list + | OPEN_PAREN copy_generic_opt_list CLOSE_PAREN + ; + +copy_opt_list + : copy_opt_item* + ; + +copy_opt_item + : BINARY + | FREEZE + | DELIMITER opt_as? sconst + | NULL_P opt_as? sconst + | CSV + | HEADER_P + | QUOTE opt_as? sconst + | ESCAPE opt_as? sconst + | FORCE QUOTE columnlist + | FORCE QUOTE STAR + | FORCE NOT NULL_P columnlist + | FORCE NULL_P columnlist + | ENCODING sconst + ; + +opt_binary + : BINARY + ; + +copy_delimiter + : opt_using? DELIMITERS sconst + ; + +opt_using + : USING + ; + +copy_generic_opt_list + : copy_generic_opt_elem (COMMA copy_generic_opt_elem)* + ; + +copy_generic_opt_elem + : collabel copy_generic_opt_arg? + ; + +copy_generic_opt_arg + : opt_boolean_or_string + | numericonly + | STAR + | OPEN_PAREN copy_generic_opt_arg_list CLOSE_PAREN + ; + +copy_generic_opt_arg_list + : copy_generic_opt_arg_list_item (COMMA copy_generic_opt_arg_list_item)* + ; + +copy_generic_opt_arg_list_item + : opt_boolean_or_string + ; + +createstmt + : CREATE opttemp? TABLE (IF_P NOT EXISTS)? table_name ( + OPEN_PAREN opttableelementlist? CLOSE_PAREN opt_backup_clause? opt_table_attributes* + ) + ; + +opt_table_attributes + : DISTSTYLE (AUTO | EVEN | KEY | ALL) + | DISTKEY OPEN_PAREN distkey_identifier=colid CLOSE_PAREN + | (COMPOUND | INTERLEAVED)? SORTKEY OPEN_PAREN sortkey_columnlist=columnlist CLOSE_PAREN + | ENCODE AUTO + ; + + +opttemp + : LOCAL? (TEMPORARY | TEMP) + ; + +opttableelementlist + : tableelementlist + ; + +opttypedtableelementlist + : OPEN_PAREN typedtableelementlist CLOSE_PAREN + ; + +tableelementlist + : tableelement (COMMA tableelement)* + ; + +typedtableelementlist + : typedtableelement (COMMA typedtableelement)* + ; + +tableelement + : tableconstraint + | tablelikeclause + | columnDef + ; + +typedtableelement + : columnOptions + | tableconstraint + ; + +columnDef + : colid extern_typename create_generic_options? rs_colattributes? + ; + +rs_colattributes: + rs_colattribute+ + ; + +rs_colattribute + : DEFAULT b_expr + | IDENTITY_P OPEN_PAREN seed=iconst COMMA step=iconst CLOSE_PAREN + | GENERATED generated_when AS IDENTITY_P (OPEN_PAREN seed=iconst COMMA step=iconst CLOSE_PAREN)? + | ENCODE colid + | DISTKEY + | SORTKEY + | COLLATE (CASE_SENSITIVE | CASE_INSENSITIVE) + | NOT NULL_P | NULL_P + | UNIQUE | PRIMARY KEY + | REFERENCES qualified_name opt_column_list? + ; + +columnOptions + : colid (WITH OPTIONS)? colquallist + ; + +colquallist + : colconstraint* + ; + +colconstraint + : CONSTRAINT name colconstraintelem + | colconstraintelem + | constraintattr + | COLLATE any_name + ; + +colconstraintelem + : NOT NULL_P + | NULL_P + | UNIQUE opt_unique_null_treatment? opt_definition? optconstablespace? + | PRIMARY KEY opt_definition? optconstablespace? + | CHECK OPEN_PAREN a_expr CLOSE_PAREN opt_no_inherit? + | DEFAULT b_expr + | GENERATED generated_when AS (IDENTITY_P optparenthesizedseqoptlist? | OPEN_PAREN a_expr CLOSE_PAREN STORED) + | REFERENCES qualified_name opt_column_list? key_match? key_actions? + ; + +opt_unique_null_treatment + : NULLS_P NOT? DISTINCT + ; + +generated_when + : ALWAYS + | BY DEFAULT + ; + +constraintattr + : DEFERRABLE + | NOT DEFERRABLE + | INITIALLY (DEFERRED | IMMEDIATE) + ; + +tablelikeclause + : LIKE qualified_name tablelikeoptionlist + ; + +tablelikeoptionlist + : ((INCLUDING | EXCLUDING) tablelikeoption)* + ; + +tablelikeoption + : COMMENTS + | CONSTRAINTS + | DEFAULTS + | IDENTITY_P + | GENERATED + | INDEXES + | STATISTICS + | STORAGE + | ALL + ; + +tableconstraint + : CONSTRAINT name constraintelem + | constraintelem + ; + +constraintelem + : CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + | UNIQUE opt_unique_null_treatment? (OPEN_PAREN columnlist CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? constraintattributespec | existingindex constraintattributespec) + | PRIMARY KEY (OPEN_PAREN columnlist CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? constraintattributespec | existingindex constraintattributespec) + | EXCLUDE access_method_clause? OPEN_PAREN exclusionconstraintlist CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? exclusionwhereclause? constraintattributespec + | FOREIGN KEY OPEN_PAREN columnlist CLOSE_PAREN REFERENCES qualified_name opt_column_list? key_match? key_actions? constraintattributespec + ; + +opt_no_inherit + : NO INHERIT + ; + +opt_column_list + : OPEN_PAREN columnlist CLOSE_PAREN + ; + +columnlist + : columnElem (COMMA columnElem)* + ; + +columnElem + : colid + ; + +opt_c_include + : INCLUDE OPEN_PAREN columnlist CLOSE_PAREN + ; + +key_match + : MATCH (FULL | PARTIAL | SIMPLE) + ; + +exclusionconstraintlist + : exclusionconstraintelem (COMMA exclusionconstraintelem)* + ; + +exclusionconstraintelem + : index_elem WITH (any_operator | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN) + ; + +exclusionwhereclause + : WHERE OPEN_PAREN a_expr CLOSE_PAREN + ; + +key_actions + : key_update + | key_delete + | key_update key_delete + | key_delete key_update + ; + +key_update + : ON UPDATE key_action + ; + +key_delete + : ON DELETE_P key_action + ; + +key_action + : NO ACTION + | RESTRICT + | CASCADE + | SET (NULL_P | DEFAULT) opt_column_list? + ; + +optinherit + : INHERITS OPEN_PAREN qualified_name_list CLOSE_PAREN + ; + +optpartitionspec + : partitionspec + ; + +partitionspec + : PARTITION BY colid OPEN_PAREN part_params CLOSE_PAREN + ; + +part_params + : part_elem (COMMA part_elem)* + ; + +part_elem + : colid opt_collate? opt_class? + | func_expr_windowless opt_collate? opt_class? + | OPEN_PAREN a_expr CLOSE_PAREN opt_collate? opt_class? + ; + +table_access_method_clause + : USING name + ; + +optwith + : WITH reloptions + | WITHOUT OIDS + ; + +oncommitoption + : ON COMMIT (DROP | DELETE_P ROWS | PRESERVE ROWS) + ; + +opttablespace + : TABLESPACE name + ; + +optredshifttableoptions + : redshifttableoption+ + ; + +redshifttableoption + : BACKUP (YES_P | NO) + | DISTSTYLE (ALL | EVEN | KEY | AUTO) + | DISTKEY OPEN_PAREN colid CLOSE_PAREN + | sortkeyclause + | ENCODE AUTO + ; + +sortkeyclause + : sortkeyclausetype? SORTKEY OPEN_PAREN columnlist CLOSE_PAREN + ; + +sortkeyclausetype + : COMPOUND + | INTERLEAVED + ; + +optconstablespace + : USING INDEX TABLESPACE name + ; + +existingindex + : USING INDEX name + ; + +createstatsstmt + : CREATE STATISTICS (IF_P NOT EXISTS)? any_name opt_name_list? ON expr_list FROM from_list + ; + +alterstatsstmt + : ALTER STATISTICS (IF_P EXISTS)? any_name SET STATISTICS signediconst + ; + +createasstmt + : CREATE opttemp? TABLE create_as_target AS selectstmt + ; + +create_as_target + : table_name opt_column_list? opt_backup_clause_table_attributes? + ; + +opt_backup_clause_table_attributes + : opt_backup_clause opt_table_attributes* + | opt_table_attributes+ opt_backup_clause? opt_table_attributes* + ; + +table_attributes + : DISTSTYLE (AUTO | EVEN | ALL | KEY) + | DISTKEY OPEN_PAREN distkey_identifier=colid CLOSE_PAREN + | (COMPOUND | INTERLEAVED)? SORTKEY OPEN_PAREN sortkey_columnlist=columnlist CLOSE_PAREN + ; + +opt_backup_clause + : BACKUP (YES_P | NO) + ; + +opt_with_data + : WITH (DATA_P | NO DATA_P) + ; + +creatematviewstmt + : CREATE MATERIALIZED VIEW qualified_name opt_backup_clause? opt_table_attributes* opt_auto_refresh? AS selectstmt + ; + +opt_auto_refresh + : AUTO REFRESH (YES_P | NO); + +refreshmatviewstmt + : REFRESH MATERIALIZED VIEW opt_concurrently? qualified_name opt_with_data? (RESTRICT | CASCADE)? + ; + +createseqstmt + : CREATE opttemp? SEQUENCE (IF_P NOT EXISTS)? qualified_name optseqoptlist? + ; + +alterseqstmt + : ALTER SEQUENCE (IF_P EXISTS)? qualified_name seqoptlist + ; + +optseqoptlist + : seqoptlist + ; + +optparenthesizedseqoptlist + : OPEN_PAREN seqoptlist CLOSE_PAREN + ; + +seqoptlist + : seqoptelem+ + ; + +seqoptelem + : AS simpletypename + | CACHE numericonly + | CYCLE + | INCREMENT opt_by? numericonly + | LOGGED + | MAXVALUE numericonly + | MINVALUE numericonly + | NO (MAXVALUE | MINVALUE | CYCLE) + | OWNED BY any_name + | SEQUENCE NAME_P any_name + | START opt_with? numericonly + | RESTART opt_with? numericonly? + | UNLOGGED + ; + +opt_by + : BY + ; + +numericonly + : fconst + | PLUS fconst + | MINUS fconst + | signediconst + ; + +numericonly_list + : numericonly (COMMA numericonly)* + ; + +createplangstmt + : CREATE opt_or_replace? opt_trusted? opt_procedural? LANGUAGE name (HANDLER handler_name opt_inline_handler? opt_validator?)? + ; + +opt_trusted + : TRUSTED + ; + +handler_name + : name attrs? + ; + +opt_inline_handler + : INLINE_P handler_name + ; + +validator_clause + : VALIDATOR handler_name + | NO VALIDATOR + ; + +opt_validator + : validator_clause + ; + +opt_procedural + : PROCEDURAL + ; + +createtablespacestmt + : CREATE TABLESPACE name opttablespaceowner? LOCATION sconst opt_reloptions? + ; + +opttablespaceowner + : OWNER rolespec + ; + +droptablespacestmt + : DROP TABLESPACE (IF_P EXISTS)? name + ; + +createextensionstmt + : CREATE EXTENSION (IF_P NOT EXISTS)? name opt_with? create_extension_opt_list + ; + +create_extension_opt_list + : create_extension_opt_item* + ; + +create_extension_opt_item + : SCHEMA name + | VERSION_P nonreservedword_or_sconst + | FROM nonreservedword_or_sconst + | CASCADE + ; + +alterextensionstmt + : ALTER EXTENSION name UPDATE alter_extension_opt_list + ; + +alter_extension_opt_list + : alter_extension_opt_item* + ; + +alter_extension_opt_item + : TO nonreservedword_or_sconst + ; + +alterextensioncontentsstmt + : ALTER EXTENSION name add_drop object_type_name name + | ALTER EXTENSION name add_drop object_type_any_name any_name + | ALTER EXTENSION name add_drop AGGREGATE aggregate_with_argtypes + | ALTER EXTENSION name add_drop CAST OPEN_PAREN typename AS typename CLOSE_PAREN + | ALTER EXTENSION name add_drop DOMAIN_P typename + | ALTER EXTENSION name add_drop FUNCTION function_with_argtypes + | ALTER EXTENSION name add_drop OPERATOR operator_with_argtypes + | ALTER EXTENSION name add_drop OPERATOR CLASS any_name USING name + | ALTER EXTENSION name add_drop OPERATOR FAMILY any_name USING name + | ALTER EXTENSION name add_drop PROCEDURE function_with_argtypes + | ALTER EXTENSION name add_drop ROUTINE function_with_argtypes + | ALTER EXTENSION name add_drop TRANSFORM FOR typename LANGUAGE name + | ALTER EXTENSION name add_drop TYPE_P typename + ; + +createfdwstmt + : CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options? create_generic_options? + ; + +fdw_option + : HANDLER handler_name + | NO HANDLER + | VALIDATOR handler_name + | NO VALIDATOR + ; + +fdw_options + : fdw_option+ + ; + +opt_fdw_options + : fdw_options + ; + +alterfdwstmt + : ALTER FOREIGN DATA_P WRAPPER name opt_fdw_options? alter_generic_options + | ALTER FOREIGN DATA_P WRAPPER name fdw_options + ; + +create_generic_options + : OPTIONS OPEN_PAREN generic_option_list CLOSE_PAREN + ; + +generic_option_list + : generic_option_elem (COMMA generic_option_elem)* + ; + +alter_generic_options + : OPTIONS OPEN_PAREN alter_generic_option_list CLOSE_PAREN + ; + +alter_generic_option_list + : alter_generic_option_elem (COMMA alter_generic_option_elem)* + ; + +alter_generic_option_elem + : generic_option_elem + | SET generic_option_elem + | ADD_P generic_option_elem + | DROP generic_option_name + ; + +generic_option_elem + : generic_option_name generic_option_arg + ; + +generic_option_name + : collabel + ; + +generic_option_arg + : sconst + ; + +createforeignserverstmt + : CREATE SERVER name opt_type? opt_foreign_server_version? FOREIGN DATA_P WRAPPER name create_generic_options? + | CREATE SERVER IF_P NOT EXISTS name opt_type? opt_foreign_server_version? FOREIGN DATA_P WRAPPER name create_generic_options? + ; + +opt_type + : TYPE_P sconst + ; + +foreign_server_version + : VERSION_P (sconst | NULL_P) + ; + +opt_foreign_server_version + : foreign_server_version + ; + +alterforeignserverstmt + : ALTER SERVER name (alter_generic_options | foreign_server_version alter_generic_options?) + ; + +createforeigntablestmt + : CREATE FOREIGN TABLE qualified_name OPEN_PAREN opttableelementlist? CLOSE_PAREN optinherit? SERVER name create_generic_options? + | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name OPEN_PAREN opttableelementlist? CLOSE_PAREN optinherit? SERVER name create_generic_options? + | CREATE FOREIGN TABLE qualified_name PARTITION OF qualified_name opttypedtableelementlist? partitionboundspec SERVER name create_generic_options? + | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name PARTITION OF qualified_name opttypedtableelementlist? partitionboundspec SERVER name create_generic_options? + ; + +importforeignschemastmt + : IMPORT_P FOREIGN SCHEMA name import_qualification? FROM SERVER name INTO name create_generic_options? + ; + +import_qualification_type + : LIMIT TO + | EXCEPT + ; + +import_qualification + : import_qualification_type OPEN_PAREN relation_expr_list CLOSE_PAREN + ; + +createusermappingstmt + : CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options? + | CREATE USER MAPPING IF_P NOT EXISTS FOR auth_ident SERVER name create_generic_options? + ; + +auth_ident + : rolespec + | USER + ; + +dropusermappingstmt + : DROP USER MAPPING FOR auth_ident SERVER name + | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name + ; + +alterusermappingstmt + : ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options + ; + +createpolicystmt + : CREATE POLICY name ON qualified_name rowsecuritydefaultpermissive? rowsecuritydefaultforcmd? rowsecuritydefaulttorole? rowsecurityoptionalexpr? rowsecurityoptionalwithcheck? + ; + +alterpolicystmt + : ALTER POLICY name ON qualified_name rowsecurityoptionaltorole? rowsecurityoptionalexpr? rowsecurityoptionalwithcheck? + ; + +rowsecurityoptionalexpr + : USING OPEN_PAREN a_expr CLOSE_PAREN + ; + +rowsecurityoptionalwithcheck + : WITH CHECK OPEN_PAREN a_expr CLOSE_PAREN + ; + +rowsecuritydefaulttorole + : TO role_list + ; + +rowsecurityoptionaltorole + : TO role_list + ; + +rowsecuritydefaultpermissive + : AS identifier + ; + +rowsecuritydefaultforcmd + : FOR row_security_cmd + ; + +row_security_cmd + : ALL + | SELECT + | INSERT + | UPDATE + | DELETE_P + ; + +createamstmt + : CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name + ; + +am_type + : INDEX + | TABLE + ; + +createtrigstmt + : CREATE TRIGGER name triggeractiontime triggerevents ON qualified_name triggerreferencing? triggerforspec? triggerwhen? EXECUTE function_or_procedure func_name OPEN_PAREN triggerfuncargs CLOSE_PAREN + | CREATE CONSTRAINT TRIGGER name AFTER triggerevents ON qualified_name optconstrfromtable? constraintattributespec FOR EACH ROW triggerwhen? EXECUTE function_or_procedure func_name OPEN_PAREN triggerfuncargs CLOSE_PAREN + ; + +triggeractiontime + : BEFORE + | AFTER + | INSTEAD OF + ; + +triggerevents + : triggeroneevent (OR triggeroneevent)* + ; + +triggeroneevent + : INSERT + | DELETE_P + | UPDATE + | UPDATE OF columnlist + | TRUNCATE + ; + +triggerreferencing + : REFERENCING triggertransitions + ; + +triggertransitions + : triggertransition+ + ; + +triggertransition + : transitionoldornew transitionrowortable opt_as? transitionrelname + ; + +transitionoldornew + : NEW + | OLD + ; + +transitionrowortable + : TABLE + | ROW + ; + +transitionrelname + : colid + ; + +triggerforspec + : FOR triggerforopteach? triggerfortype + ; + +triggerforopteach + : EACH + ; + +triggerfortype + : ROW + | STATEMENT + ; + +triggerwhen + : WHEN OPEN_PAREN a_expr CLOSE_PAREN + ; + +function_or_procedure + : FUNCTION + | PROCEDURE + ; + +triggerfuncargs + : (triggerfuncarg |) (COMMA triggerfuncarg)* + ; + +triggerfuncarg + : iconst + | fconst + | sconst + | collabel + ; + +optconstrfromtable + : FROM qualified_name + ; + +constraintattributespec + : constraintattributeElem* + ; + +constraintattributeElem + : NOT DEFERRABLE + | DEFERRABLE + | INITIALLY IMMEDIATE + | INITIALLY DEFERRED + | NOT VALID + | NO INHERIT + ; + +createeventtrigstmt + : CREATE EVENT TRIGGER name ON collabel EXECUTE function_or_procedure func_name OPEN_PAREN CLOSE_PAREN + | CREATE EVENT TRIGGER name ON collabel WHEN event_trigger_when_list EXECUTE function_or_procedure func_name OPEN_PAREN CLOSE_PAREN + ; + +event_trigger_when_list + : event_trigger_when_item (AND event_trigger_when_item)* + ; + +event_trigger_when_item + : colid IN_P OPEN_PAREN event_trigger_value_list CLOSE_PAREN + ; + +event_trigger_value_list + : sconst (COMMA sconst)* + ; + +altereventtrigstmt + : ALTER EVENT TRIGGER name enable_trigger + ; + +enable_trigger + : ENABLE_P + | ENABLE_P REPLICA + | ENABLE_P ALWAYS + | DISABLE_P + ; + +createassertionstmt + : CREATE ASSERTION any_name CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + ; + +definestmt + : CREATE opt_or_replace? AGGREGATE func_name aggr_args definition + | CREATE opt_or_replace? AGGREGATE func_name old_aggr_definition + | CREATE OPERATOR any_operator definition + | CREATE TYPE_P any_name definition + | CREATE TYPE_P any_name + | CREATE TYPE_P any_name AS OPEN_PAREN opttablefuncelementlist? CLOSE_PAREN + | CREATE TYPE_P any_name AS ENUM_P OPEN_PAREN opt_enum_val_list? CLOSE_PAREN + | CREATE TYPE_P any_name AS RANGE definition + | CREATE TEXT_P SEARCH PARSER any_name definition + | CREATE TEXT_P SEARCH DICTIONARY any_name definition + | CREATE TEXT_P SEARCH TEMPLATE any_name definition + | CREATE TEXT_P SEARCH CONFIGURATION any_name definition + | CREATE COLLATION any_name definition + | CREATE COLLATION IF_P NOT EXISTS any_name definition + | CREATE COLLATION any_name FROM any_name + | CREATE COLLATION IF_P NOT EXISTS any_name FROM any_name + ; + +definition + : OPEN_PAREN def_list CLOSE_PAREN + ; + +def_list + : def_elem (COMMA def_elem)* + ; + +def_elem + : collabel (EQUAL def_arg)? + ; + +def_arg + : func_type + | reserved_keyword + | qual_all_op + | numericonly + | sconst + | NONE + ; + +old_aggr_definition + : OPEN_PAREN old_aggr_list CLOSE_PAREN + ; + +old_aggr_list + : old_aggr_elem (COMMA old_aggr_elem)* + ; + +old_aggr_elem + : identifier EQUAL def_arg + ; + +opt_enum_val_list + : enum_val_list + ; + +enum_val_list + : sconst (COMMA sconst)* + ; + +alterenumstmt + : ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists? sconst + | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists? sconst BEFORE sconst + | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists? sconst AFTER sconst + | ALTER TYPE_P any_name RENAME VALUE_P sconst TO sconst + ; + +opt_if_not_exists + : IF_P NOT EXISTS + ; + +createopclassstmt + : CREATE OPERATOR CLASS any_name opt_default? FOR TYPE_P typename USING name opt_opfamily? AS opclass_item_list + ; + +opclass_item_list + : opclass_item (COMMA opclass_item)* + ; + +opclass_item + : OPERATOR iconst any_operator opclass_purpose? opt_recheck? + | OPERATOR iconst operator_with_argtypes opclass_purpose? opt_recheck? + | FUNCTION iconst function_with_argtypes + | FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN function_with_argtypes + | STORAGE typename + ; + +opt_default + : DEFAULT + ; + +opt_opfamily + : FAMILY any_name + ; + +opclass_purpose + : FOR SEARCH + | FOR ORDER BY any_name + ; + +opt_recheck + : RECHECK + ; + +createopfamilystmt + : CREATE OPERATOR FAMILY any_name USING name + ; + +alteropfamilystmt + : ALTER OPERATOR FAMILY any_name USING name ADD_P opclass_item_list + | ALTER OPERATOR FAMILY any_name USING name DROP opclass_drop_list + ; + +opclass_drop_list + : opclass_drop (COMMA opclass_drop)* + ; + +opclass_drop + : OPERATOR iconst OPEN_PAREN type_list CLOSE_PAREN + | FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN + ; + +dropopclassstmt + : DROP OPERATOR CLASS any_name USING name opt_drop_behavior? + | DROP OPERATOR CLASS IF_P EXISTS any_name USING name opt_drop_behavior? + ; + +dropopfamilystmt + : DROP OPERATOR FAMILY any_name USING name opt_drop_behavior? + | DROP OPERATOR FAMILY IF_P EXISTS any_name USING name opt_drop_behavior? + ; + +dropownedstmt + : DROP OWNED BY role_list opt_drop_behavior? + ; + +reassignownedstmt + : REASSIGN OWNED BY role_list TO rolespec + ; + +dropstmt + : DROP object_type_any_name IF_P EXISTS any_name_list opt_drop_behavior? + | DROP object_type_any_name any_name_list opt_drop_behavior? + | DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior? + | DROP drop_type_name name_list opt_drop_behavior? + | DROP object_type_name_on_any_name name ON any_name opt_drop_behavior? + | DROP object_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior? + | DROP TYPE_P type_name_list opt_drop_behavior? + | DROP TYPE_P IF_P EXISTS type_name_list opt_drop_behavior? + | DROP DOMAIN_P type_name_list opt_drop_behavior? + | DROP DOMAIN_P IF_P EXISTS type_name_list opt_drop_behavior? + | DROP INDEX CONCURRENTLY any_name_list opt_drop_behavior? + | DROP INDEX CONCURRENTLY IF_P EXISTS any_name_list opt_drop_behavior? + ; + +object_type_any_name + : TABLE + | SEQUENCE + | VIEW + | MATERIALIZED VIEW + | INDEX + | FOREIGN TABLE + | COLLATION + | CONVERSION_P + | STATISTICS + | TEXT_P SEARCH PARSER + | TEXT_P SEARCH DICTIONARY + | TEXT_P SEARCH TEMPLATE + | TEXT_P SEARCH CONFIGURATION + ; + +object_type_name + : drop_type_name + | SCHEMA + | DATABASE + | ROLE + | SUBSCRIPTION + | TABLESPACE + ; + +drop_type_name + : ACCESS METHOD + | EVENT TRIGGER + | EXTENSION + | FOREIGN DATA_P WRAPPER + | opt_procedural? LANGUAGE + | PUBLICATION + | SERVER + ; + +object_type_name_on_any_name + : POLICY + | RULE + | TRIGGER + ; + +any_name_list + : any_name (COMMA any_name)* + ; + +any_name + : colid attrs? + ; + +attrs + :(DOT attr_name)+ + ; + +type_name_list + : typename (COMMA typename)* + ; + +truncatestmt + : TRUNCATE opt_table? relation_expr_list opt_restart_seqs? opt_drop_behavior? + ; + +opt_restart_seqs + : CONTINUE_P IDENTITY_P + | RESTART IDENTITY_P + ; + +commentstmt + : COMMENT ON object_type_any_name any_name IS comment_text + | COMMENT ON COLUMN any_name IS comment_text + | COMMENT ON object_type_name name IS comment_text + | COMMENT ON TYPE_P typename IS comment_text + | COMMENT ON DOMAIN_P typename IS comment_text + | COMMENT ON AGGREGATE aggregate_with_argtypes IS comment_text + | COMMENT ON FUNCTION function_with_argtypes IS comment_text + | COMMENT ON OPERATOR operator_with_argtypes IS comment_text + | COMMENT ON CONSTRAINT name ON any_name IS comment_text + | COMMENT ON CONSTRAINT name ON DOMAIN_P any_name IS comment_text + | COMMENT ON object_type_name_on_any_name name ON any_name IS comment_text + | COMMENT ON PROCEDURE function_with_argtypes IS comment_text + | COMMENT ON ROUTINE function_with_argtypes IS comment_text + | COMMENT ON TRANSFORM FOR typename LANGUAGE name IS comment_text + | COMMENT ON OPERATOR CLASS any_name USING name IS comment_text + | COMMENT ON OPERATOR FAMILY any_name USING name IS comment_text + | COMMENT ON LARGE_P OBJECT_P numericonly IS comment_text + | COMMENT ON CAST OPEN_PAREN typename AS typename CLOSE_PAREN IS comment_text + ; + +comment_text + : sconst + | NULL_P + ; + +seclabelstmt + : SECURITY LABEL opt_provider? ON object_type_any_name any_name IS security_label + | SECURITY LABEL opt_provider? ON COLUMN any_name IS security_label + | SECURITY LABEL opt_provider? ON object_type_name name IS security_label + | SECURITY LABEL opt_provider? ON TYPE_P typename IS security_label + | SECURITY LABEL opt_provider? ON DOMAIN_P typename IS security_label + | SECURITY LABEL opt_provider? ON AGGREGATE aggregate_with_argtypes IS security_label + | SECURITY LABEL opt_provider? ON FUNCTION function_with_argtypes IS security_label + | SECURITY LABEL opt_provider? ON LARGE_P OBJECT_P numericonly IS security_label + | SECURITY LABEL opt_provider? ON PROCEDURE function_with_argtypes IS security_label + | SECURITY LABEL opt_provider? ON ROUTINE function_with_argtypes IS security_label + ; + +opt_provider + : FOR nonreservedword_or_sconst + ; + +security_label + : sconst + | NULL_P + ; + +fetchstmt + : FETCH fetch_args + ; + +fetch_args + : NEXT FROM cursor_name + | ALL FROM cursor_name + | FORWARD (signediconst | ALL)? FROM cursor_name + | FROM cursor_name + ; + +grantstmt + : common_grant + | grant_column_level_permissions + | grant_assume_role_permissions + | grant_spectrum_integration_permissions + | grant_datashare_permissions + | grant_scoped_permissions + | grant_machine_learning_permissions + | grant_role_permissions + | grant_explain_permissions_for_row_level_security_policy_filters + | grant_permissions_for_rls_lookup_tables + ; + +grant_permissions_for_rls_lookup_tables + : GRANT SELECT ON TABLE? qualified_name_list TO RLS POLICY columnlist + ; + +grant_explain_permissions_for_row_level_security_policy_filters + : GRANT (EXPLAIN | IGNORE) RLS TO ROLE rolespec + ; + +grant_machine_learning_permissions + : GRANT CREATE MODEL TO grantee_list + | GRANT function_privilege_list ON MODEL columnlist TO grantee_list + ; + +grant_role_permissions + : GRANT ROLE rolespec (COMMA ROLE rolespec)* TO grant_role_permission_target_list + | GRANT system_permissions TO ROLE role_list + ; + +grant_role_permission_target_list + : grant_role_permission_target_list_item (COMMA grant_role_permission_target_list_item)* + ; + +grant_role_permission_target_list_item + : rolespec opt_with_admin_option? + | ROLE rolespec + ; + +system_permissions + : system_permissions_item (COMMA system_permissions_item)* + | all_privileges + ; + +system_permissions_item + : (CREATE | DROP | ALTER) USER + | (CREATE | DROP) SCHEMA + | ALTER DEFAULT PRIVILEGES + | ACCESS (CATALOG | (SYSTEM_P TABLE)) + | (CREATE | DROP | ALTER) TABLE + | CREATE OR REPLACE (FUNCTION | (EXTERNAL FUNCTION)) + | DROP FUNCTION + | ((CREATE OR REPLACE) | DROP) PROCEDURE + | ((CREATE OR REPLACE) | DROP) VIEW + | (CREATE | DROP) MODEL + | (CREATE | ALTER | DROP) DATASHARE + | (CREATE | DROP) LIBRARY + | (CREATE | DROP) ROLE + | TRUNCATE TABLE + | VACUUM | ANALYZE | CANCEL + | (IGNORE | EXPLAIN) RLS + | EXPLAIN MASKING + ; + +opt_with_admin_option + : WITH ADMIN OPTION + ; + +grant_scoped_permissions + : grant_scoped_schemas_permissions + | grant_scoped_tables_permissions + | grant_scoped_functions_permissions + | grant_scoped_procedures_permissions + | grant_scoped_languages_permissions + | grant_scoped_copy_jobs_permissions + ; + +grant_scoped_schemas_permissions + : GRANT schema_privilege_list FOR SCHEMAS IN_P DATABASE colid TO grantee_list_without_public + ; + +grant_scoped_tables_permissions + : GRANT table_privilege_list FOR TABLES IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) TO grantee_list_without_public + ; + +grant_scoped_functions_permissions + : GRANT function_privilege_list FOR FUNCTIONS IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) TO grantee_list_without_public + ; + +grant_scoped_procedures_permissions + : GRANT procedure_privilege_list FOR PROCEDURES IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) TO grantee_list_without_public + ; + +grant_scoped_languages_permissions + : GRANT language_privilege_list FOR LANGUAGES IN_P DATABASE colid TO grantee_list_without_public + ; + +grant_scoped_copy_jobs_permissions + : GRANT copy_job_privilege_list FOR COPY JOBS IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) TO grantee_list_without_public + ; + +grantee_list_without_public + : grantee_without_public (COMMA grantee_without_public)* + ; + +grantee_without_public + : rolespec opt_with_grant_option? + | ROLE rolespec + ; + +grant_datashare_permissions + : GRANT (ALTER | SHARE) ON DATASHARE colid TO grantee_list + | GRANT USAGE ON DATASHARE colid TO ((NAMESPACE sconst) | (ACCOUNT sconst (VIA DATA_P CATALOG)?)) + | GRANT USAGE ON (DATABASE columnlist | SCHEMA colid) TO grantee_list + ; + +grant_spectrum_integration_permissions + : grant_spectrum_integration_extenral_column_permissions + | grant_spectrum_integration_external_table_permissions + | grant_spectrum_integration_external_schema_permissions + ; + +grant_spectrum_integration_external_schema_permissions + : GRANT spectrum_integration_external_schema_permission_list ON EXTERNAL SCHEMA columnlist TO iamrolelist_or_public opt_with_grant_option? + ; + +spectrum_integration_external_schema_permission_list + : spectrum_integration_external_schema_permission (COMMA spectrum_integration_external_schema_permission)* + | all_privileges + ; + +spectrum_integration_external_schema_permission + : CREATE + | ALTER + | DROP + ; + +grant_spectrum_integration_external_table_permissions + : GRANT spectrum_integration_external_table_permission_list ON EXTERNAL TABLE qualified_name_list TO iamrolelist_or_public opt_with_grant_option? + ; + +spectrum_integration_external_table_permission + : SELECT | ALTER | DROP | DELETE_P | INSERT + | all_privileges + ; + +spectrum_integration_external_table_permission_list + : spectrum_integration_external_table_permission (COMMA spectrum_integration_external_table_permission)* + ; + + +grant_spectrum_integration_extenral_column_permissions + : GRANT (SELECT | all_privileges) OPEN_PAREN columnlist CLOSE_PAREN ON EXTERNAL TABLE qualified_name TO iamrolelist_or_public opt_with_grant_option? + ; + +iamrolelist_or_public + : iamrolelist + | PUBLIC + ; + +iamrolelist + : IAM_ROLE iamrolevalue (COMMA IAM_ROLE iamrolevalue)* + ; + +grant_assume_role_permissions + : GRANT ASSUMEROLE grant_assume_role_target TO grantee_list FOR grant_assume_role_for_list + ; + +grant_assume_role_for_list + : grant_assume_role_for_item (COMMA grant_assume_role_for_item)* + ; + +grant_assume_role_for_item + : ALL + | COPY + | UNLOAD + | EXTERNAL FUNCTION + | CREATE MODEL + ; + +grant_assume_role_target + : sconst (COMMA sconst)* | DEFAULT | ALL + ; + +grant_column_level_permissions + : GRANT column_privilege_list ON column_privilege_target TO grantee_list + ; + +column_privilege_target + : TABLE? qualified_name_list + ; + +column_privilege_list + : column_select_update_privilege (COMMA column_select_update_privilege)* + | column_all_privilege (COMMA column_all_privilege)* + ; + +column_all_privilege + : ALL PRIVILEGES? OPEN_PAREN columnlist? CLOSE_PAREN + ; + +column_select_update_privilege + : (SELECT | UPDATE) OPEN_PAREN columnlist? CLOSE_PAREN + ; + +common_grant + : GRANT table_privilege_list ON grant_table_target TO grantee_list + | GRANT database_privilege_list ON grant_database_target TO grantee_list + | GRANT schema_privilege_list ON grant_schema_target TO grantee_list + | GRANT function_privilege_list ON grant_function_target TO grantee_list + | GRANT procedure_privilege_list ON grant_procedure_target TO grantee_list + | GRANT language_privilege_list ON grant_language_target TO grantee_list + | GRANT copy_job_privilege_list ON copy_job_target TO grantee_list + ; + +copy_job_privilege_list + : copy_job_privilege (COMMA copy_job_privilege)* + | all_privileges + ; + +copy_job_privilege + : ALTER + | DROP + ; + +copy_job_target + : COPY JOB copy_job_name (COMMA copy_job_name)* + ; + +copy_job_name + : colid + ; + +language_privilege_list + : USAGE + ; + +grant_language_target + : LANGUAGE columnlist + ; + +grant_procedure_target + : PROCEDURE function_with_argtypes_list (COMMA function_with_argtypes_list)* + | ALL PROCEDURES IN_P SCHEMA columnlist + ; + +procedure_privilege_list + : procedure_privilege + | all_privileges + ; + +procedure_privilege + : EXECUTE + | all_privileges + ; + +function_privilege_list + : function_privilege + | all_privileges + ; + +function_privilege + : EXECUTE + | all_privileges + ; + +grant_function_target + : FUNCTION function_with_argtypes_list (COMMA function_with_argtypes_list)* + | ALL FUNCTIONS IN_P SCHEMA columnlist + ; + +grant_schema_target + : SCHEMA colid (COMMA colid)* + ; + +revoke_schema_target + : SCHEMA (IF_P EXISTS)? colid (COMMA colid)* + ; + +schema_privilege_list + : schema_privilege (COMMA schema_privilege)* + | all_privileges + ; + +schema_privilege + : CREATE + | USAGE + | ALTER + | DROP + ; + +database_privilege_list + : database_privilege (COMMA database_privilege)* + | all_privileges + ; + +database_privilege + : CREATE + | USAGE + | TEMPORARY + | TEMP + | ALTER + ; + +grant_database_target + : DATABASE colid (COMMA colid)* + ; + + +grant_table_target + : TABLE? qualified_name_list + | all_tables_in_schema_list + ; + +revoke_table_target + : TABLE? (IF_P EXISTS)? qualified_name_list + | all_tables_in_schema_list + ; + +all_tables_in_schema_list + : ALL TABLES IN_P SCHEMA qualified_name_list + ; + +all_privileges + : ALL PRIVILEGES? + ; + +grantee_list + : grantee (COMMA grantee)* + ; + +grantee + : rolespec opt_with_grant_option? + | GROUP_P rolespec + | ROLE rolespec + | PUBLIC + ; + +opt_with_grant_option + : WITH GRANT OPTION + ; + +table_privilege + : SELECT + | INSERT + | UPDATE + | DELETE_P + | DROP + | ALTER + | TRUNCATE + | REFERENCES + ; + +table_privilege_list + : table_privilege (COMMA table_privilege)* + | all_privileges + ; + +revokestmt + : common_revoke + | revoke_column_level_permissions + | revoke_assume_role_permissions + | revoke_spectrum_integration_permissions + | revoke_datashare_permissions + | revoke_scoped_permissions + | revoke_machine_learning_permissions + | revoke_role_permissions + | revoke_explain_permissions_for_row_level_security_policy_filters + | revoke_permissions_for_rls_lookup_tables + ; + +revoke_permissions_for_rls_lookup_tables + : REVOKE SELECT ON TABLE? qualified_name_list FROM RLS POLICY columnlist opt_drop_behavior? + ; + +revoke_explain_permissions_for_row_level_security_policy_filters + : REVOKE (EXPLAIN | IGNORE) RLS FROM ROLE rolespec opt_drop_behavior? + ; + +revoke_machine_learning_permissions + : REVOKE CREATE MODEL FROM grantee_list opt_drop_behavior? + | REVOKE function_privilege_list ON MODEL columnlist FROM grantee_list opt_drop_behavior? + ; + +revoke_role_permissions + : REVOKE ROLE rolespec (COMMA ROLE rolespec)* FROM grant_role_permission_target_list opt_drop_behavior? + | REVOKE system_permissions FROM ROLE role_list opt_drop_behavior? + | REVOKE ADMIN OPTION FOR ROLE rolespec (COMMA ROLE rolespec)* FROM grant_role_permission_target_list opt_drop_behavior? + ; + +revoke_scoped_permissions + : revoke_scoped_schemas_permissions + | revoke_scoped_tables_permissions + | revoke_scoped_functions_permissions + | revoke_scoped_procedures_permissions + | revoke_scoped_languages_permissions + | revoke_scoped_copy_jobs_permissions + ; + +revoke_scoped_schemas_permissions + : REVOKE schema_privilege_list FOR SCHEMAS IN_P DATABASE colid FROM grantee_list_without_public opt_drop_behavior? + ; + +revoke_scoped_tables_permissions + : REVOKE table_privilege_list FOR TABLES IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) FROM grantee_list_without_public opt_drop_behavior? + ; + +revoke_scoped_functions_permissions + : REVOKE function_privilege_list FOR FUNCTIONS IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) FROM grantee_list_without_public opt_drop_behavior? + ; + +revoke_scoped_procedures_permissions + : REVOKE procedure_privilege_list FOR PROCEDURES IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) FROM grantee_list_without_public opt_drop_behavior? + ; + +revoke_scoped_languages_permissions + : REVOKE language_privilege_list FOR LANGUAGES IN_P DATABASE colid FROM grantee_list_without_public opt_drop_behavior? + ; + +revoke_scoped_copy_jobs_permissions + : REVOKE copy_job_privilege_list FOR COPY JOBS IN_P ((SCHEMA colid (DATABASE colid)?) | (DATABASE colid) ) FROM grantee_list_without_public opt_drop_behavior? + ; + +revoke_datashare_permissions + : REVOKE (GRANT OPTION FOR)? (ALTER | SHARE) ON DATASHARE colid FROM grantee_list opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? USAGE ON DATASHARE colid FROM ((NAMESPACE sconst) | (ACCOUNT sconst (VIA DATA_CATALOG)?)) opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? USAGE ON (DATABASE columnlist | SCHEMA colid) FROM grantee_list opt_drop_behavior? + ; + +revoke_spectrum_integration_permissions + : revoke_spectrum_integration_extenral_column_permissions + | revoke_spectrum_integration_external_table_permissions + | revoke_spectrum_integration_external_schema_permissions + ; + +revoke_spectrum_integration_external_schema_permissions + : REVOKE spectrum_integration_external_schema_permission_list ON EXTERNAL SCHEMA columnlist FROM iamrolelist opt_drop_behavior? + ; + +revoke_spectrum_integration_external_table_permissions + : REVOKE spectrum_integration_external_table_permission_list ON EXTERNAL TABLE qualified_name_list FROM iamrolelist_or_public opt_drop_behavior? + ; + +revoke_spectrum_integration_extenral_column_permissions + : REVOKE (SELECT | all_privileges) OPEN_PAREN columnlist CLOSE_PAREN ON EXTERNAL TABLE qualified_name FROM iamrolelist opt_drop_behavior? + ; + +revoke_assume_role_permissions + : REVOKE ASSUMEROLE grant_assume_role_target FROM grantee_list FOR grant_assume_role_for_list opt_drop_behavior? + ; + +revoke_column_level_permissions + : REVOKE column_privilege_list ON column_privilege_target FROM grantee_list opt_drop_behavior? + | REVOKE GRANT OPTION FOR column_privilege_list ON column_privilege_target FROM grantee_list opt_drop_behavior? + ; + +common_revoke + : REVOKE (GRANT OPTION FOR)? table_privilege_list ON revoke_table_target FROM grantee_list opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? database_privilege_list ON grant_database_target FROM grantee_list opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? schema_privilege_list ON revoke_schema_target FROM grantee_list opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? function_privilege_list ON grant_function_target FROM grantee_list opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? procedure_privilege_list ON grant_procedure_target FROM grantee_list opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? language_privilege_list ON grant_language_target FROM grantee_list opt_drop_behavior? + | REVOKE (GRANT OPTION FOR)? copy_job_privilege_list ON copy_job_target FROM grantee_list opt_drop_behavior? + ; + +privileges + : privilege_list + | ALL + | ALL PRIVILEGES + | ALL OPEN_PAREN columnlist CLOSE_PAREN + | ALL PRIVILEGES OPEN_PAREN columnlist CLOSE_PAREN + ; + +privilege_list + : privilege (COMMA privilege)* + ; + +privilege + : SELECT opt_column_list? + | REFERENCES opt_column_list? + | CREATE opt_column_list? + | ALTER SYSTEM_P + | colid opt_column_list? + ; + +privilege_target + : qualified_name_list + | TABLE qualified_name_list + | SEQUENCE qualified_name_list + | FOREIGN DATA_P WRAPPER name_list + | FOREIGN SERVER name_list + | FUNCTION function_with_argtypes_list + | PROCEDURE function_with_argtypes_list + | ROUTINE function_with_argtypes_list + | DATABASE name_list + | DOMAIN_P any_name_list + | LANGUAGE name_list + | LARGE_P OBJECT_P numericonly_list + | PARAMETER parameter_name_list + | SCHEMA name_list + | TABLESPACE name_list + | TYPE_P any_name_list + | ALL TABLES IN_P SCHEMA name_list + | ALL SEQUENCES IN_P SCHEMA name_list + | ALL FUNCTIONS IN_P SCHEMA name_list + | ALL PROCEDURES IN_P SCHEMA name_list + | ALL ROUTINES IN_P SCHEMA name_list + ; + +parameter_name_list + : parameter_name (COMMA parameter_name)* + ; + +parameter_name + : colid (DOT colid)? + ; + +opt_grant_grant_option + : WITH GRANT OPTION + ; + +grantrolestmt + : GRANT privilege_list TO role_list opt_grant_admin_option? opt_granted_by? + ; + +revokerolestmt + : REVOKE privilege_list FROM role_list opt_granted_by? opt_drop_behavior? + | REVOKE ADMIN OPTION FOR privilege_list FROM role_list opt_granted_by? opt_drop_behavior? + ; + +opt_grant_admin_option + : WITH ADMIN OPTION + ; + +opt_granted_by + : GRANTED BY rolespec + ; + +alterdefaultprivilegesstmt + : ALTER DEFAULT PRIVILEGES defacloptionlist defaclaction + ; + +defacloptionlist + : defacloption* + ; + +defacloption + : IN_P SCHEMA name_list + | FOR ROLE role_list + | FOR USER role_list + ; + +defaclaction + : GRANT privileges ON defacl_privilege_target TO grantee_list opt_grant_grant_option? + | REVOKE privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior? + | REVOKE GRANT OPTION FOR privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior? + ; + +defacl_privilege_target + : TABLES + | FUNCTIONS + | PROCEDURES + | ROUTINES + | SEQUENCES + | TYPES_P + | SCHEMAS + ; + //create index + +indexstmt + : CREATE opt_unique? INDEX opt_concurrently? ((IF_P NOT EXISTS)? name)? ON relation_expr access_method_clause? OPEN_PAREN index_params CLOSE_PAREN opt_include? opt_unique_null_treatment? opt_reloptions? opttablespace? where_clause? + ; + +opt_unique + : UNIQUE + ; + +opt_concurrently + : CONCURRENTLY + ; + +opt_index_name + : name + ; + +access_method_clause + : USING name + ; + +index_params + : index_elem (COMMA index_elem)* + ; + +index_elem_options + : opt_collate? opt_class? opt_asc_desc? opt_nulls_order? + | opt_collate? any_name reloptions opt_asc_desc? opt_nulls_order? + ; + +index_elem + : colid index_elem_options + | func_expr_windowless index_elem_options + | OPEN_PAREN a_expr CLOSE_PAREN index_elem_options + ; + +opt_include + : INCLUDE OPEN_PAREN index_including_params CLOSE_PAREN + ; + +index_including_params + : index_elem (COMMA index_elem)* + ; + +opt_collate + : COLLATE any_name + ; + +opt_class + : any_name + ; + +opt_asc_desc + : ASC + | DESC + ; + //TOD NULLS_LA was used + +opt_nulls_order + : NULLS_P FIRST_P + | NULLS_P LAST_P + ; + +createfunctionstmt + : CREATE opt_or_replace? FUNCTION func_name func_py_args_or_sql_args + ( + RETURNS (func_return | TABLE OPEN_PAREN table_func_column_list CLOSE_PAREN) + )? + (VOLATILE | STABLE | IMMUTABLE) + createfunc_opt_list + ; + +createprocedurestmt + : CREATE opt_or_replace? PROCEDURE func_name func_args + ( + RETURNS (func_return | TABLE OPEN_PAREN table_func_column_list CLOSE_PAREN) + )? + opt_nonatomic? + createfunc_opt_list; + +opt_nonatomic + : NONATOMIC + ; + +opt_or_replace + : OR REPLACE + ; + +func_py_args_or_sql_args + : OPEN_PAREN func_py_args_or_sql_args_list? CLOSE_PAREN + ; + +func_py_args_or_sql_args_list + : param_name func_type (COMMA param_name func_type)* + | func_type (COMMA func_type)* + ; + +func_args + : OPEN_PAREN func_args_list? CLOSE_PAREN + ; + +func_args_list + : func_arg (COMMA func_arg)* + ; + +function_with_argtypes_list + : function_with_argtypes (COMMA function_with_argtypes)* + ; + +function_with_argtypes + : func_name func_args + | type_func_name_keyword + | colid indirection? + ; + +func_args_with_defaults + : OPEN_PAREN func_args_with_defaults_list? CLOSE_PAREN + ; + +func_args_with_defaults_list + : func_arg_with_default (COMMA func_arg_with_default)* + ; + +func_arg + : arg_class param_name? func_type + | param_name arg_class? func_type + | func_type + ; + +arg_class + : IN_P + | OUT_P + | INOUT + ; + +param_name + : type_function_name + | builtin_function_name + | LEFT + | RIGHT + ; + +func_return + : func_type + ; + +func_type + : typename + | SETOF? (builtin_function_name | type_function_name | LEFT | RIGHT) attrs PERCENT TYPE_P + ; + +func_arg_with_default + : func_arg ((DEFAULT | EQUAL) a_expr)? + ; + +aggr_arg + : func_arg + ; + +aggr_args + : OPEN_PAREN (STAR | aggr_args_list | ORDER BY aggr_args_list | aggr_args_list ORDER BY aggr_args_list) CLOSE_PAREN + ; + +aggr_args_list + : aggr_arg (COMMA aggr_arg)* + ; + +aggregate_with_argtypes + : func_name aggr_args + ; + +aggregate_with_argtypes_list + : aggregate_with_argtypes (COMMA aggregate_with_argtypes)* + ; + +createfunc_opt_list + : createfunc_opt_item+ + { + p.ParseRoutineBody(localctx); + } + // | createfunc_opt_list createfunc_opt_item + + ; + +common_func_opt_item + : CALLED ON NULL_P INPUT_P + | RETURNS NULL_P ON NULL_P INPUT_P + | STRICT_P + | IMMUTABLE + | STABLE + | VOLATILE + | EXTERNAL SECURITY DEFINER + | EXTERNAL SECURITY INVOKER + | SECURITY DEFINER + | SECURITY INVOKER + | LEAKPROOF + | NOT LEAKPROOF + | COST numericonly + | ROWS numericonly + | SUPPORT any_name + | functionsetresetclause + | PARALLEL colid + ; + +createfunc_opt_item + : AS func_as + | BEGIN_P ATOMIC_P stmtmulti END_P + | LANGUAGE nonreservedword_or_sconst + | TRANSFORM transform_type_list + | WINDOW + | common_func_opt_item + ; + //https://www.postgresql.org/docs/9.1/sql-createfunction.html + + // | AS 'definition' + + // | AS 'obj_file', 'link_symbol' + +func_as locals[antlr.ParserRuleContext Definition] + : + /* |AS 'definition'*/ + def = sconst + /*| AS 'obj_file', 'link_symbol'*/ + | sconst COMMA sconst + ; + +transform_type_list + :FOR TYPE_P typename (COMMA FOR TYPE_P typename)* + ; + +opt_definition + : WITH definition + ; + +table_func_column + : param_name func_type + ; + +table_func_column_list + : table_func_column (COMMA table_func_column)* + ; + +alterfunctionstmt + : ALTER FUNCTION func_name func_py_args_or_sql_args ((RENAME TO func_name) | (OWNER TO rolespec)) + ; + +alterprocedurestmt + : ALTER PROCEDURE func_name func_args ((RENAME TO func_name) | (OWNER TO rolespec)) + ; + +alterfunc_opt_list + : common_func_opt_item+ + ; + +opt_restrict + : RESTRICT + ; + +removefuncstmt + : DROP FUNCTION function_with_argtypes_list opt_drop_behavior? + | DROP FUNCTION IF_P EXISTS function_with_argtypes_list opt_drop_behavior? + | DROP PROCEDURE function_with_argtypes_list opt_drop_behavior? + | DROP PROCEDURE IF_P EXISTS function_with_argtypes_list opt_drop_behavior? + | DROP ROUTINE function_with_argtypes_list opt_drop_behavior? + | DROP ROUTINE IF_P EXISTS function_with_argtypes_list opt_drop_behavior? + ; + +removeaggrstmt + : DROP AGGREGATE aggregate_with_argtypes_list opt_drop_behavior? + | DROP AGGREGATE IF_P EXISTS aggregate_with_argtypes_list opt_drop_behavior? + ; + +removeoperstmt + : DROP OPERATOR operator_with_argtypes_list opt_drop_behavior? + | DROP OPERATOR IF_P EXISTS operator_with_argtypes_list opt_drop_behavior? + ; + +oper_argtypes + : OPEN_PAREN typename CLOSE_PAREN + | OPEN_PAREN typename COMMA typename CLOSE_PAREN + | OPEN_PAREN NONE COMMA typename CLOSE_PAREN + | OPEN_PAREN typename COMMA NONE CLOSE_PAREN + ; + +any_operator + : (colid DOT)* all_op + ; + +operator_with_argtypes_list + : operator_with_argtypes (COMMA operator_with_argtypes)* + ; + +operator_with_argtypes + : any_operator oper_argtypes + ; + +dostmt + : DO dostmt_opt_list + ; + +dostmt_opt_list + : dostmt_opt_item+ + ; + +dostmt_opt_item + : sconst + | LANGUAGE nonreservedword_or_sconst + ; + +createcaststmt + : CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITH FUNCTION function_with_argtypes cast_context? + | CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITHOUT FUNCTION cast_context? + | CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITH INOUT cast_context? + ; + +cast_context + : AS IMPLICIT_P + | AS ASSIGNMENT + ; + +dropcaststmt + : DROP CAST opt_if_exists? OPEN_PAREN typename AS typename CLOSE_PAREN opt_drop_behavior? + ; + +opt_if_exists + : IF_P EXISTS + ; + +createtransformstmt + : CREATE opt_or_replace? TRANSFORM FOR typename LANGUAGE name OPEN_PAREN transform_element_list CLOSE_PAREN + ; + +transform_element_list + : FROM SQL_P WITH FUNCTION function_with_argtypes COMMA TO SQL_P WITH FUNCTION function_with_argtypes + | TO SQL_P WITH FUNCTION function_with_argtypes COMMA FROM SQL_P WITH FUNCTION function_with_argtypes + | FROM SQL_P WITH FUNCTION function_with_argtypes + | TO SQL_P WITH FUNCTION function_with_argtypes + ; + +droptransformstmt + : DROP TRANSFORM opt_if_exists? FOR typename LANGUAGE name opt_drop_behavior? + ; + +reindexstmt + : REINDEX reindex_target_type opt_concurrently? qualified_name + | REINDEX reindex_target_multitable opt_concurrently? name + | REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_type opt_concurrently? qualified_name + | REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_multitable opt_concurrently? name + ; + +reindex_target_type + : INDEX + | TABLE + | SCHEMA + | DATABASE + | SYSTEM_P + ; + +reindex_target_multitable + : SCHEMA + | SYSTEM_P + | DATABASE + ; + +reindex_option_list + : reindex_option_elem (COMMA reindex_option_elem)* + ; + +reindex_option_elem + : VERBOSE + | TABLESPACE + | CONCURRENTLY + ; + +altertblspcstmt + : ALTER TABLESPACE name SET reloptions + | ALTER TABLESPACE name RESET reloptions + ; + +renamestmt + : ALTER AGGREGATE aggregate_with_argtypes RENAME TO name + | ALTER COLLATION any_name RENAME TO name + | ALTER CONVERSION_P any_name RENAME TO name + | ALTER DATABASE name RENAME TO name + | ALTER DOMAIN_P any_name RENAME TO name + | ALTER DOMAIN_P any_name RENAME CONSTRAINT name TO name + | ALTER FOREIGN DATA_P WRAPPER name RENAME TO name + | ALTER FUNCTION function_with_argtypes RENAME TO name + | ALTER GROUP_P roleid RENAME TO roleid + | ALTER opt_procedural? LANGUAGE name RENAME TO name + | ALTER OPERATOR CLASS any_name USING name RENAME TO name + | ALTER OPERATOR FAMILY any_name USING name RENAME TO name + | ALTER POLICY name ON qualified_name RENAME TO name + | ALTER POLICY IF_P EXISTS name ON qualified_name RENAME TO name + | ALTER PROCEDURE function_with_argtypes RENAME TO name + | ALTER PUBLICATION name RENAME TO name + | ALTER ROUTINE function_with_argtypes RENAME TO name + | ALTER SCHEMA name RENAME TO name + | ALTER SERVER name RENAME TO name + | ALTER SUBSCRIPTION name RENAME TO name + | ALTER TABLE relation_expr RENAME TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME TO name + | ALTER SEQUENCE qualified_name RENAME TO name + | ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name + | ALTER VIEW qualified_name RENAME TO name + | ALTER VIEW IF_P EXISTS qualified_name RENAME TO name + | ALTER MATERIALIZED VIEW qualified_name RENAME TO name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME TO name + | ALTER INDEX qualified_name RENAME TO name + | ALTER INDEX IF_P EXISTS qualified_name RENAME TO name + | ALTER FOREIGN TABLE relation_expr RENAME TO name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME TO name + | ALTER TABLE relation_expr RENAME opt_column? name TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column? name TO name + | ALTER VIEW qualified_name RENAME opt_column? name TO name + | ALTER VIEW IF_P EXISTS qualified_name RENAME opt_column? name TO name + | ALTER MATERIALIZED VIEW qualified_name RENAME opt_column? name TO name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME opt_column? name TO name + | ALTER TABLE relation_expr RENAME CONSTRAINT name TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name + | ALTER FOREIGN TABLE relation_expr RENAME opt_column? name TO name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME opt_column? name TO name + | ALTER RULE name ON qualified_name RENAME TO name + | ALTER TRIGGER name ON qualified_name RENAME TO name + | ALTER EVENT TRIGGER name RENAME TO name + | ALTER ROLE roleid RENAME TO roleid + | ALTER USER roleid RENAME TO roleid + | ALTER TABLESPACE name RENAME TO name + | ALTER STATISTICS any_name RENAME TO name + | ALTER TEXT_P SEARCH PARSER any_name RENAME TO name + | ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name + | ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name + | ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name + | ALTER TYPE_P any_name RENAME TO name + | ALTER TYPE_P any_name RENAME ATTRIBUTE name TO name opt_drop_behavior? + ; + +opt_column + : COLUMN + ; + +opt_set_data + : SET DATA_P + ; + +alterobjectdependsstmt + : ALTER FUNCTION function_with_argtypes opt_no? DEPENDS ON EXTENSION name + | ALTER PROCEDURE function_with_argtypes opt_no? DEPENDS ON EXTENSION name + | ALTER ROUTINE function_with_argtypes opt_no? DEPENDS ON EXTENSION name + | ALTER TRIGGER name ON qualified_name opt_no? DEPENDS ON EXTENSION name + | ALTER MATERIALIZED VIEW qualified_name opt_no? DEPENDS ON EXTENSION name + | ALTER INDEX qualified_name opt_no? DEPENDS ON EXTENSION name + ; + +opt_no + : NO + ; + +alterobjectschemastmt + : ALTER AGGREGATE aggregate_with_argtypes SET SCHEMA name + | ALTER COLLATION any_name SET SCHEMA name + | ALTER CONVERSION_P any_name SET SCHEMA name + | ALTER DOMAIN_P any_name SET SCHEMA name + | ALTER EXTENSION name SET SCHEMA name + | ALTER FUNCTION function_with_argtypes SET SCHEMA name + | ALTER OPERATOR operator_with_argtypes SET SCHEMA name + | ALTER OPERATOR CLASS any_name USING name SET SCHEMA name + | ALTER OPERATOR FAMILY any_name USING name SET SCHEMA name + | ALTER PROCEDURE function_with_argtypes SET SCHEMA name + | ALTER ROUTINE function_with_argtypes SET SCHEMA name + | ALTER TABLE relation_expr SET SCHEMA name + | ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name + | ALTER STATISTICS any_name SET SCHEMA name + | ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name + | ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name + | ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name + | ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name + | ALTER SEQUENCE qualified_name SET SCHEMA name + | ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name + | ALTER VIEW qualified_name SET SCHEMA name + | ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name + | ALTER MATERIALIZED VIEW qualified_name SET SCHEMA name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name SET SCHEMA name + | ALTER FOREIGN TABLE relation_expr SET SCHEMA name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr SET SCHEMA name + | ALTER TYPE_P any_name SET SCHEMA name + ; + +alteroperatorstmt + : ALTER OPERATOR operator_with_argtypes SET OPEN_PAREN operator_def_list CLOSE_PAREN + ; + +operator_def_list + : operator_def_elem (COMMA operator_def_elem)* + ; + +operator_def_elem + : collabel EQUAL NONE + | collabel EQUAL operator_def_arg + ; + +operator_def_arg + : func_type + | reserved_keyword + | qual_all_op + | numericonly + | sconst + ; + +altertypestmt + : ALTER TYPE_P any_name SET OPEN_PAREN operator_def_list CLOSE_PAREN + ; + +alterownerstmt + : ALTER AGGREGATE aggregate_with_argtypes OWNER TO rolespec + | ALTER COLLATION any_name OWNER TO rolespec + | ALTER CONVERSION_P any_name OWNER TO rolespec + | ALTER DATABASE name OWNER TO rolespec + | ALTER DOMAIN_P any_name OWNER TO rolespec + | ALTER FUNCTION function_with_argtypes OWNER TO rolespec + | ALTER opt_procedural? LANGUAGE name OWNER TO rolespec + | ALTER LARGE_P OBJECT_P numericonly OWNER TO rolespec + | ALTER OPERATOR operator_with_argtypes OWNER TO rolespec + | ALTER OPERATOR CLASS any_name USING name OWNER TO rolespec + | ALTER OPERATOR FAMILY any_name USING name OWNER TO rolespec + | ALTER PROCEDURE function_with_argtypes OWNER TO rolespec + | ALTER ROUTINE function_with_argtypes OWNER TO rolespec + | ALTER SCHEMA name OWNER TO rolespec + | ALTER TYPE_P any_name OWNER TO rolespec + | ALTER TABLESPACE name OWNER TO rolespec + | ALTER STATISTICS any_name OWNER TO rolespec + | ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO rolespec + | ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO rolespec + | ALTER FOREIGN DATA_P WRAPPER name OWNER TO rolespec + | ALTER SERVER name OWNER TO rolespec + | ALTER EVENT TRIGGER name OWNER TO rolespec + | ALTER PUBLICATION name OWNER TO rolespec + | ALTER SUBSCRIPTION name OWNER TO rolespec + ; + +createpublicationstmt + : CREATE PUBLICATION name opt_definition? + | CREATE PUBLICATION name FOR ALL TABLES opt_definition? + | CREATE PUBLICATION name FOR pub_obj_list opt_definition? + ; + +pub_obj_list + : publication_obj_spec (COMMA publication_obj_spec)* + ; + +publication_obj_spec + : TABLE relation_expr opt_column_list? opt_where_clause? + | TABLE IN_P SCHEMA (colid | CURRENT_SCHEMA) + | colid opt_column_list? opt_where_clause? + | colid indirection opt_column_list? opt_where_clause? + | relation_expr opt_column_list? opt_where_clause? + | CURRENT_SCHEMA + ; + +opt_where_clause + : WHERE OPEN_PAREN a_expr CLOSE_PAREN + ; + +alterpublicationstmt + : ALTER PUBLICATION name SET definition + | ALTER PUBLICATION name ADD_P pub_obj_list + | ALTER PUBLICATION name SET pub_obj_list + | ALTER PUBLICATION name DROP pub_obj_list + ; + +createsubscriptionstmt + : CREATE SUBSCRIPTION name CONNECTION sconst PUBLICATION publication_name_list opt_definition? + ; + +publication_name_list + : publication_name_item (COMMA publication_name_item)* + ; + +publication_name_item + : collabel + ; + +altersubscriptionstmt + : ALTER SUBSCRIPTION name SET definition + | ALTER SUBSCRIPTION name CONNECTION sconst + | ALTER SUBSCRIPTION name REFRESH PUBLICATION opt_definition? + | ALTER SUBSCRIPTION name SET PUBLICATION publication_name_list opt_definition? + | ALTER SUBSCRIPTION name ENABLE_P + | ALTER SUBSCRIPTION name DISABLE_P + | ALTER SUBSCRIPTION name SKIP_P definition + ; + +dropsubscriptionstmt + : DROP SUBSCRIPTION name opt_drop_behavior? + | DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior? + ; + +rulestmt + : CREATE opt_or_replace? RULE name AS ON event TO qualified_name where_clause? DO opt_instead? ruleactionlist + ; + +ruleactionlist + : NOTHING + | ruleactionstmt + | OPEN_PAREN ruleactionmulti CLOSE_PAREN + ; + +ruleactionmulti + : ruleactionstmtOrEmpty? (SEMI ruleactionstmtOrEmpty?)* + ; + +ruleactionstmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + | notifystmt + ; + +ruleactionstmtOrEmpty + : ruleactionstmt + ; + +event + : SELECT + | UPDATE + | DELETE_P + | INSERT + ; + +opt_instead + : INSTEAD + | ALSO + ; + +notifystmt + : NOTIFY colid notify_payload? + ; + +notify_payload + : COMMA sconst + ; + +listenstmt + : LISTEN colid + ; + +unlistenstmt + : UNLISTEN colid + | UNLISTEN STAR + ; + +transactionstmt + : ABORT_P opt_transaction? opt_transaction_chain? + | BEGIN_P opt_transaction? transaction_mode_list_or_empty? + | START TRANSACTION transaction_mode_list_or_empty? + | COMMIT opt_transaction? opt_transaction_chain? + | END_P opt_transaction? opt_transaction_chain? + | ROLLBACK opt_transaction? opt_transaction_chain? + | SAVEPOINT colid + | RELEASE SAVEPOINT colid + | RELEASE colid + | ROLLBACK opt_transaction? TO SAVEPOINT colid + | ROLLBACK opt_transaction? TO colid + | PREPARE TRANSACTION sconst + | COMMIT PREPARED sconst + | ROLLBACK PREPARED sconst + ; + +opt_transaction + : WORK + | TRANSACTION + ; + +transaction_mode_item + : ISOLATION LEVEL iso_level + | READ ONLY + | READ WRITE + | DEFERRABLE + | NOT DEFERRABLE + ; + +transaction_mode_list + : transaction_mode_item (COMMA? transaction_mode_item)* + ; + +transaction_mode_list_or_empty + : transaction_mode_list + ; + +opt_transaction_chain + : AND NO? CHAIN + ; + +viewstmt + : CREATE (OR REPLACE)? opttemp? + ( + VIEW qualified_name opt_column_list? opt_reloptions? + | RECURSIVE VIEW qualified_name OPEN_PAREN columnlist CLOSE_PAREN opt_reloptions? + ) + AS selectstmt opt_check_option? with_no_schema_binding? + ; + +with_no_schema_binding + : WITH NO SCHEMA BINDING + ; + +opt_check_option + : WITH (CASCADED | LOCAL)? CHECK OPTION + ; + +loadstmt + : LOAD file_name + ; + +// ============================================================================== +// REDSHIFT-SPECIFIC STATEMENTS +// These statements are specific to Amazon Redshift and not part of PostgreSQL +// ============================================================================== + +// DATASHARE statements +alterdatasharestmt + : ALTER DATASHARE colid alterdatashare_action + ; + +alterdatashare_action + : alterdatashare_add_drop alterdatashare_objects + | SET PUBLICACCESSIBLE opt_equal? opt_boolean_or_string + | SET INCLUDENEW opt_equal? opt_boolean_or_string FOR SCHEMA colid + ; + +alterdatashare_add_drop + : ADD_P + | REMOVE + ; + +alterdatashare_objects + : TABLE datashare_table_list + | SCHEMA name_list + | FUNCTION datashare_function_list + | ALL TABLES IN_P SCHEMA name_list + | ALL FUNCTIONS IN_P SCHEMA name_list + ; + +datashare_table_list + : datashare_table_name (COMMA datashare_table_name)* + ; + +datashare_table_name + : colid (DOT colid)? + ; + +table_name + : qualified_name + | temporary_table_name + ; + +temporary_table_name + : TemporaryIdentifier + ; + +datashare_function_list + : datashare_function (COMMA datashare_function)* + ; + +datashare_function + : datashare_function_name func_args + ; + +datashare_function_name + : colid (DOT colid)? + ; + +createdatasharestmt + : CREATE DATASHARE qualified_name createdatashareoptions? + ; + +createdatashareoptions + : createdatashareoption (COMMA createdatashareoption)* + ; + +createdatashareoption + : setpublicaccessibleoption + | managedbyoption + ; + +setpublicaccessibleoption + : SET? PUBLICACCESSIBLE (EQUAL? (TRUE_P | FALSE_P))? + ; + +managedbyoption + : MANAGEDBY ADX + ; + +descdatasharestmt + : (DESC | DESCRIBE) DATASHARE datashare_name=colid (OF (ACCOUNT account_id=sconst)? NAMESPACE namespace_guid=sconst)? + ; + +dropdatasharestmt + : DROP DATASHARE opt_if_exists? colid + ; + +// EXTERNAL statements +alterexternalschemastmt + : ALTER EXTERNAL SCHEMA colid altexternalschemaopts+ + ; + +altexternalschemaopts + : RENAME TO colid + | OWNER TO colid + | IAM_ROLE (DEFAULT | SESSION | sconst) + | AUTHENTICATION (NONE | IAM | MTLS) + | AUTHENTICATION_ARN sconst + | SECRET_ARN sconst + | URI sconst + ; + +alterexternalviewstmt + : ALTER EXTERNAL VIEW qualified_name FORCE? ((AS selectstmt) | (REMOVE DEFINITION))? + ; + +createexternalschemastmt + : CREATE EXTERNAL SCHEMA opt_if_not_exists? schema_name=colid + ( fromdatacatalogclause + | fromhivemetastoreclause + | frompostgresclause + | frommysqlclause + | fromkinesisclause + | fromkafkaclause + | frommskclause + | fromredshiftclause + | implicitdatacatalogclause // Support implicit data catalog + ) + ; + +// External schema FROM clauses +fromdatacatalogclause + : FROM (DATA_P CATALOG | DATA_CATALOG) + DATABASE sconst + colid sconst // REGION AS literal + IAM_ROLE iamrolevalue + (CATALOG_ROLE catalogrolevalue)? + (CREATE EXTERNAL DATABASE opt_if_not_exists)? + (CATALOG_ID sconst)? + ; + +dropschemastmt: + DROP SCHEMA opt_if_exists? qualified_name (COMMA qualified_name)* (DROP EXTERNAL DATABASE)? (CASCADE | RESTRICT)?; + +// Implicit data catalog clause (without explicit DATA CATALOG keywords) +implicitdatacatalogclause + : FROM DATABASE sconst + colid sconst // REGION AS literal + IAM_ROLE iamrolevalue + (CATALOG_ROLE catalogrolevalue)? + (CREATE EXTERNAL DATABASE opt_if_not_exists)? + (CATALOG_ID sconst)? + ; + +fromhivemetastoreclause + : FROM HIVE METASTORE + DATABASE sconst + URI sconst + (PORT iconst)? + IAM_ROLE sconst + ; + +frompostgresclause + : FROM POSTGRES + DATABASE sconst + (SCHEMA sconst)? + URI sconst + (PORT iconst)? + IAM_ROLE iamrolevalue + SECRET_ARN sconst + ; + +frommysqlclause + : FROM MYSQL + DATABASE sconst + URI sconst + (PORT iconst)? + IAM_ROLE iamrolevalue + SECRET_ARN sconst + ; + +fromkinesisclause + : FROM KINESIS + IAM_ROLE iamrolevalue + ; + +fromkafkaclause + : FROM KAFKA + IAM_ROLE iamrolevalue + (URI sconst)? + (AUTHENTICATION authenticationvalue)? + (AUTHENTICATION_ARN sconst)? + ; + +frommskclause + : FROM MSK + IAM_ROLE iamrolevalue + (URI sconst)? + (AUTHENTICATION authenticationvalue)? + (AUTHENTICATION_ARN sconst)? + ; + +fromredshiftclause + : FROM REDSHIFT + DATABASE sconst + (SCHEMA sconst)? + (colid sconst)? // REGION 'region-name' + (IAM_ROLE iamrolevalue)? + ; + +iamrolevalue + : DEFAULT + | SESSION_TOKEN + | sconst + ; + +catalogrolevalue + : SESSION_TOKEN + | sconst + ; + +authenticationvalue + : NONE + | IAM + | MTLS + ; + +createexternalfunctionstmt + : CREATE (OR REPLACE)? EXTERNAL FUNCTION function_name=qualified_name '(' external_func_params? ')' + RETURNS typename + (STABLE | IMMUTABLE | VOLATILE) + LAMBDA sconst + IAM_ROLE iamrolevalue + (RETRY_TIMEOUT iconst)? + (MAX_BATCH_ROWS iconst)? + (MAX_BATCH_SIZE iconst (KB | MB)?)? + ; + +external_func_params + : typename (',' typename)* + ; + +paramlist + : param_spec (',' param_spec)* + | + ; + +param_spec + : paramname=colid typename + ; + +createexternalmodelstmt + : CREATE EXTERNAL MODEL qualified_name + FROM sconst // S3 path + (FUNCTION_NAME qualified_name)? + IAM_ROLE iamrolevalue + (SETTINGS '(' settingsclause ')')? + | CREATE EXTERNAL MODEL qualified_name + FUNCTION qualified_name + IAM_ROLE iamrolevalue + MODEL_TYPE BEDROCK + SETTINGS '(' settingsclause ')' + ; + +createexternaltablestmt + : CREATE EXTERNAL TABLE opt_if_not_exists? qualified_name '(' extern_column_list ')' + (PARTITIONED BY '(' extern_column_list ')')? + extern_table_format + LOCATION sconst + (TABLE PROPERTIES '(' table_properties_list ')')? + ; + +extern_column_list + : extern_column_def (',' extern_column_def)* + ; + +extern_column_def + : colid extern_typename + ; + +extern_typename + : typename + | STRING // Support STRING type + ; + +extern_table_format + : STORED AS external_format_spec + | row_format_spec STORED AS external_format_spec + | STORED AS INPUTFORMAT sconst OUTPUTFORMAT sconst + ; + +row_format_spec + : ROW FORMAT DELIMITED + (FIELDS TERMINATED BY sconst (ESCAPED BY sconst)?)? + (COLLECTION ITEMS TERMINATED BY sconst)? + (MAP KEYS TERMINATED BY sconst)? + (LINES TERMINATED BY sconst)? + (NULL_P DEFINED AS sconst)? + | ROW FORMAT SERDE sconst (WITH SERDEPROPERTIES '(' serde_properties_list ')')? + ; + +serde_properties_list + : serde_property (',' serde_property)* + ; + +serde_property + : sconst '=' sconst + ; + +external_format_spec + : PARQUET + | AVRO + | RCFILE + | SEQUENCEFILE + | TEXTFILE + | ORC + | ION + | JSON + ; + +table_properties_list + : table_property (',' table_property)* + ; + +table_property + : sconst EQUAL sconst + ; + +createexternalviewstmt + : CREATE (OR REPLACE)? EXTERNAL PROTECTED? VIEW qualified_name + (IF_P NOT EXISTS)? + (OPEN_PAREN name_list CLOSE_PAREN)? + AS selectstmt + ; + +dropexternalviewstmt + : DROP EXTERNAL VIEW opt_if_exists? qualified_name opt_drop_behavior? + ; + +// SECURITY/POLICY statements +alteridentityproviderstmt + : ALTER IDENTITY_P PROVIDER identity_provider_name=colid alteridprovideropts+ + ; + +alteridprovideropts + : PARAMETERS parameter_string=sconst + | NAMESPACE namespace=sconst + | IAM_ROLE iam_role=sconst + | AUTO_CREATE_ROLES ((TRUE_P ((INCLUDE | EXCLUDE) GROUPS LIKE filter_pattern=sconst)?) | FALSE_P)? + | DISABLE_P | ENABLE_P + ; + +altermaskingpolicystmt + : ALTER MASKING POLICY colid altmaskingpolicyopts + ; + +altermaterializedviewstmt + : ALTER MATERIALIZED VIEW qualified_name + ( + AUTO REFRESH (YES_P | NO) + | ALTER DISTKEY colid + | ALTER DISTSTYLE (ALL | EVEN | (KEY DISTKEY colid) | AUTO) + | ALTER COMPOUND? SORTKEY OPEN_PAREN (colid (COMMA colid)*) CLOSE_PAREN + | ALTER SORTKEY (AUTO | NONE) + | ROW LEVEL SECURITY (ON | OFF) (CONJUNCTION TYPE_P (AND | OR))? (FOR DATASHARES)? + ) + ; + +altmaskingpolicyopts + : RENAME TO colid + | OWNER TO colid + | SET '(' altmaskingpolicyargs ')' + | USING '(' maskingexpression ')' + ; + +altmaskingpolicyargs + : altmaskingpolicyarg (',' altmaskingpolicyarg)* + ; + +altmaskingpolicyarg + : colid typename + ; + +alterrlspolicystmt + : ALTER RLS POLICY colid USING OPEN_PAREN a_expr CLOSE_PAREN + ; + +attachmaskingpolicystmt + : ATTACH MASKING POLICY colid + ON qualified_name + '(' attachpolicycollist ')' + (USING '(' attachpolicycollist ')')? + TO attachpolicytargets + (PRIORITY iconst)? + ; + +attachpolicycollist + : attachpolicycolumn (',' attachpolicycolumn)* + ; + +attachpolicycolumn + : qualified_name // supports dotted paths like person.name.first_name + ; + +attachpolicytargets + : attachpolicytarget (',' attachpolicytarget)* + ; + +attachpolicytarget + : ROLE qualified_name + | colid // PUBLIC or user name - PUBLIC is treated as an identifier here + ; + +attachrlspolicystmt + : ATTACH RLS POLICY policy_name=colid ON TABLE? table_name_list TO attachpolicytargets + ; + +table_name_list + : qualified_name (COMMA qualified_name)* + ; + +createidentityproviderstmt + : CREATE IDENTITY_P PROVIDER colid + TYPE_P (sconst | colid) + createidprovideropts* + ; + +createidprovideropts + : PROVIDER_URL sconst + | PROVIDER_URL_PORT iconst + | ATTRIBUTE_MAP sconst + | PROVIDER_ARN sconst + | ASSUME_ROLE_ARN sconst + | NAMESPACE sconst + | PARAMETERS sconst + | APPLICATION_ARN sconst + | IAM_ROLE (DEFAULT | sconst) + | AUTO_CREATE_ROLES (TRUE_P | FALSE_P) (groupfilter)? + ; + +groupfilter + : INCLUDE GROUPS LIKE sconst + | EXCLUDE GROUPS LIKE sconst + ; + +createlibrarystmt + : CREATE (OR REPLACE)? LIBRARY colid LANGUAGE PLPYTHONU + FROM sconst createlibraryopts* + ; + +createlibraryopts + : CREDENTIALS sconst + | colid (AS)? sconst // REGION AS literal + | IAM_ROLE (DEFAULT | sconst) + ; + +createmaskingpolicystmt + : CREATE MASKING POLICY opt_if_not_exists? policy_name=colid + WITH '(' inputcolumnlist ')' + USING '(' maskingexpression ')' + ; + +inputcolumnlist + : inputcolumn (',' inputcolumn)* + ; + +inputcolumn + : column_name=colid typename + ; + +maskingexpression + : a_expr + ; + +createmodelstmt + : CREATE MODEL model_name=qualified_name + FROM createmodelfromclause + (TARGET target_column=qualified_name)? + FUNCTION function_name=qualified_name ('(' datatypelist ')')? + (RETURNS typename)? + (SAGEMAKER sagemakerspec)? + IAM_ROLE iamrolespec + (AUTO (ON | OFF))? + (MODEL_TYPE modeltypespec)? + (PROBLEM_TYPE problemtypespec)? + (OBJECTIVE objectivespec)? + (PREPROCESSORS sconst)? + (HYPERPARAMETERS hyperparametersspec)? + (SETTINGS '(' settingsclause ')')? + ; + +createmodelfromclause + : qualified_name + | '(' selectstmt ')' + | sconst + ; + +iamrolespec + : DEFAULT + | sconst + ; + +sagemakerspec + : sconst (':' sconst)? + ; + +modeltypespec + : XGBOOST + | MLP + | LINEAR_LEARNER + | KMEANS + | FORECAST + ; + +problemtypespec + : '(' problemtype ')' + ; + +problemtype + : REGRESSION + | BINARY_CLASSIFICATION + | MULTICLASS_CLASSIFICATION + ; + +objectivespec + : '(' sconst ')' + ; + +hyperparametersspec + : DEFAULT + | DEFAULT EXCEPT '(' hyperparameterslist ')' + ; + +hyperparameterslist + : hyperparameteritem (',' hyperparameteritem)* + ; + +hyperparameteritem + : colid sconst + ; + +settingsclause + : settingsitem (',' settingsitem)* + ; + +settingsitem + : S3_BUCKET sconst + | TAGS sconst + | KMS_KEY_ID sconst + | S3_GARBAGE_COLLECT (ON | OFF) + | MAX_CELLS iconst + | MAX_RUNTIME iconst + | MAX_BATCH_SIZE sconst + | MAX_PAYLOAD_IN_MB sconst + | HORIZON iconst + | FREQUENCY iconst + | PERCENTILES sconst + | MAX_BATCH_ROWS iconst + | MODEL_ID sconst + | PROMPT sconst + | SUFFIX sconst + | REQUEST_TYPE (RAW | UNIFIED) + | RESPONSE_TYPE (VARCHAR | SUPER) + ; + +datatypelist + : datatype (',' datatype)* + ; + +datatype + : typename + | colid typename // named parameter: name type + | colid colid // named parameter with non-standard type like: data json + ; + + +createrlspolicystmt + : CREATE RLS POLICY colid + (WITH '(' inputcolumnlist ')' (AS colid)?)? + USING '(' a_expr ')' + ; + +descidentityproviderstmt + : (DESC | DESCRIBE) IDENTITY_P PROVIDER colid + ; + +detachmaskingpolicystmt + : DETACH MASKING POLICY colid + ON qualified_name + '(' attachpolicycollist ')' + FROM attachpolicytargets + ; + +detachrlspolicystmt + : DETACH RLS POLICY rlspolicyname ON TABLE? table_name_list + FROM role_or_user_or_public_list + ; + +role_or_user_or_public_list + : role_or_user_or_public (COMMA role_or_user_or_public)* + ; + +role_or_user_or_public + : rolespec + | ROLE rolespec + | PUBLIC + ; + +rlspolicyname: + colid + ; + +dropidentityproviderstmt + : DROP IDENTITY_P PROVIDER opt_if_exists? colid (CASCADE)? + ; + +droplibrarystmt + : DROP LIBRARY opt_if_exists? colid + ; + +dropmaskingpolicystmt + : DROP MASKING POLICY opt_if_exists? colid + ; + +dropmodelstmt + : DROP MODEL opt_if_exists? qualified_name + ; + + +droprlspolicystmt + : DROP RLS POLICY opt_if_exists? colid (CASCADE | RESTRICT)? + ; + +// REDSHIFT-SPECIFIC UTILITY statements +altertableappendstmt + : ALTER TABLE qualified_name APPEND FROM qualified_name appendoptions* + ; + +appendoptions + : FILLTARGET + | IGNOREEXTRA + ; + +alteruserstmt + : ALTER USER rolespec (WITH)? alteruseropts+ + ; + +alteruseropts + : CREATEDB | NOCREATEDB + | CREATEUSER | NOCREATEUSER + | SYSLOG ACCESS (RESTRICTED | UNRESTRICTED) + | PASSWORD (sconst | DISABLE_P) + | VALID UNTIL sconst + | RENAME TO colid + | CONNECTION LIMIT (iconst | UNLIMITED) + | SESSION TIMEOUT iconst + | RESET SESSION TIMEOUT + | SET colid TO a_expr + | RESET colid + | EXTERNALID colid + ; + +analyzecompressionstmt + : (ANALYZE | ANALYSE) COMPRESSION (qualified_name ('(' name_list ')')?)? (COMPROWS iconst)? + ; + +cancelstmt + : CANCEL (sconst | iconst) (sconst)? // session PID/query ID, optional message + ; + +closestmt + : CLOSE cursorname=colid + ; + +insertexternaltablestmt + : INSERT INTO qualified_name select_or_values + ; + +select_or_values + : selectstmt + | values_clause + ; + +selectintostmt + : SELECT opt_all_clause? opt_target_list INTO qualified_name from_clause? + ; + +setsessionauthorizationstmt + : SET SESSION AUTHORIZATION colid + | SET SESSION AUTHORIZATION DEFAULT + | RESET SESSION AUTHORIZATION + ; + +setsessioncharacteristicsstmt + : SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list + ; + +// SHOW statements +showcolumnsstmt + : SHOW COLUMNS FROM TABLE? qualified_name (LIKE sconst)? (LIMIT iconst)? + ; + +showdatabasesstmt + : SHOW DATABASES (FROM DATA_P CATALOG)? showdbsopts* + ; + +showdbsopts + : LIKE sconst + | WITH DATASHARE sconst + | LIMIT iconst + | ACCOUNT sconst (',' sconst)* + | IAM_ROLE (DEFAULT | SESSION | sconst) + ; + +showdatasharesstmt + : SHOW DATASHARES (LIKE sconst)? + ; + +showexternaltablestmt + : SHOW EXTERNAL TABLE qualified_name (PARTITION)? + ; + +showgrantsstmt + : SHOW GRANTS (ON grantobject)? (FOR grantprincipal)? (LIMIT iconst)? + | SHOW GRANTS (FOR grantprincipal) (LIMIT iconst)? + ; + +grantobject + : DATABASE colid + | SCHEMA qualified_name + | TABLE? qualified_name + | FUNCTION qualified_name ('(' datatypelist? ')')? + ; + +grantprincipal + : colid + | ROLE colid + ; + +showmodelstmt + : SHOW MODEL (qualified_name | ALL) + ; + +showprocedurestmt + : SHOW PROCEDURE qualified_name func_args? + ; + +showschemasstmt + : SHOW SCHEMAS (FROM DATABASE colid)? (LIKE sconst)? (LIMIT iconst)? + ; + +showtablestmt + : SHOW TABLE qualified_name + ; + +showtablesstmt + : SHOW TABLES FROM SCHEMA database_name=colid '.' schema_name=colid + (LIKE pattern=sconst)? + (LIMIT limit_value=iconst)? + ; + +showviewstmt + : SHOW VIEW qualified_name + ; + +// OTHER REDSHIFT statements +unloadstmt + : UNLOAD '(' sconst ')' TO sconst iamroleclause unloadoptions* + ; + +iamroleclause + : IAM_ROLE (DEFAULT | sconst) + ; + +unloadoptions + : formatoption + | partitionbyoption + | manifestoption + | headeroption + | delimiteroption + | fixedwidthoption + | encryptedoption + | kmskeyoption + | compressionoption + | addquotesoption + | nullasoption + | escapeoption + | allowoverwriteoption + | cleanpathoption + | paralleloption + | maxfilesizeoption + | rowgroupsizeoption + | regionoption + | extensionoption + ; + +formatoption + : FORMAT (CSV | PARQUET | JSON) + ; + +partitionbyoption + : PARTITION BY '(' columnlist ')' INCLUDE? + ; + +manifestoption + : MANIFEST VERBOSE? + ; + +headeroption + : HEADER_P + ; + +delimiteroption + : DELIMITER AS? sconst + ; + +fixedwidthoption + : FIXEDWIDTH sconst + ; + +encryptedoption + : ENCRYPTED AUTO? + ; + +kmskeyoption + : KMS_KEY_ID sconst + ; + +compressionoption + : BZIP2 + | GZIP + | ZSTD + ; + +addquotesoption + : ADDQUOTES + ; + +nullasoption + : NULL_P AS sconst + ; + +escapeoption + : ESCAPE + ; + +allowoverwriteoption + : ALLOWOVERWRITE + ; + +cleanpathoption + : CLEANPATH + ; + +paralleloption + : PARALLEL (ON | OFF) + ; + +maxfilesizeoption + : MAXFILESIZE AS? iconst sizeunit? + ; + +rowgroupsizeoption + : ROWGROUPSIZE AS? iconst sizeunit? + ; + +sizeunit + : MB + | GB + ; + +regionoption + : colid AS? sconst // REGION AS literal + ; + +extensionoption + : EXTENSION sconst + ; + +usestmt + : USE database_name=colid + ; + +createdbstmt + : CREATE DATABASE name opt_with? createdb_opt_list? + ; + +createdb_opt_list + : createdb_opt_items + ; + +createdb_opt_items + : createdb_opt_item+ + ; + +createdb_opt_item + : createdb_opt_name opt_equal? (signediconst | opt_boolean_or_string | DEFAULT | UNLIMITED) + | ISOLATION LEVEL (SERIALIZABLE | SNAPSHOT) + | COLLATE (CASE_SENSITIVE | CASE_INSENSITIVE | CI | CS) + ; + +createdb_opt_name + : identifier + | CONNECTION LIMIT + | ENCODING + | LOCATION + | OWNER + | TABLESPACE + | TEMPLATE + ; + +opt_equal + : EQUAL + ; + +alterdatabasestmt + : ALTER DATABASE name (WITH createdb_opt_list? | createdb_opt_list? | SET TABLESPACE name | REFRESH COLLATION VERSION_P | COLLATE (CASE_SENSITIVE | CASE_INSENSITIVE) | CONNECTION LIMIT (iconst | UNLIMITED)) + ; + +alterdatabasesetstmt + : ALTER DATABASE name setresetclause + ; + +dropdbstmt + : DROP DATABASE name + ; + +drop_option_list + : drop_option (COMMA drop_option)* + ; + +drop_option + : FORCE + ; + +altercollationstmt + : ALTER COLLATION any_name REFRESH VERSION_P + ; + +altersystemstmt + : ALTER SYSTEM_P (SET | RESET) generic_set + ; + +createdomainstmt + : CREATE DOMAIN_P any_name opt_as? typename colquallist + ; + +alterdomainstmt + : ALTER DOMAIN_P any_name (alter_column_default | DROP NOT NULL_P | SET NOT NULL_P | ADD_P tableconstraint | DROP CONSTRAINT (IF_P EXISTS)? name opt_drop_behavior? | VALIDATE CONSTRAINT name) + ; + +opt_as + : AS + ; + +altertsdictionarystmt + : ALTER TEXT_P SEARCH DICTIONARY any_name definition + ; + +altertsconfigurationstmt + : ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list any_with any_name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list any_with any_name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name any_with any_name + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name any_with any_name + | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list + ; + +any_with + : WITH + //TODO + + // | WITH_LA + + ; + +createconversionstmt + : CREATE opt_default? CONVERSION_P any_name FOR sconst TO sconst FROM any_name + ; + +clusterstmt + : CLUSTER opt_verbose? qualified_name cluster_index_specification? + | CLUSTER opt_verbose? + | CLUSTER opt_verbose? name ON qualified_name + ; + +cluster_index_specification + : USING name + ; + +vacuumstmt + : VACUUM opt_full? opt_freeze? opt_verbose? opt_analyze? opt_vacuum_relation_list? + | VACUUM OPEN_PAREN vac_analyze_option_list CLOSE_PAREN opt_vacuum_relation_list? + | VACUUM vacuum_option? qualified_name? (TO iconst PERCENT_WORD)? BOOST? + ; + +vacuum_option + : FULL + | SORT ONLY + | DELETE_P ONLY + | REINDEX + | RECLUSTER + ; + +analyzestmt + : analyze_keyword opt_verbose? (qualified_name (OPEN_PAREN columnlist CLOSE_PAREN)?)? ((PREDICATE COLUMNS) | (ALL COLUMNS))? + ; + +vac_analyze_option_list + : vac_analyze_option_elem (COMMA vac_analyze_option_elem)* + ; + +analyze_keyword + : ANALYZE + | ANALYSE + ; + +vac_analyze_option_elem + : vac_analyze_option_name vac_analyze_option_arg? + ; + +vac_analyze_option_name + : nonreservedword + | analyze_keyword + ; + +vac_analyze_option_arg + : opt_boolean_or_string + | numericonly + ; + +opt_analyze + : analyze_keyword + ; + +opt_verbose + : VERBOSE + ; + +opt_full + : FULL + ; + +opt_freeze + : FREEZE + ; + +opt_name_list + : OPEN_PAREN name_list CLOSE_PAREN + ; + +vacuum_relation + : qualified_name opt_name_list? + ; + +vacuum_relation_list + : vacuum_relation (COMMA vacuum_relation)* + ; + +opt_vacuum_relation_list + : vacuum_relation_list + ; + +explainstmt + : EXPLAIN explainablestmt + | EXPLAIN analyze_keyword opt_verbose? explainablestmt + | EXPLAIN VERBOSE explainablestmt + | EXPLAIN OPEN_PAREN explain_option_list CLOSE_PAREN explainablestmt + ; + +explainablestmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + | declarecursorstmt + | createasstmt + | creatematviewstmt + | refreshmatviewstmt + | executestmt + ; + +explain_option_list + : explain_option_elem (COMMA explain_option_elem)* + ; + +explain_option_elem + : explain_option_name explain_option_arg? + ; + +explain_option_name + : nonreservedword + | analyze_keyword + ; + +explain_option_arg + : opt_boolean_or_string + | numericonly + ; + +preparestmt + : PREPARE name prep_type_clause? AS preparablestmt + ; + +prep_type_clause + : OPEN_PAREN type_list CLOSE_PAREN + ; + +preparablestmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + | mergestmt + ; + +executestmt + : EXECUTE name execute_param_clause? + | CREATE opttemp? TABLE create_as_target AS EXECUTE name execute_param_clause? opt_with_data? + | CREATE opttemp? TABLE IF_P NOT EXISTS create_as_target AS EXECUTE name execute_param_clause? opt_with_data? + ; + +execute_param_clause + : OPEN_PAREN expr_list CLOSE_PAREN + ; + +deallocatestmt + : DEALLOCATE name + | DEALLOCATE PREPARE name + | DEALLOCATE ALL + | DEALLOCATE PREPARE ALL + ; + +insertstmt + : opt_with_clause? INSERT INTO insert_target insert_rest opt_on_conflict? returning_clause? + ; + +insert_target + : qualified_name (AS colid)? + ; + +insert_rest + : selectstmt + | OVERRIDING override_kind VALUE_P selectstmt + | OPEN_PAREN insert_column_list CLOSE_PAREN (OVERRIDING override_kind VALUE_P)? selectstmt + | DEFAULT VALUES + ; + +override_kind + : USER + | SYSTEM_P + ; + +insert_column_list + : insert_column_item (COMMA insert_column_item)* + ; + +insert_column_item + : colid opt_indirection + ; + +opt_on_conflict + : ON CONFLICT opt_conf_expr? DO (UPDATE SET set_clause_list where_clause? | NOTHING) + ; + +opt_conf_expr + : OPEN_PAREN index_params CLOSE_PAREN where_clause? + | ON CONSTRAINT name + ; + +returning_clause + : RETURNING target_list + ; + +// https://www.postgresql.org/docs/current/sql-merge.html +mergestmt + : with_clause? MERGE INTO ONLY? qualified_name alias_clause? USING (select_with_parens|qualified_name) alias_clause? ON a_expr + (merge_when_clause+ | REMOVE DUPLICATES) + ; + +merge_when_clause + : merge_insert_clause + | merge_update_clause + | merge_delete_clause + ; + +merge_insert_clause + : WHEN NOT MATCHED (AND a_expr)? THEN? INSERT (OPEN_PAREN insert_column_list CLOSE_PAREN)? values_clause + ; + +merge_update_clause + : WHEN MATCHED (AND a_expr)? THEN? UPDATE SET set_clause_list + ; + +merge_delete_clause + : WHEN MATCHED (AND a_expr)? THEN? DELETE_P + ; + +deletestmt + : opt_with_clause? DELETE_P FROM? relation_expr_opt_alias using_clause? where_or_current_clause? returning_clause? + ; + +using_clause + : USING from_list + ; + +lockstmt + : LOCK_P opt_table? relation_expr_list opt_lock? opt_nowait? + ; + +opt_lock + : IN_P lock_type MODE + ; + +lock_type + : ACCESS (SHARE | EXCLUSIVE) + | ROW (SHARE | EXCLUSIVE) + | SHARE (UPDATE EXCLUSIVE | ROW EXCLUSIVE)? + | EXCLUSIVE + ; + +opt_nowait + : NOWAIT + ; + +opt_nowait_or_skip + : NOWAIT + | SKIP_P LOCKED + ; + +updatestmt + : opt_with_clause? UPDATE relation_expr_opt_alias SET set_clause_list from_clause? where_or_current_clause? returning_clause? + ; + +set_clause_list + : set_clause (COMMA set_clause)* + ; + +set_clause + : set_target EQUAL a_expr + | OPEN_PAREN set_target_list CLOSE_PAREN EQUAL a_expr + ; + +set_target + : colid opt_indirection + ; + +set_target_list + : set_target (COMMA set_target)* + ; + +declarecursorstmt + : DECLARE cursor_name cursor_options CURSOR opt_hold? FOR selectstmt + ; + +cursor_name + : name + ; + +cursor_options + : (NO SCROLL | SCROLL | BINARY | INSENSITIVE)* + ; + +opt_hold + : WITH HOLD + | WITHOUT HOLD + ; +/* +TODO: why select_with_parens alternative is needed at all? +i guess it because original byson grammar can choose selectstmt(2)->select_with_parens on only OPEN_PARENT/SELECT kewords at the begining of statement; +(select * from tab); +parse can go through selectstmt( )->select_no_parens(1)->select_clause(2)->select_with_parens(1)->select_no_parens(1)->select_clause(1)->simple_select +instead of selectstmt(1)->select_no_parens(1)->select_clause(2)->select_with_parens(1)->select_no_parens(1)->select_clause(1)->simple_select +all standard tests passed on both variants +*/ + + +selectstmt + : select_no_parens + | select_with_parens + ; + +select_with_parens + : OPEN_PAREN select_no_parens CLOSE_PAREN + | OPEN_PAREN select_with_parens CLOSE_PAREN + ; + +select_no_parens + : select_clause opt_sort_clause? (for_locking_clause opt_select_limit? | select_limit opt_for_locking_clause?)? + | with_clause select_clause opt_sort_clause? (for_locking_clause opt_select_limit? | select_limit opt_for_locking_clause?)? + ; + +select_clause + : simple_select_intersect ((UNION | EXCEPT) all_or_distinct? simple_select_intersect)* + ; + +simple_select_intersect + : simple_select_pramary (INTERSECT all_or_distinct? simple_select_pramary)* + ; + +simple_select_pramary + : ( SELECT (opt_all_clause? into_clause? opt_target_list? | opt_top_clause? into_clause? target_list | distinct_clause target_list) + exclude_clause? + into_clause? + from_clause? + where_clause? + start_with_clause? + group_clause? + having_clause? + qualify_clause? + window_clause? + ) + | values_clause + | TABLE relation_expr + | select_with_parens + ; + +exclude_clause + : EXCLUDE OPEN_PAREN columnlist CLOSE_PAREN + ; + +qualify_clause + : QUALIFY a_expr + ; + +start_with_clause + : (START WITH a_expr)? CONNECT BY a_expr; + +with_clause + : WITH RECURSIVE? cte_list + ; + +cte_list + : common_table_expr (COMMA common_table_expr)* + ; + +common_table_expr + : name opt_name_list? AS opt_materialized? OPEN_PAREN preparablestmt CLOSE_PAREN + ; + +opt_materialized + : MATERIALIZED + | NOT MATERIALIZED + ; + +opt_with_clause + : with_clause + ; + +into_clause + : INTO (opt_strict? opttempTableName | into_target) + ; + +opt_top_clause + : TOP iconst + ; + +opt_strict + : STRICT_P + ; + +opttempTableName + : (LOCAL|GLOBAL)? (TEMPORARY | TEMP) opt_table? qualified_name + | UNLOGGED opt_table? qualified_name + | TABLE qualified_name + | qualified_name + ; + +opt_table + : TABLE + ; + +all_or_distinct + : ALL + | DISTINCT + ; + +distinct_clause + : DISTINCT (ON OPEN_PAREN expr_list CLOSE_PAREN)? + ; + +opt_all_clause + : ALL + ; + +opt_sort_clause + : sort_clause + ; + +sort_clause + : ORDER BY sortby_list + ; + +sortby_list + : sortby (COMMA sortby)* + ; + +sortby + : a_expr (USING qual_all_op | opt_asc_desc?) opt_nulls_order? + ; + +select_limit + : limit_clause offset_clause? + | offset_clause limit_clause? + ; + +opt_select_limit + : select_limit + ; + +limit_clause + : LIMIT select_limit_value (COMMA select_offset_value)? + | FETCH first_or_next (select_fetch_first_value row_or_rows (ONLY | WITH TIES) | row_or_rows (ONLY | WITH TIES)) + ; + +offset_clause + : OFFSET (select_offset_value | select_fetch_first_value row_or_rows) + ; + +select_limit_value + : a_expr + | ALL + ; + +select_offset_value + : a_expr + ; + +select_fetch_first_value + : c_expr + | PLUS i_or_f_const + | MINUS i_or_f_const + ; + +i_or_f_const + : iconst + | fconst + ; + +row_or_rows + : ROW + | ROWS + ; + +first_or_next + : FIRST_P + | NEXT + ; + +group_clause + : GROUP_P BY group_by_list + ; + +group_by_list + : group_by_item (COMMA group_by_item)* + | ALL + ; + +group_by_item + : a_expr + | empty_grouping_set + | cube_clause + | rollup_clause + | grouping_sets_clause + ; + +empty_grouping_set + : OPEN_PAREN CLOSE_PAREN + ; + +rollup_clause + : ROLLUP OPEN_PAREN expr_list CLOSE_PAREN + ; + +cube_clause + : CUBE OPEN_PAREN expr_list CLOSE_PAREN + ; + +grouping_sets_clause + : GROUPING SETS OPEN_PAREN group_by_list CLOSE_PAREN + ; + +having_clause + : HAVING a_expr + ; + +for_locking_clause + : for_locking_items + | FOR READ ONLY + ; + +opt_for_locking_clause + : for_locking_clause + ; + +for_locking_items + : for_locking_item+ + ; + +for_locking_item + : for_locking_strength locked_rels_list? opt_nowait_or_skip? + ; + +for_locking_strength + : FOR ((NO KEY)? UPDATE | KEY? SHARE) + ; + +locked_rels_list + : OF qualified_name_list + ; + +values_clause + : VALUES OPEN_PAREN expr_list CLOSE_PAREN (COMMA OPEN_PAREN expr_list CLOSE_PAREN)* + ; + +from_clause + : FROM from_list + ; + +from_list + : table_ref (COMMA table_ref)* + ; + +table_ref + : (relation_expr opt_alias_clause? tablesample_clause? + | func_table func_alias_clause? + | xmltable opt_alias_clause? + | select_with_parens opt_alias_clause? + | LATERAL_P ( + xmltable opt_alias_clause? + | func_table func_alias_clause? + | select_with_parens opt_alias_clause? + ) + | OPEN_PAREN table_ref ( + CROSS JOIN table_ref + | NATURAL join_type? JOIN table_ref + | join_type? JOIN table_ref join_qual + )? CLOSE_PAREN opt_alias_clause? + ) + joined_table* + ; + +joined_table + : join_type? JOIN table_ref join_qual + | CROSS JOIN table_ref + | NATURAL join_type? JOIN table_ref + ; + +alias_clause + : AS? colid (OPEN_PAREN name_list CLOSE_PAREN)? + ; + +opt_alias_clause + : table_alias_clause + ; + +table_alias_clause + : AS? table_alias (OPEN_PAREN name_list CLOSE_PAREN)? + ; + +func_alias_clause + : alias_clause + | (AS colid? | colid) OPEN_PAREN tablefuncelementlist CLOSE_PAREN + ; + +join_type + : (FULL | LEFT | RIGHT | INNER_P) OUTER_P? + ; + +join_qual + : USING OPEN_PAREN name_list CLOSE_PAREN + | ON a_expr + ; + +relation_expr + : qualified_name STAR? + | ONLY (qualified_name | OPEN_PAREN qualified_name CLOSE_PAREN) + ; + +relation_expr_list + : relation_expr (COMMA relation_expr)* + ; + +relation_expr_opt_alias + : relation_expr (AS? colid)? + ; + +tablesample_clause + : TABLESAMPLE func_name OPEN_PAREN expr_list CLOSE_PAREN opt_repeatable_clause? + ; + +opt_repeatable_clause + : REPEATABLE OPEN_PAREN a_expr CLOSE_PAREN + ; + +func_table + : func_expr_windowless opt_ordinality? + | ROWS FROM OPEN_PAREN rowsfrom_list CLOSE_PAREN opt_ordinality? + ; + +rowsfrom_item + : func_expr_windowless opt_col_def_list? + ; + +rowsfrom_list + : rowsfrom_item (COMMA rowsfrom_item)* + ; + +opt_col_def_list + : AS OPEN_PAREN tablefuncelementlist CLOSE_PAREN + ; + //TODO WITH_LA was used + +opt_ordinality + : WITH ORDINALITY + ; + +where_clause + : WHERE a_expr + ; + +where_or_current_clause + : WHERE (CURRENT_P OF cursor_name | a_expr) + ; + +opttablefuncelementlist + : tablefuncelementlist + ; + +tablefuncelementlist + : tablefuncelement (COMMA tablefuncelement)* + ; + +tablefuncelement + : colid typename opt_collate_clause? + ; + +xmltable + : XMLTABLE OPEN_PAREN (c_expr xmlexists_argument COLUMNS xmltable_column_list | XMLNAMESPACES OPEN_PAREN xml_namespace_list CLOSE_PAREN COMMA c_expr xmlexists_argument COLUMNS xmltable_column_list) CLOSE_PAREN + ; + +xmltable_column_list + : xmltable_column_el (COMMA xmltable_column_el)* + ; + +xmltable_column_el + : colid (typename xmltable_column_option_list? | FOR ORDINALITY) + ; + +xmltable_column_option_list + : xmltable_column_option_el+ + ; + +xmltable_column_option_el + : DEFAULT a_expr + | identifier a_expr + | NOT NULL_P + | NULL_P + ; + +xml_namespace_list + : xml_namespace_el (COMMA xml_namespace_el)* + ; + +xml_namespace_el + : b_expr AS collabel + | DEFAULT b_expr + ; + +typename + : SETOF? simpletypename (opt_array_bounds? | ARRAY (OPEN_BRACKET iconst CLOSE_BRACKET)?) + | qualified_name PERCENT (ROWTYPE | TYPE_P) + | SUPER + ; + +opt_array_bounds + : (OPEN_BRACKET iconst? CLOSE_BRACKET)+ + ; + +simpletypename + : generictype + | numeric + | bit + | character + | varbyte + | constdatetime + | constinterval (opt_interval? | OPEN_PAREN iconst CLOSE_PAREN) + | json_type + ; + +varbyte + : (VARBYTE | VARBINARY | BINARY VARYING) OPEN_PAREN iconst CLOSE_PAREN + ; + +json_type + : JSON + ; + +consttypename + : numeric + | constbit + | constcharacter + | constdatetime + ; + +generictype + : (builtin_function_name | type_function_name | LEFT | RIGHT) attrs? opt_type_modifiers? + ; + +opt_type_modifiers + : OPEN_PAREN expr_list CLOSE_PAREN + ; + +numeric + : INT_P + | INTEGER + | SMALLINT + | BIGINT + | REAL + | FLOAT_P opt_float? + | DOUBLE_P PRECISION + | DECIMAL_P opt_type_modifiers? + | DEC opt_type_modifiers? + | NUMERIC opt_type_modifiers? + | BOOLEAN_P + ; + +opt_float + : OPEN_PAREN iconst CLOSE_PAREN + ; + //todo: merge alts + +bit + : bitwithlength + | bitwithoutlength + ; + +constbit + : bitwithlength + | bitwithoutlength + ; + +bitwithlength + : BIT opt_varying? OPEN_PAREN expr_list CLOSE_PAREN + ; + +bitwithoutlength + : BIT opt_varying? + ; + +character + : character_c (OPEN_PAREN (iconst | colid) CLOSE_PAREN)? + ; + +constcharacter + : character_c (OPEN_PAREN (iconst | colid) CLOSE_PAREN)? + ; + +character_c + : (CHARACTER | CHAR_P | NCHAR) opt_varying? + | VARCHAR + | NATIONAL (CHARACTER | CHAR_P) opt_varying? + ; + +opt_varying + : VARYING + ; + +constdatetime + : (TIMESTAMP | TIME) (OPEN_PAREN iconst CLOSE_PAREN)? opt_timezone? + ; + +constinterval + : INTERVAL + ; + //TODO with_la was used + +opt_timezone + : WITH TIME ZONE + | WITHOUT TIME ZONE + ; + +opt_interval + : YEAR_P + | MONTH_P + | DAY_P + | HOUR_P + | MINUTE_P + | interval_second + | YEAR_P TO MONTH_P + | DAY_P TO (HOUR_P | MINUTE_P | interval_second) + | HOUR_P TO (MINUTE_P | interval_second) + | MINUTE_P TO interval_second + ; + +interval_second + : SECOND_P (OPEN_PAREN iconst CLOSE_PAREN)? + ; + +opt_escape + : ESCAPE a_expr + ; + //precendence accroding to Table 4.2. Operator Precedence (highest to lowest) + + //https://www.postgresql.org/docs/12/sql-syntax-lexical.html#SQL-PRECEDENCE + +/* +original version of a_expr, for info + a_expr: c_expr + //:: left PostgreSQL-style typecast + | a_expr TYPECAST typename -- 1 + | a_expr COLLATE any_name -- 2 + | a_expr AT TIME ZONE a_expr-- 3 + //right unary plus, unary minus + | (PLUS| MINUS) a_expr -- 4 + //left exponentiation + | a_expr CARET a_expr -- 5 + //left multiplication, division, modulo + | a_expr (STAR | SLASH | PERCENT) a_expr -- 6 + //left addition, subtraction + | a_expr (PLUS | MINUS) a_expr -- 7 + //left all other native and user-defined operators + | a_expr qual_op a_expr -- 8 + | qual_op a_expr -- 9 + //range containment, set membership, string matching BETWEEN IN LIKE ILIKE SIMILAR + | a_expr NOT? (LIKE|ILIKE|SIMILAR TO|(BETWEEN SYMMETRIC?)) a_expr opt_escape -- 10 + //< > = <= >= <> comparison operators + | a_expr (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr -- 11 + //IS ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS DISTINCT FROM, etc + | a_expr IS NOT? + ( + NULL_P + |TRUE_P + |FALSE_P + |UNKNOWN + |DISTINCT FROM a_expr + |OF OPEN_PAREN type_list CLOSE_PAREN + |DOCUMENT_P + |unicode_normal_form? NORMALIZED + ) -- 12 + | a_expr (ISNULL|NOTNULL) -- 13 + | row OVERLAPS row -- 14 + //NOT right logical negation + | NOT a_expr -- 15 + //AND left logical conjunction + | a_expr AND a_expr -- 16 + //OR left logical disjunction + | a_expr OR a_expr -- 17 + | a_expr (LESS_LESS|GREATER_GREATER) a_expr -- 18 + | a_expr qual_op -- 19 + | a_expr NOT? IN_P in_expr -- 20 + | a_expr subquery_Op sub_type (select_with_parens|OPEN_PAREN a_expr CLOSE_PAREN) -- 21 + | UNIQUE select_with_parens -- 22 + | DEFAULT -- 23 +; +*/ + + +a_expr + : a_expr_qual + ; +/*23*/ + + +/*moved to c_expr*/ + + +/*22*/ + + +/*moved to c_expr*/ + + +/*19*/ + + +a_expr_qual + : a_expr_lessless qual_op? + ; +/*18*/ + + +a_expr_lessless + : a_expr_or ((LESS_LESS | GREATER_GREATER) a_expr_or)* + ; +/*17*/ + + +a_expr_or + : a_expr_and (OR a_expr_and)* + ; +/*16*/ + +a_expr_and + : a_expr_between (AND a_expr_between)* + ; +/*21*/ + +a_expr_between + : a_expr_in (NOT? BETWEEN SYMMETRIC? a_expr_in AND a_expr_in)? + ; +/*20*/ + + +a_expr_in + : a_expr_unary_not (NOT? IN_P in_expr)? + ; +/*15*/ + + +a_expr_unary_not + : NOT? a_expr_isnull + ; +/*14*/ + + +/*moved to c_expr*/ + + +/*13*/ + + +a_expr_isnull + : a_expr_is_not (ISNULL | NOTNULL)? + ; +/*12*/ + + +a_expr_is_not + : a_expr_compare (IS NOT? (NULL_P | TRUE_P | FALSE_P | UNKNOWN | DISTINCT FROM a_expr | OF OPEN_PAREN type_list CLOSE_PAREN | DOCUMENT_P | unicode_normal_form? NORMALIZED))? + ; +/*11*/ + + +//a_expr_compare +// : a_expr_like ((LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr_like |subquery_Op sub_type (select_with_parens | OPEN_PAREN a_expr CLOSE_PAREN) /*21*/ +// +// )? +// ; +///*10*/ + +a_expr_compare + : a_expr_prior_or_level ((LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr_prior_or_level |subquery_Op sub_type (select_with_parens | OPEN_PAREN a_expr CLOSE_PAREN) /*21*/ + + )? + ; +/*10*/ + +/* Redshift Level and Prior Expression https://docs.aws.amazon.com/redshift/latest/dg/r_CONNECT_BY_clause.html */ +// Perf(zp): Introducing a_expr_prior_or_level seems like introduce the significant performance penalty, +// make redshift-test costs ~4x higher time than without it. Using (PRIOR | LEVEL)? a_expr_like instead will not. +//a_expr_prior_or_level +// : PRIOR? a_expr_like +// | LEVEL? a_expr_like +// ; + +a_expr_prior_or_level + : (PRIOR | LEVEL)? a_expr_like + ; + +a_expr_like + : a_expr_qual_op (NOT? (LIKE | ILIKE | SIMILAR TO) a_expr_qual_op opt_escape?)? + ; +/* 8*/ + + +a_expr_qual_op + : a_expr_unary_qualop (qual_op a_expr_unary_qualop)* + ; +/* 9*/ + + +a_expr_unary_qualop + : qual_op? a_expr_add + ; +/* 7*/ + + +a_expr_add + : a_expr_mul ((MINUS | PLUS) a_expr_mul)* + ; +/* 6*/ + + +a_expr_mul + : a_expr_caret ((STAR | SLASH | PERCENT) a_expr_caret)* + ; +/* 5*/ + + +a_expr_caret + : a_expr_unary_sign (CARET a_expr)? + ; +/* 4*/ + + +a_expr_unary_sign + : (MINUS | PLUS)? a_expr_at_time_zone /* */ + + + ; +/* 3*/ + + +a_expr_at_time_zone + : a_expr_collate (AT TIME ZONE a_expr)? + ; +/* 2*/ + + +a_expr_collate + : a_expr_typecast (COLLATE any_name)? + ; +/* 1*/ + + +a_expr_typecast + : c_expr (TYPECAST typename)* + ; + +b_expr + : c_expr + | b_expr TYPECAST typename + //right unary plus, unary minus + | (PLUS | MINUS) b_expr + //^ left exponentiation + | b_expr CARET b_expr + //* / % left multiplication, division, modulo + | b_expr (STAR | SLASH | PERCENT) b_expr + //+ - left addition, subtraction + | b_expr (PLUS | MINUS) b_expr + //(any other operator) left all other native and user-defined operators + | b_expr qual_op b_expr + //< > = <= >= <> comparison operators + | b_expr (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) b_expr + | qual_op b_expr + | b_expr qual_op + //S ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS DISTINCT FROM, etc + | b_expr IS NOT? (DISTINCT FROM b_expr | OF OPEN_PAREN type_list CLOSE_PAREN | DOCUMENT_P) + ; + +c_expr + : EXISTS select_with_parens # c_expr_exists + | ARRAY (select_with_parens | array_expr) # c_expr_expr + | PARAM opt_indirection # c_expr_expr + | GROUPING OPEN_PAREN expr_list CLOSE_PAREN # c_expr_expr + | /*22*/ + + UNIQUE select_with_parens # c_expr_expr + | columnref # c_expr_expr + | aexprconst # c_expr_expr + | plsqlvariablename # c_expr_expr + | OPEN_PAREN a_expr_in_parens = a_expr CLOSE_PAREN opt_indirection # c_expr_expr + | case_expr # c_expr_case + | func_expr # c_expr_expr + | select_with_parens indirection? # c_expr_expr + | explicit_row # c_expr_expr + | implicit_row # c_expr_expr + | row OVERLAPS row /* 14*/ + + # c_expr_expr + ; + +plsqlvariablename + : PLSQLVARIABLENAME + ; + +func_application + : func_name OPEN_PAREN (func_arg_list (COMMA VARIADIC func_arg_expr)? opt_sort_clause? | VARIADIC func_arg_expr opt_sort_clause? | (ALL | DISTINCT) func_arg_list opt_sort_clause? | STAR |) CLOSE_PAREN + ; + +func_expr + : func_application within_group_clause? filter_clause? over_clause? + | func_expr_common_subexpr + ; + +func_expr_windowless + : func_application + | func_expr_common_subexpr + ; + +func_expr_common_subexpr + : COLLATION FOR OPEN_PAREN a_expr CLOSE_PAREN + | CURRENT_DATE + | CURRENT_TIME (OPEN_PAREN iconst CLOSE_PAREN)? + | CURRENT_TIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | LOCALTIME (OPEN_PAREN iconst CLOSE_PAREN)? + | LOCALTIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | CURRENT_ROLE + | CURRENT_USER + | SESSION_USER + | USER + | CURRENT_CATALOG + | CURRENT_SCHEMA + | CAST OPEN_PAREN a_expr AS typename CLOSE_PAREN + | EXTRACT OPEN_PAREN extract_list? CLOSE_PAREN + | NORMALIZE OPEN_PAREN a_expr (COMMA unicode_normal_form)? CLOSE_PAREN + | OVERLAY OPEN_PAREN overlay_list CLOSE_PAREN + | POSITION OPEN_PAREN position_list? CLOSE_PAREN + | SUBSTRING OPEN_PAREN substr_list CLOSE_PAREN + | TREAT OPEN_PAREN a_expr AS typename CLOSE_PAREN + | TRIM OPEN_PAREN (BOTH | LEADING | TRAILING)? trim_list CLOSE_PAREN + | NULLIF OPEN_PAREN a_expr COMMA a_expr CLOSE_PAREN + | COALESCE OPEN_PAREN expr_list CLOSE_PAREN + | GREATEST OPEN_PAREN expr_list CLOSE_PAREN + | LEAST OPEN_PAREN expr_list CLOSE_PAREN + | XMLCONCAT OPEN_PAREN expr_list CLOSE_PAREN + | XMLELEMENT OPEN_PAREN NAME_P collabel (COMMA (xml_attributes | expr_list))? CLOSE_PAREN + | XMLEXISTS OPEN_PAREN c_expr xmlexists_argument CLOSE_PAREN + | XMLFOREST OPEN_PAREN xml_attribute_list CLOSE_PAREN + | XMLPARSE OPEN_PAREN document_or_content a_expr xml_whitespace_option? CLOSE_PAREN + | XMLPI OPEN_PAREN NAME_P collabel (COMMA a_expr)? CLOSE_PAREN + | XMLROOT OPEN_PAREN XML_P a_expr COMMA xml_root_version opt_xml_root_standalone? CLOSE_PAREN + | XMLSERIALIZE OPEN_PAREN document_or_content a_expr AS simpletypename CLOSE_PAREN + ; + +xml_root_version + : VERSION_P a_expr + | VERSION_P NO VALUE_P + ; + +opt_xml_root_standalone + : COMMA STANDALONE_P YES_P + | COMMA STANDALONE_P NO + | COMMA STANDALONE_P NO VALUE_P + ; + +xml_attributes + : XMLATTRIBUTES OPEN_PAREN xml_attribute_list CLOSE_PAREN + ; + +xml_attribute_list + : xml_attribute_el (COMMA xml_attribute_el)* + ; + +xml_attribute_el + : a_expr (AS collabel)? + ; + +document_or_content + : DOCUMENT_P + | CONTENT_P + ; + +xml_whitespace_option + : PRESERVE WHITESPACE_P + | STRIP_P WHITESPACE_P + ; + +xmlexists_argument + : PASSING c_expr + | PASSING c_expr xml_passing_mech + | PASSING xml_passing_mech c_expr + | PASSING xml_passing_mech c_expr xml_passing_mech + ; + +xml_passing_mech + : BY (REF | VALUE_P) + ; + +within_group_clause + : WITHIN GROUP_P OPEN_PAREN sort_clause CLOSE_PAREN + ; + +filter_clause + : FILTER OPEN_PAREN WHERE a_expr CLOSE_PAREN + ; + +window_clause + : WINDOW window_definition_list + ; + +window_definition_list + : window_definition (COMMA window_definition)* + ; + +window_definition + : colid AS window_specification + ; + +over_clause + : OVER (window_specification | colid) + ; + +window_specification + : OPEN_PAREN opt_existing_window_name? opt_partition_clause? opt_sort_clause? opt_frame_clause? CLOSE_PAREN + ; + +opt_existing_window_name + : colid + ; + +opt_partition_clause + : PARTITION BY expr_list + ; + +opt_frame_clause + : RANGE frame_extent opt_window_exclusion_clause? + | ROWS frame_extent opt_window_exclusion_clause? + | GROUPS frame_extent opt_window_exclusion_clause? + ; + +frame_extent + : frame_bound + | BETWEEN frame_bound AND frame_bound + ; + +frame_bound + : UNBOUNDED (PRECEDING | FOLLOWING) + | CURRENT_P ROW + | a_expr (PRECEDING | FOLLOWING) + ; + +opt_window_exclusion_clause + : EXCLUDE (CURRENT_P ROW | GROUP_P | TIES | NO OTHERS) + ; + +row + : ROW OPEN_PAREN expr_list? CLOSE_PAREN + | OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN + ; + +explicit_row + : ROW OPEN_PAREN expr_list? CLOSE_PAREN + ; +/* +TODO: +for some reason v1 +implicit_row: OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN; +works better than v2 +implicit_row: OPEN_PAREN expr_list CLOSE_PAREN; +while looks like they are almost the same, except v2 requieres at least 2 items in list +while v1 allows single item in list +*/ + + +implicit_row + : OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN + ; + +sub_type + : ANY + | SOME + | ALL + ; + +all_op + : Operator + | mathop + ; + +mathop + : PLUS + | MINUS + | STAR + | SLASH + | PERCENT + | CARET + | LT + | GT + | EQUAL + | LESS_EQUALS + | GREATER_EQUALS + | NOT_EQUALS + ; + +qual_op + : Operator + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + ; + +qual_all_op + : all_op + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + ; + +subquery_Op + : all_op + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + | LIKE + | NOT LIKE + | ILIKE + | NOT ILIKE + ; + +expr_list + : a_expr (COMMA a_expr)* + ; + +func_arg_list + : func_arg_expr (COMMA func_arg_expr)* + ; + +func_arg_expr + : a_expr + | param_name (COLON_EQUALS | EQUALS_GREATER) a_expr + ; + +type_list + : typename (COMMA typename)* + ; + +array_expr + : OPEN_BRACKET (expr_list | array_expr_list)? CLOSE_BRACKET + ; + +array_expr_list + : array_expr (COMMA array_expr)* + ; + +extract_list + : extract_arg FROM a_expr + ; + +extract_arg + : identifier + | YEAR_P + | MONTH_P + | DAY_P + | HOUR_P + | MINUTE_P + | SECOND_P + | sconst + ; + +unicode_normal_form + : NFC + | NFD + | NFKC + | NFKD + ; + +overlay_list + : a_expr PLACING a_expr FROM a_expr (FOR a_expr)? + ; + +position_list + : b_expr IN_P b_expr + ; + +substr_list + : a_expr FROM a_expr FOR a_expr + | a_expr FOR a_expr FROM a_expr + | a_expr FROM a_expr + | a_expr FOR a_expr + | a_expr SIMILAR a_expr ESCAPE a_expr + | expr_list + ; + +trim_list + : a_expr FROM expr_list + | FROM expr_list + | expr_list + ; + +in_expr + : select_with_parens # in_expr_select + | OPEN_PAREN expr_list CLOSE_PAREN # in_expr_list + ; + +case_expr + : CASE case_arg? when_clause_list case_default? END_P + ; + +when_clause_list + : when_clause+ + ; + +when_clause + : WHEN a_expr THEN a_expr + ; + +case_default + : ELSE a_expr + ; + +case_arg + : a_expr + ; + +columnref + : colid indirection? + ; + +indirection_el + : DOT (attr_name | STAR) + | OPEN_BRACKET (a_expr | opt_slice_bound? COLON opt_slice_bound?) CLOSE_BRACKET + ; + +opt_slice_bound + : a_expr + ; + +indirection + : indirection_el+ + ; + +opt_indirection + : indirection_el* + ; + +opt_target_list + : target_list + ; + +target_list + : target_el (COMMA target_el)* + ; + +target_el + : a_expr target_alias? # target_label + | STAR # target_star + ; + +target_alias + : AS collabel + | identifier + ; + +qualified_name_list + : qualified_name (COMMA qualified_name)* + ; + +qualified_name + : colid indirection? + ; + +name_list + : name (COMMA name)* + ; + +name + : colid + ; + +attr_name + : collabel + ; + +file_name + : sconst + ; + +func_name + : builtin_function_name + | type_function_name + | colid indirection + | LEFT + | RIGHT + ; + +aexprconst + : iconst + | fconst + | sconst + | bconst + | xconst + | func_name (sconst | OPEN_PAREN func_arg_list opt_sort_clause? CLOSE_PAREN sconst) + | consttypename sconst + | constinterval (sconst opt_interval? | OPEN_PAREN iconst CLOSE_PAREN sconst) + | TRUE_P + | FALSE_P + | NULL_P + ; + +xconst + : HexadecimalStringConstant + ; + +bconst + : BinaryStringConstant + ; + +fconst + : Numeric + ; + +iconst + : Integral + ; + +sconst + : anysconst opt_uescape? + ; + +anysconst + : StringConstant + | UnicodeEscapeStringConstant + | BeginDollarStringConstant DollarText* EndDollarStringConstant + | EscapeStringConstant + ; + +opt_uescape + : UESCAPE anysconst + ; + +signediconst + : iconst + | PLUS iconst + | MINUS iconst + ; + +roleid + : rolespec + ; + +rolespec + : nonreservedword + | NamespaceUser + | CURRENT_USER + | SESSION_USER + ; + +role_list + : rolespec (COMMA rolespec)* + ; + +colid + : identifier + | unreserved_keyword + | col_name_keyword + | plsql_unreserved_keyword + | LEFT + | RIGHT + ; + +table_alias + : identifier + | unreserved_keyword + | col_name_keyword + | plsql_unreserved_keyword + ; + + +type_function_name + : identifier + | unreserved_keyword + | plsql_unreserved_keyword + | type_func_name_keyword + ; + +nonreservedword + : identifier + | unreserved_keyword + | col_name_keyword + | type_func_name_keyword + ; + +collabel + : identifier + | plsql_unreserved_keyword + | unreserved_keyword + | col_name_keyword + | type_func_name_keyword + | reserved_keyword + ; + +identifier + : Identifier opt_uescape? + | QuotedIdentifier + | UnicodeQuotedIdentifier + | plsqlvariablename + | plsqlidentifier + | plsql_unreserved_keyword + ; + +plsqlidentifier + : PLSQLIDENTIFIER + ; + +unreserved_keyword + : ABORT_P + | ABSOLUTE_P + | ACCESS + | ACTION + | ADD_P + | ADMIN + | AFTER + | AGGREGATE + | ALSO + | ALTER + | ALWAYS + | ASSERTION + | ASSIGNMENT + | AT + | ATOMIC_P + | ATTACH + | ATTRIBUTE + | BACKWARD + | BEFORE + | BEGIN_P + | BY + | CACHE + | CALL + | CALLED + | CASCADE + | CASCADED + | CATALOG + | CHAIN + | CHARACTERISTICS + | CHECKPOINT + | CLASS + | CLOSE + | CLUSTER + | COLUMNS + | COMMENT + | COMMENTS + | COMMIT + | COMMITTED + | CONFIGURATION + | CONFLICT + | CONNECTION + | CONSTRAINTS + | CONTENT_P + | CONTINUE_P + | CONVERSION_P + | COPY + | COST + | CSV + | CUBE + | CURRENT_P + | CURSOR + | CYCLE + | DATA_P + | DATABASE + | DAY_P + | DEALLOCATE + | DECLARE + | DEFAULTS + | DEFERRED + | DEFINER + | DELETE_P + | DELIMITER + | DELIMITERS + | DEPENDS + | DETACH + | DICTIONARY + | DISABLE_P + | DISCARD + | DOCUMENT_P + | DOMAIN_P + | DOUBLE_P + | DROP + | EACH + | ENABLE_P + | ENCODING + | ENCRYPTED + | ENUM_P + | ESCAPE + | EVENT + | EXCLUDE + | EXCLUDING + | EXCLUSIVE + | EXECUTE + | EXPLAIN + | EXPRESSION + | EXTENSION + | EXTERNAL + | FAMILY + | FILTER + | FIRST_P + | FOLLOWING + | FORCE + | FORWARD + | FUNCTION + | FUNCTIONS + | GENERATED + | GLOBAL + | GRANTED + | GROUPS + | HANDLER + | HEADER_P + | HOLD + | HOUR_P + | IDENTITY_P + | IF_P + | IMMEDIATE + | IMMUTABLE + | IMPLICIT_P + | IMPORT_P + | INCLUDE + | INCLUDING + | INCREMENT + | INDEX + | INDEXES + | INHERIT + | INHERITS + | INLINE_P + | INPUT_P + | INSENSITIVE + | INSERT + | INSTEAD + | INVOKER + | ISOLATION + | KEY + | LABEL + | LANGUAGE + | LARGE_P + | LAST_P + | LEAKPROOF + | LEVEL + | LISTEN + | LOAD + | LOCAL + | LOCATION + | LOCK_P + | LOCKED + | LOGGED + | MAPPING + | MATCH + | MATERIALIZED + | MAXVALUE + | METHOD + | MINUTE_P + | MINVALUE + | MODE + | MONTH_P + | MOVE + | NAME_P + | NAMES + | NEW + | NEXT + | NFC + | NFD + | NFKC + | NFKD + | NO + | NORMALIZED + | NOTHING + | NOTIFY + | NOWAIT + | NULLS_P + | OBJECT_P + | OF + | OFF + | OIDS + | OLD + | OPERATOR + | OPTION + | OPTIONS + | ORDINALITY + | OTHERS + | OVER + | OVERRIDING + | OWNED + | OWNER + | PARALLEL + | PARAMETER + | PUBLIC + | PARSER + | PARTIAL + | PARTITION + | PASSING + | PASSWORD + | PLANS + | POLICY + | PRECEDING + | PREPARE + | PREPARED + | PRESERVE + | PRIOR + | PRIORITY + | PRIVILEGES + | PROCEDURAL + | PROCEDURE + | PROCEDURES + | PROGRAM + | PUBLICATION + | QUOTE + | RANGE + | READ + | REASSIGN + | RECHECK + | RECURSIVE + | REF + | REFERENCING + | REFRESH + | REINDEX + | RELATIVE_P + | RELEASE + | RENAME + | REPEATABLE + | REPLICA + | RESET + | RESTART + | RESTRICT + | RETURNS + | REVOKE + | ROLE + | ROLLBACK + | ROLLUP + | ROUTINE + | ROUTINES + | ROWS + | RULE + | SAVEPOINT + | SCHEMA + | SCHEMAS + | SCROLL + | SEARCH + | SECOND_P + | SECURITY + | SEQUENCE + | SEQUENCES + | SERIALIZABLE + | SERVER + | SESSION + | SET + | SETS + | SHARE + | SHOW + | SIMPLE + | SKIP_P + | SNAPSHOT + | SQL_P + | STABLE + | STANDALONE_P + | START + | STATEMENT + | STATISTICS + | STDIN + | STDOUT + | STORAGE + | STORED + | STRICT_P + | STRIP_P + | SUBSCRIPTION + | SUPPORT + | SYSID + | SYSTEM_P + | TABLES + | TABLESPACE + | TEMP + | TEMPLATE + | TEMPORARY + | TEXT_P + | TIES + | TRANSACTION + | TRANSFORM + | TRIGGER + | TRUNCATE + | TRUSTED + | TYPE_P + | TYPES_P + | UESCAPE + | UNBOUNDED + | UNCOMMITTED + | UNENCRYPTED + | UNKNOWN + | UNLISTEN + | UNLOGGED + | UNTIL + | UPDATE + | VACUUM + | VALID + | VALIDATE + | VALIDATOR + | VALUE_P + | VARYING + | VERSION_P + | VIEW + | VIEWS + | VOLATILE + | WHITESPACE_P + | WITHIN + | WITHOUT + | WORK + | WRAPPER + | WRITE + | XML_P + | YEAR_P + | YES_P + | ZONE + // REDSHIFT-SPECIFIC KEYWORDS (added to support their use as column names/identifiers) + | DEFINITION | DATASHARE | PUBLICACCESSIBLE | INCLUDENEW + | IAM_ROLE | CATALOG_ROLE | CATALOG_ID | HIVE | METASTORE | URI + | POSTGRES | MYSQL | SECRET_ARN | KINESIS | KAFKA | MSK + | AUTHENTICATION | AUTHENTICATION_ARN | SESSION_TOKEN | MTLS + | MASKING | RLS | IDENTITY | PROVIDER | PROTECTED + | MODEL | TARGET | SAGEMAKER | AUTO | MODEL_TYPE | PROBLEM_TYPE + | OBJECTIVE | PREPROCESSORS | HYPERPARAMETERS | XGBOOST | MLP + | LINEAR_LEARNER | KMEANS | FORECAST | REGRESSION | BINARY_CLASSIFICATION + | MULTICLASS_CLASSIFICATION | S3_BUCKET | TAGS | KMS_KEY_ID | S3_GARBAGE_COLLECT + | MAX_CELLS | MAX_RUNTIME | HORIZON | FREQUENCY | PERCENTILES | MAX_BATCH_ROWS + | UNLOAD | MANIFEST | ADDQUOTES | ALLOWOVERWRITE | CLEANPATH + | MAXFILESIZE | ROWGROUPSIZE | BZIP2 | GZIP | ZSTD + | DATABASES | DATASHARES | GRANTS | USE | CANCEL + | SESSION_AUTHORIZATION | SESSION_CHARACTERISTICS | COMPRESSION | LIBRARY | APPEND + | MB | GB | ACCOUNT | NAMESPACE | DESCRIBE + | NONATOMIC | MANAGEDBY | ADX | REMOVE | DUPLICATES + | BEDROCK | MODEL_ID | PROMPT | SUFFIX | REQUEST_TYPE | RESPONSE_TYPE + | RAW | UNIFIED | SUPER | CI | CS | PLPYTHONU + | FILLTARGET | IGNOREEXTRA | CREATEUSER | NOCREATEUSER | REGION | PORT + | REDSHIFT | IAM | CREATEDB | NOCREATEDB | RESTRICTED | UNLIMITED + | EXTERNALID | TIMEOUT | SYSLOG | CREDENTIALS | UNRESTRICTED | PARAMETERS + | APPLICATION_ARN | AUTO_CREATE_ROLES | COMPROWS | PROVIDER_URL | PROVIDER_URL_PORT + | ATTRIBUTE_MAP | PROVIDER_ARN | ASSUME_ROLE_ARN | PROPERTIES + | AVRO | RCFILE | SEQUENCEFILE | TEXTFILE | ORC | ION | LAMBDA | FIXEDWIDTH + | PARQUET | LZOP | REMOVEQUOTES | TRUNCATECOLUMNS | FILLRECORD + | BLANKSASNULL | EMPTYASNULL | MAXERROR | DATEFORMAT | TIMEFORMAT + | ACCEPTINVCHARS | ACCEPTANYDATE | IGNOREHEADER | IGNOREBLANKLINES + | COMPUPDATE | STATUPDATE | EXPLICIT_IDS | READRATIO | ROUNDEC + | TRIMBLANKS | PRESET | ACCESS_KEY_ID | SECRET_ACCESS_KEY + | SESSION_TOKEN_KW | HEADER | SETTINGS | FUNCTION_NAME + ; + +col_name_keyword + : BETWEEN + | BIGINT + | bit + | BOOLEAN_P + | CHAR_P + | character + | COALESCE + | DEC + | DECIMAL_P + | EXISTS + | EXTRACT + | FLOAT_P + | GREATEST + | GROUPING + | INOUT + | INT_P + | INTEGER + | INTERVAL + | JSON + | IGNOREHEADER | IGNOREBLANKLINES | TRUNCATECOLUMNS | FILLRECORD + | BLANKSASNULL | EMPTYASNULL | ACCEPTINVCHARS | ACCEPTANYDATE + | DATEFORMAT | TIMEFORMAT | COMPUPDATE | STATUPDATE + | MAXERROR | READRATIO | MANIFEST | ENCRYPTED + | REMOVEQUOTES | EXPLICIT_IDS | ROUNDEC | TRIMBLANKS + | FIXEDWIDTH | ACCESS_KEY_ID | SECRET_ACCESS_KEY | SESSION_TOKEN_KW + | GZIP | BZIP2 | LZOP | ZSTD | AVRO | PARQUET | ORC + | REGION | DELIMITER | ENCODING | COMPRESSION | QUOTE | COMPROWS + | LEAST + | NATIONAL + | NCHAR + | NONE + | NORMALIZE + | NULLIF + | numeric + | OFFSET + | OUT_P + | OVERLAY + | POSITION + | PRECISION + | REAL + | ROW + | SETOF + | SMALLINT + | SUBSTRING + | TIME + | TIMESTAMP + | TREAT + | TRIM + | VALUES + | VARCHAR + | XMLATTRIBUTES + | XMLCONCAT + | XMLELEMENT + | XMLEXISTS + | XMLFOREST + | XMLNAMESPACES + | XMLPARSE + | XMLPI + | XMLROOT + | XMLSERIALIZE + | XMLTABLE + | builtin_function_name + ; + +type_func_name_keyword + : AUTHORIZATION + | BINARY + | COLLATION + | CONCURRENTLY + | CROSS + | CURRENT_SCHEMA + | FREEZE + | FULL + | ILIKE + | INNER_P + | IS + | ISNULL + | JOIN + | LIKE + | NATURAL + | NOTNULL + | OUTER_P + | OVERLAPS + | SIMILAR + | TABLESAMPLE + | VERBOSE + ; + +reserved_keyword + : ALL + | ANALYSE + | ANALYZE + | AND + | ANY + | ARRAY + | AS + | ASC + | ASYMMETRIC + | BOTH + | CASE + | CAST + | CHECK + | COLLATE + | COLUMN + | CONSTRAINT + | CREATE + | CURRENT_CATALOG + | CURRENT_DATE + | CURRENT_ROLE + | CURRENT_TIME + | CURRENT_TIMESTAMP + | CURRENT_USER + // | DEFAULT + | DEFERRABLE + | DESC + | DISTINCT + | DO + | ELSE + | END_P + | EXCEPT + | FALSE_P + | FETCH + | FOR + | FOREIGN + | FROM + | GRANT + | GROUP_P + | HAVING + | IN_P + | INITIALLY + | INTERSECT +/* +from pl_gram.y, line ~2982 + * Fortunately, INTO is a fully reserved word in the main grammar, so + * at least we need not worry about it appearing as an identifier. +*/ + + + // | INTO + | LATERAL_P + | LEADING + | LIMIT + | LOCALTIME + | LOCALTIMESTAMP + | NOT + | NULL_P + | OFFSET + | ON + | ONLY + | OR + | ORDER + | PLACING + | PRIMARY + | REFERENCES + | RETURNING + | SELECT + | SESSION_USER + | SOME + | SYMMETRIC + | TABLE + | THEN + | TO + | TRAILING + | TRUE_P + | UNION + | UNIQUE + | USER + | USING + | VARIADIC + | WHEN + | WHERE + | WINDOW + | WITH + ; + +builtin_function_name + : XMLCOMMENT + | XML_IS_WELL_FORMED + | XML_IS_WELL_FORMED_DOCUMENT + | XML_IS_WELL_FORMED_CONTENT + | XMLAGG + | XPATH + | XPATH_EXISTS + | ABS + | CBRT + | CEIL + | CEILING + | DEGREES + | DIV + | EXP + | FACTORIAL + | FLOOR + | GCD + | LCM + | LN + | LOG + | LOG10 + | MIN_SCALE + | MOD + | PI + | POWER + | RADIANS + | ROUND + | SCALE + | SIGN + | SQRT + | TRIM_SCALE + | TRUNC + | WIDTH_BUCKET + | RANDOM + | SETSEED + | ACOS + | ACOSD + | ACOSH + | ASIN + | ASIND + | ASINH + | ATAN + | ATAND + | ATANH + | ATAN2 + | ATAN2D + | COS + | COSD + | COSH + | COT + | COTD + | SIN + | SIND + | SINH + | TAN + | TAND + | TANH + | BIT_LENGTH + | CHAR_LENGTH + | CHARACTER_LENGTH + | LOWER + | OCTET_LENGTH + | OCTET_LENGTH + | UPPER + | ASCII + | BTRIM + | CHR + | CONCAT + | CONCAT_WS + | FORMAT + | INITCAP + | LENGTH + | LPAD + | LTRIM + | MD5 + | PARSE_IDENT + | PG_CLIENT_ENCODING + | QUOTE_IDENT + | QUOTE_LITERAL + | QUOTE_NULLABLE + | REGEXP_COUNT + | REGEXP_INSTR + | REGEXP_LIKE + | REGEXP_MATCH + | REGEXP_MATCHES + | REGEXP_REPLACE + | REGEXP_SPLIT_TO_ARRAY + | REGEXP_SPLIT_TO_TABLE + | REGEXP_SUBSTR + | REPEAT + | REPLACE + | REVERSE + | RPAD + | RTRIM + | SPLIT_PART + | STARTS_WITH + | STRING_TO_ARRAY + | STRING_TO_TABLE + | STRPOS + | SUBSTR + | TO_ASCII + | TO_HEX + | TRANSLATE + | UNISTR + | AGE + | DATE_BIN + | DATE_PART + | DATE_TRUNC + | ISFINITE + | JUSTIFY_DAYS + | JUSTIFY_HOURS + | JUSTIFY_INTERVAL + | MAKE_DATE + | MAKE_INTERVAL + | MAKE_TIME + | MAKE_TIMESTAMP + | MAKE_TIMESTAMPTZ + | CLOCK_TIMESTAMP + | NOW + | STATEMENT_TIMESTAMP + | TIMEOFDAY + | TRANSACTION_TIMESTAMP + | TO_TIMESTAMP + | JUSTIFY_INTERVAL + | JUSTIFY_INTERVAL + | TO_CHAR + | TO_DATE + | TO_NUMBER + | CURRENT_USER + ; + +/************************************************************************************************************************************************************/ +/*PL/SQL GRAMMAR */ + + +/*PLSQL grammar */ + + /************************************************************************************************************************************************************/ pl_function + : comp_options pl_block opt_semi? + ; + +comp_options + : comp_option* + ; + +comp_option + : sharp OPTION DUMP + | sharp PRINT_STRICT_PARAMS option_value + | sharp VARIABLE_CONFLICT ERROR + | sharp VARIABLE_CONFLICT USE_VARIABLE + | sharp VARIABLE_CONFLICT USE_COLUMN + ; + +sharp + : Operator + ; + +option_value + : sconst + | reserved_keyword + | plsql_unreserved_keyword + | unreserved_keyword + ; + +opt_semi + : SEMI + ; + // exception_sect means opt_exception_sect in original grammar, don't be confused! + +pl_block + : decl_sect BEGIN_P proc_sect exception_sect? END_P opt_label? + ; + +decl_sect + : opt_block_label? (decl_start decl_stmts?)? + ; + +decl_start + : DECLARE + ; + +decl_stmts + : decl_stmt+ + ; + +label_decl + : LESS_LESS any_identifier GREATER_GREATER + ; + +decl_stmt + : decl_statement + | DECLARE + | label_decl + ; + +decl_statement + : decl_varname + ( + ALIAS FOR decl_aliasitem + | decl_const? decl_datatype decl_collate? decl_notnull? decl_defval? + | opt_scrollable? CURSOR decl_cursor_args? decl_is_for decl_cursor_query + ) SEMI + ; + +opt_scrollable + : NO SCROLL + | SCROLL + ; + +decl_cursor_query + : selectstmt + ; + +decl_cursor_args + : OPEN_PAREN decl_cursor_arglist CLOSE_PAREN + ; + +decl_cursor_arglist + : decl_cursor_arg (COMMA decl_cursor_arg)* + ; + +decl_cursor_arg + : decl_varname decl_datatype + ; + +decl_is_for + : IS + | FOR + ; + +decl_aliasitem + : PARAM + | colid + ; + +decl_varname + : any_identifier + ; + +decl_const + : CONSTANT + ; + +decl_datatype + : typename + ; //TODO: $$ = read_datatype(yychar); + +decl_collate + : COLLATE any_name + ; + +decl_notnull + : NOT NULL_P + ; + +decl_defval + : decl_defkey sql_expression + ; + +decl_defkey + : assign_operator + | DEFAULT + ; + +assign_operator + : EQUAL + | COLON_EQUALS + ; + +proc_sect + : proc_stmt* + ; + +proc_stmt + : pl_block SEMI + | stmt_return + | stmt_raise + | stmt_assign + | stmt_if + | stmt_case + | stmt_loop + | stmt_while + | stmt_for + | stmt_foreach_a + | stmt_exit + | stmt_assert + | stmt_execsql + | stmt_dynexecute + | stmt_perform + | stmt_call + | stmt_getdiag + | stmt_open + | stmt_fetch + | stmt_move + | stmt_close + | stmt_null + | stmt_commit + | stmt_rollback + | stmt_set + ; + +stmt_perform + : PERFORM expr_until_semi SEMI + ; + +stmt_call + : CALL any_identifier OPEN_PAREN opt_expr_list? CLOSE_PAREN SEMI + | DO any_identifier OPEN_PAREN opt_expr_list? CLOSE_PAREN SEMI + ; + +opt_expr_list + : expr_list + ; + +stmt_assign + : assign_var assign_operator sql_expression SEMI + ; + +stmt_getdiag + : GET getdiag_area_opt? DIAGNOSTICS getdiag_list SEMI + ; + +getdiag_area_opt + : CURRENT_P + | STACKED + ; + +getdiag_list + : getdiag_list_item (COMMA getdiag_list_item)* + ; + +getdiag_list_item + : getdiag_target assign_operator getdiag_item + ; + +getdiag_item + : colid + ; + +getdiag_target + : assign_var + ; + +assign_var + : (any_name | PARAM) (OPEN_BRACKET expr_until_rightbracket CLOSE_BRACKET)* + ; + +stmt_if + : IF_P expr_until_then THEN proc_sect stmt_elsifs stmt_else? END_P IF_P SEMI + ; + +stmt_elsifs + : (ELSIF a_expr THEN proc_sect)* + ; + +stmt_else + : ELSE proc_sect + ; + +stmt_case + : CASE opt_expr_until_when? case_when_list opt_case_else? END_P CASE SEMI + ; + +opt_expr_until_when + : sql_expression + ; + +case_when_list + : case_when+ + ; + +case_when + : WHEN expr_list THEN proc_sect + ; + +opt_case_else + : ELSE proc_sect + ; + +stmt_loop + : opt_loop_label? loop_body + ; + +stmt_while + : opt_loop_label? WHILE expr_until_loop loop_body + ; + +stmt_for + : opt_loop_label? FOR for_control loop_body + ; + //TODO: rewrite using read_sql_expression logic? + +for_control + : for_variable IN_P + ( + cursor_name opt_cursor_parameters? + | selectstmt + | explainstmt + | EXECUTE a_expr opt_for_using_expression? + | opt_reverse? a_expr DOT_DOT a_expr opt_by_expression? + ) + ; + +opt_for_using_expression + : USING expr_list + ; + +opt_cursor_parameters + : OPEN_PAREN a_expr (COMMA a_expr)* CLOSE_PAREN + ; + +opt_reverse + : REVERSE + ; + +opt_by_expression + : BY a_expr + ; + +for_variable + : any_name_list + ; + +stmt_foreach_a + : opt_loop_label? FOREACH for_variable foreach_slice? IN_P ARRAY a_expr loop_body + ; + +foreach_slice + : SLICE iconst + ; + +stmt_exit + : exit_type opt_label? opt_exitcond? SEMI + ; + +exit_type + : EXIT + | CONTINUE_P + ; + //todo implement RETURN statement according to initial grammar line 1754 + +stmt_return + : RETURN (NEXT sql_expression | QUERY (EXECUTE a_expr opt_for_using_expression? | selectstmt) | opt_return_result?) SEMI + ; + +opt_return_result + : sql_expression + ; + //https://www.postgresql.org/docs/current/plpgsql-errors-and-messages.html + + //RAISE [ level ] 'format' [, expression [, ... ]] [ USING option = expression [, ... ] ]; + + //RAISE [ level ] condition_name [ USING option = expression [, ... ] ]; + + //RAISE [ level ] SQLSTATE 'sqlstate' [ USING option = expression [, ... ] ]; + + //RAISE [ level ] USING option = expression [, ... ]; + + //RAISE ; + +stmt_raise + : RAISE opt_stmt_raise_level? sconst opt_raise_list? opt_raise_using? SEMI + | RAISE opt_stmt_raise_level? identifier opt_raise_using? SEMI + | RAISE opt_stmt_raise_level? SQLSTATE sconst opt_raise_using? SEMI + | RAISE opt_stmt_raise_level? opt_raise_using? SEMI + | RAISE + ; + +opt_stmt_raise_level + : DEBUG + | LOG + | INFO + | NOTICE + | WARNING + | EXCEPTION + ; + +opt_raise_list + : (COMMA a_expr)+ + ; + +opt_raise_using + : USING opt_raise_using_elem_list + ; + +opt_raise_using_elem + : identifier EQUAL a_expr + ; + +opt_raise_using_elem_list + : opt_raise_using_elem (COMMA opt_raise_using_elem)* + ; + //todo imnplement + +stmt_assert + : ASSERT sql_expression opt_stmt_assert_message? SEMI + ; + +opt_stmt_assert_message + : COMMA sql_expression + ; + +loop_body + : LOOP proc_sect END_P LOOP opt_label? SEMI + ; + //TODO: looks like all other statements like INSERT/SELECT/UPDATE/DELETE are handled here; + + //pls take a look at original grammar + +stmt_execsql + : make_execsql_stmt SEMI +/*K_IMPORT + | K_INSERT + | t_word + | t_cword +*/ + + + ; + //https://www.postgresql.org/docs/current/plpgsql-statements.html#PLPGSQL-STATEMENTS-SQL-NORESULT + + //EXECUTE command-string [ INTO [STRICT] target ] [ USING expression [, ... ] ]; + +stmt_dynexecute + : EXECUTE a_expr ( +/*this is silly, but i have to time to find nice way to code */ + + opt_execute_into? opt_execute_using? | opt_execute_using? opt_execute_into? |) SEMI + ; + +opt_execute_using + : USING opt_execute_using_list + ; + +opt_execute_using_list + : a_expr (COMMA a_expr)* + ; + +opt_execute_into + : INTO STRICT_P? into_target + ; + //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + + //OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR query; + + //OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR EXECUTE query_string + + // [ USING expression [, ... ] ]; + + //OPEN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ]; + +stmt_open + : OPEN + ( + cursor_variable opt_scroll_option? FOR (selectstmt | EXECUTE sql_expression opt_open_using?) + | colid (OPEN_PAREN opt_open_bound_list CLOSE_PAREN)? + ) SEMI + ; + +opt_open_bound_list_item + : colid COLON_EQUALS a_expr + | a_expr + ; + +opt_open_bound_list + : opt_open_bound_list_item (COMMA opt_open_bound_list_item)* + ; + +opt_open_using + : USING expr_list + ; + +opt_scroll_option + : opt_scroll_option_no? SCROLL + ; + +opt_scroll_option_no + : NO + ; + //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + + //FETCH [ direction { FROM | IN } ] cursor INTO target; + +stmt_fetch + : FETCH direction = opt_fetch_direction? opt_cursor_from? cursor_variable INTO into_target SEMI + ; + +into_target + : expr_list + ; + +opt_cursor_from + : FROM + | IN_P + ; + +opt_fetch_direction + : NEXT + | PRIOR + | FIRST_P + | LAST_P + | ABSOLUTE_P a_expr + | RELATIVE_P a_expr + | a_expr + | ALL + | (FORWARD | BACKWARD) (a_expr | ALL)? + ; + //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + + //MOVE [ direction { FROM | IN } ] cursor; + +stmt_move + : MOVE opt_fetch_direction? cursor_variable SEMI + ; + +stmt_close + : CLOSE cursor_variable SEMI + ; + +stmt_null + : NULL_P SEMI + ; + +stmt_commit + : COMMIT plsql_opt_transaction_chain? SEMI + ; + +stmt_rollback + : ROLLBACK plsql_opt_transaction_chain? SEMI + ; + +plsql_opt_transaction_chain + : AND NO? CHAIN + ; + +stmt_set + : SET any_name TO DEFAULT SEMI + | RESET (any_name | ALL) SEMI + ; + +cursor_variable + : colid + | PARAM + ; + +exception_sect + : EXCEPTION proc_exceptions + ; + +proc_exceptions + : proc_exception+ + ; + +proc_exception + : WHEN proc_conditions THEN proc_sect + ; + +proc_conditions + : proc_condition (OR proc_condition)* + ; + +proc_condition + : any_identifier + | SQLSTATE sconst + ; + //expr_until_semi: + + //; + + //expr_until_rightbracket: + + //; + + //expr_until_loop: + + //; + +opt_block_label + : label_decl + ; + +opt_loop_label + : label_decl + ; + +opt_label + : any_identifier + ; + +opt_exitcond + : WHEN expr_until_semi + ; + +any_identifier + : colid + | plsql_unreserved_keyword + ; + +plsql_unreserved_keyword + : ABSOLUTE_P + | ALIAS + | AND + | ARRAY + | ASSERT + | BACKWARD + | CALL + | CHAIN + | CLOSE + | COLLATE + | COLUMN + //| COLUMN_NAME + | COMMIT + | CONSTANT + | CONSTRAINT + //| CONSTRAINT_NAME + | CONTINUE_P + | CURRENT_P + | CURSOR + //| DATATYPE + | DEBUG + | DEFAULT + //| DETAIL + | DIAGNOSTICS + | DO + | DUMP + | ELSIF + //| ERRCODE + | ERROR + | EXCEPTION + | EXIT + | FETCH + | FIRST_P + | FORWARD + | GET + //| HINT + + //| IMPORT + | INFO + | INSERT + | IS + | LAST_P + //| MESSAGE + + //| MESSAGE_TEXT + | MOVE + | NEXT + | NO + | NOTICE + | OPEN + | OPTION + | PERFORM + //| PG_CONTEXT + + //| PG_DATATYPE_NAME + + //| PG_EXCEPTION_CONTEXT + + //| PG_EXCEPTION_DETAIL + + //| PG_EXCEPTION_HINT + | PRINT_STRICT_PARAMS + | PRIOR + | QUERY + | RAISE + | RELATIVE_P + | RESET + | RETURN + //| RETURNED_SQLSTATE + | ROLLBACK + //| ROW_COUNT + | ROWTYPE + | SCHEMA + //| SCHEMA_NAME + | SCROLL + | SET + | SLICE + | SQLSTATE + | STACKED + | TABLE + //| TABLE_NAME + | TYPE_P + | USE_COLUMN + | USE_VARIABLE + | VARIABLE_CONFLICT + | WARNING + | OUTER_P + ; + +sql_expression + : opt_target_list? into_clause? from_clause? where_clause? group_clause? having_clause? window_clause? + ; + +expr_until_then + : sql_expression + ; + +expr_until_semi + : sql_expression + ; + +expr_until_rightbracket + : a_expr + ; + +expr_until_loop + : a_expr + ; + +make_execsql_stmt + : stmt opt_returning_clause_into? + ; + +opt_returning_clause_into + : INTO opt_strict? into_target + ; diff --git a/redshift/RedshiftParser.interp b/redshift/RedshiftParser.interp new file mode 100644 index 0000000..c6c351e --- /dev/null +++ b/redshift/RedshiftParser.interp @@ -0,0 +1,2891 @@ +token literal names: +null +'$' +'(' +')' +'[' +']' +',' +';' +':' +'*' +'=' +'.' +'+' +'-' +'/' +'^' +'<' +'>' +'<<' +'>>' +':=' +'<=' +'=>' +'>=' +'..' +'<>' +'::' +'%' +null +null +'ALL' +'ANALYSE' +'ANALYZE' +'AND' +'ANY' +'ARRAY' +'AS' +'ASC' +'ASYMMETRIC' +'BOTH' +'CASE' +'CAST' +'CHECK' +'COLLATE' +'COLUMN' +'CONSTRAINT' +'CREATE' +'CURRENT_CATALOG' +'CURRENT_DATE' +'CURRENT_ROLE' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DEFAULT' +'DEFERRABLE' +'DESC' +'DISTINCT' +'DO' +'ELSE' +'EXCEPT' +'FALSE' +'FETCH' +'FOR' +'FOREIGN' +'FROM' +'GRANT' +'GROUP' +'HAVING' +'IN' +'INITIALLY' +'INTERSECT' +'INTO' +'LATERAL' +'LEADING' +'LIMIT' +'LOCALTIME' +'LOCALTIMESTAMP' +'NOT' +'NULL' +'OFFSET' +'ON' +'ONLY' +'OR' +'ORDER' +'PLACING' +'PRIMARY' +'PUBLIC' +'REFERENCES' +'RETURNING' +'SELECT' +'SESSION_USER' +'SOME' +'SYMMETRIC' +'TABLE' +'THEN' +'TO' +'TRAILING' +'TRUE' +'UNION' +'UNIQUE' +'USER' +'USING' +'VARIADIC' +'WHEN' +'WHERE' +'WINDOW' +'WITH' +'AUTHORIZATION' +'BINARY' +'BINDING' +'COLLATION' +'CONCURRENTLY' +'CROSS' +'CURRENT_SCHEMA' +'FREEZE' +'FULL' +'ILIKE' +'INNER' +'IS' +'ISNULL' +'JOIN' +'LEFT' +'LIKE' +'NATURAL' +'NOTNULL' +'OUTER' +'OVER' +'OVERLAPS' +'RIGHT' +'SIMILAR' +'VERBOSE' +'ABORT' +'ABSOLUTE' +'ACCESS' +'ACTION' +'ADD' +'ADMIN' +'AFTER' +'AGGREGATE' +'ALSO' +'ALTER' +'ALWAYS' +'ASSERTION' +'ASSIGNMENT' +'AT' +'ATTRIBUTE' +'BACKWARD' +'BEFORE' +'BEGIN' +'BY' +'CACHE' +'CALLED' +'CASCADE' +'CASCADED' +'CATALOG' +'CHAIN' +'CHARACTERISTICS' +'CHECKPOINT' +'CLASS' +'CLOSE' +'CLUSTER' +'COMMENT' +'COMMENTS' +'COMMIT' +'COMMITTED' +'CONFIGURATION' +'CONNECTION' +'CONSTRAINTS' +'CONTENT' +'CONTINUE' +'CONVERSION' +'COPY' +'COST' +'CSV' +'JSON' +'CURSOR' +'CYCLE' +'DATA' +'DATA_CATALOG' +'DATABASE' +'DAY' +'DEALLOCATE' +'DECLARE' +'DEFAULTS' +'DEFERRED' +'DEFINER' +'DELETE' +'DELIMITER' +'DELIMITERS' +'DICTIONARY' +'DISABLE' +'DISCARD' +'DOCUMENT' +'DOMAIN' +'DOUBLE' +'DROP' +'EACH' +'ENABLE' +'ENCODING' +'ENCRYPTED' +'ENUM' +'ESCAPE' +'EVENT' +'EXCLUDE' +'EXCLUDING' +'EXCLUSIVE' +'EXECUTE' +'EXPLAIN' +'EXTENSION' +'EXTERNAL' +'FAMILY' +'FIRST' +'FOLLOWING' +'FORCE' +'FORWARD' +'FUNCTION' +'FUNCTIONS' +'GLOBAL' +'GRANTED' +'HANDLER' +null +'HOLD' +'HOUR' +null +'IF' +'IMMEDIATE' +'IMMUTABLE' +'IMPLICIT' +'INCLUDING' +'INCREMENT' +'INDEX' +'INDEXES' +'INHERIT' +'INHERITS' +'INLINE' +'INSENSITIVE' +'INSERT' +'INSTEAD' +'INVOKER' +'ISOLATION' +'KEY' +'LABEL' +'LANGUAGE' +'LARGE' +'LAST' +'LEAKPROOF' +'LEVEL' +'LISTEN' +'LOAD' +'LOCAL' +'LOCATION' +'LOCK' +'MAPPING' +'MATCH' +'MATCHED' +'MATERIALIZED' +'MAXVALUE' +'MERGE' +'MINUTE' +'MINVALUE' +'MODE' +'MONTH' +'MOVE' +'NAME' +'NAMES' +'NEXT' +'NO' +'NOTHING' +'NOTIFY' +'NOWAIT' +'NULLS' +'OBJECT' +'OF' +'OFF' +'OIDS' +'OPERATOR' +'OPTION' +'OPTIONS' +'OWNED' +'OWNER' +'PARSER' +'PARTIAL' +'PARTITION' +'PASSING' +'PASSWORD' +'PLANS' +'PRECEDING' +'PREDICATE' +'PREPARE' +'PREPARED' +'PRESERVE' +'PRIOR' +'PRIVILEGES' +'PROCEDURAL' +'PROCEDURE' +'PROGRAM' +'QUOTE' +'RANGE' +'READ' +'REASSIGN' +'RECHECK' +'RECURSIVE' +'REF' +'REFRESH' +'REINDEX' +'RELATIVE' +'RELEASE' +'RENAME' +'REPEATABLE' +'REPLACE' +'REPLICA' +'RESET' +'RESTART' +'RESTRICT' +'RETURNS' +'REVOKE' +'ROLE' +'ROLLBACK' +'ROWS' +'RULE' +'SAVEPOINT' +'SCHEMA' +'SCROLL' +'SEARCH' +'SECOND' +'SECURITY' +'SEQUENCE' +'SEQUENCES' +'SERIALIZABLE' +'SERVER' +null +'SET' +'SHARE' +'SHOW' +'SIMPLE' +'SNAPSHOT' +'STABLE' +'STANDALONE' +'START' +'STATEMENT' +'STATISTICS' +'STDIN' +'STDOUT' +'STORAGE' +'STRICT' +'STRIP' +'SYSID' +'SYSTEM' +'TABLES' +'TABLESPACE' +'TEMP' +'TEMPLATE' +'TEMPORARY' +'TEXT' +'TRANSACTION' +'TRIGGER' +'TRUNCATE' +'TRUSTED' +'TYPE' +'TYPES' +'UNBOUNDED' +'UNCOMMITTED' +'UNENCRYPTED' +'UNKNOWN' +'UNLISTEN' +'UNLOGGED' +'UNTIL' +'UPDATE' +'VACUUM' +'VALID' +'VALIDATE' +'VALIDATOR' +'VARYING' +'VERSION' +'VIEW' +'VOLATILE' +'WHITESPACE' +'WITHOUT' +'WORK' +'WRAPPER' +'WRITE' +'XML' +'YEAR' +'YES' +'ZONE' +'QUALIFY' +'CONNECT' +'TOP' +'VARBYTE' +'VARBINARY' +'CONJUNCTION' +'DEFINITION' +'DATASHARE' +'FILE' +'PUBLICACCESSIBLE' +'INCLUDENEW' +'IAM_ROLE' +'CATALOG_ROLE' +'CATALOG_ID' +'HIVE' +'METASTORE' +'URI' +'POSTGRES' +'MYSQL' +'SECRET_ARN' +'KINESIS' +'KAFKA' +'MSK' +'AUTHENTICATION' +'AUTHENTICATION_ARN' +null +'MTLS' +'MASKING' +'RLS' +null +'PROVIDER' +'PROTECTED' +'MODEL' +'TARGET' +'SAGEMAKER' +'AUTO' +'MODEL_TYPE' +'PROBLEM_TYPE' +'OBJECTIVE' +'PREPROCESSORS' +'HYPERPARAMETERS' +'XGBOOST' +'MLP' +'LINEAR_LEARNER' +'KMEANS' +'FORECAST' +'REGRESSION' +'BINARY_CLASSIFICATION' +'MULTICLASS_CLASSIFICATION' +'S3_BUCKET' +'TAGS' +'KMS_KEY_ID' +'S3_GARBAGE_COLLECT' +'MAX_CELLS' +'MAX_RUNTIME' +'HORIZON' +'FREQUENCY' +'PERCENTILES' +'MAX_BATCH_ROWS' +'UNLOAD' +'MANIFEST' +'ADDQUOTES' +'ALLOWOVERWRITE' +'CLEANPATH' +'MAXFILESIZE' +'ROWGROUPSIZE' +'BZIP2' +'GZIP' +'ZSTD' +'DATABASES' +'DATASHARES' +'GRANTS' +'USE' +'CANCEL' +'SESSION_AUTHORIZATION' +'SESSION_CHARACTERISTICS' +'COMPRESSION' +'LIBRARY' +'APPEND' +'MB' +'GB' +'ACCOUNT' +'NAMESPACE' +'DESCRIBE' +'NONATOMIC' +'MANAGEDBY' +'ADX' +'REMOVE' +'DUPLICATES' +'BEDROCK' +'MODEL_ID' +'PROMPT' +'SUFFIX' +'REQUEST_TYPE' +'RESPONSE_TYPE' +'RAW' +'UNIFIED' +'SUPER' +'CI' +'CS' +'PLPYTHONU' +'FILLTARGET' +'IGNOREEXTRA' +'CREATEUSER' +'NOCREATEUSER' +'REGION' +'PORT' +'REDSHIFT' +'IAM' +'CREATEDB' +'NOCREATEDB' +'RESTRICTED' +'UNLIMITED' +'EXTERNALID' +'TIMEOUT' +'SYSLOG' +'CREDENTIALS' +'UNRESTRICTED' +'PARAMETERS' +'APPLICATION_ARN' +'AUTO_CREATE_ROLES' +'COMPROWS' +'PROVIDER_URL' +'PROVIDER_URL_PORT' +'ATTRIBUTE_MAP' +'PROVIDER_ARN' +'ASSUME_ROLE_ARN' +'PROPERTIES' +'AVRO' +'RCFILE' +'SEQUENCEFILE' +'TEXTFILE' +'ORC' +'ION' +'LAMBDA' +'FIXEDWIDTH' +'PARQUET' +'LZOP' +'REMOVEQUOTES' +'TRUNCATECOLUMNS' +'FILLRECORD' +'BLANKSASNULL' +'EMPTYASNULL' +'MAXERROR' +'DATEFORMAT' +'TIMEFORMAT' +'ACCEPTINVCHARS' +'ACCEPTANYDATE' +'IGNOREHEADER' +'IGNOREBLANKLINES' +'COMPUPDATE' +'STATUPDATE' +'EXPLICIT_IDS' +'READRATIO' +'ROUNDEC' +'TRIMBLANKS' +'PRESET' +'ACCESS_KEY_ID' +'SECRET_ACCESS_KEY' +'SESSION_TOKEN' +null +'SETTINGS' +'FUNCTION_NAME' +'ATOMIC' +'BETWEEN' +'BIGINT' +'BIT' +'BOOLEAN' +'CHAR' +'CHARACTER' +'COALESCE' +'DEC' +'DECIMAL' +'EXISTS' +'EXTRACT' +'FLOAT' +'GREATEST' +'INOUT' +'INT' +'INTEGER' +'INTERVAL' +'LEAST' +'NATIONAL' +'NCHAR' +'NONE' +'NULLIF' +'NUMERIC' +'OVERLAY' +'PARAMETER' +'POSITION' +'PRECISION' +'REAL' +'ROW' +'SETOF' +'SMALLINT' +'SUBSTRING' +'TIME' +'TIMESTAMP' +'TREAT' +'TRIM' +'VALUES' +'VARCHAR' +'XMLATTRIBUTES' +'XMLCOMMENT' +'XMLAGG' +'XML_IS_WELL_FORMED' +'XML_IS_WELL_FORMED_DOCUMENT' +'XML_IS_WELL_FORMED_CONTENT' +'XPATH' +'XPATH_EXISTS' +'XMLCONCAT' +'XMLELEMENT' +'XMLEXISTS' +'XMLFOREST' +'XMLPARSE' +'XMLPI' +'XMLROOT' +'XMLSERIALIZE' +'CALL' +'CURRENT' +'ATTACH' +'DETACH' +'EXPRESSION' +'GENERATED' +'LOGGED' +'STORED' +'SERDE' +'SERDEPROPERTIES' +'INPUTFORMAT' +'OUTPUTFORMAT' +'FIELDS' +'COLLECTION' +'ITEMS' +'TERMINATED' +'ESCAPED' +'DEFINED' +'LINES' +'KEYS' +'PARTITIONED' +'STRUCT' +'MAP' +'STRING' +'DELIMITED' +'USAGE' +'IGNORE' +'LANGUAGES' +'JOB' +'JOBS' +'VIA' +'ASSUMEROLE' +'RETRY_TIMEOUT' +'MAX_BATCH_SIZE' +'MAX_PAYLOAD_IN_MB' +'KB' +'INCLUDE' +'ROUTINE' +'TRANSFORM' +'IMPORT' +'POLICY' +'PRIORITY' +'METHOD' +'REFERENCING' +'NEW' +'OLD' +'VALUE' +'SUBSCRIPTION' +'PUBLICATION' +'OUT' +'END' +'ROUTINES' +'SCHEMAS' +'PROCEDURES' +'INPUT' +'SUPPORT' +'PARALLEL' +'SQL' +'DEPENDS' +'OVERRIDING' +'CONFLICT' +'SKIP' +'LOCKED' +'TIES' +'ROLLUP' +'CUBE' +'GROUPING' +'SETS' +'TABLESAMPLE' +'ORDINALITY' +'XMLTABLE' +'COLUMNS' +'XMLNAMESPACES' +'ROWTYPE' +'NORMALIZED' +'WITHIN' +'FILTER' +'GROUPS' +'OTHERS' +'NFC' +'NFD' +'NFKC' +'NFKD' +'UESCAPE' +'VIEWS' +'NORMALIZE' +'DUMP' +'PRINT_STRICT_PARAMS' +'VARIABLE_CONFLICT' +'ERROR' +'USE_VARIABLE' +'USE_COLUMN' +'ALIAS' +'CONSTANT' +'PERFORM' +'GET' +'DIAGNOSTICS' +'STACKED' +'ELSIF' +'WHILE' +'REVERSE' +'FOREACH' +'SLICE' +'EXIT' +'RETURN' +'QUERY' +'RAISE' +'SQLSTATE' +'DEBUG' +'LOG' +'INFO' +'NOTICE' +'WARNING' +'EXCEPTION' +'ASSERT' +'LOOP' +'OPEN' +'ABS' +'CBRT' +'CEIL' +'CEILING' +'DEGREES' +'DIV' +'EXP' +'FACTORIAL' +'FLOOR' +'GCD' +'LCM' +'LN' +'LOG10' +'MIN_SCALE' +'MOD' +'PI' +'POWER' +'RADIANS' +'ROUND' +'SCALE' +'SIGN' +'SQRT' +'TRIM_SCALE' +'TRUNC' +'WIDTH_BUCKET' +'RANDOM' +'SETSEED' +'ACOS' +'ACOSD' +'ASIN' +'ASIND' +'ATAN' +'ATAND' +'ATAN2' +'ATAN2D' +'COS' +'COSD' +'COT' +'COTD' +'SIN' +'SIND' +'TAN' +'TAND' +'SINH' +'COSH' +'TANH' +'ASINH' +'ACOSH' +'ATANH' +'BIT_LENGTH' +'CHAR_LENGTH' +'CHARACTER_LENGTH' +'LOWER' +'OCTET_LENGTH' +'UPPER' +'ASCII' +'BTRIM' +'CHR' +'CONCAT' +'CONCAT_WS' +'FORMAT' +'INITCAP' +'LENGTH' +'LPAD' +'LTRIM' +'MD5' +'PARSE_IDENT' +'PG_CLIENT_ENCODING' +'QUOTE_IDENT' +'QUOTE_LITERAL' +'QUOTE_NULLABLE' +'REGEXP_COUNT' +'REGEXP_INSTR' +'REGEXP_LIKE' +'REGEXP_MATCH' +'REGEXP_MATCHES' +'REGEXP_REPLACE' +'REGEXP_SPLIT_TO_ARRAY' +'REGEXP_SPLIT_TO_TABLE' +'REGEXP_SUBSTR' +'REPEAT' +'RPAD' +'RTRIM' +'SPLIT_PART' +'STARTS_WITH' +'STRING_TO_ARRAY' +'STRING_TO_TABLE' +'STRPOS' +'SUBSTR' +'TO_ASCII' +'TO_HEX' +'TRANSLATE' +'UNISTR' +'AGE' +'CLOCK_TIMESTAMP' +'DATE_BIN' +'DATE_PART' +'DATE_TRUNC' +'ISFINITE' +'JUSTIFY_DAYS' +'JUSTIFY_HOURS' +'JUSTIFY_INTERVAL' +'MAKE_DATE' +'MAKE_INTERVAL' +'MAKE_TIME' +'MAKE_TIMESTAMP' +'MAKE_TIMESTAMPTZ' +'NOW' +'STATEMENT_TIMESTAMP' +'TIMEOFDAY' +'TRANSACTION_TIMESTAMP' +'TO_TIMESTAMP' +'TO_CHAR' +'TO_DATE' +'TO_NUMBER' +'ENCODE' +'DISTKEY' +'SORTKEY' +'DISTSTYLE' +'BACKUP' +'COMPOUND' +'INTERLEAVED' +'EVEN' +'CASE_SENSITIVE' +'QUOTA' +'TB' +'BOOST' +'RECLUSTER' +'SORT' +'PERCENT' +'CASE_INSENSITIVE' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'\\\\' +null +null +null +null +null +null +null +null +null +'\'' + +token symbolic names: +null +Dollar +OPEN_PAREN +CLOSE_PAREN +OPEN_BRACKET +CLOSE_BRACKET +COMMA +SEMI +COLON +STAR +EQUAL +DOT +PLUS +MINUS +SLASH +CARET +LT +GT +LESS_LESS +GREATER_GREATER +COLON_EQUALS +LESS_EQUALS +EQUALS_GREATER +GREATER_EQUALS +DOT_DOT +NOT_EQUALS +TYPECAST +PERCENT +PARAM +Operator +ALL +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASYMMETRIC +BOTH +CASE +CAST +CHECK +COLLATE +COLUMN +CONSTRAINT +CREATE +CURRENT_CATALOG +CURRENT_DATE +CURRENT_ROLE +CURRENT_TIME +CURRENT_TIMESTAMP +CURRENT_USER +DEFAULT +DEFERRABLE +DESC +DISTINCT +DO +ELSE +EXCEPT +FALSE_P +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP_P +HAVING +IN_P +INITIALLY +INTERSECT +INTO +LATERAL_P +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL_P +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +PUBLIC +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE_P +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +AUTHORIZATION +BINARY +BINDING +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER_P +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER_P +OVER +OVERLAPS +RIGHT +SIMILAR +VERBOSE +ABORT_P +ABSOLUTE_P +ACCESS +ACTION +ADD_P +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTRIBUTE +BACKWARD +BEFORE +BEGIN_P +BY +CACHE +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONNECTION +CONSTRAINTS +CONTENT_P +CONTINUE_P +CONVERSION_P +COPY +COST +CSV +JSON +CURSOR +CYCLE +DATA_P +DATA_CATALOG +DATABASE +DAY_P +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE_P +DELIMITER +DELIMITERS +DICTIONARY +DISABLE_P +DISCARD +DOCUMENT_P +DOMAIN_P +DOUBLE_P +DROP +EACH +ENABLE_P +ENCODING +ENCRYPTED +ENUM_P +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FIRST_P +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GLOBAL +GRANTED +HANDLER +HEADER_P +HOLD +HOUR_P +IDENTITY_P +IF_P +IMMEDIATE +IMMUTABLE +IMPLICIT_P +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE_P +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE_P +LAST_P +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK_P +MAPPING +MATCH +MATCHED +MATERIALIZED +MAXVALUE +MERGE +MINUTE_P +MINVALUE +MODE +MONTH_P +MOVE +NAME_P +NAMES +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS_P +OBJECT_P +OF +OFF +OIDS +OPERATOR +OPTION +OPTIONS +OWNED +OWNER +PARSER +PARTIAL +PARTITION +PASSING +PASSWORD +PLANS +PRECEDING +PREDICATE +PREPARE +PREPARED +PRESERVE +PRIOR +PRIVILEGES +PROCEDURAL +PROCEDURE +PROGRAM +QUOTE +RANGE +READ +REASSIGN +RECHECK +RECURSIVE +REF +REFRESH +REINDEX +RELATIVE_P +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROWS +RULE +SAVEPOINT +SCHEMA +SCROLL +SEARCH +SECOND_P +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SHARE +SHOW +SIMPLE +SNAPSHOT +STABLE +STANDALONE_P +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STRICT_P +STRIP_P +SYSID +SYSTEM_P +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT_P +TRANSACTION +TRIGGER +TRUNCATE +TRUSTED +TYPE_P +TYPES_P +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VARYING +VERSION_P +VIEW +VOLATILE +WHITESPACE_P +WITHOUT +WORK +WRAPPER +WRITE +XML_P +YEAR_P +YES_P +ZONE +QUALIFY +CONNECT +TOP +VARBYTE +VARBINARY +CONJUNCTION +DEFINITION +DATASHARE +FILE +PUBLICACCESSIBLE +INCLUDENEW +IAM_ROLE +CATALOG_ROLE +CATALOG_ID +HIVE +METASTORE +URI +POSTGRES +MYSQL +SECRET_ARN +KINESIS +KAFKA +MSK +AUTHENTICATION +AUTHENTICATION_ARN +SESSION_TOKEN +MTLS +MASKING +RLS +IDENTITY +PROVIDER +PROTECTED +MODEL +TARGET +SAGEMAKER +AUTO +MODEL_TYPE +PROBLEM_TYPE +OBJECTIVE +PREPROCESSORS +HYPERPARAMETERS +XGBOOST +MLP +LINEAR_LEARNER +KMEANS +FORECAST +REGRESSION +BINARY_CLASSIFICATION +MULTICLASS_CLASSIFICATION +S3_BUCKET +TAGS +KMS_KEY_ID +S3_GARBAGE_COLLECT +MAX_CELLS +MAX_RUNTIME +HORIZON +FREQUENCY +PERCENTILES +MAX_BATCH_ROWS +UNLOAD +MANIFEST +ADDQUOTES +ALLOWOVERWRITE +CLEANPATH +MAXFILESIZE +ROWGROUPSIZE +BZIP2 +GZIP +ZSTD +DATABASES +DATASHARES +GRANTS +USE +CANCEL +SESSION_AUTHORIZATION +SESSION_CHARACTERISTICS +COMPRESSION +LIBRARY +APPEND +MB +GB +ACCOUNT +NAMESPACE +DESCRIBE +NONATOMIC +MANAGEDBY +ADX +REMOVE +DUPLICATES +BEDROCK +MODEL_ID +PROMPT +SUFFIX +REQUEST_TYPE +RESPONSE_TYPE +RAW +UNIFIED +SUPER +CI +CS +PLPYTHONU +FILLTARGET +IGNOREEXTRA +CREATEUSER +NOCREATEUSER +REGION +PORT +REDSHIFT +IAM +CREATEDB +NOCREATEDB +RESTRICTED +UNLIMITED +EXTERNALID +TIMEOUT +SYSLOG +CREDENTIALS +UNRESTRICTED +PARAMETERS +APPLICATION_ARN +AUTO_CREATE_ROLES +COMPROWS +PROVIDER_URL +PROVIDER_URL_PORT +ATTRIBUTE_MAP +PROVIDER_ARN +ASSUME_ROLE_ARN +PROPERTIES +AVRO +RCFILE +SEQUENCEFILE +TEXTFILE +ORC +ION +LAMBDA +FIXEDWIDTH +PARQUET +LZOP +REMOVEQUOTES +TRUNCATECOLUMNS +FILLRECORD +BLANKSASNULL +EMPTYASNULL +MAXERROR +DATEFORMAT +TIMEFORMAT +ACCEPTINVCHARS +ACCEPTANYDATE +IGNOREHEADER +IGNOREBLANKLINES +COMPUPDATE +STATUPDATE +EXPLICIT_IDS +READRATIO +ROUNDEC +TRIMBLANKS +PRESET +ACCESS_KEY_ID +SECRET_ACCESS_KEY +SESSION_TOKEN_KW +HEADER +SETTINGS +FUNCTION_NAME +ATOMIC_P +BETWEEN +BIGINT +BIT +BOOLEAN_P +CHAR_P +CHARACTER +COALESCE +DEC +DECIMAL_P +EXISTS +EXTRACT +FLOAT_P +GREATEST +INOUT +INT_P +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OVERLAY +PARAMETER +POSITION +PRECISION +REAL +ROW +SETOF +SMALLINT +SUBSTRING +TIME +TIMESTAMP +TREAT +TRIM +VALUES +VARCHAR +XMLATTRIBUTES +XMLCOMMENT +XMLAGG +XML_IS_WELL_FORMED +XML_IS_WELL_FORMED_DOCUMENT +XML_IS_WELL_FORMED_CONTENT +XPATH +XPATH_EXISTS +XMLCONCAT +XMLELEMENT +XMLEXISTS +XMLFOREST +XMLPARSE +XMLPI +XMLROOT +XMLSERIALIZE +CALL +CURRENT_P +ATTACH +DETACH +EXPRESSION +GENERATED +LOGGED +STORED +SERDE +SERDEPROPERTIES +INPUTFORMAT +OUTPUTFORMAT +FIELDS +COLLECTION +ITEMS +TERMINATED +ESCAPED +DEFINED +LINES +KEYS +PARTITIONED +STRUCT +MAP +STRING +DELIMITED +USAGE +IGNORE +LANGUAGES +JOB +JOBS +VIA +ASSUMEROLE +RETRY_TIMEOUT +MAX_BATCH_SIZE +MAX_PAYLOAD_IN_MB +KB +INCLUDE +ROUTINE +TRANSFORM +IMPORT_P +POLICY +PRIORITY +METHOD +REFERENCING +NEW +OLD +VALUE_P +SUBSCRIPTION +PUBLICATION +OUT_P +END_P +ROUTINES +SCHEMAS +PROCEDURES +INPUT_P +SUPPORT +PARALLEL +SQL_P +DEPENDS +OVERRIDING +CONFLICT +SKIP_P +LOCKED +TIES +ROLLUP +CUBE +GROUPING +SETS +TABLESAMPLE +ORDINALITY +XMLTABLE +COLUMNS +XMLNAMESPACES +ROWTYPE +NORMALIZED +WITHIN +FILTER +GROUPS +OTHERS +NFC +NFD +NFKC +NFKD +UESCAPE +VIEWS +NORMALIZE +DUMP +PRINT_STRICT_PARAMS +VARIABLE_CONFLICT +ERROR +USE_VARIABLE +USE_COLUMN +ALIAS +CONSTANT +PERFORM +GET +DIAGNOSTICS +STACKED +ELSIF +WHILE +REVERSE +FOREACH +SLICE +EXIT +RETURN +QUERY +RAISE +SQLSTATE +DEBUG +LOG +INFO +NOTICE +WARNING +EXCEPTION +ASSERT +LOOP +OPEN +ABS +CBRT +CEIL +CEILING +DEGREES +DIV +EXP +FACTORIAL +FLOOR +GCD +LCM +LN +LOG10 +MIN_SCALE +MOD +PI +POWER +RADIANS +ROUND +SCALE +SIGN +SQRT +TRIM_SCALE +TRUNC +WIDTH_BUCKET +RANDOM +SETSEED +ACOS +ACOSD +ASIN +ASIND +ATAN +ATAND +ATAN2 +ATAN2D +COS +COSD +COT +COTD +SIN +SIND +TAN +TAND +SINH +COSH +TANH +ASINH +ACOSH +ATANH +BIT_LENGTH +CHAR_LENGTH +CHARACTER_LENGTH +LOWER +OCTET_LENGTH +UPPER +ASCII +BTRIM +CHR +CONCAT +CONCAT_WS +FORMAT +INITCAP +LENGTH +LPAD +LTRIM +MD5 +PARSE_IDENT +PG_CLIENT_ENCODING +QUOTE_IDENT +QUOTE_LITERAL +QUOTE_NULLABLE +REGEXP_COUNT +REGEXP_INSTR +REGEXP_LIKE +REGEXP_MATCH +REGEXP_MATCHES +REGEXP_REPLACE +REGEXP_SPLIT_TO_ARRAY +REGEXP_SPLIT_TO_TABLE +REGEXP_SUBSTR +REPEAT +RPAD +RTRIM +SPLIT_PART +STARTS_WITH +STRING_TO_ARRAY +STRING_TO_TABLE +STRPOS +SUBSTR +TO_ASCII +TO_HEX +TRANSLATE +UNISTR +AGE +CLOCK_TIMESTAMP +DATE_BIN +DATE_PART +DATE_TRUNC +ISFINITE +JUSTIFY_DAYS +JUSTIFY_HOURS +JUSTIFY_INTERVAL +MAKE_DATE +MAKE_INTERVAL +MAKE_TIME +MAKE_TIMESTAMP +MAKE_TIMESTAMPTZ +NOW +STATEMENT_TIMESTAMP +TIMEOFDAY +TRANSACTION_TIMESTAMP +TO_TIMESTAMP +TO_CHAR +TO_DATE +TO_NUMBER +ENCODE +DISTKEY +SORTKEY +DISTSTYLE +BACKUP +COMPOUND +INTERLEAVED +EVEN +CASE_SENSITIVE +QUOTA +TB +BOOST +RECLUSTER +SORT +PERCENT_WORD +CASE_INSENSITIVE +Identifier +TemporaryIdentifier +NamespaceUser +QuotedIdentifier +UnterminatedQuotedIdentifier +InvalidQuotedIdentifier +InvalidUnterminatedQuotedIdentifier +UnicodeQuotedIdentifier +UnterminatedUnicodeQuotedIdentifier +InvalidUnicodeQuotedIdentifier +InvalidUnterminatedUnicodeQuotedIdentifier +StringConstant +UnterminatedStringConstant +UnicodeEscapeStringConstant +UnterminatedUnicodeEscapeStringConstant +BeginDollarStringConstant +BinaryStringConstant +UnterminatedBinaryStringConstant +InvalidBinaryStringConstant +InvalidUnterminatedBinaryStringConstant +HexadecimalStringConstant +UnterminatedHexadecimalStringConstant +InvalidHexadecimalStringConstant +InvalidUnterminatedHexadecimalStringConstant +Integral +NumericFail +Numeric +PLSQLVARIABLENAME +PLSQLIDENTIFIER +Whitespace +Newline +LineComment +BlockComment +UnterminatedBlockComment +MetaCommand +EndMetaCommand +ErrorCharacter +EscapeStringConstant +UnterminatedEscapeStringConstant +InvalidEscapeStringConstant +InvalidUnterminatedEscapeStringConstant +AfterEscapeStringConstantMode_NotContinued +AfterEscapeStringConstantWithNewlineMode_NotContinued +DollarText +EndDollarStringConstant +AfterEscapeStringConstantWithNewlineMode_Continued + +rule names: +root +plsqlroot +stmtblock +stmtmulti +stmt +plsqlconsolecommand +callstmt +createrolestmt +opt_with +optrolelist +alteroptrolelist +alteroptroleelem +createoptroleelem +createuserstmt +alterrolestmt +alterroleaction +opt_in_database +alterrolesetstmt +alterschemastmt +droprolestmt +dropuserstmt +dropgroupstmt +creategroupstmt +altergroupstmt +add_drop +createschemastmt +opt_auth_clause +opt_quota +optschemaeltlist +schema_stmt +variablesetstmt +set_rest +generic_set +set_rest_more +var_name +var_list +var_value +iso_level +opt_boolean_or_string +zone_value +opt_encoding +nonreservedword_or_sconst +variableresetstmt +reset_rest +generic_reset +setresetclause +functionsetresetclause +variableshowstmt +constraintssetstmt +constraints_set_list +constraints_set_mode +checkpointstmt +discardstmt +altertablestmt +alter_table_cmds +table_constraint +partition_cmd +index_partition_cmd +alter_table_cmd +alter_column_default +opt_drop_behavior +opt_collate_clause +alter_using +replica_identity +reloptions +opt_reloptions +reloption_list +reloption_elem +alter_identity_column_option_list +alter_identity_column_option +partitionboundspec +hash_partbound_elem +hash_partbound +altercompositetypestmt +alter_type_cmds +alter_type_cmd +closeportalstmt +copystmt +redshift_copy_authorization +redshift_copy_format +redshift_copy_parameter +copy_param_name +copy_param_value +copy_from +opt_program +copy_file_name +copy_options +copy_opt_list +copy_opt_item +opt_binary +copy_delimiter +opt_using +copy_generic_opt_list +copy_generic_opt_elem +copy_generic_opt_arg +copy_generic_opt_arg_list +copy_generic_opt_arg_list_item +createstmt +opt_table_attributes +opttemp +opttableelementlist +opttypedtableelementlist +tableelementlist +typedtableelementlist +tableelement +typedtableelement +columnDef +rs_colattributes +rs_colattribute +columnOptions +colquallist +colconstraint +colconstraintelem +opt_unique_null_treatment +generated_when +constraintattr +tablelikeclause +tablelikeoptionlist +tablelikeoption +tableconstraint +constraintelem +opt_no_inherit +opt_column_list +columnlist +columnElem +opt_c_include +key_match +exclusionconstraintlist +exclusionconstraintelem +exclusionwhereclause +key_actions +key_update +key_delete +key_action +optinherit +optpartitionspec +partitionspec +part_params +part_elem +table_access_method_clause +optwith +oncommitoption +opttablespace +optredshifttableoptions +redshifttableoption +sortkeyclause +sortkeyclausetype +optconstablespace +existingindex +createstatsstmt +alterstatsstmt +createasstmt +create_as_target +opt_backup_clause_table_attributes +table_attributes +opt_backup_clause +opt_with_data +creatematviewstmt +opt_auto_refresh +refreshmatviewstmt +createseqstmt +alterseqstmt +optseqoptlist +optparenthesizedseqoptlist +seqoptlist +seqoptelem +opt_by +numericonly +numericonly_list +createplangstmt +opt_trusted +handler_name +opt_inline_handler +validator_clause +opt_validator +opt_procedural +createtablespacestmt +opttablespaceowner +droptablespacestmt +createextensionstmt +create_extension_opt_list +create_extension_opt_item +alterextensionstmt +alter_extension_opt_list +alter_extension_opt_item +alterextensioncontentsstmt +createfdwstmt +fdw_option +fdw_options +opt_fdw_options +alterfdwstmt +create_generic_options +generic_option_list +alter_generic_options +alter_generic_option_list +alter_generic_option_elem +generic_option_elem +generic_option_name +generic_option_arg +createforeignserverstmt +opt_type +foreign_server_version +opt_foreign_server_version +alterforeignserverstmt +createforeigntablestmt +importforeignschemastmt +import_qualification_type +import_qualification +createusermappingstmt +auth_ident +dropusermappingstmt +alterusermappingstmt +createpolicystmt +alterpolicystmt +rowsecurityoptionalexpr +rowsecurityoptionalwithcheck +rowsecuritydefaulttorole +rowsecurityoptionaltorole +rowsecuritydefaultpermissive +rowsecuritydefaultforcmd +row_security_cmd +createamstmt +am_type +createtrigstmt +triggeractiontime +triggerevents +triggeroneevent +triggerreferencing +triggertransitions +triggertransition +transitionoldornew +transitionrowortable +transitionrelname +triggerforspec +triggerforopteach +triggerfortype +triggerwhen +function_or_procedure +triggerfuncargs +triggerfuncarg +optconstrfromtable +constraintattributespec +constraintattributeElem +createeventtrigstmt +event_trigger_when_list +event_trigger_when_item +event_trigger_value_list +altereventtrigstmt +enable_trigger +createassertionstmt +definestmt +definition +def_list +def_elem +def_arg +old_aggr_definition +old_aggr_list +old_aggr_elem +opt_enum_val_list +enum_val_list +alterenumstmt +opt_if_not_exists +createopclassstmt +opclass_item_list +opclass_item +opt_default +opt_opfamily +opclass_purpose +opt_recheck +createopfamilystmt +alteropfamilystmt +opclass_drop_list +opclass_drop +dropopclassstmt +dropopfamilystmt +dropownedstmt +reassignownedstmt +dropstmt +object_type_any_name +object_type_name +drop_type_name +object_type_name_on_any_name +any_name_list +any_name +attrs +type_name_list +truncatestmt +opt_restart_seqs +commentstmt +comment_text +seclabelstmt +opt_provider +security_label +fetchstmt +fetch_args +grantstmt +grant_permissions_for_rls_lookup_tables +grant_explain_permissions_for_row_level_security_policy_filters +grant_machine_learning_permissions +grant_role_permissions +grant_role_permission_target_list +grant_role_permission_target_list_item +system_permissions +system_permissions_item +opt_with_admin_option +grant_scoped_permissions +grant_scoped_schemas_permissions +grant_scoped_tables_permissions +grant_scoped_functions_permissions +grant_scoped_procedures_permissions +grant_scoped_languages_permissions +grant_scoped_copy_jobs_permissions +grantee_list_without_public +grantee_without_public +grant_datashare_permissions +grant_spectrum_integration_permissions +grant_spectrum_integration_external_schema_permissions +spectrum_integration_external_schema_permission_list +spectrum_integration_external_schema_permission +grant_spectrum_integration_external_table_permissions +spectrum_integration_external_table_permission +spectrum_integration_external_table_permission_list +grant_spectrum_integration_extenral_column_permissions +iamrolelist_or_public +iamrolelist +grant_assume_role_permissions +grant_assume_role_for_list +grant_assume_role_for_item +grant_assume_role_target +grant_column_level_permissions +column_privilege_target +column_privilege_list +column_all_privilege +column_select_update_privilege +common_grant +copy_job_privilege_list +copy_job_privilege +copy_job_target +copy_job_name +language_privilege_list +grant_language_target +grant_procedure_target +procedure_privilege_list +procedure_privilege +function_privilege_list +function_privilege +grant_function_target +grant_schema_target +revoke_schema_target +schema_privilege_list +schema_privilege +database_privilege_list +database_privilege +grant_database_target +grant_table_target +revoke_table_target +all_tables_in_schema_list +all_privileges +grantee_list +grantee +opt_with_grant_option +table_privilege +table_privilege_list +revokestmt +revoke_permissions_for_rls_lookup_tables +revoke_explain_permissions_for_row_level_security_policy_filters +revoke_machine_learning_permissions +revoke_role_permissions +revoke_scoped_permissions +revoke_scoped_schemas_permissions +revoke_scoped_tables_permissions +revoke_scoped_functions_permissions +revoke_scoped_procedures_permissions +revoke_scoped_languages_permissions +revoke_scoped_copy_jobs_permissions +revoke_datashare_permissions +revoke_spectrum_integration_permissions +revoke_spectrum_integration_external_schema_permissions +revoke_spectrum_integration_external_table_permissions +revoke_spectrum_integration_extenral_column_permissions +revoke_assume_role_permissions +revoke_column_level_permissions +common_revoke +privileges +privilege_list +privilege +privilege_target +parameter_name_list +parameter_name +opt_grant_grant_option +grantrolestmt +revokerolestmt +opt_grant_admin_option +opt_granted_by +alterdefaultprivilegesstmt +defacloptionlist +defacloption +defaclaction +defacl_privilege_target +indexstmt +opt_unique +opt_concurrently +opt_index_name +access_method_clause +index_params +index_elem_options +index_elem +opt_include +index_including_params +opt_collate +opt_class +opt_asc_desc +opt_nulls_order +createfunctionstmt +createprocedurestmt +opt_nonatomic +opt_or_replace +func_py_args_or_sql_args +func_py_args_or_sql_args_list +func_args +func_args_list +function_with_argtypes_list +function_with_argtypes +func_args_with_defaults +func_args_with_defaults_list +func_arg +arg_class +param_name +func_return +func_type +func_arg_with_default +aggr_arg +aggr_args +aggr_args_list +aggregate_with_argtypes +aggregate_with_argtypes_list +createfunc_opt_list +common_func_opt_item +createfunc_opt_item +func_as +transform_type_list +opt_definition +table_func_column +table_func_column_list +alterfunctionstmt +alterprocedurestmt +alterfunc_opt_list +opt_restrict +removefuncstmt +removeaggrstmt +removeoperstmt +oper_argtypes +any_operator +operator_with_argtypes_list +operator_with_argtypes +dostmt +dostmt_opt_list +dostmt_opt_item +createcaststmt +cast_context +dropcaststmt +opt_if_exists +createtransformstmt +transform_element_list +droptransformstmt +reindexstmt +reindex_target_type +reindex_target_multitable +reindex_option_list +reindex_option_elem +altertblspcstmt +renamestmt +opt_column +opt_set_data +alterobjectdependsstmt +opt_no +alterobjectschemastmt +alteroperatorstmt +operator_def_list +operator_def_elem +operator_def_arg +altertypestmt +alterownerstmt +createpublicationstmt +pub_obj_list +publication_obj_spec +opt_where_clause +alterpublicationstmt +createsubscriptionstmt +publication_name_list +publication_name_item +altersubscriptionstmt +dropsubscriptionstmt +rulestmt +ruleactionlist +ruleactionmulti +ruleactionstmt +ruleactionstmtOrEmpty +event +opt_instead +notifystmt +notify_payload +listenstmt +unlistenstmt +transactionstmt +opt_transaction +transaction_mode_item +transaction_mode_list +transaction_mode_list_or_empty +opt_transaction_chain +viewstmt +with_no_schema_binding +opt_check_option +loadstmt +alterdatasharestmt +alterdatashare_action +alterdatashare_add_drop +alterdatashare_objects +datashare_table_list +datashare_table_name +table_name +temporary_table_name +datashare_function_list +datashare_function +datashare_function_name +createdatasharestmt +createdatashareoptions +createdatashareoption +setpublicaccessibleoption +managedbyoption +descdatasharestmt +dropdatasharestmt +alterexternalschemastmt +altexternalschemaopts +alterexternalviewstmt +createexternalschemastmt +fromdatacatalogclause +dropschemastmt +implicitdatacatalogclause +fromhivemetastoreclause +frompostgresclause +frommysqlclause +fromkinesisclause +fromkafkaclause +frommskclause +fromredshiftclause +iamrolevalue +catalogrolevalue +authenticationvalue +createexternalfunctionstmt +external_func_params +paramlist +param_spec +createexternalmodelstmt +createexternaltablestmt +extern_column_list +extern_column_def +extern_typename +extern_table_format +row_format_spec +serde_properties_list +serde_property +external_format_spec +table_properties_list +table_property +createexternalviewstmt +dropexternalviewstmt +alteridentityproviderstmt +alteridprovideropts +altermaskingpolicystmt +altermaterializedviewstmt +altmaskingpolicyopts +altmaskingpolicyargs +altmaskingpolicyarg +alterrlspolicystmt +attachmaskingpolicystmt +attachpolicycollist +attachpolicycolumn +attachpolicytargets +attachpolicytarget +attachrlspolicystmt +table_name_list +createidentityproviderstmt +createidprovideropts +groupfilter +createlibrarystmt +createlibraryopts +createmaskingpolicystmt +inputcolumnlist +inputcolumn +maskingexpression +createmodelstmt +createmodelfromclause +iamrolespec +sagemakerspec +modeltypespec +problemtypespec +problemtype +objectivespec +hyperparametersspec +hyperparameterslist +hyperparameteritem +settingsclause +settingsitem +datatypelist +datatype +createrlspolicystmt +descidentityproviderstmt +detachmaskingpolicystmt +detachrlspolicystmt +role_or_user_or_public_list +role_or_user_or_public +rlspolicyname +dropidentityproviderstmt +droplibrarystmt +dropmaskingpolicystmt +dropmodelstmt +droprlspolicystmt +altertableappendstmt +appendoptions +alteruserstmt +alteruseropts +analyzecompressionstmt +cancelstmt +closestmt +insertexternaltablestmt +select_or_values +selectintostmt +setsessionauthorizationstmt +setsessioncharacteristicsstmt +showcolumnsstmt +showdatabasesstmt +showdbsopts +showdatasharesstmt +showexternaltablestmt +showgrantsstmt +grantobject +grantprincipal +showmodelstmt +showprocedurestmt +showschemasstmt +showtablestmt +showtablesstmt +showviewstmt +unloadstmt +iamroleclause +unloadoptions +formatoption +partitionbyoption +manifestoption +headeroption +delimiteroption +fixedwidthoption +encryptedoption +kmskeyoption +compressionoption +addquotesoption +nullasoption +escapeoption +allowoverwriteoption +cleanpathoption +paralleloption +maxfilesizeoption +rowgroupsizeoption +sizeunit +regionoption +extensionoption +usestmt +createdbstmt +createdb_opt_list +createdb_opt_items +createdb_opt_item +createdb_opt_name +opt_equal +alterdatabasestmt +alterdatabasesetstmt +dropdbstmt +drop_option_list +drop_option +altercollationstmt +altersystemstmt +createdomainstmt +alterdomainstmt +opt_as +altertsdictionarystmt +altertsconfigurationstmt +any_with +createconversionstmt +clusterstmt +cluster_index_specification +vacuumstmt +vacuum_option +analyzestmt +vac_analyze_option_list +analyze_keyword +vac_analyze_option_elem +vac_analyze_option_name +vac_analyze_option_arg +opt_analyze +opt_verbose +opt_full +opt_freeze +opt_name_list +vacuum_relation +vacuum_relation_list +opt_vacuum_relation_list +explainstmt +explainablestmt +explain_option_list +explain_option_elem +explain_option_name +explain_option_arg +preparestmt +prep_type_clause +preparablestmt +executestmt +execute_param_clause +deallocatestmt +insertstmt +insert_target +insert_rest +override_kind +insert_column_list +insert_column_item +opt_on_conflict +opt_conf_expr +returning_clause +mergestmt +merge_when_clause +merge_insert_clause +merge_update_clause +merge_delete_clause +deletestmt +using_clause +lockstmt +opt_lock +lock_type +opt_nowait +opt_nowait_or_skip +updatestmt +set_clause_list +set_clause +set_target +set_target_list +declarecursorstmt +cursor_name +cursor_options +opt_hold +selectstmt +select_with_parens +select_no_parens +select_clause +simple_select_intersect +simple_select_pramary +exclude_clause +qualify_clause +start_with_clause +with_clause +cte_list +common_table_expr +opt_materialized +opt_with_clause +into_clause +opt_top_clause +opt_strict +opttempTableName +opt_table +all_or_distinct +distinct_clause +opt_all_clause +opt_sort_clause +sort_clause +sortby_list +sortby +select_limit +opt_select_limit +limit_clause +offset_clause +select_limit_value +select_offset_value +select_fetch_first_value +i_or_f_const +row_or_rows +first_or_next +group_clause +group_by_list +group_by_item +empty_grouping_set +rollup_clause +cube_clause +grouping_sets_clause +having_clause +for_locking_clause +opt_for_locking_clause +for_locking_items +for_locking_item +for_locking_strength +locked_rels_list +values_clause +from_clause +from_list +table_ref +joined_table +alias_clause +opt_alias_clause +table_alias_clause +func_alias_clause +join_type +join_qual +relation_expr +relation_expr_list +relation_expr_opt_alias +tablesample_clause +opt_repeatable_clause +func_table +rowsfrom_item +rowsfrom_list +opt_col_def_list +opt_ordinality +where_clause +where_or_current_clause +opttablefuncelementlist +tablefuncelementlist +tablefuncelement +xmltable +xmltable_column_list +xmltable_column_el +xmltable_column_option_list +xmltable_column_option_el +xml_namespace_list +xml_namespace_el +typename +opt_array_bounds +simpletypename +varbyte +json_type +consttypename +generictype +opt_type_modifiers +numeric +opt_float +bit +constbit +bitwithlength +bitwithoutlength +character +constcharacter +character_c +opt_varying +constdatetime +constinterval +opt_timezone +opt_interval +interval_second +opt_escape +a_expr +a_expr_qual +a_expr_lessless +a_expr_or +a_expr_and +a_expr_between +a_expr_in +a_expr_unary_not +a_expr_isnull +a_expr_is_not +a_expr_compare +a_expr_prior_or_level +a_expr_like +a_expr_qual_op +a_expr_unary_qualop +a_expr_add +a_expr_mul +a_expr_caret +a_expr_unary_sign +a_expr_at_time_zone +a_expr_collate +a_expr_typecast +b_expr +c_expr +plsqlvariablename +func_application +func_expr +func_expr_windowless +func_expr_common_subexpr +xml_root_version +opt_xml_root_standalone +xml_attributes +xml_attribute_list +xml_attribute_el +document_or_content +xml_whitespace_option +xmlexists_argument +xml_passing_mech +within_group_clause +filter_clause +window_clause +window_definition_list +window_definition +over_clause +window_specification +opt_existing_window_name +opt_partition_clause +opt_frame_clause +frame_extent +frame_bound +opt_window_exclusion_clause +row +explicit_row +implicit_row +sub_type +all_op +mathop +qual_op +qual_all_op +subquery_Op +expr_list +func_arg_list +func_arg_expr +type_list +array_expr +array_expr_list +extract_list +extract_arg +unicode_normal_form +overlay_list +position_list +substr_list +trim_list +in_expr +case_expr +when_clause_list +when_clause +case_default +case_arg +columnref +indirection_el +opt_slice_bound +indirection +opt_indirection +opt_target_list +target_list +target_el +target_alias +qualified_name_list +qualified_name +name_list +name +attr_name +file_name +func_name +aexprconst +xconst +bconst +fconst +iconst +sconst +anysconst +opt_uescape +signediconst +roleid +rolespec +role_list +colid +table_alias +type_function_name +nonreservedword +collabel +identifier +plsqlidentifier +unreserved_keyword +col_name_keyword +type_func_name_keyword +reserved_keyword +builtin_function_name +pl_function +comp_options +comp_option +sharp +option_value +opt_semi +pl_block +decl_sect +decl_start +decl_stmts +label_decl +decl_stmt +decl_statement +opt_scrollable +decl_cursor_query +decl_cursor_args +decl_cursor_arglist +decl_cursor_arg +decl_is_for +decl_aliasitem +decl_varname +decl_const +decl_datatype +decl_collate +decl_notnull +decl_defval +decl_defkey +assign_operator +proc_sect +proc_stmt +stmt_perform +stmt_call +opt_expr_list +stmt_assign +stmt_getdiag +getdiag_area_opt +getdiag_list +getdiag_list_item +getdiag_item +getdiag_target +assign_var +stmt_if +stmt_elsifs +stmt_else +stmt_case +opt_expr_until_when +case_when_list +case_when +opt_case_else +stmt_loop +stmt_while +stmt_for +for_control +opt_for_using_expression +opt_cursor_parameters +opt_reverse +opt_by_expression +for_variable +stmt_foreach_a +foreach_slice +stmt_exit +exit_type +stmt_return +opt_return_result +stmt_raise +opt_stmt_raise_level +opt_raise_list +opt_raise_using +opt_raise_using_elem +opt_raise_using_elem_list +stmt_assert +opt_stmt_assert_message +loop_body +stmt_execsql +stmt_dynexecute +opt_execute_using +opt_execute_using_list +opt_execute_into +stmt_open +opt_open_bound_list_item +opt_open_bound_list +opt_open_using +opt_scroll_option +opt_scroll_option_no +stmt_fetch +into_target +opt_cursor_from +opt_fetch_direction +stmt_move +stmt_close +stmt_null +stmt_commit +stmt_rollback +plsql_opt_transaction_chain +stmt_set +cursor_variable +exception_sect +proc_exceptions +proc_exception +proc_conditions +proc_condition +opt_block_label +opt_loop_label +opt_label +opt_exitcond +any_identifier +plsql_unreserved_keyword +sql_expression +expr_until_then +expr_until_semi +expr_until_rightbracket +expr_until_loop +make_execsql_stmt +opt_returning_clause_into + + +atn: +[4, 1, 896, 15082, 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, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 3, 3, 2186, 8, 3, 5, 3, 2188, 8, 3, 10, 3, 12, 3, 2191, 9, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2376, 8, 4, 1, 5, 1, 5, 3, 5, 2380, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 3, 7, 2389, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 5, 9, 2396, 8, 9, 10, 9, 12, 9, 2399, 9, 9, 1, 10, 1, 10, 1, 10, 5, 10, 2404, 8, 10, 10, 10, 12, 10, 2407, 9, 10, 1, 10, 5, 10, 2410, 8, 10, 10, 10, 12, 10, 2413, 9, 10, 3, 10, 2415, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2421, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2431, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2441, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2461, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2468, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 2480, 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 2486, 8, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 3, 14, 2494, 8, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 2507, 8, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 3, 17, 2516, 8, 17, 1, 17, 1, 17, 3, 17, 2520, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 2530, 8, 18, 1, 18, 3, 18, 2533, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 2539, 8, 19, 1, 20, 1, 20, 1, 20, 3, 20, 2544, 8, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 2556, 8, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 3, 25, 2572, 8, 25, 1, 25, 1, 25, 3, 25, 2576, 8, 25, 1, 25, 3, 25, 2579, 8, 25, 1, 25, 3, 25, 2582, 8, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 2588, 8, 25, 1, 25, 3, 25, 2591, 8, 25, 3, 25, 2593, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 3, 27, 2601, 8, 27, 1, 27, 3, 27, 2604, 8, 27, 1, 27, 3, 27, 2607, 8, 27, 1, 28, 4, 28, 2610, 8, 28, 11, 28, 12, 28, 2611, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 2620, 8, 29, 1, 30, 1, 30, 3, 30, 2624, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, 31, 2636, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 2656, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 2669, 8, 33, 1, 34, 1, 34, 1, 34, 5, 34, 2674, 8, 34, 10, 34, 12, 34, 2677, 9, 34, 1, 35, 1, 35, 1, 35, 5, 35, 2682, 8, 35, 10, 35, 12, 35, 2685, 9, 35, 1, 36, 1, 36, 3, 36, 2689, 8, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 2696, 8, 37, 1, 38, 1, 38, 1, 38, 1, 38, 3, 38, 2702, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 2709, 8, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 2720, 8, 39, 1, 40, 1, 40, 3, 40, 2724, 8, 40, 1, 41, 1, 41, 3, 41, 2728, 8, 41, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, 2741, 8, 43, 1, 44, 1, 44, 3, 44, 2745, 8, 44, 1, 45, 1, 45, 1, 45, 3, 45, 2750, 8, 45, 1, 46, 1, 46, 1, 46, 3, 46, 2755, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 2770, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 3, 49, 2779, 8, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, 53, 2794, 8, 53, 10, 53, 12, 53, 2797, 9, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2805, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2850, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2868, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2874, 8, 54, 1, 54, 1, 54, 3, 54, 2878, 8, 54, 1, 54, 3, 54, 2881, 8, 54, 1, 54, 3, 54, 2884, 8, 54, 1, 54, 1, 54, 3, 54, 2888, 8, 54, 1, 54, 1, 54, 3, 54, 2892, 8, 54, 1, 54, 1, 54, 3, 54, 2896, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2905, 8, 54, 1, 54, 1, 54, 3, 54, 2909, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2919, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 2946, 8, 54, 10, 54, 12, 54, 2949, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2958, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 2971, 8, 54, 10, 54, 12, 54, 2974, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 2992, 8, 54, 10, 54, 12, 54, 2995, 9, 54, 1, 54, 1, 54, 3, 54, 2999, 8, 54, 1, 55, 1, 55, 3, 55, 3003, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 3027, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 3037, 8, 56, 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, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3061, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3068, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3077, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3086, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3094, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3104, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3113, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3122, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3130, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3138, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3147, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3156, 8, 58, 1, 58, 1, 58, 3, 58, 3160, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3167, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3175, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3185, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3191, 8, 58, 1, 58, 1, 58, 3, 58, 3195, 8, 58, 1, 58, 1, 58, 3, 58, 3199, 8, 58, 1, 58, 1, 58, 3, 58, 3203, 8, 58, 1, 58, 1, 58, 3, 58, 3207, 8, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3212, 8, 58, 1, 58, 3, 58, 3215, 8, 58, 1, 58, 1, 58, 3, 58, 3219, 8, 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, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3240, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3246, 8, 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, 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, 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, 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, 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, 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, 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, 3, 58, 3345, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 3352, 8, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 3368, 8, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 5, 66, 3380, 8, 66, 10, 66, 12, 66, 3383, 9, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 3392, 8, 67, 3, 67, 3394, 8, 67, 1, 68, 4, 68, 3397, 8, 68, 11, 68, 12, 68, 3398, 1, 69, 1, 69, 3, 69, 3403, 8, 69, 1, 69, 3, 69, 3406, 8, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 3412, 8, 69, 3, 69, 3414, 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, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 3442, 8, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 5, 72, 3450, 8, 72, 10, 72, 12, 72, 3453, 9, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 5, 74, 3463, 8, 74, 10, 74, 12, 74, 3466, 9, 74, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 3472, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 3478, 8, 75, 1, 75, 1, 75, 3, 75, 3482, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 3488, 8, 75, 1, 75, 1, 75, 1, 75, 3, 75, 3493, 8, 75, 1, 75, 3, 75, 3496, 8, 75, 3, 75, 3498, 8, 75, 1, 76, 1, 76, 1, 76, 3, 76, 3503, 8, 76, 1, 77, 1, 77, 3, 77, 3507, 8, 77, 1, 77, 1, 77, 3, 77, 3511, 8, 77, 1, 77, 1, 77, 3, 77, 3515, 8, 77, 1, 77, 1, 77, 3, 77, 3519, 8, 77, 1, 77, 3, 77, 3522, 8, 77, 1, 77, 1, 77, 3, 77, 3526, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 3534, 8, 77, 1, 77, 1, 77, 3, 77, 3538, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 3545, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 3551, 8, 77, 1, 77, 5, 77, 3554, 8, 77, 10, 77, 12, 77, 3557, 9, 77, 3, 77, 3559, 8, 77, 1, 78, 1, 78, 1, 78, 3, 78, 3564, 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3574, 8, 78, 3, 78, 3576, 8, 78, 1, 79, 3, 79, 3579, 8, 79, 1, 79, 3, 79, 3582, 8, 79, 1, 79, 1, 79, 3, 79, 3586, 8, 79, 1, 80, 1, 80, 3, 80, 3590, 8, 80, 1, 80, 3, 80, 3593, 8, 80, 1, 81, 1, 81, 3, 81, 3597, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 3610, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 3, 85, 3619, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 3626, 8, 86, 1, 87, 5, 87, 3629, 8, 87, 10, 87, 12, 87, 3632, 9, 87, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3638, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3643, 8, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3650, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3655, 8, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3673, 8, 88, 1, 89, 1, 89, 1, 90, 3, 90, 3678, 8, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 5, 92, 3688, 8, 92, 10, 92, 12, 92, 3691, 9, 92, 1, 93, 1, 93, 3, 93, 3695, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 3, 94, 3704, 8, 94, 1, 95, 1, 95, 1, 95, 5, 95, 3709, 8, 95, 10, 95, 12, 95, 3712, 9, 95, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, 3718, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3724, 8, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3729, 8, 97, 1, 97, 1, 97, 3, 97, 3733, 8, 97, 1, 97, 5, 97, 3736, 8, 97, 10, 97, 12, 97, 3739, 9, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3749, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3758, 8, 98, 1, 99, 3, 99, 3761, 8, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 5, 102, 3774, 8, 102, 10, 102, 12, 102, 3777, 9, 102, 1, 103, 1, 103, 1, 103, 5, 103, 3782, 8, 103, 10, 103, 12, 103, 3785, 9, 103, 1, 104, 1, 104, 1, 104, 3, 104, 3790, 8, 104, 1, 105, 1, 105, 3, 105, 3794, 8, 105, 1, 106, 1, 106, 1, 106, 3, 106, 3799, 8, 106, 1, 106, 3, 106, 3802, 8, 106, 1, 107, 4, 107, 3805, 8, 107, 11, 107, 12, 107, 3806, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3828, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3845, 8, 108, 3, 108, 3847, 8, 108, 1, 109, 1, 109, 1, 109, 3, 109, 3852, 8, 109, 1, 109, 1, 109, 1, 110, 5, 110, 3857, 8, 110, 10, 110, 12, 110, 3860, 9, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 3870, 8, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3877, 8, 112, 1, 112, 3, 112, 3880, 8, 112, 1, 112, 3, 112, 3883, 8, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3888, 8, 112, 1, 112, 3, 112, 3891, 8, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3898, 8, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3907, 8, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3914, 8, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3919, 8, 112, 1, 112, 3, 112, 3922, 8, 112, 1, 112, 3, 112, 3925, 8, 112, 3, 112, 3927, 8, 112, 1, 113, 1, 113, 3, 113, 3931, 8, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 3, 114, 3938, 8, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 3, 115, 3945, 8, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 5, 117, 3953, 8, 117, 10, 117, 12, 117, 3956, 9, 117, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 3965, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3975, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3981, 8, 120, 1, 120, 3, 120, 3984, 8, 120, 1, 120, 3, 120, 3987, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3994, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4002, 8, 120, 1, 120, 3, 120, 4005, 8, 120, 1, 120, 3, 120, 4008, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4015, 8, 120, 1, 120, 1, 120, 3, 120, 4019, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4025, 8, 120, 1, 120, 3, 120, 4028, 8, 120, 1, 120, 3, 120, 4031, 8, 120, 1, 120, 3, 120, 4034, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4046, 8, 120, 1, 120, 3, 120, 4049, 8, 120, 1, 120, 3, 120, 4052, 8, 120, 1, 120, 1, 120, 3, 120, 4056, 8, 120, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 5, 123, 4068, 8, 123, 10, 123, 12, 123, 4071, 9, 123, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 5, 127, 4086, 8, 127, 10, 127, 12, 127, 4089, 9, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 4099, 8, 128, 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, 3, 130, 4114, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 4131, 8, 133, 3, 133, 4133, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 5, 137, 4152, 8, 137, 10, 137, 12, 137, 4155, 9, 137, 1, 138, 1, 138, 3, 138, 4159, 8, 138, 1, 138, 3, 138, 4162, 8, 138, 1, 138, 1, 138, 3, 138, 4166, 8, 138, 1, 138, 3, 138, 4169, 8, 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 4175, 8, 138, 1, 138, 3, 138, 4178, 8, 138, 3, 138, 4180, 8, 138, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4189, 8, 140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4198, 8, 141, 1, 142, 1, 142, 1, 142, 1, 143, 4, 143, 4204, 8, 143, 11, 143, 12, 143, 4205, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 4220, 8, 144, 1, 145, 3, 145, 4223, 8, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 4246, 8, 149, 1, 149, 1, 149, 3, 149, 4250, 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 3, 150, 4261, 8, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 3, 151, 4270, 8, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 152, 1, 152, 3, 152, 4279, 8, 152, 1, 152, 3, 152, 4282, 8, 152, 1, 153, 1, 153, 5, 153, 4286, 8, 153, 10, 153, 12, 153, 4289, 9, 153, 1, 153, 4, 153, 4292, 8, 153, 11, 153, 12, 153, 4293, 1, 153, 3, 153, 4297, 8, 153, 1, 153, 5, 153, 4300, 8, 153, 10, 153, 12, 153, 4303, 9, 153, 3, 153, 4305, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 4315, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 4322, 8, 154, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 3, 156, 4331, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 4338, 8, 157, 1, 157, 5, 157, 4341, 8, 157, 10, 157, 12, 157, 4344, 9, 157, 1, 157, 3, 157, 4347, 8, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 4360, 8, 159, 1, 159, 1, 159, 3, 159, 4364, 8, 159, 1, 159, 3, 159, 4367, 8, 159, 1, 160, 1, 160, 3, 160, 4371, 8, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 4377, 8, 160, 1, 160, 1, 160, 3, 160, 4381, 8, 160, 1, 161, 1, 161, 1, 161, 1, 161, 3, 161, 4387, 8, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 4, 164, 4399, 8, 164, 11, 164, 12, 164, 4400, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4410, 8, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4428, 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4433, 8, 165, 1, 165, 3, 165, 4436, 8, 165, 1, 165, 3, 165, 4439, 8, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 3, 167, 4449, 8, 167, 1, 168, 1, 168, 1, 168, 5, 168, 4454, 8, 168, 10, 168, 12, 168, 4457, 9, 168, 1, 169, 1, 169, 3, 169, 4461, 8, 169, 1, 169, 3, 169, 4464, 8, 169, 1, 169, 3, 169, 4467, 8, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 4474, 8, 169, 1, 169, 3, 169, 4477, 8, 169, 3, 169, 4479, 8, 169, 1, 170, 1, 170, 1, 171, 1, 171, 3, 171, 4485, 8, 171, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 3, 173, 4494, 8, 173, 1, 174, 1, 174, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 4504, 8, 176, 1, 176, 1, 176, 1, 176, 3, 176, 4509, 8, 176, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 3, 178, 4518, 8, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 3, 179, 4527, 8, 179, 1, 179, 1, 179, 3, 179, 4531, 8, 179, 1, 179, 1, 179, 1, 180, 5, 180, 4536, 8, 180, 10, 180, 12, 180, 4539, 9, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4548, 8, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 5, 183, 4557, 8, 183, 10, 183, 12, 183, 4560, 9, 183, 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, 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, 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, 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, 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, 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, 185, 1, 185, 3, 185, 4669, 8, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 4677, 8, 186, 1, 186, 3, 186, 4680, 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 4690, 8, 187, 1, 188, 4, 188, 4693, 8, 188, 11, 188, 12, 188, 4694, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 4705, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 4716, 8, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, 1, 192, 1, 192, 1, 192, 5, 192, 4726, 8, 192, 10, 192, 12, 192, 4729, 9, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 5, 194, 4739, 8, 194, 10, 194, 12, 194, 4742, 9, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 4751, 8, 195, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4764, 8, 199, 1, 199, 3, 199, 4767, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4774, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4783, 8, 199, 1, 199, 3, 199, 4786, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4793, 8, 199, 3, 199, 4795, 8, 199, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 3, 201, 4803, 8, 201, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 4813, 8, 203, 3, 203, 4815, 8, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4823, 8, 204, 1, 204, 1, 204, 3, 204, 4827, 8, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4832, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4843, 8, 204, 1, 204, 1, 204, 3, 204, 4847, 8, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4852, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4862, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4868, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4881, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4887, 8, 204, 3, 204, 4889, 8, 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 4896, 8, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 3, 205, 4904, 8, 205, 1, 206, 1, 206, 1, 206, 3, 206, 4909, 8, 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 4924, 8, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 4937, 8, 208, 3, 208, 4939, 8, 208, 1, 209, 1, 209, 3, 209, 4943, 8, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, 210, 4963, 8, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 3, 212, 4980, 8, 212, 1, 212, 3, 212, 4983, 8, 212, 1, 212, 3, 212, 4986, 8, 212, 1, 212, 3, 212, 4989, 8, 212, 1, 212, 3, 212, 4992, 8, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 5000, 8, 213, 1, 213, 3, 213, 5003, 8, 213, 1, 213, 3, 213, 5006, 8, 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, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5052, 8, 223, 1, 223, 3, 223, 5055, 8, 223, 1, 223, 3, 223, 5058, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5076, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5083, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5092, 8, 223, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 5098, 8, 224, 1, 225, 1, 225, 1, 225, 5, 225, 5103, 8, 225, 10, 225, 12, 225, 5106, 9, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 3, 226, 5115, 8, 226, 1, 227, 1, 227, 1, 227, 1, 228, 4, 228, 5121, 8, 228, 11, 228, 12, 228, 5122, 1, 229, 1, 229, 1, 229, 3, 229, 5128, 8, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 231, 1, 231, 1, 232, 1, 232, 1, 233, 1, 233, 3, 233, 5140, 8, 233, 1, 233, 1, 233, 1, 234, 1, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 238, 1, 238, 3, 238, 5157, 8, 238, 1, 238, 1, 238, 5, 238, 5161, 8, 238, 10, 238, 12, 238, 5164, 9, 238, 1, 239, 1, 239, 1, 239, 1, 239, 3, 239, 5170, 8, 239, 1, 240, 1, 240, 1, 240, 1, 241, 5, 241, 5176, 8, 241, 10, 241, 12, 241, 5179, 9, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 3, 242, 5192, 8, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 5220, 8, 243, 1, 244, 1, 244, 1, 244, 5, 244, 5225, 8, 244, 10, 244, 12, 244, 5228, 9, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, 1, 246, 1, 246, 5, 246, 5239, 8, 246, 10, 246, 12, 246, 5242, 9, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 3, 248, 5256, 8, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 3, 250, 5269, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5278, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5303, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5314, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5381, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 5, 252, 5390, 8, 252, 10, 252, 12, 252, 5393, 9, 252, 1, 253, 1, 253, 1, 253, 3, 253, 5398, 8, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 3, 254, 5406, 8, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 5, 256, 5415, 8, 256, 10, 256, 12, 256, 5418, 9, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 5, 259, 5429, 8, 259, 10, 259, 12, 259, 5432, 9, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, 260, 5440, 8, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, 260, 5450, 8, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, 260, 5462, 8, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, 260, 5477, 8, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 5488, 8, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 5496, 8, 262, 1, 262, 1, 262, 1, 262, 1, 263, 1, 263, 1, 263, 5, 263, 5504, 8, 263, 10, 263, 12, 263, 5507, 9, 263, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 5513, 8, 264, 1, 264, 3, 264, 5516, 8, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 5522, 8, 264, 1, 264, 3, 264, 5525, 8, 264, 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, 264, 3, 264, 5540, 8, 264, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 3, 267, 5553, 8, 267, 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, 270, 1, 270, 1, 270, 3, 270, 5582, 8, 270, 1, 271, 1, 271, 1, 271, 5, 271, 5587, 8, 271, 10, 271, 12, 271, 5590, 9, 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, 3, 272, 5604, 8, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 5613, 8, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 5624, 8, 273, 3, 273, 5626, 8, 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5635, 8, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5646, 8, 274, 3, 274, 5648, 8, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, 5655, 8, 275, 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, 3, 277, 5670, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5676, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5684, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5690, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5698, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5708, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5714, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5722, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5728, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5736, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5743, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5752, 8, 277, 3, 277, 5754, 8, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 5779, 8, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 3, 279, 5787, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 3, 280, 5798, 8, 280, 1, 280, 1, 280, 1, 280, 3, 280, 5803, 8, 280, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 5, 282, 5810, 8, 282, 10, 282, 12, 282, 5813, 9, 282, 1, 283, 1, 283, 3, 283, 5817, 8, 283, 1, 284, 1, 284, 4, 284, 5821, 8, 284, 11, 284, 12, 284, 5822, 1, 285, 1, 285, 1, 285, 5, 285, 5828, 8, 285, 10, 285, 12, 285, 5831, 9, 285, 1, 286, 1, 286, 3, 286, 5835, 8, 286, 1, 286, 1, 286, 3, 286, 5839, 8, 286, 1, 286, 3, 286, 5842, 8, 286, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 5848, 8, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 3, 288, 5997, 8, 288, 1, 289, 1, 289, 3, 289, 6001, 8, 289, 1, 290, 1, 290, 1, 290, 3, 290, 6006, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6017, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6028, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6039, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6050, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6061, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6072, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6083, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6095, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6106, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6114, 8, 290, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 3, 292, 6121, 8, 292, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 6135, 8, 294, 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 6141, 8, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 3, 295, 6153, 8, 295, 1, 296, 1, 296, 1, 296, 1, 296, 3, 296, 6159, 8, 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, 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, 3, 298, 6187, 8, 298, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 5, 299, 6195, 8, 299, 10, 299, 12, 299, 6198, 9, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, 6209, 8, 299, 1, 300, 1, 300, 1, 300, 5, 300, 6214, 8, 300, 10, 300, 12, 300, 6217, 9, 300, 1, 301, 1, 301, 3, 301, 6221, 8, 301, 1, 301, 1, 301, 3, 301, 6225, 8, 301, 1, 302, 1, 302, 1, 302, 5, 302, 6230, 8, 302, 10, 302, 12, 302, 6233, 9, 302, 1, 302, 3, 302, 6236, 8, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6249, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6259, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6267, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6274, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 3, 303, 6294, 8, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 6306, 8, 305, 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, 3, 307, 6327, 8, 307, 1, 307, 1, 307, 3, 307, 6331, 8, 307, 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 3, 308, 6345, 8, 308, 1, 308, 1, 308, 3, 308, 6349, 8, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 6363, 8, 309, 1, 309, 1, 309, 3, 309, 6367, 8, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 6392, 8, 311, 1, 311, 1, 311, 3, 311, 6396, 8, 311, 1, 311, 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 5, 312, 6404, 8, 312, 10, 312, 12, 312, 6407, 9, 312, 1, 313, 1, 313, 3, 313, 6411, 8, 313, 1, 313, 1, 313, 3, 313, 6415, 8, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 3, 314, 6438, 8, 314, 3, 314, 6440, 8, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 3, 314, 6449, 8, 314, 1, 314, 1, 314, 1, 314, 3, 314, 6454, 8, 314, 1, 315, 1, 315, 1, 315, 3, 315, 6459, 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 6470, 8, 316, 1, 317, 1, 317, 1, 317, 5, 317, 6475, 8, 317, 10, 317, 12, 317, 6478, 9, 317, 1, 317, 3, 317, 6481, 8, 317, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 3, 319, 6494, 8, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 6502, 8, 320, 1, 321, 1, 321, 1, 321, 5, 321, 6507, 8, 321, 10, 321, 12, 321, 6510, 9, 321, 1, 322, 1, 322, 1, 322, 3, 322, 6515, 8, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 3, 322, 6527, 8, 322, 1, 323, 1, 323, 3, 323, 6531, 8, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 5, 324, 6538, 8, 324, 10, 324, 12, 324, 6541, 9, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 5, 326, 6554, 8, 326, 10, 326, 12, 326, 6557, 9, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 3, 327, 6566, 8, 327, 1, 328, 1, 328, 1, 328, 5, 328, 6571, 8, 328, 10, 328, 12, 328, 6574, 9, 328, 1, 328, 1, 328, 3, 328, 6578, 8, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 3, 330, 6588, 8, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 5, 331, 6595, 8, 331, 10, 331, 12, 331, 6598, 9, 331, 1, 331, 1, 331, 1, 331, 5, 331, 6603, 8, 331, 10, 331, 12, 331, 6606, 9, 331, 3, 331, 6608, 8, 331, 1, 332, 1, 332, 3, 332, 6612, 8, 332, 1, 332, 1, 332, 3, 332, 6616, 8, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 3, 333, 6623, 8, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6676, 8, 334, 1, 335, 1, 335, 1, 335, 5, 335, 6681, 8, 335, 10, 335, 12, 335, 6684, 9, 335, 1, 335, 3, 335, 6687, 8, 335, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 5, 337, 6696, 8, 337, 10, 337, 12, 337, 6699, 9, 337, 1, 338, 1, 338, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 5, 341, 6712, 8, 341, 10, 341, 12, 341, 6715, 9, 341, 1, 341, 1, 341, 1, 341, 1, 341, 1, 341, 3, 341, 6722, 8, 341, 1, 342, 1, 342, 3, 342, 6726, 8, 342, 1, 343, 1, 343, 3, 343, 6730, 8, 343, 1, 344, 1, 344, 3, 344, 6734, 8, 344, 1, 345, 1, 345, 3, 345, 6738, 8, 345, 1, 346, 1, 346, 1, 346, 1, 346, 5, 346, 6744, 8, 346, 10, 346, 12, 346, 6747, 9, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 3, 346, 6754, 8, 346, 1, 347, 1, 347, 1, 347, 1, 347, 5, 347, 6760, 8, 347, 10, 347, 12, 347, 6763, 9, 347, 1, 348, 1, 348, 1, 348, 3, 348, 6768, 8, 348, 1, 348, 1, 348, 1, 348, 5, 348, 6773, 8, 348, 10, 348, 12, 348, 6776, 9, 348, 1, 349, 1, 349, 1, 349, 5, 349, 6781, 8, 349, 10, 349, 12, 349, 6784, 9, 349, 1, 349, 3, 349, 6787, 8, 349, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 5, 351, 6794, 8, 351, 10, 351, 12, 351, 6797, 9, 351, 1, 351, 3, 351, 6800, 8, 351, 1, 352, 1, 352, 1, 353, 1, 353, 1, 353, 1, 353, 5, 353, 6808, 8, 353, 10, 353, 12, 353, 6811, 9, 353, 1, 354, 3, 354, 6814, 8, 354, 1, 354, 1, 354, 3, 354, 6818, 8, 354, 1, 355, 3, 355, 6821, 8, 355, 1, 355, 1, 355, 3, 355, 6825, 8, 355, 1, 355, 1, 355, 3, 355, 6829, 8, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 3, 357, 6839, 8, 357, 1, 358, 1, 358, 1, 358, 5, 358, 6844, 8, 358, 10, 358, 12, 358, 6847, 9, 358, 1, 359, 1, 359, 3, 359, 6851, 8, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 3, 359, 6858, 8, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 362, 1, 362, 1, 362, 5, 362, 6869, 8, 362, 10, 362, 12, 362, 6872, 9, 362, 1, 362, 3, 362, 6875, 8, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 3, 363, 6887, 8, 363, 1, 364, 1, 364, 1, 364, 1, 364, 3, 364, 6893, 8, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 3, 364, 6901, 8, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 3, 365, 6910, 8, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, 366, 6918, 8, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, 366, 6928, 8, 366, 3, 366, 6930, 8, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 5, 367, 6938, 8, 367, 10, 367, 12, 367, 6941, 9, 367, 1, 367, 1, 367, 1, 367, 3, 367, 6946, 8, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 3, 367, 6954, 8, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 5, 367, 6965, 8, 367, 10, 367, 12, 367, 6968, 9, 367, 1, 367, 1, 367, 1, 367, 3, 367, 6973, 8, 367, 3, 367, 6975, 8, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 3, 368, 6983, 8, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 3, 369, 6995, 8, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 7006, 8, 370, 1, 370, 1, 370, 3, 370, 7010, 8, 370, 1, 370, 1, 370, 1, 370, 3, 370, 7015, 8, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 7026, 8, 371, 1, 371, 1, 371, 3, 371, 7030, 8, 371, 1, 371, 1, 371, 1, 371, 3, 371, 7035, 8, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7046, 8, 372, 1, 372, 1, 372, 3, 372, 7050, 8, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7055, 8, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 7067, 8, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 7079, 8, 374, 1, 374, 1, 374, 3, 374, 7083, 8, 374, 1, 374, 1, 374, 1, 374, 3, 374, 7088, 8, 374, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7094, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7103, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7109, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7122, 8, 375, 3, 375, 7124, 8, 375, 1, 375, 3, 375, 7127, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7133, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7141, 8, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7146, 8, 375, 3, 375, 7148, 8, 375, 1, 376, 1, 376, 1, 376, 3, 376, 7153, 8, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 3, 377, 7164, 8, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 3, 378, 7175, 8, 378, 1, 379, 1, 379, 1, 379, 3, 379, 7180, 8, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 3, 379, 7192, 8, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 3, 380, 7202, 8, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 7211, 8, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 7223, 8, 381, 3, 381, 7225, 8, 381, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7231, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7239, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7245, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7253, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7259, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7267, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7273, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7281, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7287, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7295, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7301, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7309, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7315, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7323, 8, 382, 3, 382, 7325, 8, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 7342, 8, 383, 1, 384, 1, 384, 1, 384, 5, 384, 7347, 8, 384, 10, 384, 12, 384, 7350, 9, 384, 1, 385, 1, 385, 3, 385, 7354, 8, 385, 1, 385, 1, 385, 3, 385, 7358, 8, 385, 1, 385, 1, 385, 3, 385, 7362, 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 7368, 8, 385, 3, 385, 7370, 8, 385, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 3, 386, 7432, 8, 386, 1, 387, 1, 387, 1, 387, 5, 387, 7437, 8, 387, 10, 387, 12, 387, 7440, 9, 387, 1, 388, 1, 388, 1, 388, 3, 388, 7445, 8, 388, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 3, 390, 7456, 8, 390, 1, 390, 3, 390, 7459, 8, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 3, 391, 7466, 8, 391, 1, 391, 3, 391, 7469, 8, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 3, 391, 7479, 8, 391, 1, 391, 3, 391, 7482, 8, 391, 3, 391, 7484, 8, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 395, 5, 395, 7501, 8, 395, 10, 395, 12, 395, 7504, 9, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 3, 396, 7515, 8, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, 7524, 8, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, 7533, 8, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, 7545, 8, 397, 3, 397, 7547, 8, 397, 1, 398, 1, 398, 1, 399, 1, 399, 3, 399, 7553, 8, 399, 1, 399, 1, 399, 3, 399, 7557, 8, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7562, 8, 399, 1, 399, 3, 399, 7565, 8, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7570, 8, 399, 1, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7576, 8, 399, 1, 399, 3, 399, 7579, 8, 399, 1, 399, 3, 399, 7582, 8, 399, 1, 399, 3, 399, 7585, 8, 399, 1, 399, 3, 399, 7588, 8, 399, 1, 400, 1, 400, 1, 401, 1, 401, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 404, 1, 404, 1, 404, 5, 404, 7602, 8, 404, 10, 404, 12, 404, 7605, 9, 404, 1, 405, 3, 405, 7608, 8, 405, 1, 405, 3, 405, 7611, 8, 405, 1, 405, 3, 405, 7614, 8, 405, 1, 405, 3, 405, 7617, 8, 405, 1, 405, 3, 405, 7620, 8, 405, 1, 405, 1, 405, 1, 405, 3, 405, 7625, 8, 405, 1, 405, 3, 405, 7628, 8, 405, 3, 405, 7630, 8, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 3, 406, 7643, 8, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, 5, 408, 7653, 8, 408, 10, 408, 12, 408, 7656, 9, 408, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 3, 412, 7669, 8, 412, 1, 413, 1, 413, 3, 413, 7673, 8, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, 7685, 8, 413, 3, 413, 7687, 8, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, 414, 3, 414, 7694, 8, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 3, 414, 7706, 8, 414, 3, 414, 7708, 8, 414, 1, 414, 3, 414, 7711, 8, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, 3, 417, 7722, 8, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 5, 418, 7732, 8, 418, 10, 418, 12, 418, 7735, 9, 418, 1, 418, 1, 418, 1, 418, 5, 418, 7740, 8, 418, 10, 418, 12, 418, 7743, 9, 418, 3, 418, 7745, 8, 418, 1, 419, 1, 419, 3, 419, 7749, 8, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 5, 420, 7756, 8, 420, 10, 420, 12, 420, 7759, 9, 420, 1, 421, 1, 421, 1, 421, 5, 421, 7764, 8, 421, 10, 421, 12, 421, 7767, 9, 421, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 3, 422, 7775, 8, 422, 3, 422, 7777, 8, 422, 1, 423, 1, 423, 3, 423, 7781, 8, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, 5, 424, 7788, 8, 424, 10, 424, 12, 424, 7791, 9, 424, 1, 425, 1, 425, 3, 425, 7795, 8, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7801, 8, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7806, 8, 425, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, 3, 427, 7814, 8, 427, 1, 428, 1, 428, 1, 429, 1, 429, 3, 429, 7820, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 7826, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 7832, 8, 429, 1, 430, 1, 430, 1, 430, 3, 430, 7837, 8, 430, 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, 3, 432, 7852, 8, 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 5, 433, 7859, 8, 433, 10, 433, 12, 433, 7862, 9, 433, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 5, 435, 7870, 8, 435, 10, 435, 12, 435, 7873, 9, 435, 1, 436, 4, 436, 7876, 8, 436, 11, 436, 12, 436, 7877, 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, 437, 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, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 3, 437, 7917, 8, 437, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 3, 438, 7932, 8, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 3, 439, 7939, 8, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 5, 440, 7948, 8, 440, 10, 440, 12, 440, 7951, 9, 440, 1, 441, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 5, 443, 7962, 8, 443, 10, 443, 12, 443, 7965, 9, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 3, 444, 7977, 8, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 3, 445, 7989, 8, 445, 1, 446, 4, 446, 7992, 8, 446, 11, 446, 12, 446, 7993, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8002, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8010, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8016, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8024, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8030, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8038, 8, 448, 3, 448, 8040, 8, 448, 1, 449, 1, 449, 1, 449, 1, 449, 3, 449, 8046, 8, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 3, 449, 8054, 8, 449, 3, 449, 8056, 8, 449, 1, 450, 1, 450, 1, 450, 1, 450, 3, 450, 8062, 8, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, 3, 450, 8070, 8, 450, 3, 450, 8072, 8, 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, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 8096, 8, 451, 1, 452, 1, 452, 1, 452, 5, 452, 8101, 8, 452, 10, 452, 12, 452, 8104, 9, 452, 1, 452, 1, 452, 1, 453, 1, 453, 1, 453, 5, 453, 8111, 8, 453, 10, 453, 12, 453, 8114, 9, 453, 1, 454, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 456, 4, 456, 8123, 8, 456, 11, 456, 12, 456, 8124, 1, 457, 1, 457, 1, 457, 3, 457, 8130, 8, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 3, 458, 8143, 8, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 3, 458, 8155, 8, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 3, 458, 8167, 8, 458, 3, 458, 8169, 8, 458, 1, 459, 1, 459, 1, 459, 1, 459, 3, 459, 8175, 8, 459, 1, 460, 1, 460, 1, 460, 3, 460, 8180, 8, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 8188, 8, 460, 1, 461, 1, 461, 1, 461, 1, 462, 1, 462, 3, 462, 8195, 8, 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, 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, 3, 463, 8240, 8, 463, 1, 464, 1, 464, 1, 464, 3, 464, 8245, 8, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, 8252, 8, 464, 1, 465, 1, 465, 1, 465, 3, 465, 8257, 8, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 3, 465, 8264, 8, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 3, 465, 8274, 8, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 3, 465, 8284, 8, 465, 1, 465, 1, 465, 3, 465, 8288, 8, 465, 1, 466, 1, 466, 1, 467, 1, 467, 1, 468, 1, 468, 1, 468, 5, 468, 8297, 8, 468, 10, 468, 12, 468, 8300, 9, 468, 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, 3, 470, 8316, 8, 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, 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, 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, 3, 471, 8387, 8, 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, 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, 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, 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, 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, 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, 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, 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, 471, 1, 471, 3, 471, 8582, 8, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8595, 8, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8606, 8, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8619, 8, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8631, 8, 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, 3, 471, 8645, 8, 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, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8677, 8, 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, 3, 471, 8691, 8, 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, 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, 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, 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, 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, 3, 471, 8803, 8, 471, 3, 471, 8805, 8, 471, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8816, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8827, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8838, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8851, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8863, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8874, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8881, 8, 474, 1, 475, 1, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 3, 476, 9102, 8, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, 5, 478, 9115, 8, 478, 10, 478, 12, 478, 9118, 9, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 3, 479, 9128, 8, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 3, 480, 9135, 8, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 3, 482, 9189, 8, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 3, 482, 9330, 8, 482, 1, 483, 1, 483, 1, 483, 1, 483, 3, 483, 9336, 8, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 3, 483, 9345, 8, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 3, 483, 9353, 8, 483, 3, 483, 9355, 8, 483, 1, 484, 1, 484, 1, 484, 5, 484, 9360, 8, 484, 10, 484, 12, 484, 9363, 9, 484, 1, 485, 1, 485, 1, 485, 3, 485, 9368, 8, 485, 1, 485, 3, 485, 9371, 8, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 3, 485, 9378, 8, 485, 1, 485, 1, 485, 3, 485, 9382, 8, 485, 1, 485, 3, 485, 9385, 8, 485, 1, 485, 1, 485, 1, 485, 3, 485, 9390, 8, 485, 1, 485, 3, 485, 9393, 8, 485, 1, 485, 1, 485, 3, 485, 9397, 8, 485, 1, 485, 3, 485, 9400, 8, 485, 1, 485, 3, 485, 9403, 8, 485, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 3, 487, 9434, 8, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 3, 488, 9444, 8, 488, 1, 489, 1, 489, 1, 489, 5, 489, 9449, 8, 489, 10, 489, 12, 489, 9452, 9, 489, 1, 490, 1, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 3, 491, 9474, 8, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 3, 491, 9483, 8, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 3, 491, 9501, 8, 491, 1, 492, 1, 492, 1, 492, 1, 492, 3, 492, 9507, 8, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 3, 492, 9515, 8, 492, 3, 492, 9517, 8, 492, 1, 493, 1, 493, 3, 493, 9521, 8, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 3, 493, 9531, 8, 493, 1, 493, 1, 493, 3, 493, 9535, 8, 493, 1, 493, 1, 493, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 3, 494, 9545, 8, 494, 1, 495, 3, 495, 9548, 8, 495, 1, 495, 1, 495, 3, 495, 9552, 8, 495, 5, 495, 9554, 8, 495, 10, 495, 12, 495, 9557, 9, 495, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 3, 496, 9564, 8, 496, 1, 497, 1, 497, 1, 498, 1, 498, 1, 499, 1, 499, 1, 500, 1, 500, 1, 500, 3, 500, 9575, 8, 500, 1, 501, 1, 501, 1, 501, 1, 502, 1, 502, 1, 502, 1, 503, 1, 503, 1, 503, 1, 503, 3, 503, 9587, 8, 503, 1, 504, 1, 504, 3, 504, 9591, 8, 504, 1, 504, 3, 504, 9594, 8, 504, 1, 504, 1, 504, 3, 504, 9598, 8, 504, 1, 504, 3, 504, 9601, 8, 504, 1, 504, 1, 504, 1, 504, 3, 504, 9606, 8, 504, 1, 504, 1, 504, 3, 504, 9610, 8, 504, 1, 504, 3, 504, 9613, 8, 504, 1, 504, 1, 504, 3, 504, 9617, 8, 504, 1, 504, 3, 504, 9620, 8, 504, 1, 504, 1, 504, 3, 504, 9624, 8, 504, 1, 504, 3, 504, 9627, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 9638, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 9645, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 9658, 8, 504, 1, 505, 1, 505, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 3, 506, 9672, 8, 506, 1, 507, 1, 507, 3, 507, 9676, 8, 507, 1, 507, 5, 507, 9679, 8, 507, 10, 507, 12, 507, 9682, 9, 507, 1, 508, 1, 508, 1, 509, 1, 509, 3, 509, 9688, 8, 509, 1, 509, 1, 509, 1, 510, 1, 510, 1, 510, 3, 510, 9695, 8, 510, 1, 510, 3, 510, 9698, 8, 510, 1, 510, 1, 510, 1, 510, 3, 510, 9703, 8, 510, 1, 510, 3, 510, 9706, 8, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 3, 510, 9715, 8, 510, 3, 510, 9717, 8, 510, 1, 510, 1, 510, 1, 510, 3, 510, 9722, 8, 510, 1, 510, 3, 510, 9725, 8, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 512, 1, 512, 3, 512, 9734, 8, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 3, 515, 9753, 8, 515, 1, 515, 1, 515, 1, 515, 1, 515, 3, 515, 9759, 8, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 3, 515, 9766, 8, 515, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 3, 517, 9786, 8, 517, 1, 518, 1, 518, 1, 518, 5, 518, 9791, 8, 518, 10, 518, 12, 518, 9794, 9, 518, 1, 519, 1, 519, 1, 519, 3, 519, 9799, 8, 519, 1, 520, 1, 520, 3, 520, 9803, 8, 520, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 5, 522, 9810, 8, 522, 10, 522, 12, 522, 9813, 9, 522, 1, 523, 1, 523, 1, 523, 1, 524, 1, 524, 1, 524, 3, 524, 9821, 8, 524, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, 9827, 8, 525, 1, 526, 1, 526, 1, 526, 5, 526, 9832, 8, 526, 10, 526, 12, 526, 9835, 9, 526, 1, 527, 1, 527, 3, 527, 9839, 8, 527, 1, 528, 3, 528, 9842, 8, 528, 1, 528, 1, 528, 3, 528, 9846, 8, 528, 1, 528, 3, 528, 9849, 8, 528, 1, 529, 1, 529, 1, 529, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 9860, 8, 530, 1, 530, 1, 530, 3, 530, 9864, 8, 530, 1, 531, 1, 531, 1, 531, 3, 531, 9869, 8, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 4, 532, 9878, 8, 532, 11, 532, 12, 532, 9879, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 9892, 8, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 9902, 8, 533, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 3, 534, 9909, 8, 534, 1, 534, 1, 534, 1, 534, 1, 534, 3, 534, 9915, 8, 534, 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 9921, 8, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 9933, 8, 535, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, 9939, 8, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, 9949, 8, 536, 1, 536, 1, 536, 1, 536, 1, 536, 3, 536, 9955, 8, 536, 1, 536, 1, 536, 3, 536, 9959, 8, 536, 1, 537, 1, 537, 1, 537, 3, 537, 9964, 8, 537, 1, 537, 1, 537, 1, 537, 5, 537, 9969, 8, 537, 10, 537, 12, 537, 9972, 9, 537, 1, 537, 1, 537, 1, 537, 3, 537, 9977, 8, 537, 1, 537, 3, 537, 9980, 8, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 3, 538, 9991, 8, 538, 1, 538, 1, 538, 1, 538, 1, 538, 3, 538, 9997, 8, 538, 1, 538, 1, 538, 3, 538, 10001, 8, 538, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 3, 539, 10012, 8, 539, 1, 539, 1, 539, 1, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 3, 540, 10023, 8, 540, 1, 540, 1, 540, 1, 540, 1, 540, 3, 540, 10029, 8, 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, 3, 541, 10044, 8, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 542, 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, 3, 543, 10062, 8, 543, 1, 543, 1, 543, 3, 543, 10066, 8, 543, 1, 543, 1, 543, 3, 543, 10070, 8, 543, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 544, 3, 544, 10078, 8, 544, 1, 544, 1, 544, 3, 544, 10082, 8, 544, 1, 544, 1, 544, 3, 544, 10086, 8, 544, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 3, 545, 10094, 8, 545, 1, 545, 1, 545, 1, 545, 3, 545, 10099, 8, 545, 1, 545, 1, 545, 3, 545, 10103, 8, 545, 1, 546, 1, 546, 1, 546, 3, 546, 10108, 8, 546, 1, 547, 1, 547, 3, 547, 10112, 8, 547, 1, 548, 1, 548, 1, 549, 1, 549, 1, 549, 3, 549, 10119, 8, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 3, 549, 10126, 8, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 3, 549, 10138, 8, 549, 1, 549, 1, 549, 3, 549, 10142, 8, 549, 1, 549, 1, 549, 1, 549, 3, 549, 10147, 8, 549, 3, 549, 10149, 8, 549, 1, 550, 1, 550, 1, 550, 5, 550, 10154, 8, 550, 10, 550, 12, 550, 10157, 9, 550, 1, 551, 1, 551, 1, 551, 5, 551, 10162, 8, 551, 10, 551, 12, 551, 10165, 9, 551, 1, 551, 3, 551, 10168, 8, 551, 1, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 10181, 8, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 10190, 8, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 10207, 8, 553, 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 10213, 8, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 10225, 8, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 10236, 8, 554, 1, 555, 1, 555, 1, 555, 5, 555, 10241, 8, 555, 10, 555, 12, 555, 10244, 9, 555, 1, 556, 1, 556, 1, 556, 1, 557, 1, 557, 3, 557, 10251, 8, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 3, 558, 10268, 8, 558, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10280, 8, 559, 3, 559, 10282, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10289, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10296, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10302, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10308, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10320, 8, 559, 3, 559, 10322, 8, 559, 1, 560, 1, 560, 1, 560, 5, 560, 10327, 8, 560, 10, 560, 12, 560, 10330, 9, 560, 1, 561, 1, 561, 1, 561, 1, 561, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, 5, 563, 10341, 8, 563, 10, 563, 12, 563, 10344, 9, 563, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 3, 565, 10353, 8, 565, 1, 565, 1, 565, 3, 565, 10357, 8, 565, 1, 565, 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 10364, 8, 565, 1, 565, 1, 565, 1, 565, 1, 565, 3, 565, 10370, 8, 565, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 3, 566, 10379, 8, 566, 1, 566, 1, 566, 3, 566, 10383, 8, 566, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 4, 567, 10390, 8, 567, 11, 567, 12, 567, 10391, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 3, 568, 10406, 8, 568, 1, 568, 3, 568, 10409, 8, 568, 1, 568, 1, 568, 3, 568, 10413, 8, 568, 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, 3, 570, 10439, 8, 570, 1, 570, 1, 570, 3, 570, 10443, 8, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 5, 570, 10450, 8, 570, 10, 570, 12, 570, 10453, 9, 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, 3, 570, 10467, 8, 570, 1, 570, 1, 570, 3, 570, 10471, 8, 570, 3, 570, 10473, 8, 570, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 3, 571, 10491, 8, 571, 1, 572, 1, 572, 1, 572, 5, 572, 10496, 8, 572, 10, 572, 12, 572, 10499, 9, 572, 1, 573, 1, 573, 1, 573, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 3, 575, 10527, 8, 575, 1, 575, 1, 575, 1, 575, 1, 575, 3, 575, 10533, 8, 575, 1, 576, 1, 576, 1, 576, 5, 576, 10538, 8, 576, 10, 576, 12, 576, 10541, 9, 576, 1, 577, 1, 577, 1, 578, 1, 578, 1, 578, 5, 578, 10548, 8, 578, 10, 578, 12, 578, 10551, 9, 578, 1, 579, 1, 579, 1, 579, 3, 579, 10556, 8, 579, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 3, 580, 10564, 8, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 581, 1, 581, 1, 581, 5, 581, 10573, 8, 581, 10, 581, 12, 581, 10576, 9, 581, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 3, 582, 10585, 8, 582, 1, 582, 5, 582, 10588, 8, 582, 10, 582, 12, 582, 10591, 9, 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, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 3, 583, 10612, 8, 583, 1, 583, 1, 583, 1, 583, 3, 583, 10617, 8, 583, 3, 583, 10619, 8, 583, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 3, 584, 10629, 8, 584, 1, 585, 1, 585, 1, 585, 3, 585, 10634, 8, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 5, 585, 10643, 8, 585, 10, 585, 12, 585, 10646, 9, 585, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 10652, 8, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 3, 586, 10659, 8, 586, 3, 586, 10661, 8, 586, 1, 587, 1, 587, 1, 587, 1, 587, 3, 587, 10667, 8, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 588, 1, 588, 1, 588, 5, 588, 10682, 8, 588, 10, 588, 12, 588, 10685, 9, 588, 1, 589, 1, 589, 1, 589, 1, 590, 1, 590, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 10699, 8, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 10707, 8, 591, 1, 591, 1, 591, 3, 591, 10711, 8, 591, 1, 591, 1, 591, 3, 591, 10715, 8, 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 10721, 8, 591, 1, 591, 1, 591, 3, 591, 10725, 8, 591, 1, 591, 1, 591, 3, 591, 10729, 8, 591, 1, 591, 1, 591, 3, 591, 10733, 8, 591, 1, 591, 1, 591, 3, 591, 10737, 8, 591, 1, 591, 1, 591, 3, 591, 10741, 8, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 10748, 8, 591, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 3, 592, 10756, 8, 592, 1, 593, 1, 593, 3, 593, 10760, 8, 593, 1, 594, 1, 594, 1, 594, 3, 594, 10765, 8, 594, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 597, 1, 597, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 3, 599, 10786, 8, 599, 1, 600, 1, 600, 1, 600, 5, 600, 10791, 8, 600, 10, 600, 12, 600, 10794, 9, 600, 1, 601, 1, 601, 1, 601, 1, 602, 1, 602, 1, 602, 5, 602, 10802, 8, 602, 10, 602, 12, 602, 10805, 9, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 10841, 8, 603, 1, 604, 1, 604, 1, 604, 5, 604, 10846, 8, 604, 10, 604, 12, 604, 10849, 9, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 3, 605, 10858, 8, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 3, 606, 10870, 8, 606, 3, 606, 10872, 8, 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, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 3, 609, 10902, 8, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 610, 1, 610, 1, 610, 5, 610, 10911, 8, 610, 10, 610, 12, 610, 10914, 9, 610, 1, 611, 1, 611, 1, 611, 1, 611, 3, 611, 10920, 8, 611, 1, 612, 1, 612, 1, 613, 1, 613, 1, 613, 1, 613, 3, 613, 10928, 8, 613, 1, 613, 1, 613, 3, 613, 10932, 8, 613, 1, 614, 1, 614, 1, 614, 3, 614, 10937, 8, 614, 1, 614, 1, 614, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 10945, 8, 615, 1, 615, 1, 615, 1, 616, 1, 616, 1, 616, 3, 616, 10952, 8, 616, 1, 616, 1, 616, 1, 617, 1, 617, 1, 617, 1, 617, 3, 617, 10960, 8, 617, 1, 617, 1, 617, 3, 617, 10964, 8, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 5, 618, 10973, 8, 618, 10, 618, 12, 618, 10976, 9, 618, 1, 619, 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 3, 620, 10984, 8, 620, 1, 620, 4, 620, 10987, 8, 620, 11, 620, 12, 620, 10988, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 11001, 8, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 11013, 8, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 11030, 8, 621, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 3, 622, 11039, 8, 622, 3, 622, 11041, 8, 622, 1, 622, 1, 622, 3, 622, 11045, 8, 622, 1, 623, 1, 623, 1, 623, 3, 623, 11050, 8, 623, 1, 623, 3, 623, 11053, 8, 623, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 626, 1, 626, 3, 626, 11065, 8, 626, 1, 627, 1, 627, 3, 627, 11069, 8, 627, 1, 627, 1, 627, 1, 627, 1, 627, 3, 627, 11075, 8, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 3, 628, 11088, 8, 628, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 630, 1, 630, 1, 630, 1, 630, 3, 630, 11101, 8, 630, 1, 630, 1, 630, 1, 630, 3, 630, 11106, 8, 630, 1, 630, 1, 630, 3, 630, 11110, 8, 630, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 11117, 8, 631, 1, 631, 5, 631, 11120, 8, 631, 10, 631, 12, 631, 11123, 9, 631, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 5, 632, 11136, 8, 632, 10, 632, 12, 632, 11139, 9, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 11145, 8, 632, 3, 632, 11147, 8, 632, 1, 633, 1, 633, 1, 633, 1, 633, 3, 633, 11153, 8, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 3, 634, 11160, 8, 634, 1, 635, 1, 635, 1, 635, 1, 635, 3, 635, 11166, 8, 635, 1, 635, 1, 635, 3, 635, 11170, 8, 635, 1, 635, 1, 635, 3, 635, 11174, 8, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 3, 635, 11183, 8, 635, 3, 635, 11185, 8, 635, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 3, 636, 11192, 8, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 3, 636, 11199, 8, 636, 1, 636, 3, 636, 11202, 8, 636, 3, 636, 11204, 8, 636, 1, 637, 1, 637, 1, 637, 3, 637, 11209, 8, 637, 1, 638, 1, 638, 1, 638, 1, 638, 3, 638, 11215, 8, 638, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 11221, 8, 639, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 3, 640, 11228, 8, 640, 1, 640, 1, 640, 3, 640, 11232, 8, 640, 1, 640, 1, 640, 3, 640, 11236, 8, 640, 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, 3, 642, 11251, 8, 642, 1, 642, 1, 642, 3, 642, 11255, 8, 642, 1, 643, 1, 643, 1, 643, 1, 643, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 5, 644, 11269, 8, 644, 10, 644, 12, 644, 11272, 9, 644, 1, 645, 1, 645, 1, 645, 3, 645, 11277, 8, 645, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 3, 646, 11298, 8, 646, 1, 647, 1, 647, 1, 647, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 3, 648, 11309, 8, 648, 1, 649, 1, 649, 3, 649, 11313, 8, 649, 1, 650, 1, 650, 1, 651, 1, 651, 3, 651, 11319, 8, 651, 1, 651, 1, 651, 1, 652, 1, 652, 1, 652, 1, 653, 1, 653, 3, 653, 11328, 8, 653, 1, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 656, 1, 656, 1, 657, 1, 657, 1, 657, 1, 657, 1, 658, 1, 658, 1, 659, 1, 659, 1, 660, 1, 660, 1, 661, 1, 661, 1, 661, 1, 662, 1, 662, 3, 662, 11352, 8, 662, 1, 662, 1, 662, 3, 662, 11356, 8, 662, 1, 663, 1, 663, 3, 663, 11360, 8, 663, 1, 663, 1, 663, 3, 663, 11364, 8, 663, 1, 664, 1, 664, 1, 665, 1, 665, 3, 665, 11370, 8, 665, 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 1, 667, 1, 667, 1, 667, 1, 668, 1, 668, 1, 668, 1, 668, 3, 668, 11384, 8, 668, 1, 668, 3, 668, 11387, 8, 668, 1, 669, 1, 669, 1, 670, 4, 670, 11392, 8, 670, 11, 670, 12, 670, 11393, 1, 671, 1, 671, 3, 671, 11398, 8, 671, 1, 671, 1, 671, 1, 671, 1, 671, 3, 671, 11404, 8, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 3, 671, 11411, 8, 671, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 3, 672, 11421, 8, 672, 1, 673, 1, 673, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 3, 674, 11430, 8, 674, 1, 674, 3, 674, 11433, 8, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 3, 674, 11447, 8, 674, 3, 674, 11449, 8, 674, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 676, 1, 676, 1, 676, 1, 676, 1, 677, 1, 677, 1, 677, 5, 677, 11463, 8, 677, 10, 677, 12, 677, 11466, 9, 677, 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, 3, 681, 11485, 8, 681, 1, 681, 1, 681, 1, 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 3, 682, 11506, 8, 682, 1, 682, 1, 682, 3, 682, 11510, 8, 682, 1, 682, 1, 682, 1, 682, 3, 682, 11515, 8, 682, 1, 683, 1, 683, 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, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 3, 685, 11598, 8, 685, 1, 686, 1, 686, 1, 687, 1, 687, 3, 687, 11604, 8, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 688, 1, 688, 3, 688, 11617, 8, 688, 1, 688, 1, 688, 3, 688, 11621, 8, 688, 1, 688, 1, 688, 3, 688, 11625, 8, 688, 1, 688, 1, 688, 3, 688, 11629, 8, 688, 1, 688, 1, 688, 1, 688, 1, 688, 3, 688, 11635, 8, 688, 1, 689, 1, 689, 1, 689, 1, 690, 1, 690, 3, 690, 11642, 8, 690, 1, 690, 3, 690, 11645, 8, 690, 1, 690, 3, 690, 11648, 8, 690, 1, 690, 3, 690, 11651, 8, 690, 1, 690, 3, 690, 11654, 8, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 3, 690, 11661, 8, 690, 1, 690, 1, 690, 3, 690, 11665, 8, 690, 1, 690, 3, 690, 11668, 8, 690, 1, 690, 1, 690, 1, 690, 1, 690, 3, 690, 11674, 8, 690, 1, 690, 3, 690, 11677, 8, 690, 3, 690, 11679, 8, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 3, 691, 11688, 8, 691, 1, 692, 1, 692, 3, 692, 11692, 8, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 3, 692, 11699, 8, 692, 3, 692, 11701, 8, 692, 1, 692, 1, 692, 1, 692, 1, 692, 3, 692, 11707, 8, 692, 1, 693, 1, 693, 1, 693, 5, 693, 11712, 8, 693, 10, 693, 12, 693, 11715, 9, 693, 1, 694, 1, 694, 1, 695, 1, 695, 3, 695, 11721, 8, 695, 1, 696, 1, 696, 3, 696, 11725, 8, 696, 1, 697, 1, 697, 3, 697, 11729, 8, 697, 1, 698, 1, 698, 1, 699, 1, 699, 1, 700, 1, 700, 1, 701, 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, 1, 703, 1, 703, 3, 703, 11745, 8, 703, 1, 704, 1, 704, 1, 704, 5, 704, 11750, 8, 704, 10, 704, 12, 704, 11753, 9, 704, 1, 705, 1, 705, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 3, 706, 11762, 8, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 3, 706, 11775, 8, 706, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 3, 707, 11786, 8, 707, 1, 708, 1, 708, 1, 708, 5, 708, 11791, 8, 708, 10, 708, 12, 708, 11794, 9, 708, 1, 709, 1, 709, 3, 709, 11798, 8, 709, 1, 710, 1, 710, 3, 710, 11802, 8, 710, 1, 711, 1, 711, 3, 711, 11806, 8, 711, 1, 712, 1, 712, 1, 712, 3, 712, 11811, 8, 712, 1, 712, 1, 712, 1, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 3, 714, 11825, 8, 714, 1, 715, 1, 715, 1, 715, 3, 715, 11830, 8, 715, 1, 715, 1, 715, 3, 715, 11834, 8, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 3, 715, 11842, 8, 715, 1, 715, 3, 715, 11845, 8, 715, 1, 715, 1, 715, 3, 715, 11849, 8, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 3, 715, 11860, 8, 715, 1, 715, 3, 715, 11863, 8, 715, 3, 715, 11865, 8, 715, 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, 717, 3, 717, 11881, 8, 717, 1, 718, 3, 718, 11884, 8, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 3, 718, 11891, 8, 718, 1, 718, 3, 718, 11894, 8, 718, 1, 719, 1, 719, 1, 719, 3, 719, 11899, 8, 719, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 3, 720, 11914, 8, 720, 1, 720, 1, 720, 1, 720, 1, 720, 3, 720, 11920, 8, 720, 1, 721, 1, 721, 1, 722, 1, 722, 1, 722, 5, 722, 11927, 8, 722, 10, 722, 12, 722, 11930, 9, 722, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 3, 724, 11938, 8, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 3, 724, 11945, 8, 724, 1, 724, 3, 724, 11948, 8, 724, 1, 725, 1, 725, 1, 725, 1, 725, 3, 725, 11954, 8, 725, 1, 725, 1, 725, 1, 725, 3, 725, 11959, 8, 725, 1, 726, 1, 726, 1, 726, 1, 727, 3, 727, 11965, 8, 727, 1, 727, 1, 727, 1, 727, 3, 727, 11970, 8, 727, 1, 727, 1, 727, 3, 727, 11974, 8, 727, 1, 727, 1, 727, 1, 727, 3, 727, 11979, 8, 727, 1, 727, 3, 727, 11982, 8, 727, 1, 727, 1, 727, 1, 727, 4, 727, 11987, 8, 727, 11, 727, 12, 727, 11988, 1, 727, 1, 727, 3, 727, 11993, 8, 727, 1, 728, 1, 728, 1, 728, 3, 728, 11998, 8, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 3, 729, 12005, 8, 729, 1, 729, 3, 729, 12008, 8, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 3, 729, 12015, 8, 729, 1, 729, 1, 729, 1, 730, 1, 730, 1, 730, 1, 730, 3, 730, 12023, 8, 730, 1, 730, 3, 730, 12026, 8, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, 1, 731, 3, 731, 12036, 8, 731, 1, 731, 3, 731, 12039, 8, 731, 1, 731, 1, 731, 1, 732, 3, 732, 12044, 8, 732, 1, 732, 1, 732, 3, 732, 12048, 8, 732, 1, 732, 1, 732, 3, 732, 12052, 8, 732, 1, 732, 3, 732, 12055, 8, 732, 1, 732, 3, 732, 12058, 8, 732, 1, 733, 1, 733, 1, 733, 1, 734, 1, 734, 3, 734, 12065, 8, 734, 1, 734, 1, 734, 3, 734, 12069, 8, 734, 1, 734, 3, 734, 12072, 8, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 3, 736, 12087, 8, 736, 1, 736, 3, 736, 12090, 8, 736, 1, 737, 1, 737, 1, 738, 1, 738, 1, 738, 3, 738, 12097, 8, 738, 1, 739, 3, 739, 12100, 8, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 3, 739, 12107, 8, 739, 1, 739, 3, 739, 12110, 8, 739, 1, 739, 3, 739, 12113, 8, 739, 1, 740, 1, 740, 1, 740, 5, 740, 12118, 8, 740, 10, 740, 12, 740, 12121, 9, 740, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 3, 741, 12133, 8, 741, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 1, 743, 5, 743, 12141, 8, 743, 10, 743, 12, 743, 12144, 9, 743, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 3, 744, 12151, 8, 744, 1, 744, 1, 744, 1, 744, 1, 745, 1, 745, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 5, 746, 12163, 8, 746, 10, 746, 12, 746, 12166, 9, 746, 1, 747, 1, 747, 1, 747, 1, 747, 3, 747, 12172, 8, 747, 1, 748, 1, 748, 3, 748, 12176, 8, 748, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 3, 749, 12186, 8, 749, 1, 750, 1, 750, 3, 750, 12190, 8, 750, 1, 750, 1, 750, 3, 750, 12194, 8, 750, 1, 750, 1, 750, 3, 750, 12198, 8, 750, 3, 750, 12200, 8, 750, 1, 750, 1, 750, 1, 750, 3, 750, 12205, 8, 750, 1, 750, 1, 750, 3, 750, 12209, 8, 750, 1, 750, 1, 750, 3, 750, 12213, 8, 750, 3, 750, 12215, 8, 750, 3, 750, 12217, 8, 750, 1, 751, 1, 751, 1, 751, 3, 751, 12222, 8, 751, 1, 751, 5, 751, 12225, 8, 751, 10, 751, 12, 751, 12228, 9, 751, 1, 752, 1, 752, 1, 752, 3, 752, 12233, 8, 752, 1, 752, 5, 752, 12236, 8, 752, 10, 752, 12, 752, 12239, 9, 752, 1, 753, 1, 753, 3, 753, 12243, 8, 753, 1, 753, 3, 753, 12246, 8, 753, 1, 753, 3, 753, 12249, 8, 753, 1, 753, 3, 753, 12252, 8, 753, 1, 753, 3, 753, 12255, 8, 753, 1, 753, 1, 753, 1, 753, 1, 753, 3, 753, 12261, 8, 753, 1, 753, 3, 753, 12264, 8, 753, 1, 753, 3, 753, 12267, 8, 753, 1, 753, 3, 753, 12270, 8, 753, 1, 753, 3, 753, 12273, 8, 753, 1, 753, 3, 753, 12276, 8, 753, 1, 753, 3, 753, 12279, 8, 753, 1, 753, 3, 753, 12282, 8, 753, 1, 753, 3, 753, 12285, 8, 753, 1, 753, 3, 753, 12288, 8, 753, 1, 753, 1, 753, 1, 753, 1, 753, 3, 753, 12294, 8, 753, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 755, 1, 755, 1, 755, 1, 756, 1, 756, 1, 756, 3, 756, 12307, 8, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 757, 1, 757, 3, 757, 12315, 8, 757, 1, 757, 1, 757, 1, 758, 1, 758, 1, 758, 5, 758, 12322, 8, 758, 10, 758, 12, 758, 12325, 9, 758, 1, 759, 1, 759, 3, 759, 12329, 8, 759, 1, 759, 1, 759, 3, 759, 12333, 8, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 760, 1, 760, 1, 760, 3, 760, 12342, 8, 760, 1, 761, 1, 761, 1, 762, 1, 762, 3, 762, 12348, 8, 762, 1, 762, 1, 762, 3, 762, 12352, 8, 762, 1, 763, 1, 763, 1, 763, 1, 764, 1, 764, 1, 765, 3, 765, 12360, 8, 765, 1, 765, 1, 765, 3, 765, 12364, 8, 765, 1, 765, 1, 765, 1, 765, 3, 765, 12369, 8, 765, 1, 765, 1, 765, 1, 765, 1, 765, 3, 765, 12375, 8, 765, 1, 766, 1, 766, 1, 767, 1, 767, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 3, 768, 12387, 8, 768, 1, 769, 1, 769, 1, 770, 1, 770, 1, 771, 1, 771, 1, 771, 1, 771, 1, 772, 1, 772, 1, 772, 5, 772, 12400, 8, 772, 10, 772, 12, 772, 12403, 9, 772, 1, 773, 1, 773, 1, 773, 1, 773, 3, 773, 12409, 8, 773, 3, 773, 12411, 8, 773, 1, 773, 3, 773, 12414, 8, 773, 1, 774, 1, 774, 3, 774, 12418, 8, 774, 1, 774, 1, 774, 3, 774, 12422, 8, 774, 3, 774, 12424, 8, 774, 1, 775, 1, 775, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 12432, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 12441, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, 3, 776, 12447, 8, 776, 3, 776, 12449, 8, 776, 3, 776, 12451, 8, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 3, 777, 12458, 8, 777, 1, 778, 1, 778, 3, 778, 12462, 8, 778, 1, 779, 1, 779, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 3, 780, 12471, 8, 780, 1, 781, 1, 781, 3, 781, 12475, 8, 781, 1, 782, 1, 782, 1, 783, 1, 783, 1, 784, 1, 784, 1, 784, 1, 784, 1, 785, 1, 785, 1, 785, 5, 785, 12488, 8, 785, 10, 785, 12, 785, 12491, 9, 785, 1, 785, 3, 785, 12494, 8, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 3, 786, 12501, 8, 786, 1, 787, 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 791, 1, 791, 1, 791, 1, 792, 1, 792, 1, 792, 1, 792, 3, 792, 12529, 8, 792, 1, 793, 1, 793, 1, 794, 4, 794, 12534, 8, 794, 11, 794, 12, 794, 12535, 1, 795, 1, 795, 3, 795, 12540, 8, 795, 1, 795, 3, 795, 12543, 8, 795, 1, 796, 1, 796, 1, 796, 3, 796, 12548, 8, 796, 1, 796, 1, 796, 3, 796, 12552, 8, 796, 1, 796, 3, 796, 12555, 8, 796, 1, 797, 1, 797, 1, 797, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 5, 798, 12569, 8, 798, 10, 798, 12, 798, 12572, 9, 798, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 5, 800, 12580, 8, 800, 10, 800, 12, 800, 12583, 9, 800, 1, 801, 1, 801, 3, 801, 12587, 8, 801, 1, 801, 3, 801, 12590, 8, 801, 1, 801, 1, 801, 3, 801, 12594, 8, 801, 1, 801, 1, 801, 3, 801, 12598, 8, 801, 1, 801, 1, 801, 3, 801, 12602, 8, 801, 1, 801, 1, 801, 1, 801, 3, 801, 12607, 8, 801, 1, 801, 1, 801, 3, 801, 12611, 8, 801, 1, 801, 1, 801, 3, 801, 12615, 8, 801, 3, 801, 12617, 8, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 3, 801, 12626, 8, 801, 1, 801, 1, 801, 1, 801, 3, 801, 12631, 8, 801, 1, 801, 1, 801, 1, 801, 1, 801, 3, 801, 12637, 8, 801, 1, 801, 1, 801, 3, 801, 12641, 8, 801, 3, 801, 12643, 8, 801, 1, 801, 5, 801, 12646, 8, 801, 10, 801, 12, 801, 12649, 9, 801, 1, 802, 3, 802, 12652, 8, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 3, 802, 12663, 8, 802, 1, 802, 1, 802, 3, 802, 12667, 8, 802, 1, 803, 3, 803, 12670, 8, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 3, 803, 12677, 8, 803, 1, 804, 1, 804, 1, 805, 3, 805, 12682, 8, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 3, 805, 12689, 8, 805, 1, 806, 1, 806, 1, 806, 3, 806, 12694, 8, 806, 1, 806, 3, 806, 12697, 8, 806, 1, 806, 1, 806, 1, 806, 1, 806, 3, 806, 12703, 8, 806, 1, 807, 1, 807, 3, 807, 12707, 8, 807, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 3, 808, 12716, 8, 808, 1, 809, 1, 809, 3, 809, 12720, 8, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 3, 809, 12728, 8, 809, 3, 809, 12730, 8, 809, 1, 810, 1, 810, 1, 810, 5, 810, 12735, 8, 810, 10, 810, 12, 810, 12738, 9, 810, 1, 811, 1, 811, 3, 811, 12742, 8, 811, 1, 811, 3, 811, 12745, 8, 811, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 3, 812, 12753, 8, 812, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 814, 1, 814, 3, 814, 12762, 8, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 3, 814, 12770, 8, 814, 3, 814, 12772, 8, 814, 1, 815, 1, 815, 3, 815, 12776, 8, 815, 1, 816, 1, 816, 1, 816, 5, 816, 12781, 8, 816, 10, 816, 12, 816, 12784, 9, 816, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 819, 1, 819, 1, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 3, 820, 12802, 8, 820, 1, 821, 1, 821, 1, 822, 1, 822, 1, 822, 5, 822, 12809, 8, 822, 10, 822, 12, 822, 12812, 9, 822, 1, 823, 1, 823, 1, 823, 3, 823, 12817, 8, 823, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 3, 824, 12836, 8, 824, 1, 824, 1, 824, 1, 825, 1, 825, 1, 825, 5, 825, 12843, 8, 825, 10, 825, 12, 825, 12846, 9, 825, 1, 826, 1, 826, 1, 826, 3, 826, 12851, 8, 826, 1, 826, 1, 826, 3, 826, 12855, 8, 826, 1, 827, 4, 827, 12858, 8, 827, 11, 827, 12, 827, 12859, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 3, 828, 12870, 8, 828, 1, 829, 1, 829, 1, 829, 5, 829, 12875, 8, 829, 10, 829, 12, 829, 12878, 9, 829, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 3, 830, 12886, 8, 830, 1, 831, 3, 831, 12889, 8, 831, 1, 831, 1, 831, 3, 831, 12893, 8, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 3, 831, 12900, 8, 831, 3, 831, 12902, 8, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 3, 831, 12909, 8, 831, 1, 832, 1, 832, 3, 832, 12913, 8, 832, 1, 832, 4, 832, 12916, 8, 832, 11, 832, 12, 832, 12917, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 3, 833, 12928, 8, 833, 1, 833, 1, 833, 1, 833, 1, 833, 3, 833, 12934, 8, 833, 1, 833, 3, 833, 12937, 8, 833, 1, 834, 1, 834, 1, 834, 1, 834, 3, 834, 12943, 8, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, 1, 835, 1, 836, 1, 836, 1, 836, 1, 836, 3, 836, 12955, 8, 836, 1, 837, 1, 837, 1, 837, 1, 837, 3, 837, 12961, 8, 837, 1, 837, 3, 837, 12964, 8, 837, 1, 837, 3, 837, 12967, 8, 837, 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 3, 839, 12980, 8, 839, 1, 839, 1, 839, 1, 839, 1, 839, 3, 839, 12986, 8, 839, 1, 839, 1, 839, 3, 839, 12990, 8, 839, 1, 839, 1, 839, 3, 839, 12994, 8, 839, 1, 839, 3, 839, 12997, 8, 839, 1, 840, 1, 840, 1, 840, 1, 840, 1, 841, 1, 841, 3, 841, 13005, 8, 841, 1, 842, 1, 842, 3, 842, 13009, 8, 842, 1, 843, 1, 843, 3, 843, 13013, 8, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 844, 1, 844, 3, 844, 13021, 8, 844, 1, 845, 1, 845, 1, 845, 1, 845, 3, 845, 13027, 8, 845, 1, 845, 1, 845, 3, 845, 13031, 8, 845, 1, 846, 1, 846, 1, 846, 1, 846, 3, 846, 13037, 8, 846, 1, 846, 1, 846, 3, 846, 13041, 8, 846, 1, 847, 1, 847, 3, 847, 13045, 8, 847, 1, 847, 1, 847, 1, 847, 1, 847, 3, 847, 13051, 8, 847, 3, 847, 13053, 8, 847, 1, 848, 1, 848, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 3, 849, 13062, 8, 849, 1, 849, 3, 849, 13065, 8, 849, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 3, 851, 13075, 8, 851, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 3, 852, 13091, 8, 852, 1, 852, 1, 852, 1, 852, 1, 852, 3, 852, 13097, 8, 852, 1, 852, 1, 852, 1, 852, 3, 852, 13102, 8, 852, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 3, 853, 13109, 8, 853, 1, 854, 1, 854, 1, 854, 1, 855, 1, 855, 1, 856, 1, 856, 3, 856, 13118, 8, 856, 1, 857, 1, 857, 1, 857, 5, 857, 13123, 8, 857, 10, 857, 12, 857, 13126, 9, 857, 1, 858, 1, 858, 1, 858, 5, 858, 13131, 8, 858, 10, 858, 12, 858, 13134, 9, 858, 1, 859, 1, 859, 1, 859, 5, 859, 13139, 8, 859, 10, 859, 12, 859, 13142, 9, 859, 1, 860, 1, 860, 3, 860, 13146, 8, 860, 1, 860, 1, 860, 3, 860, 13150, 8, 860, 1, 860, 1, 860, 1, 860, 1, 860, 3, 860, 13156, 8, 860, 1, 861, 1, 861, 3, 861, 13160, 8, 861, 1, 861, 1, 861, 3, 861, 13164, 8, 861, 1, 862, 3, 862, 13167, 8, 862, 1, 862, 1, 862, 1, 863, 1, 863, 3, 863, 13173, 8, 863, 1, 864, 1, 864, 1, 864, 3, 864, 13178, 8, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 3, 864, 13194, 8, 864, 1, 864, 3, 864, 13197, 8, 864, 3, 864, 13199, 8, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 3, 865, 13211, 8, 865, 3, 865, 13213, 8, 865, 1, 866, 3, 866, 13216, 8, 866, 1, 866, 1, 866, 1, 867, 1, 867, 3, 867, 13222, 8, 867, 1, 867, 1, 867, 1, 867, 1, 867, 3, 867, 13228, 8, 867, 1, 867, 1, 867, 3, 867, 13232, 8, 867, 3, 867, 13234, 8, 867, 1, 868, 1, 868, 1, 868, 1, 868, 5, 868, 13240, 8, 868, 10, 868, 12, 868, 13243, 9, 868, 1, 869, 3, 869, 13246, 8, 869, 1, 869, 1, 869, 1, 870, 1, 870, 1, 870, 5, 870, 13253, 8, 870, 10, 870, 12, 870, 13256, 9, 870, 1, 871, 1, 871, 1, 871, 5, 871, 13261, 8, 871, 10, 871, 12, 871, 13264, 9, 871, 1, 872, 1, 872, 1, 872, 3, 872, 13269, 8, 872, 1, 873, 3, 873, 13272, 8, 873, 1, 873, 1, 873, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 3, 874, 13281, 8, 874, 1, 875, 1, 875, 1, 875, 3, 875, 13286, 8, 875, 1, 876, 1, 876, 1, 876, 5, 876, 13291, 8, 876, 10, 876, 12, 876, 13294, 9, 876, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 13303, 8, 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, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 13329, 8, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 13340, 8, 877, 5, 877, 13342, 8, 877, 10, 877, 12, 877, 13345, 9, 877, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 3, 878, 13352, 8, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 3, 878, 13375, 8, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 3, 878, 13383, 8, 878, 1, 879, 1, 879, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 3, 880, 13393, 8, 880, 1, 880, 3, 880, 13396, 8, 880, 1, 880, 1, 880, 1, 880, 3, 880, 13401, 8, 880, 1, 880, 1, 880, 1, 880, 3, 880, 13406, 8, 880, 1, 880, 1, 880, 3, 880, 13410, 8, 880, 1, 880, 1, 880, 1, 881, 1, 881, 3, 881, 13416, 8, 881, 1, 881, 3, 881, 13419, 8, 881, 1, 881, 3, 881, 13422, 8, 881, 1, 881, 3, 881, 13425, 8, 881, 1, 882, 1, 882, 3, 882, 13429, 8, 882, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13443, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13450, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13457, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13464, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13482, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13490, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13502, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13520, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13559, 8, 883, 3, 883, 13561, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13581, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13591, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13602, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13614, 8, 883, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 3, 884, 13621, 8, 884, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 3, 885, 13633, 8, 885, 1, 886, 1, 886, 1, 886, 1, 886, 1, 886, 1, 887, 1, 887, 1, 887, 5, 887, 13643, 8, 887, 10, 887, 12, 887, 13646, 9, 887, 1, 888, 1, 888, 1, 888, 3, 888, 13651, 8, 888, 1, 889, 1, 889, 1, 890, 1, 890, 1, 890, 1, 890, 3, 890, 13659, 8, 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, 3, 891, 13676, 8, 891, 1, 892, 1, 892, 1, 892, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 895, 1, 895, 1, 895, 1, 896, 1, 896, 1, 896, 5, 896, 13699, 8, 896, 10, 896, 12, 896, 13702, 9, 896, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 1, 898, 3, 898, 13711, 8, 898, 1, 899, 1, 899, 3, 899, 13715, 8, 899, 1, 899, 3, 899, 13718, 8, 899, 1, 899, 3, 899, 13721, 8, 899, 1, 899, 3, 899, 13724, 8, 899, 1, 899, 1, 899, 1, 900, 1, 900, 1, 901, 1, 901, 1, 901, 1, 901, 1, 902, 1, 902, 1, 902, 3, 902, 13737, 8, 902, 1, 902, 1, 902, 1, 902, 3, 902, 13742, 8, 902, 1, 902, 1, 902, 1, 902, 3, 902, 13747, 8, 902, 3, 902, 13749, 8, 902, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 3, 903, 13757, 8, 903, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 3, 904, 13766, 8, 904, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 3, 905, 13775, 8, 905, 1, 906, 1, 906, 1, 906, 3, 906, 13780, 8, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 3, 906, 13789, 8, 906, 1, 907, 1, 907, 1, 907, 3, 907, 13794, 8, 907, 1, 907, 1, 907, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 910, 1, 910, 3, 910, 13808, 8, 910, 1, 911, 1, 911, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 3, 912, 13818, 8, 912, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 3, 913, 13826, 8, 913, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 3, 914, 13840, 8, 914, 1, 915, 1, 915, 1, 915, 5, 915, 13845, 8, 915, 10, 915, 12, 915, 13848, 9, 915, 1, 916, 1, 916, 1, 916, 5, 916, 13853, 8, 916, 10, 916, 12, 916, 13856, 9, 916, 1, 917, 1, 917, 1, 917, 1, 917, 1, 917, 3, 917, 13863, 8, 917, 1, 918, 1, 918, 1, 918, 5, 918, 13868, 8, 918, 10, 918, 12, 918, 13871, 9, 918, 1, 919, 1, 919, 1, 919, 3, 919, 13876, 8, 919, 1, 919, 1, 919, 1, 920, 1, 920, 1, 920, 5, 920, 13883, 8, 920, 10, 920, 12, 920, 13886, 9, 920, 1, 921, 1, 921, 1, 921, 1, 921, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 3, 922, 13900, 8, 922, 1, 923, 1, 923, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 3, 924, 13911, 8, 924, 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, 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, 3, 926, 13944, 8, 926, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 3, 927, 13953, 8, 927, 1, 928, 1, 928, 1, 928, 1, 928, 1, 928, 3, 928, 13960, 8, 928, 1, 929, 1, 929, 3, 929, 13964, 8, 929, 1, 929, 1, 929, 3, 929, 13968, 8, 929, 1, 929, 1, 929, 1, 930, 4, 930, 13973, 8, 930, 11, 930, 12, 930, 13974, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 932, 1, 932, 1, 932, 1, 933, 1, 933, 1, 934, 1, 934, 3, 934, 13989, 8, 934, 1, 935, 1, 935, 1, 935, 3, 935, 13994, 8, 935, 1, 935, 1, 935, 1, 935, 3, 935, 13999, 8, 935, 1, 935, 1, 935, 3, 935, 14003, 8, 935, 3, 935, 14005, 8, 935, 1, 935, 3, 935, 14008, 8, 935, 1, 936, 1, 936, 1, 937, 4, 937, 14013, 8, 937, 11, 937, 12, 937, 14014, 1, 938, 5, 938, 14018, 8, 938, 10, 938, 12, 938, 14021, 9, 938, 1, 939, 1, 939, 1, 940, 1, 940, 1, 940, 5, 940, 14028, 8, 940, 10, 940, 12, 940, 14031, 9, 940, 1, 941, 1, 941, 3, 941, 14035, 8, 941, 1, 941, 3, 941, 14038, 8, 941, 1, 942, 1, 942, 1, 942, 3, 942, 14043, 8, 942, 1, 943, 1, 943, 1, 943, 5, 943, 14048, 8, 943, 10, 943, 12, 943, 14051, 9, 943, 1, 944, 1, 944, 3, 944, 14055, 8, 944, 1, 945, 1, 945, 1, 945, 5, 945, 14060, 8, 945, 10, 945, 12, 945, 14063, 9, 945, 1, 946, 1, 946, 1, 947, 1, 947, 1, 948, 1, 948, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 3, 949, 14078, 8, 949, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 3, 950, 14090, 8, 950, 1, 950, 1, 950, 1, 950, 3, 950, 14095, 8, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 3, 950, 14103, 8, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 3, 950, 14110, 8, 950, 1, 950, 1, 950, 1, 950, 3, 950, 14115, 8, 950, 1, 951, 1, 951, 1, 952, 1, 952, 1, 953, 1, 953, 1, 954, 1, 954, 1, 955, 1, 955, 3, 955, 14127, 8, 955, 1, 956, 1, 956, 1, 956, 1, 956, 5, 956, 14133, 8, 956, 10, 956, 12, 956, 14136, 9, 956, 1, 956, 1, 956, 3, 956, 14140, 8, 956, 1, 957, 1, 957, 1, 957, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 3, 958, 14150, 8, 958, 1, 959, 1, 959, 1, 960, 1, 960, 1, 960, 1, 960, 3, 960, 14158, 8, 960, 1, 961, 1, 961, 1, 961, 5, 961, 14163, 8, 961, 10, 961, 12, 961, 14166, 9, 961, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 3, 962, 14174, 8, 962, 1, 963, 1, 963, 1, 963, 1, 963, 3, 963, 14180, 8, 963, 1, 964, 1, 964, 1, 964, 1, 964, 3, 964, 14186, 8, 964, 1, 965, 1, 965, 1, 965, 1, 965, 3, 965, 14192, 8, 965, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 3, 966, 14200, 8, 966, 1, 967, 1, 967, 3, 967, 14204, 8, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 3, 967, 14211, 8, 967, 1, 968, 1, 968, 1, 969, 1, 969, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 3, 970, 14308, 8, 970, 1, 971, 1, 971, 1, 972, 1, 972, 1, 973, 1, 973, 1, 974, 1, 974, 1, 974, 3, 974, 14319, 8, 974, 1, 975, 5, 975, 14322, 8, 975, 10, 975, 12, 975, 14325, 9, 975, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 3, 976, 14347, 8, 976, 1, 977, 1, 977, 1, 978, 1, 978, 1, 978, 1, 978, 3, 978, 14355, 8, 978, 1, 979, 1, 979, 1, 980, 1, 980, 1, 980, 1, 980, 3, 980, 14363, 8, 980, 1, 980, 1, 980, 3, 980, 14367, 8, 980, 1, 981, 3, 981, 14370, 8, 981, 1, 981, 1, 981, 3, 981, 14374, 8, 981, 3, 981, 14376, 8, 981, 1, 982, 1, 982, 1, 983, 4, 983, 14381, 8, 983, 11, 983, 12, 983, 14382, 1, 984, 1, 984, 1, 984, 1, 984, 1, 985, 1, 985, 1, 985, 3, 985, 14392, 8, 985, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 3, 986, 14399, 8, 986, 1, 986, 1, 986, 3, 986, 14403, 8, 986, 1, 986, 3, 986, 14406, 8, 986, 1, 986, 3, 986, 14409, 8, 986, 1, 986, 3, 986, 14412, 8, 986, 1, 986, 1, 986, 3, 986, 14416, 8, 986, 1, 986, 1, 986, 1, 986, 3, 986, 14421, 8, 986, 1, 986, 1, 986, 1, 987, 1, 987, 1, 987, 3, 987, 14428, 8, 987, 1, 988, 1, 988, 1, 989, 1, 989, 1, 989, 1, 989, 1, 990, 1, 990, 1, 990, 5, 990, 14439, 8, 990, 10, 990, 12, 990, 14442, 9, 990, 1, 991, 1, 991, 1, 991, 1, 992, 1, 992, 1, 993, 1, 993, 3, 993, 14451, 8, 993, 1, 994, 1, 994, 1, 995, 1, 995, 1, 996, 1, 996, 1, 997, 1, 997, 1, 997, 1, 998, 1, 998, 1, 998, 1, 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 3, 1000, 14470, 8, 1000, 1, 1001, 1, 1001, 1, 1002, 5, 1002, 14475, 8, 1002, 10, 1002, 12, 1002, 14478, 9, 1002, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 3, 1003, 14507, 8, 1003, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 14517, 8, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 14526, 8, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 14531, 8, 1005, 1, 1006, 1, 1006, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1008, 1, 1008, 3, 1008, 14542, 8, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1009, 1, 1009, 1, 1010, 1, 1010, 1, 1010, 5, 1010, 14553, 8, 1010, 10, 1010, 12, 1010, 14556, 9, 1010, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1012, 1, 1012, 1, 1013, 1, 1013, 1, 1014, 1, 1014, 3, 1014, 14568, 8, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 5, 1014, 14574, 8, 1014, 10, 1014, 12, 1014, 14577, 9, 1014, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 3, 1015, 14585, 8, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 5, 1016, 14596, 8, 1016, 10, 1016, 12, 1016, 14599, 9, 1016, 1, 1017, 1, 1017, 1, 1017, 1, 1018, 1, 1018, 3, 1018, 14606, 8, 1018, 1, 1018, 1, 1018, 3, 1018, 14610, 8, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1019, 1, 1019, 1, 1020, 4, 1020, 14619, 8, 1020, 11, 1020, 12, 1020, 14620, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1023, 3, 1023, 14632, 8, 1023, 1, 1023, 1, 1023, 1, 1024, 3, 1024, 14637, 8, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1025, 3, 1025, 14644, 8, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 14654, 8, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 14661, 8, 1026, 1, 1026, 3, 1026, 14664, 8, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 14670, 8, 1026, 3, 1026, 14672, 8, 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 5, 1028, 14681, 8, 1028, 10, 1028, 12, 1028, 14684, 9, 1028, 1, 1028, 1, 1028, 1, 1029, 1, 1029, 1, 1030, 1, 1030, 1, 1030, 1, 1031, 1, 1031, 1, 1032, 3, 1032, 14696, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 14701, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1033, 1, 1033, 1, 1033, 1, 1034, 1, 1034, 3, 1034, 14713, 8, 1034, 1, 1034, 3, 1034, 14716, 8, 1034, 1, 1034, 1, 1034, 1, 1035, 1, 1035, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 3, 1036, 14729, 8, 1036, 1, 1036, 3, 1036, 14732, 8, 1036, 1, 1036, 3, 1036, 14735, 8, 1036, 3, 1036, 14737, 8, 1036, 1, 1036, 1, 1036, 1, 1037, 1, 1037, 1, 1038, 1, 1038, 3, 1038, 14745, 8, 1038, 1, 1038, 1, 1038, 3, 1038, 14749, 8, 1038, 1, 1038, 3, 1038, 14752, 8, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 3, 1038, 14758, 8, 1038, 1, 1038, 1, 1038, 3, 1038, 14762, 8, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 3, 1038, 14768, 8, 1038, 1, 1038, 1, 1038, 1, 1038, 3, 1038, 14773, 8, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 3, 1038, 14779, 8, 1038, 1, 1038, 3, 1038, 14782, 8, 1038, 1, 1038, 1, 1038, 3, 1038, 14786, 8, 1038, 1, 1039, 1, 1039, 1, 1040, 1, 1040, 4, 1040, 14792, 8, 1040, 11, 1040, 12, 1040, 14793, 1, 1041, 1, 1041, 1, 1041, 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1043, 1, 1043, 1, 1043, 5, 1043, 14806, 8, 1043, 10, 1043, 12, 1043, 14809, 9, 1043, 1, 1044, 1, 1044, 1, 1044, 3, 1044, 14814, 8, 1044, 1, 1044, 1, 1044, 1, 1045, 1, 1045, 1, 1045, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 3, 1046, 14826, 8, 1046, 1, 1046, 1, 1046, 1, 1047, 1, 1047, 1, 1047, 1, 1048, 1, 1048, 1, 1048, 3, 1048, 14836, 8, 1048, 1, 1048, 3, 1048, 14839, 8, 1048, 1, 1048, 3, 1048, 14842, 8, 1048, 1, 1048, 3, 1048, 14845, 8, 1048, 1, 1048, 3, 1048, 14848, 8, 1048, 1, 1048, 1, 1048, 1, 1049, 1, 1049, 1, 1049, 1, 1050, 1, 1050, 1, 1050, 5, 1050, 14858, 8, 1050, 10, 1050, 12, 1050, 14861, 9, 1050, 1, 1051, 1, 1051, 3, 1051, 14865, 8, 1051, 1, 1051, 1, 1051, 1, 1052, 1, 1052, 1, 1052, 3, 1052, 14872, 8, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 3, 1052, 14879, 8, 1052, 3, 1052, 14881, 8, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 3, 1052, 14888, 8, 1052, 3, 1052, 14890, 8, 1052, 1, 1052, 1, 1052, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 3, 1053, 14899, 8, 1053, 1, 1054, 1, 1054, 1, 1054, 5, 1054, 14904, 8, 1054, 10, 1054, 12, 1054, 14907, 9, 1054, 1, 1055, 1, 1055, 1, 1055, 1, 1056, 3, 1056, 14913, 8, 1056, 1, 1056, 1, 1056, 1, 1057, 1, 1057, 1, 1058, 1, 1058, 3, 1058, 14921, 8, 1058, 1, 1058, 3, 1058, 14924, 8, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1059, 1, 1059, 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, 3, 1061, 14948, 8, 1061, 3, 1061, 14950, 8, 1061, 1, 1062, 1, 1062, 3, 1062, 14954, 8, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1064, 1, 1064, 1, 1064, 1, 1065, 1, 1065, 3, 1065, 14968, 8, 1065, 1, 1065, 1, 1065, 1, 1066, 1, 1066, 3, 1066, 14974, 8, 1066, 1, 1066, 1, 1066, 1, 1067, 1, 1067, 3, 1067, 14980, 8, 1067, 1, 1067, 1, 1067, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 3, 1068, 14993, 8, 1068, 1, 1068, 3, 1068, 14996, 8, 1068, 1, 1069, 1, 1069, 3, 1069, 15000, 8, 1069, 1, 1070, 1, 1070, 1, 1070, 1, 1071, 4, 1071, 15006, 8, 1071, 11, 1071, 12, 1071, 15007, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1073, 1, 1073, 1, 1073, 5, 1073, 15018, 8, 1073, 10, 1073, 12, 1073, 15021, 9, 1073, 1, 1074, 1, 1074, 1, 1074, 3, 1074, 15026, 8, 1074, 1, 1075, 1, 1075, 1, 1076, 1, 1076, 1, 1077, 1, 1077, 1, 1078, 1, 1078, 1, 1078, 1, 1079, 1, 1079, 3, 1079, 15039, 8, 1079, 1, 1080, 1, 1080, 1, 1081, 3, 1081, 15044, 8, 1081, 1, 1081, 3, 1081, 15047, 8, 1081, 1, 1081, 3, 1081, 15050, 8, 1081, 1, 1081, 3, 1081, 15053, 8, 1081, 1, 1081, 3, 1081, 15056, 8, 1081, 1, 1081, 3, 1081, 15059, 8, 1081, 1, 1081, 3, 1081, 15062, 8, 1081, 1, 1082, 1, 1082, 1, 1083, 1, 1083, 1, 1084, 1, 1084, 1, 1085, 1, 1085, 1, 1086, 1, 1086, 3, 1086, 15074, 8, 1086, 1, 1087, 1, 1087, 3, 1087, 15078, 8, 1087, 1, 1087, 1, 1087, 1, 1087, 0, 1, 1754, 1088, 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, 0, 113, 2, 0, 199, 199, 362, 362, 2, 0, 496, 496, 502, 502, 2, 0, 10, 10, 95, 95, 2, 0, 66, 66, 316, 316, 2, 0, 100, 100, 316, 316, 2, 0, 464, 465, 845, 845, 2, 0, 213, 213, 313, 313, 2, 0, 135, 135, 195, 195, 2, 0, 249, 249, 330, 330, 2, 0, 164, 164, 361, 361, 2, 0, 184, 184, 225, 225, 5, 0, 30, 30, 285, 285, 327, 327, 350, 350, 352, 352, 2, 0, 152, 152, 313, 313, 3, 0, 483, 484, 843, 843, 850, 850, 2, 0, 80, 80, 273, 273, 2, 0, 33, 33, 82, 82, 1, 0, 486, 487, 4, 0, 173, 174, 513, 513, 517, 517, 521, 521, 2, 0, 64, 64, 95, 95, 4, 0, 30, 30, 240, 240, 420, 420, 842, 842, 1, 0, 840, 841, 2, 0, 350, 350, 352, 352, 2, 0, 843, 843, 850, 850, 2, 0, 204, 204, 228, 228, 9, 0, 30, 30, 162, 162, 167, 167, 183, 183, 223, 223, 231, 231, 340, 340, 343, 343, 608, 608, 3, 0, 115, 115, 281, 281, 334, 334, 2, 0, 53, 53, 78, 78, 2, 0, 266, 266, 383, 383, 3, 0, 176, 176, 256, 256, 259, 259, 5, 0, 30, 30, 89, 89, 186, 186, 236, 236, 367, 367, 2, 0, 93, 93, 230, 230, 1, 0, 647, 648, 2, 0, 93, 93, 577, 577, 2, 0, 339, 339, 577, 577, 2, 0, 215, 215, 294, 294, 3, 0, 319, 319, 355, 355, 643, 643, 2, 0, 207, 207, 629, 629, 3, 0, 46, 46, 140, 140, 195, 195, 2, 0, 46, 46, 195, 195, 2, 0, 140, 140, 332, 332, 2, 0, 89, 89, 367, 367, 2, 0, 140, 140, 195, 195, 4, 0, 46, 46, 140, 140, 195, 195, 628, 628, 5, 0, 46, 46, 140, 140, 350, 350, 352, 352, 628, 628, 8, 0, 87, 87, 89, 89, 140, 140, 186, 186, 195, 195, 236, 236, 356, 356, 367, 367, 5, 0, 216, 216, 327, 327, 348, 348, 359, 359, 654, 656, 2, 0, 37, 37, 55, 55, 3, 0, 226, 226, 336, 336, 375, 375, 3, 0, 68, 68, 562, 562, 652, 652, 2, 0, 10, 10, 53, 53, 5, 0, 93, 93, 179, 179, 230, 230, 321, 321, 347, 347, 3, 0, 179, 179, 321, 321, 347, 347, 3, 0, 111, 111, 130, 130, 349, 349, 4, 0, 89, 89, 186, 186, 236, 236, 367, 367, 2, 0, 139, 139, 237, 237, 2, 0, 354, 354, 378, 378, 2, 0, 153, 153, 249, 249, 2, 0, 135, 135, 472, 472, 2, 0, 60, 60, 97, 97, 2, 0, 55, 55, 468, 468, 3, 0, 411, 411, 493, 493, 569, 569, 2, 0, 464, 464, 638, 638, 3, 0, 174, 174, 513, 518, 521, 521, 2, 0, 203, 203, 639, 639, 2, 0, 420, 420, 569, 569, 1, 0, 426, 430, 1, 0, 431, 433, 1, 0, 480, 481, 2, 0, 482, 482, 586, 586, 1, 0, 31, 32, 2, 0, 173, 174, 521, 521, 1, 0, 451, 453, 1, 0, 464, 465, 2, 0, 328, 328, 335, 335, 2, 0, 311, 311, 331, 331, 2, 0, 100, 100, 347, 347, 2, 0, 205, 205, 332, 332, 2, 0, 59, 59, 98, 98, 2, 0, 217, 217, 249, 249, 2, 0, 30, 30, 56, 56, 2, 0, 318, 318, 577, 577, 2, 0, 211, 211, 265, 265, 4, 0, 115, 115, 117, 117, 121, 121, 128, 128, 2, 0, 358, 358, 676, 676, 2, 0, 553, 554, 568, 568, 1, 0, 553, 554, 1, 0, 581, 582, 1, 0, 18, 19, 2, 0, 119, 119, 124, 124, 5, 0, 10, 10, 16, 17, 21, 21, 23, 23, 25, 25, 2, 0, 246, 246, 291, 291, 1, 0, 12, 13, 3, 0, 9, 9, 14, 14, 27, 27, 3, 0, 39, 39, 73, 73, 96, 96, 2, 0, 168, 168, 192, 192, 2, 0, 302, 302, 649, 649, 2, 0, 212, 212, 286, 286, 3, 0, 30, 30, 34, 34, 91, 91, 6, 0, 9, 10, 12, 17, 21, 21, 23, 23, 25, 25, 27, 27, 2, 0, 20, 20, 22, 22, 1, 0, 682, 685, 19, 0, 86, 86, 126, 126, 131, 173, 175, 177, 179, 253, 255, 256, 258, 286, 288, 308, 310, 384, 391, 392, 394, 548, 573, 573, 603, 610, 639, 651, 654, 668, 670, 670, 672, 672, 674, 674, 677, 687, 6, 0, 107, 108, 110, 120, 122, 125, 127, 127, 129, 130, 671, 671, 5, 0, 30, 52, 54, 70, 72, 85, 87, 106, 653, 653, 6, 0, 52, 52, 309, 309, 588, 594, 703, 703, 712, 712, 720, 834, 2, 0, 62, 62, 118, 118, 2, 0, 10, 10, 20, 20, 2, 0, 604, 604, 700, 700, 2, 0, 169, 169, 706, 706, 1, 0, 711, 716, 2, 0, 64, 64, 68, 68, 2, 0, 146, 146, 214, 214, 36, 0, 33, 33, 35, 35, 43, 45, 53, 53, 57, 57, 61, 61, 93, 93, 118, 118, 125, 125, 132, 132, 146, 146, 155, 155, 159, 159, 163, 163, 169, 169, 175, 175, 211, 211, 214, 214, 236, 236, 244, 244, 262, 262, 265, 266, 276, 276, 291, 291, 305, 305, 311, 311, 317, 317, 321, 322, 331, 331, 358, 358, 603, 604, 676, 676, 689, 701, 705, 711, 713, 717, 719, 719, 16714, 0, 2176, 1, 0, 0, 0, 2, 2179, 1, 0, 0, 0, 4, 2181, 1, 0, 0, 0, 6, 2189, 1, 0, 0, 0, 8, 2375, 1, 0, 0, 0, 10, 2377, 1, 0, 0, 0, 12, 2381, 1, 0, 0, 0, 14, 2384, 1, 0, 0, 0, 16, 2392, 1, 0, 0, 0, 18, 2397, 1, 0, 0, 0, 20, 2414, 1, 0, 0, 0, 22, 2467, 1, 0, 0, 0, 24, 2479, 1, 0, 0, 0, 26, 2481, 1, 0, 0, 0, 28, 2489, 1, 0, 0, 0, 30, 2506, 1, 0, 0, 0, 32, 2508, 1, 0, 0, 0, 34, 2512, 1, 0, 0, 0, 36, 2523, 1, 0, 0, 0, 38, 2534, 1, 0, 0, 0, 40, 2540, 1, 0, 0, 0, 42, 2547, 1, 0, 0, 0, 44, 2551, 1, 0, 0, 0, 46, 2559, 1, 0, 0, 0, 48, 2566, 1, 0, 0, 0, 50, 2592, 1, 0, 0, 0, 52, 2594, 1, 0, 0, 0, 54, 2597, 1, 0, 0, 0, 56, 2609, 1, 0, 0, 0, 58, 2619, 1, 0, 0, 0, 60, 2621, 1, 0, 0, 0, 62, 2635, 1, 0, 0, 0, 64, 2637, 1, 0, 0, 0, 66, 2668, 1, 0, 0, 0, 68, 2670, 1, 0, 0, 0, 70, 2678, 1, 0, 0, 0, 72, 2688, 1, 0, 0, 0, 74, 2695, 1, 0, 0, 0, 76, 2701, 1, 0, 0, 0, 78, 2719, 1, 0, 0, 0, 80, 2723, 1, 0, 0, 0, 82, 2727, 1, 0, 0, 0, 84, 2729, 1, 0, 0, 0, 86, 2740, 1, 0, 0, 0, 88, 2744, 1, 0, 0, 0, 90, 2749, 1, 0, 0, 0, 92, 2754, 1, 0, 0, 0, 94, 2756, 1, 0, 0, 0, 96, 2771, 1, 0, 0, 0, 98, 2778, 1, 0, 0, 0, 100, 2780, 1, 0, 0, 0, 102, 2782, 1, 0, 0, 0, 104, 2784, 1, 0, 0, 0, 106, 2787, 1, 0, 0, 0, 108, 2998, 1, 0, 0, 0, 110, 3002, 1, 0, 0, 0, 112, 3036, 1, 0, 0, 0, 114, 3038, 1, 0, 0, 0, 116, 3344, 1, 0, 0, 0, 118, 3351, 1, 0, 0, 0, 120, 3353, 1, 0, 0, 0, 122, 3355, 1, 0, 0, 0, 124, 3358, 1, 0, 0, 0, 126, 3367, 1, 0, 0, 0, 128, 3369, 1, 0, 0, 0, 130, 3373, 1, 0, 0, 0, 132, 3376, 1, 0, 0, 0, 134, 3384, 1, 0, 0, 0, 136, 3396, 1, 0, 0, 0, 138, 3413, 1, 0, 0, 0, 140, 3441, 1, 0, 0, 0, 142, 3443, 1, 0, 0, 0, 144, 3446, 1, 0, 0, 0, 146, 3454, 1, 0, 0, 0, 148, 3459, 1, 0, 0, 0, 150, 3497, 1, 0, 0, 0, 152, 3499, 1, 0, 0, 0, 154, 3558, 1, 0, 0, 0, 156, 3575, 1, 0, 0, 0, 158, 3578, 1, 0, 0, 0, 160, 3587, 1, 0, 0, 0, 162, 3596, 1, 0, 0, 0, 164, 3609, 1, 0, 0, 0, 166, 3611, 1, 0, 0, 0, 168, 3613, 1, 0, 0, 0, 170, 3618, 1, 0, 0, 0, 172, 3625, 1, 0, 0, 0, 174, 3630, 1, 0, 0, 0, 176, 3672, 1, 0, 0, 0, 178, 3674, 1, 0, 0, 0, 180, 3677, 1, 0, 0, 0, 182, 3682, 1, 0, 0, 0, 184, 3684, 1, 0, 0, 0, 186, 3692, 1, 0, 0, 0, 188, 3703, 1, 0, 0, 0, 190, 3705, 1, 0, 0, 0, 192, 3713, 1, 0, 0, 0, 194, 3715, 1, 0, 0, 0, 196, 3757, 1, 0, 0, 0, 198, 3760, 1, 0, 0, 0, 200, 3764, 1, 0, 0, 0, 202, 3766, 1, 0, 0, 0, 204, 3770, 1, 0, 0, 0, 206, 3778, 1, 0, 0, 0, 208, 3789, 1, 0, 0, 0, 210, 3793, 1, 0, 0, 0, 212, 3795, 1, 0, 0, 0, 214, 3804, 1, 0, 0, 0, 216, 3846, 1, 0, 0, 0, 218, 3848, 1, 0, 0, 0, 220, 3858, 1, 0, 0, 0, 222, 3869, 1, 0, 0, 0, 224, 3926, 1, 0, 0, 0, 226, 3928, 1, 0, 0, 0, 228, 3937, 1, 0, 0, 0, 230, 3944, 1, 0, 0, 0, 232, 3946, 1, 0, 0, 0, 234, 3954, 1, 0, 0, 0, 236, 3957, 1, 0, 0, 0, 238, 3964, 1, 0, 0, 0, 240, 4055, 1, 0, 0, 0, 242, 4057, 1, 0, 0, 0, 244, 4060, 1, 0, 0, 0, 246, 4064, 1, 0, 0, 0, 248, 4072, 1, 0, 0, 0, 250, 4074, 1, 0, 0, 0, 252, 4079, 1, 0, 0, 0, 254, 4082, 1, 0, 0, 0, 256, 4090, 1, 0, 0, 0, 258, 4100, 1, 0, 0, 0, 260, 4113, 1, 0, 0, 0, 262, 4115, 1, 0, 0, 0, 264, 4119, 1, 0, 0, 0, 266, 4132, 1, 0, 0, 0, 268, 4134, 1, 0, 0, 0, 270, 4139, 1, 0, 0, 0, 272, 4141, 1, 0, 0, 0, 274, 4148, 1, 0, 0, 0, 276, 4179, 1, 0, 0, 0, 278, 4181, 1, 0, 0, 0, 280, 4188, 1, 0, 0, 0, 282, 4190, 1, 0, 0, 0, 284, 4199, 1, 0, 0, 0, 286, 4203, 1, 0, 0, 0, 288, 4219, 1, 0, 0, 0, 290, 4222, 1, 0, 0, 0, 292, 4229, 1, 0, 0, 0, 294, 4231, 1, 0, 0, 0, 296, 4236, 1, 0, 0, 0, 298, 4240, 1, 0, 0, 0, 300, 4256, 1, 0, 0, 0, 302, 4267, 1, 0, 0, 0, 304, 4276, 1, 0, 0, 0, 306, 4304, 1, 0, 0, 0, 308, 4321, 1, 0, 0, 0, 310, 4323, 1, 0, 0, 0, 312, 4326, 1, 0, 0, 0, 314, 4332, 1, 0, 0, 0, 316, 4351, 1, 0, 0, 0, 318, 4355, 1, 0, 0, 0, 320, 4368, 1, 0, 0, 0, 322, 4382, 1, 0, 0, 0, 324, 4391, 1, 0, 0, 0, 326, 4393, 1, 0, 0, 0, 328, 4398, 1, 0, 0, 0, 330, 4438, 1, 0, 0, 0, 332, 4440, 1, 0, 0, 0, 334, 4448, 1, 0, 0, 0, 336, 4450, 1, 0, 0, 0, 338, 4458, 1, 0, 0, 0, 340, 4480, 1, 0, 0, 0, 342, 4482, 1, 0, 0, 0, 344, 4486, 1, 0, 0, 0, 346, 4493, 1, 0, 0, 0, 348, 4495, 1, 0, 0, 0, 350, 4497, 1, 0, 0, 0, 352, 4499, 1, 0, 0, 0, 354, 4510, 1, 0, 0, 0, 356, 4513, 1, 0, 0, 0, 358, 4521, 1, 0, 0, 0, 360, 4537, 1, 0, 0, 0, 362, 4547, 1, 0, 0, 0, 364, 4549, 1, 0, 0, 0, 366, 4558, 1, 0, 0, 0, 368, 4561, 1, 0, 0, 0, 370, 4668, 1, 0, 0, 0, 372, 4670, 1, 0, 0, 0, 374, 4689, 1, 0, 0, 0, 376, 4692, 1, 0, 0, 0, 378, 4696, 1, 0, 0, 0, 380, 4715, 1, 0, 0, 0, 382, 4717, 1, 0, 0, 0, 384, 4722, 1, 0, 0, 0, 386, 4730, 1, 0, 0, 0, 388, 4735, 1, 0, 0, 0, 390, 4750, 1, 0, 0, 0, 392, 4752, 1, 0, 0, 0, 394, 4755, 1, 0, 0, 0, 396, 4757, 1, 0, 0, 0, 398, 4794, 1, 0, 0, 0, 400, 4796, 1, 0, 0, 0, 402, 4799, 1, 0, 0, 0, 404, 4804, 1, 0, 0, 0, 406, 4806, 1, 0, 0, 0, 408, 4888, 1, 0, 0, 0, 410, 4890, 1, 0, 0, 0, 412, 4908, 1, 0, 0, 0, 414, 4910, 1, 0, 0, 0, 416, 4938, 1, 0, 0, 0, 418, 4942, 1, 0, 0, 0, 420, 4962, 1, 0, 0, 0, 422, 4964, 1, 0, 0, 0, 424, 4973, 1, 0, 0, 0, 426, 4993, 1, 0, 0, 0, 428, 5007, 1, 0, 0, 0, 430, 5012, 1, 0, 0, 0, 432, 5018, 1, 0, 0, 0, 434, 5021, 1, 0, 0, 0, 436, 5024, 1, 0, 0, 0, 438, 5027, 1, 0, 0, 0, 440, 5030, 1, 0, 0, 0, 442, 5032, 1, 0, 0, 0, 444, 5041, 1, 0, 0, 0, 446, 5091, 1, 0, 0, 0, 448, 5097, 1, 0, 0, 0, 450, 5099, 1, 0, 0, 0, 452, 5114, 1, 0, 0, 0, 454, 5116, 1, 0, 0, 0, 456, 5120, 1, 0, 0, 0, 458, 5124, 1, 0, 0, 0, 460, 5131, 1, 0, 0, 0, 462, 5133, 1, 0, 0, 0, 464, 5135, 1, 0, 0, 0, 466, 5137, 1, 0, 0, 0, 468, 5143, 1, 0, 0, 0, 470, 5145, 1, 0, 0, 0, 472, 5147, 1, 0, 0, 0, 474, 5152, 1, 0, 0, 0, 476, 5156, 1, 0, 0, 0, 478, 5169, 1, 0, 0, 0, 480, 5171, 1, 0, 0, 0, 482, 5177, 1, 0, 0, 0, 484, 5191, 1, 0, 0, 0, 486, 5219, 1, 0, 0, 0, 488, 5221, 1, 0, 0, 0, 490, 5229, 1, 0, 0, 0, 492, 5235, 1, 0, 0, 0, 494, 5243, 1, 0, 0, 0, 496, 5255, 1, 0, 0, 0, 498, 5257, 1, 0, 0, 0, 500, 5380, 1, 0, 0, 0, 502, 5382, 1, 0, 0, 0, 504, 5386, 1, 0, 0, 0, 506, 5394, 1, 0, 0, 0, 508, 5405, 1, 0, 0, 0, 510, 5407, 1, 0, 0, 0, 512, 5411, 1, 0, 0, 0, 514, 5419, 1, 0, 0, 0, 516, 5423, 1, 0, 0, 0, 518, 5425, 1, 0, 0, 0, 520, 5476, 1, 0, 0, 0, 522, 5478, 1, 0, 0, 0, 524, 5482, 1, 0, 0, 0, 526, 5500, 1, 0, 0, 0, 528, 5539, 1, 0, 0, 0, 530, 5541, 1, 0, 0, 0, 532, 5543, 1, 0, 0, 0, 534, 5552, 1, 0, 0, 0, 536, 5554, 1, 0, 0, 0, 538, 5556, 1, 0, 0, 0, 540, 5581, 1, 0, 0, 0, 542, 5583, 1, 0, 0, 0, 544, 5603, 1, 0, 0, 0, 546, 5625, 1, 0, 0, 0, 548, 5647, 1, 0, 0, 0, 550, 5649, 1, 0, 0, 0, 552, 5656, 1, 0, 0, 0, 554, 5753, 1, 0, 0, 0, 556, 5778, 1, 0, 0, 0, 558, 5786, 1, 0, 0, 0, 560, 5802, 1, 0, 0, 0, 562, 5804, 1, 0, 0, 0, 564, 5806, 1, 0, 0, 0, 566, 5814, 1, 0, 0, 0, 568, 5820, 1, 0, 0, 0, 570, 5824, 1, 0, 0, 0, 572, 5832, 1, 0, 0, 0, 574, 5847, 1, 0, 0, 0, 576, 5996, 1, 0, 0, 0, 578, 6000, 1, 0, 0, 0, 580, 6113, 1, 0, 0, 0, 582, 6115, 1, 0, 0, 0, 584, 6120, 1, 0, 0, 0, 586, 6122, 1, 0, 0, 0, 588, 6140, 1, 0, 0, 0, 590, 6152, 1, 0, 0, 0, 592, 6154, 1, 0, 0, 0, 594, 6166, 1, 0, 0, 0, 596, 6186, 1, 0, 0, 0, 598, 6208, 1, 0, 0, 0, 600, 6210, 1, 0, 0, 0, 602, 6224, 1, 0, 0, 0, 604, 6235, 1, 0, 0, 0, 606, 6293, 1, 0, 0, 0, 608, 6295, 1, 0, 0, 0, 610, 6305, 1, 0, 0, 0, 612, 6307, 1, 0, 0, 0, 614, 6317, 1, 0, 0, 0, 616, 6335, 1, 0, 0, 0, 618, 6353, 1, 0, 0, 0, 620, 6371, 1, 0, 0, 0, 622, 6381, 1, 0, 0, 0, 624, 6400, 1, 0, 0, 0, 626, 6414, 1, 0, 0, 0, 628, 6453, 1, 0, 0, 0, 630, 6458, 1, 0, 0, 0, 632, 6460, 1, 0, 0, 0, 634, 6480, 1, 0, 0, 0, 636, 6482, 1, 0, 0, 0, 638, 6484, 1, 0, 0, 0, 640, 6501, 1, 0, 0, 0, 642, 6503, 1, 0, 0, 0, 644, 6511, 1, 0, 0, 0, 646, 6530, 1, 0, 0, 0, 648, 6532, 1, 0, 0, 0, 650, 6542, 1, 0, 0, 0, 652, 6550, 1, 0, 0, 0, 654, 6565, 1, 0, 0, 0, 656, 6577, 1, 0, 0, 0, 658, 6579, 1, 0, 0, 0, 660, 6587, 1, 0, 0, 0, 662, 6607, 1, 0, 0, 0, 664, 6609, 1, 0, 0, 0, 666, 6619, 1, 0, 0, 0, 668, 6675, 1, 0, 0, 0, 670, 6686, 1, 0, 0, 0, 672, 6688, 1, 0, 0, 0, 674, 6690, 1, 0, 0, 0, 676, 6700, 1, 0, 0, 0, 678, 6702, 1, 0, 0, 0, 680, 6704, 1, 0, 0, 0, 682, 6721, 1, 0, 0, 0, 684, 6725, 1, 0, 0, 0, 686, 6729, 1, 0, 0, 0, 688, 6733, 1, 0, 0, 0, 690, 6737, 1, 0, 0, 0, 692, 6753, 1, 0, 0, 0, 694, 6755, 1, 0, 0, 0, 696, 6764, 1, 0, 0, 0, 698, 6786, 1, 0, 0, 0, 700, 6788, 1, 0, 0, 0, 702, 6799, 1, 0, 0, 0, 704, 6801, 1, 0, 0, 0, 706, 6803, 1, 0, 0, 0, 708, 6817, 1, 0, 0, 0, 710, 6828, 1, 0, 0, 0, 712, 6830, 1, 0, 0, 0, 714, 6836, 1, 0, 0, 0, 716, 6840, 1, 0, 0, 0, 718, 6857, 1, 0, 0, 0, 720, 6859, 1, 0, 0, 0, 722, 6863, 1, 0, 0, 0, 724, 6874, 1, 0, 0, 0, 726, 6886, 1, 0, 0, 0, 728, 6888, 1, 0, 0, 0, 730, 6902, 1, 0, 0, 0, 732, 6929, 1, 0, 0, 0, 734, 6974, 1, 0, 0, 0, 736, 6982, 1, 0, 0, 0, 738, 6984, 1, 0, 0, 0, 740, 6996, 1, 0, 0, 0, 742, 7016, 1, 0, 0, 0, 744, 7036, 1, 0, 0, 0, 746, 7056, 1, 0, 0, 0, 748, 7068, 1, 0, 0, 0, 750, 7147, 1, 0, 0, 0, 752, 7152, 1, 0, 0, 0, 754, 7154, 1, 0, 0, 0, 756, 7165, 1, 0, 0, 0, 758, 7176, 1, 0, 0, 0, 760, 7193, 1, 0, 0, 0, 762, 7224, 1, 0, 0, 0, 764, 7324, 1, 0, 0, 0, 766, 7341, 1, 0, 0, 0, 768, 7343, 1, 0, 0, 0, 770, 7369, 1, 0, 0, 0, 772, 7431, 1, 0, 0, 0, 774, 7433, 1, 0, 0, 0, 776, 7441, 1, 0, 0, 0, 778, 7446, 1, 0, 0, 0, 780, 7450, 1, 0, 0, 0, 782, 7483, 1, 0, 0, 0, 784, 7485, 1, 0, 0, 0, 786, 7489, 1, 0, 0, 0, 788, 7493, 1, 0, 0, 0, 790, 7502, 1, 0, 0, 0, 792, 7514, 1, 0, 0, 0, 794, 7546, 1, 0, 0, 0, 796, 7548, 1, 0, 0, 0, 798, 7550, 1, 0, 0, 0, 800, 7589, 1, 0, 0, 0, 802, 7591, 1, 0, 0, 0, 804, 7593, 1, 0, 0, 0, 806, 7595, 1, 0, 0, 0, 808, 7598, 1, 0, 0, 0, 810, 7629, 1, 0, 0, 0, 812, 7642, 1, 0, 0, 0, 814, 7644, 1, 0, 0, 0, 816, 7649, 1, 0, 0, 0, 818, 7657, 1, 0, 0, 0, 820, 7660, 1, 0, 0, 0, 822, 7662, 1, 0, 0, 0, 824, 7668, 1, 0, 0, 0, 826, 7670, 1, 0, 0, 0, 828, 7691, 1, 0, 0, 0, 830, 7714, 1, 0, 0, 0, 832, 7716, 1, 0, 0, 0, 834, 7719, 1, 0, 0, 0, 836, 7744, 1, 0, 0, 0, 838, 7746, 1, 0, 0, 0, 840, 7752, 1, 0, 0, 0, 842, 7760, 1, 0, 0, 0, 844, 7776, 1, 0, 0, 0, 846, 7778, 1, 0, 0, 0, 848, 7784, 1, 0, 0, 0, 850, 7805, 1, 0, 0, 0, 852, 7807, 1, 0, 0, 0, 854, 7813, 1, 0, 0, 0, 856, 7815, 1, 0, 0, 0, 858, 7831, 1, 0, 0, 0, 860, 7833, 1, 0, 0, 0, 862, 7838, 1, 0, 0, 0, 864, 7840, 1, 0, 0, 0, 866, 7855, 1, 0, 0, 0, 868, 7863, 1, 0, 0, 0, 870, 7866, 1, 0, 0, 0, 872, 7875, 1, 0, 0, 0, 874, 7916, 1, 0, 0, 0, 876, 7931, 1, 0, 0, 0, 878, 7938, 1, 0, 0, 0, 880, 7940, 1, 0, 0, 0, 882, 7952, 1, 0, 0, 0, 884, 7955, 1, 0, 0, 0, 886, 7958, 1, 0, 0, 0, 888, 7966, 1, 0, 0, 0, 890, 7978, 1, 0, 0, 0, 892, 7991, 1, 0, 0, 0, 894, 7995, 1, 0, 0, 0, 896, 8039, 1, 0, 0, 0, 898, 8055, 1, 0, 0, 0, 900, 8071, 1, 0, 0, 0, 902, 8095, 1, 0, 0, 0, 904, 8102, 1, 0, 0, 0, 906, 8107, 1, 0, 0, 0, 908, 8115, 1, 0, 0, 0, 910, 8118, 1, 0, 0, 0, 912, 8122, 1, 0, 0, 0, 914, 8129, 1, 0, 0, 0, 916, 8168, 1, 0, 0, 0, 918, 8174, 1, 0, 0, 0, 920, 8176, 1, 0, 0, 0, 922, 8189, 1, 0, 0, 0, 924, 8192, 1, 0, 0, 0, 926, 8239, 1, 0, 0, 0, 928, 8241, 1, 0, 0, 0, 930, 8287, 1, 0, 0, 0, 932, 8289, 1, 0, 0, 0, 934, 8291, 1, 0, 0, 0, 936, 8293, 1, 0, 0, 0, 938, 8301, 1, 0, 0, 0, 940, 8315, 1, 0, 0, 0, 942, 8804, 1, 0, 0, 0, 944, 8806, 1, 0, 0, 0, 946, 8808, 1, 0, 0, 0, 948, 8880, 1, 0, 0, 0, 950, 8882, 1, 0, 0, 0, 952, 9101, 1, 0, 0, 0, 954, 9103, 1, 0, 0, 0, 956, 9111, 1, 0, 0, 0, 958, 9127, 1, 0, 0, 0, 960, 9134, 1, 0, 0, 0, 962, 9136, 1, 0, 0, 0, 964, 9329, 1, 0, 0, 0, 966, 9354, 1, 0, 0, 0, 968, 9356, 1, 0, 0, 0, 970, 9402, 1, 0, 0, 0, 972, 9404, 1, 0, 0, 0, 974, 9433, 1, 0, 0, 0, 976, 9435, 1, 0, 0, 0, 978, 9445, 1, 0, 0, 0, 980, 9453, 1, 0, 0, 0, 982, 9500, 1, 0, 0, 0, 984, 9516, 1, 0, 0, 0, 986, 9518, 1, 0, 0, 0, 988, 9544, 1, 0, 0, 0, 990, 9547, 1, 0, 0, 0, 992, 9563, 1, 0, 0, 0, 994, 9565, 1, 0, 0, 0, 996, 9567, 1, 0, 0, 0, 998, 9569, 1, 0, 0, 0, 1000, 9571, 1, 0, 0, 0, 1002, 9576, 1, 0, 0, 0, 1004, 9579, 1, 0, 0, 0, 1006, 9586, 1, 0, 0, 0, 1008, 9657, 1, 0, 0, 0, 1010, 9659, 1, 0, 0, 0, 1012, 9671, 1, 0, 0, 0, 1014, 9673, 1, 0, 0, 0, 1016, 9683, 1, 0, 0, 0, 1018, 9685, 1, 0, 0, 0, 1020, 9691, 1, 0, 0, 0, 1022, 9726, 1, 0, 0, 0, 1024, 9731, 1, 0, 0, 0, 1026, 9738, 1, 0, 0, 0, 1028, 9741, 1, 0, 0, 0, 1030, 9765, 1, 0, 0, 0, 1032, 9767, 1, 0, 0, 0, 1034, 9785, 1, 0, 0, 0, 1036, 9787, 1, 0, 0, 0, 1038, 9795, 1, 0, 0, 0, 1040, 9802, 1, 0, 0, 0, 1042, 9804, 1, 0, 0, 0, 1044, 9806, 1, 0, 0, 0, 1046, 9814, 1, 0, 0, 0, 1048, 9817, 1, 0, 0, 0, 1050, 9822, 1, 0, 0, 0, 1052, 9828, 1, 0, 0, 0, 1054, 9838, 1, 0, 0, 0, 1056, 9841, 1, 0, 0, 0, 1058, 9850, 1, 0, 0, 0, 1060, 9853, 1, 0, 0, 0, 1062, 9865, 1, 0, 0, 0, 1064, 9872, 1, 0, 0, 0, 1066, 9901, 1, 0, 0, 0, 1068, 9903, 1, 0, 0, 0, 1070, 9916, 1, 0, 0, 0, 1072, 9934, 1, 0, 0, 0, 1074, 9960, 1, 0, 0, 0, 1076, 9981, 1, 0, 0, 0, 1078, 10002, 1, 0, 0, 0, 1080, 10016, 1, 0, 0, 0, 1082, 10035, 1, 0, 0, 0, 1084, 10050, 1, 0, 0, 0, 1086, 10055, 1, 0, 0, 0, 1088, 10071, 1, 0, 0, 0, 1090, 10087, 1, 0, 0, 0, 1092, 10107, 1, 0, 0, 0, 1094, 10111, 1, 0, 0, 0, 1096, 10113, 1, 0, 0, 0, 1098, 10115, 1, 0, 0, 0, 1100, 10150, 1, 0, 0, 0, 1102, 10167, 1, 0, 0, 0, 1104, 10169, 1, 0, 0, 0, 1106, 10206, 1, 0, 0, 0, 1108, 10208, 1, 0, 0, 0, 1110, 10237, 1, 0, 0, 0, 1112, 10245, 1, 0, 0, 0, 1114, 10250, 1, 0, 0, 0, 1116, 10267, 1, 0, 0, 0, 1118, 10321, 1, 0, 0, 0, 1120, 10323, 1, 0, 0, 0, 1122, 10331, 1, 0, 0, 0, 1124, 10335, 1, 0, 0, 0, 1126, 10337, 1, 0, 0, 0, 1128, 10345, 1, 0, 0, 0, 1130, 10349, 1, 0, 0, 0, 1132, 10374, 1, 0, 0, 0, 1134, 10384, 1, 0, 0, 0, 1136, 10412, 1, 0, 0, 0, 1138, 10414, 1, 0, 0, 0, 1140, 10420, 1, 0, 0, 0, 1142, 10490, 1, 0, 0, 0, 1144, 10492, 1, 0, 0, 0, 1146, 10500, 1, 0, 0, 0, 1148, 10503, 1, 0, 0, 0, 1150, 10512, 1, 0, 0, 0, 1152, 10534, 1, 0, 0, 0, 1154, 10542, 1, 0, 0, 0, 1156, 10544, 1, 0, 0, 0, 1158, 10555, 1, 0, 0, 0, 1160, 10557, 1, 0, 0, 0, 1162, 10569, 1, 0, 0, 0, 1164, 10577, 1, 0, 0, 0, 1166, 10618, 1, 0, 0, 0, 1168, 10628, 1, 0, 0, 0, 1170, 10630, 1, 0, 0, 0, 1172, 10660, 1, 0, 0, 0, 1174, 10662, 1, 0, 0, 0, 1176, 10678, 1, 0, 0, 0, 1178, 10686, 1, 0, 0, 0, 1180, 10689, 1, 0, 0, 0, 1182, 10691, 1, 0, 0, 0, 1184, 10755, 1, 0, 0, 0, 1186, 10759, 1, 0, 0, 0, 1188, 10761, 1, 0, 0, 0, 1190, 10766, 1, 0, 0, 0, 1192, 10768, 1, 0, 0, 0, 1194, 10772, 1, 0, 0, 0, 1196, 10774, 1, 0, 0, 0, 1198, 10785, 1, 0, 0, 0, 1200, 10787, 1, 0, 0, 0, 1202, 10795, 1, 0, 0, 0, 1204, 10798, 1, 0, 0, 0, 1206, 10840, 1, 0, 0, 0, 1208, 10842, 1, 0, 0, 0, 1210, 10857, 1, 0, 0, 0, 1212, 10859, 1, 0, 0, 0, 1214, 10878, 1, 0, 0, 0, 1216, 10883, 1, 0, 0, 0, 1218, 10895, 1, 0, 0, 0, 1220, 10907, 1, 0, 0, 0, 1222, 10919, 1, 0, 0, 0, 1224, 10921, 1, 0, 0, 0, 1226, 10923, 1, 0, 0, 0, 1228, 10933, 1, 0, 0, 0, 1230, 10940, 1, 0, 0, 0, 1232, 10948, 1, 0, 0, 0, 1234, 10955, 1, 0, 0, 0, 1236, 10965, 1, 0, 0, 0, 1238, 10977, 1, 0, 0, 0, 1240, 10979, 1, 0, 0, 0, 1242, 11029, 1, 0, 0, 0, 1244, 11031, 1, 0, 0, 0, 1246, 11046, 1, 0, 0, 0, 1248, 11054, 1, 0, 0, 0, 1250, 11057, 1, 0, 0, 0, 1252, 11064, 1, 0, 0, 0, 1254, 11066, 1, 0, 0, 0, 1256, 11087, 1, 0, 0, 0, 1258, 11089, 1, 0, 0, 0, 1260, 11096, 1, 0, 0, 0, 1262, 11111, 1, 0, 0, 0, 1264, 11146, 1, 0, 0, 0, 1266, 11148, 1, 0, 0, 0, 1268, 11154, 1, 0, 0, 0, 1270, 11184, 1, 0, 0, 0, 1272, 11203, 1, 0, 0, 0, 1274, 11208, 1, 0, 0, 0, 1276, 11210, 1, 0, 0, 0, 1278, 11216, 1, 0, 0, 0, 1280, 11222, 1, 0, 0, 0, 1282, 11237, 1, 0, 0, 0, 1284, 11241, 1, 0, 0, 0, 1286, 11256, 1, 0, 0, 0, 1288, 11260, 1, 0, 0, 0, 1290, 11273, 1, 0, 0, 0, 1292, 11297, 1, 0, 0, 0, 1294, 11299, 1, 0, 0, 0, 1296, 11302, 1, 0, 0, 0, 1298, 11310, 1, 0, 0, 0, 1300, 11314, 1, 0, 0, 0, 1302, 11316, 1, 0, 0, 0, 1304, 11322, 1, 0, 0, 0, 1306, 11325, 1, 0, 0, 0, 1308, 11329, 1, 0, 0, 0, 1310, 11332, 1, 0, 0, 0, 1312, 11334, 1, 0, 0, 0, 1314, 11336, 1, 0, 0, 0, 1316, 11340, 1, 0, 0, 0, 1318, 11342, 1, 0, 0, 0, 1320, 11344, 1, 0, 0, 0, 1322, 11346, 1, 0, 0, 0, 1324, 11349, 1, 0, 0, 0, 1326, 11357, 1, 0, 0, 0, 1328, 11365, 1, 0, 0, 0, 1330, 11367, 1, 0, 0, 0, 1332, 11373, 1, 0, 0, 0, 1334, 11376, 1, 0, 0, 0, 1336, 11379, 1, 0, 0, 0, 1338, 11388, 1, 0, 0, 0, 1340, 11391, 1, 0, 0, 0, 1342, 11410, 1, 0, 0, 0, 1344, 11420, 1, 0, 0, 0, 1346, 11422, 1, 0, 0, 0, 1348, 11424, 1, 0, 0, 0, 1350, 11450, 1, 0, 0, 0, 1352, 11455, 1, 0, 0, 0, 1354, 11459, 1, 0, 0, 0, 1356, 11467, 1, 0, 0, 0, 1358, 11469, 1, 0, 0, 0, 1360, 11475, 1, 0, 0, 0, 1362, 11480, 1, 0, 0, 0, 1364, 11489, 1, 0, 0, 0, 1366, 11516, 1, 0, 0, 0, 1368, 11518, 1, 0, 0, 0, 1370, 11597, 1, 0, 0, 0, 1372, 11599, 1, 0, 0, 0, 1374, 11601, 1, 0, 0, 0, 1376, 11634, 1, 0, 0, 0, 1378, 11636, 1, 0, 0, 0, 1380, 11678, 1, 0, 0, 0, 1382, 11687, 1, 0, 0, 0, 1384, 11689, 1, 0, 0, 0, 1386, 11708, 1, 0, 0, 0, 1388, 11716, 1, 0, 0, 0, 1390, 11718, 1, 0, 0, 0, 1392, 11724, 1, 0, 0, 0, 1394, 11728, 1, 0, 0, 0, 1396, 11730, 1, 0, 0, 0, 1398, 11732, 1, 0, 0, 0, 1400, 11734, 1, 0, 0, 0, 1402, 11736, 1, 0, 0, 0, 1404, 11738, 1, 0, 0, 0, 1406, 11742, 1, 0, 0, 0, 1408, 11746, 1, 0, 0, 0, 1410, 11754, 1, 0, 0, 0, 1412, 11774, 1, 0, 0, 0, 1414, 11785, 1, 0, 0, 0, 1416, 11787, 1, 0, 0, 0, 1418, 11795, 1, 0, 0, 0, 1420, 11801, 1, 0, 0, 0, 1422, 11805, 1, 0, 0, 0, 1424, 11807, 1, 0, 0, 0, 1426, 11815, 1, 0, 0, 0, 1428, 11824, 1, 0, 0, 0, 1430, 11864, 1, 0, 0, 0, 1432, 11866, 1, 0, 0, 0, 1434, 11880, 1, 0, 0, 0, 1436, 11883, 1, 0, 0, 0, 1438, 11895, 1, 0, 0, 0, 1440, 11919, 1, 0, 0, 0, 1442, 11921, 1, 0, 0, 0, 1444, 11923, 1, 0, 0, 0, 1446, 11931, 1, 0, 0, 0, 1448, 11934, 1, 0, 0, 0, 1450, 11958, 1, 0, 0, 0, 1452, 11960, 1, 0, 0, 0, 1454, 11964, 1, 0, 0, 0, 1456, 11997, 1, 0, 0, 0, 1458, 11999, 1, 0, 0, 0, 1460, 12018, 1, 0, 0, 0, 1462, 12031, 1, 0, 0, 0, 1464, 12043, 1, 0, 0, 0, 1466, 12059, 1, 0, 0, 0, 1468, 12062, 1, 0, 0, 0, 1470, 12073, 1, 0, 0, 0, 1472, 12089, 1, 0, 0, 0, 1474, 12091, 1, 0, 0, 0, 1476, 12096, 1, 0, 0, 0, 1478, 12099, 1, 0, 0, 0, 1480, 12114, 1, 0, 0, 0, 1482, 12132, 1, 0, 0, 0, 1484, 12134, 1, 0, 0, 0, 1486, 12137, 1, 0, 0, 0, 1488, 12145, 1, 0, 0, 0, 1490, 12155, 1, 0, 0, 0, 1492, 12164, 1, 0, 0, 0, 1494, 12171, 1, 0, 0, 0, 1496, 12175, 1, 0, 0, 0, 1498, 12185, 1, 0, 0, 0, 1500, 12216, 1, 0, 0, 0, 1502, 12218, 1, 0, 0, 0, 1504, 12229, 1, 0, 0, 0, 1506, 12293, 1, 0, 0, 0, 1508, 12295, 1, 0, 0, 0, 1510, 12300, 1, 0, 0, 0, 1512, 12306, 1, 0, 0, 0, 1514, 12312, 1, 0, 0, 0, 1516, 12318, 1, 0, 0, 0, 1518, 12326, 1, 0, 0, 0, 1520, 12341, 1, 0, 0, 0, 1522, 12343, 1, 0, 0, 0, 1524, 12345, 1, 0, 0, 0, 1526, 12353, 1, 0, 0, 0, 1528, 12356, 1, 0, 0, 0, 1530, 12374, 1, 0, 0, 0, 1532, 12376, 1, 0, 0, 0, 1534, 12378, 1, 0, 0, 0, 1536, 12380, 1, 0, 0, 0, 1538, 12388, 1, 0, 0, 0, 1540, 12390, 1, 0, 0, 0, 1542, 12392, 1, 0, 0, 0, 1544, 12396, 1, 0, 0, 0, 1546, 12404, 1, 0, 0, 0, 1548, 12423, 1, 0, 0, 0, 1550, 12425, 1, 0, 0, 0, 1552, 12450, 1, 0, 0, 0, 1554, 12452, 1, 0, 0, 0, 1556, 12461, 1, 0, 0, 0, 1558, 12463, 1, 0, 0, 0, 1560, 12470, 1, 0, 0, 0, 1562, 12474, 1, 0, 0, 0, 1564, 12476, 1, 0, 0, 0, 1566, 12478, 1, 0, 0, 0, 1568, 12480, 1, 0, 0, 0, 1570, 12493, 1, 0, 0, 0, 1572, 12500, 1, 0, 0, 0, 1574, 12502, 1, 0, 0, 0, 1576, 12505, 1, 0, 0, 0, 1578, 12510, 1, 0, 0, 0, 1580, 12515, 1, 0, 0, 0, 1582, 12521, 1, 0, 0, 0, 1584, 12528, 1, 0, 0, 0, 1586, 12530, 1, 0, 0, 0, 1588, 12533, 1, 0, 0, 0, 1590, 12537, 1, 0, 0, 0, 1592, 12544, 1, 0, 0, 0, 1594, 12556, 1, 0, 0, 0, 1596, 12559, 1, 0, 0, 0, 1598, 12573, 1, 0, 0, 0, 1600, 12576, 1, 0, 0, 0, 1602, 12642, 1, 0, 0, 0, 1604, 12666, 1, 0, 0, 0, 1606, 12669, 1, 0, 0, 0, 1608, 12678, 1, 0, 0, 0, 1610, 12681, 1, 0, 0, 0, 1612, 12702, 1, 0, 0, 0, 1614, 12704, 1, 0, 0, 0, 1616, 12715, 1, 0, 0, 0, 1618, 12729, 1, 0, 0, 0, 1620, 12731, 1, 0, 0, 0, 1622, 12739, 1, 0, 0, 0, 1624, 12746, 1, 0, 0, 0, 1626, 12754, 1, 0, 0, 0, 1628, 12771, 1, 0, 0, 0, 1630, 12773, 1, 0, 0, 0, 1632, 12777, 1, 0, 0, 0, 1634, 12785, 1, 0, 0, 0, 1636, 12790, 1, 0, 0, 0, 1638, 12793, 1, 0, 0, 0, 1640, 12796, 1, 0, 0, 0, 1642, 12803, 1, 0, 0, 0, 1644, 12805, 1, 0, 0, 0, 1646, 12813, 1, 0, 0, 0, 1648, 12818, 1, 0, 0, 0, 1650, 12839, 1, 0, 0, 0, 1652, 12847, 1, 0, 0, 0, 1654, 12857, 1, 0, 0, 0, 1656, 12869, 1, 0, 0, 0, 1658, 12871, 1, 0, 0, 0, 1660, 12885, 1, 0, 0, 0, 1662, 12908, 1, 0, 0, 0, 1664, 12915, 1, 0, 0, 0, 1666, 12936, 1, 0, 0, 0, 1668, 12942, 1, 0, 0, 0, 1670, 12948, 1, 0, 0, 0, 1672, 12954, 1, 0, 0, 0, 1674, 12960, 1, 0, 0, 0, 1676, 12968, 1, 0, 0, 0, 1678, 12996, 1, 0, 0, 0, 1680, 12998, 1, 0, 0, 0, 1682, 13004, 1, 0, 0, 0, 1684, 13008, 1, 0, 0, 0, 1686, 13010, 1, 0, 0, 0, 1688, 13018, 1, 0, 0, 0, 1690, 13022, 1, 0, 0, 0, 1692, 13032, 1, 0, 0, 0, 1694, 13052, 1, 0, 0, 0, 1696, 13054, 1, 0, 0, 0, 1698, 13056, 1, 0, 0, 0, 1700, 13066, 1, 0, 0, 0, 1702, 13074, 1, 0, 0, 0, 1704, 13101, 1, 0, 0, 0, 1706, 13103, 1, 0, 0, 0, 1708, 13110, 1, 0, 0, 0, 1710, 13113, 1, 0, 0, 0, 1712, 13115, 1, 0, 0, 0, 1714, 13119, 1, 0, 0, 0, 1716, 13127, 1, 0, 0, 0, 1718, 13135, 1, 0, 0, 0, 1720, 13143, 1, 0, 0, 0, 1722, 13157, 1, 0, 0, 0, 1724, 13166, 1, 0, 0, 0, 1726, 13170, 1, 0, 0, 0, 1728, 13174, 1, 0, 0, 0, 1730, 13200, 1, 0, 0, 0, 1732, 13215, 1, 0, 0, 0, 1734, 13219, 1, 0, 0, 0, 1736, 13235, 1, 0, 0, 0, 1738, 13245, 1, 0, 0, 0, 1740, 13249, 1, 0, 0, 0, 1742, 13257, 1, 0, 0, 0, 1744, 13265, 1, 0, 0, 0, 1746, 13271, 1, 0, 0, 0, 1748, 13275, 1, 0, 0, 0, 1750, 13282, 1, 0, 0, 0, 1752, 13287, 1, 0, 0, 0, 1754, 13302, 1, 0, 0, 0, 1756, 13382, 1, 0, 0, 0, 1758, 13384, 1, 0, 0, 0, 1760, 13386, 1, 0, 0, 0, 1762, 13424, 1, 0, 0, 0, 1764, 13428, 1, 0, 0, 0, 1766, 13613, 1, 0, 0, 0, 1768, 13620, 1, 0, 0, 0, 1770, 13632, 1, 0, 0, 0, 1772, 13634, 1, 0, 0, 0, 1774, 13639, 1, 0, 0, 0, 1776, 13647, 1, 0, 0, 0, 1778, 13652, 1, 0, 0, 0, 1780, 13658, 1, 0, 0, 0, 1782, 13675, 1, 0, 0, 0, 1784, 13677, 1, 0, 0, 0, 1786, 13680, 1, 0, 0, 0, 1788, 13686, 1, 0, 0, 0, 1790, 13692, 1, 0, 0, 0, 1792, 13695, 1, 0, 0, 0, 1794, 13703, 1, 0, 0, 0, 1796, 13707, 1, 0, 0, 0, 1798, 13712, 1, 0, 0, 0, 1800, 13727, 1, 0, 0, 0, 1802, 13729, 1, 0, 0, 0, 1804, 13748, 1, 0, 0, 0, 1806, 13756, 1, 0, 0, 0, 1808, 13765, 1, 0, 0, 0, 1810, 13767, 1, 0, 0, 0, 1812, 13788, 1, 0, 0, 0, 1814, 13790, 1, 0, 0, 0, 1816, 13797, 1, 0, 0, 0, 1818, 13803, 1, 0, 0, 0, 1820, 13807, 1, 0, 0, 0, 1822, 13809, 1, 0, 0, 0, 1824, 13817, 1, 0, 0, 0, 1826, 13825, 1, 0, 0, 0, 1828, 13839, 1, 0, 0, 0, 1830, 13841, 1, 0, 0, 0, 1832, 13849, 1, 0, 0, 0, 1834, 13862, 1, 0, 0, 0, 1836, 13864, 1, 0, 0, 0, 1838, 13872, 1, 0, 0, 0, 1840, 13879, 1, 0, 0, 0, 1842, 13887, 1, 0, 0, 0, 1844, 13899, 1, 0, 0, 0, 1846, 13901, 1, 0, 0, 0, 1848, 13903, 1, 0, 0, 0, 1850, 13912, 1, 0, 0, 0, 1852, 13943, 1, 0, 0, 0, 1854, 13952, 1, 0, 0, 0, 1856, 13959, 1, 0, 0, 0, 1858, 13961, 1, 0, 0, 0, 1860, 13972, 1, 0, 0, 0, 1862, 13976, 1, 0, 0, 0, 1864, 13981, 1, 0, 0, 0, 1866, 13984, 1, 0, 0, 0, 1868, 13986, 1, 0, 0, 0, 1870, 14007, 1, 0, 0, 0, 1872, 14009, 1, 0, 0, 0, 1874, 14012, 1, 0, 0, 0, 1876, 14019, 1, 0, 0, 0, 1878, 14022, 1, 0, 0, 0, 1880, 14024, 1, 0, 0, 0, 1882, 14037, 1, 0, 0, 0, 1884, 14042, 1, 0, 0, 0, 1886, 14044, 1, 0, 0, 0, 1888, 14052, 1, 0, 0, 0, 1890, 14056, 1, 0, 0, 0, 1892, 14064, 1, 0, 0, 0, 1894, 14066, 1, 0, 0, 0, 1896, 14068, 1, 0, 0, 0, 1898, 14077, 1, 0, 0, 0, 1900, 14114, 1, 0, 0, 0, 1902, 14116, 1, 0, 0, 0, 1904, 14118, 1, 0, 0, 0, 1906, 14120, 1, 0, 0, 0, 1908, 14122, 1, 0, 0, 0, 1910, 14124, 1, 0, 0, 0, 1912, 14139, 1, 0, 0, 0, 1914, 14141, 1, 0, 0, 0, 1916, 14149, 1, 0, 0, 0, 1918, 14151, 1, 0, 0, 0, 1920, 14157, 1, 0, 0, 0, 1922, 14159, 1, 0, 0, 0, 1924, 14173, 1, 0, 0, 0, 1926, 14179, 1, 0, 0, 0, 1928, 14185, 1, 0, 0, 0, 1930, 14191, 1, 0, 0, 0, 1932, 14199, 1, 0, 0, 0, 1934, 14210, 1, 0, 0, 0, 1936, 14212, 1, 0, 0, 0, 1938, 14214, 1, 0, 0, 0, 1940, 14307, 1, 0, 0, 0, 1942, 14309, 1, 0, 0, 0, 1944, 14311, 1, 0, 0, 0, 1946, 14313, 1, 0, 0, 0, 1948, 14315, 1, 0, 0, 0, 1950, 14323, 1, 0, 0, 0, 1952, 14346, 1, 0, 0, 0, 1954, 14348, 1, 0, 0, 0, 1956, 14354, 1, 0, 0, 0, 1958, 14356, 1, 0, 0, 0, 1960, 14358, 1, 0, 0, 0, 1962, 14369, 1, 0, 0, 0, 1964, 14377, 1, 0, 0, 0, 1966, 14380, 1, 0, 0, 0, 1968, 14384, 1, 0, 0, 0, 1970, 14391, 1, 0, 0, 0, 1972, 14393, 1, 0, 0, 0, 1974, 14427, 1, 0, 0, 0, 1976, 14429, 1, 0, 0, 0, 1978, 14431, 1, 0, 0, 0, 1980, 14435, 1, 0, 0, 0, 1982, 14443, 1, 0, 0, 0, 1984, 14446, 1, 0, 0, 0, 1986, 14450, 1, 0, 0, 0, 1988, 14452, 1, 0, 0, 0, 1990, 14454, 1, 0, 0, 0, 1992, 14456, 1, 0, 0, 0, 1994, 14458, 1, 0, 0, 0, 1996, 14461, 1, 0, 0, 0, 1998, 14464, 1, 0, 0, 0, 2000, 14469, 1, 0, 0, 0, 2002, 14471, 1, 0, 0, 0, 2004, 14476, 1, 0, 0, 0, 2006, 14506, 1, 0, 0, 0, 2008, 14508, 1, 0, 0, 0, 2010, 14530, 1, 0, 0, 0, 2012, 14532, 1, 0, 0, 0, 2014, 14534, 1, 0, 0, 0, 2016, 14539, 1, 0, 0, 0, 2018, 14547, 1, 0, 0, 0, 2020, 14549, 1, 0, 0, 0, 2022, 14557, 1, 0, 0, 0, 2024, 14561, 1, 0, 0, 0, 2026, 14563, 1, 0, 0, 0, 2028, 14567, 1, 0, 0, 0, 2030, 14578, 1, 0, 0, 0, 2032, 14597, 1, 0, 0, 0, 2034, 14600, 1, 0, 0, 0, 2036, 14603, 1, 0, 0, 0, 2038, 14615, 1, 0, 0, 0, 2040, 14618, 1, 0, 0, 0, 2042, 14622, 1, 0, 0, 0, 2044, 14627, 1, 0, 0, 0, 2046, 14631, 1, 0, 0, 0, 2048, 14636, 1, 0, 0, 0, 2050, 14643, 1, 0, 0, 0, 2052, 14649, 1, 0, 0, 0, 2054, 14673, 1, 0, 0, 0, 2056, 14676, 1, 0, 0, 0, 2058, 14687, 1, 0, 0, 0, 2060, 14689, 1, 0, 0, 0, 2062, 14692, 1, 0, 0, 0, 2064, 14695, 1, 0, 0, 0, 2066, 14707, 1, 0, 0, 0, 2068, 14710, 1, 0, 0, 0, 2070, 14719, 1, 0, 0, 0, 2072, 14721, 1, 0, 0, 0, 2074, 14740, 1, 0, 0, 0, 2076, 14785, 1, 0, 0, 0, 2078, 14787, 1, 0, 0, 0, 2080, 14791, 1, 0, 0, 0, 2082, 14795, 1, 0, 0, 0, 2084, 14798, 1, 0, 0, 0, 2086, 14802, 1, 0, 0, 0, 2088, 14810, 1, 0, 0, 0, 2090, 14817, 1, 0, 0, 0, 2092, 14820, 1, 0, 0, 0, 2094, 14829, 1, 0, 0, 0, 2096, 14832, 1, 0, 0, 0, 2098, 14851, 1, 0, 0, 0, 2100, 14854, 1, 0, 0, 0, 2102, 14862, 1, 0, 0, 0, 2104, 14868, 1, 0, 0, 0, 2106, 14898, 1, 0, 0, 0, 2108, 14900, 1, 0, 0, 0, 2110, 14908, 1, 0, 0, 0, 2112, 14912, 1, 0, 0, 0, 2114, 14916, 1, 0, 0, 0, 2116, 14918, 1, 0, 0, 0, 2118, 14930, 1, 0, 0, 0, 2120, 14932, 1, 0, 0, 0, 2122, 14949, 1, 0, 0, 0, 2124, 14951, 1, 0, 0, 0, 2126, 14958, 1, 0, 0, 0, 2128, 14962, 1, 0, 0, 0, 2130, 14965, 1, 0, 0, 0, 2132, 14971, 1, 0, 0, 0, 2134, 14977, 1, 0, 0, 0, 2136, 14995, 1, 0, 0, 0, 2138, 14999, 1, 0, 0, 0, 2140, 15001, 1, 0, 0, 0, 2142, 15005, 1, 0, 0, 0, 2144, 15009, 1, 0, 0, 0, 2146, 15014, 1, 0, 0, 0, 2148, 15025, 1, 0, 0, 0, 2150, 15027, 1, 0, 0, 0, 2152, 15029, 1, 0, 0, 0, 2154, 15031, 1, 0, 0, 0, 2156, 15033, 1, 0, 0, 0, 2158, 15038, 1, 0, 0, 0, 2160, 15040, 1, 0, 0, 0, 2162, 15043, 1, 0, 0, 0, 2164, 15063, 1, 0, 0, 0, 2166, 15065, 1, 0, 0, 0, 2168, 15067, 1, 0, 0, 0, 2170, 15069, 1, 0, 0, 0, 2172, 15071, 1, 0, 0, 0, 2174, 15075, 1, 0, 0, 0, 2176, 2177, 3, 4, 2, 0, 2177, 2178, 5, 0, 0, 1, 2178, 1, 1, 0, 0, 0, 2179, 2180, 3, 1948, 974, 0, 2180, 3, 1, 0, 0, 0, 2181, 2182, 3, 6, 3, 0, 2182, 5, 1, 0, 0, 0, 2183, 2185, 3, 8, 4, 0, 2184, 2186, 5, 7, 0, 0, 2185, 2184, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2188, 1, 0, 0, 0, 2187, 2183, 1, 0, 0, 0, 2188, 2191, 1, 0, 0, 0, 2189, 2187, 1, 0, 0, 0, 2189, 2190, 1, 0, 0, 0, 2190, 7, 1, 0, 0, 0, 2191, 2189, 1, 0, 0, 0, 2192, 2376, 3, 494, 247, 0, 2193, 2376, 3, 1358, 679, 0, 2194, 2376, 3, 1348, 674, 0, 2195, 2376, 3, 1350, 675, 0, 2196, 2376, 3, 788, 394, 0, 2197, 2376, 3, 1364, 682, 0, 2198, 2376, 3, 520, 260, 0, 2199, 2376, 3, 364, 182, 0, 2200, 2376, 3, 370, 185, 0, 2201, 2376, 3, 380, 190, 0, 2202, 2376, 3, 406, 203, 0, 2203, 2376, 3, 888, 444, 0, 2204, 2376, 3, 890, 445, 0, 2205, 2376, 3, 46, 23, 0, 2206, 2376, 3, 948, 474, 0, 2207, 2376, 3, 952, 476, 0, 2208, 2376, 3, 964, 482, 0, 2209, 2376, 3, 954, 477, 0, 2210, 2376, 3, 962, 481, 0, 2211, 2376, 3, 426, 213, 0, 2212, 2376, 3, 322, 161, 0, 2213, 2376, 3, 1360, 680, 0, 2214, 2376, 3, 106, 53, 0, 2215, 2376, 3, 940, 470, 0, 2216, 2376, 3, 146, 73, 0, 2217, 2376, 3, 974, 487, 0, 2218, 2376, 3, 34, 17, 0, 2219, 2376, 3, 28, 14, 0, 2220, 2376, 3, 1240, 620, 0, 2221, 2376, 3, 36, 18, 0, 2222, 2376, 3, 982, 491, 0, 2223, 2376, 3, 300, 150, 0, 2224, 2376, 3, 1370, 685, 0, 2225, 2376, 3, 1368, 684, 0, 2226, 2376, 3, 422, 211, 0, 2227, 2376, 3, 1384, 692, 0, 2228, 2376, 3, 12, 6, 0, 2229, 2376, 3, 102, 51, 0, 2230, 2376, 3, 152, 76, 0, 2231, 2376, 3, 1376, 688, 0, 2232, 2376, 3, 576, 288, 0, 2233, 2376, 3, 96, 48, 0, 2234, 2376, 3, 154, 77, 0, 2235, 2376, 3, 442, 221, 0, 2236, 2376, 3, 302, 151, 0, 2237, 2376, 3, 498, 249, 0, 2238, 2376, 3, 916, 458, 0, 2239, 2376, 3, 1374, 687, 0, 2240, 2376, 3, 1362, 681, 0, 2241, 2376, 3, 358, 179, 0, 2242, 2376, 3, 372, 186, 0, 2243, 2376, 3, 398, 199, 0, 2244, 2376, 3, 408, 204, 0, 2245, 2376, 3, 826, 413, 0, 2246, 2376, 3, 828, 414, 0, 2247, 2376, 3, 44, 22, 0, 2248, 2376, 3, 314, 157, 0, 2249, 2376, 3, 524, 262, 0, 2250, 2376, 3, 538, 269, 0, 2251, 2376, 3, 966, 483, 0, 2252, 2376, 3, 540, 270, 0, 2253, 2376, 3, 424, 212, 0, 2254, 2376, 3, 338, 169, 0, 2255, 2376, 3, 50, 25, 0, 2256, 2376, 3, 320, 160, 0, 2257, 2376, 3, 194, 97, 0, 2258, 2376, 3, 976, 488, 0, 2259, 2376, 3, 298, 149, 0, 2260, 2376, 3, 352, 176, 0, 2261, 2376, 3, 924, 462, 0, 2262, 2376, 3, 446, 223, 0, 2263, 2376, 3, 486, 243, 0, 2264, 2376, 3, 14, 7, 0, 2265, 2376, 3, 26, 13, 0, 2266, 2376, 3, 416, 208, 0, 2267, 2376, 3, 1336, 668, 0, 2268, 2376, 3, 1434, 717, 0, 2269, 2376, 3, 1488, 744, 0, 2270, 2376, 3, 500, 250, 0, 2271, 2376, 3, 1464, 732, 0, 2272, 2376, 3, 104, 52, 0, 2273, 2376, 3, 910, 455, 0, 2274, 2376, 3, 920, 460, 0, 2275, 2376, 3, 546, 273, 0, 2276, 2376, 3, 548, 274, 0, 2277, 2376, 3, 550, 275, 0, 2278, 2376, 3, 1074, 537, 0, 2279, 2376, 3, 554, 277, 0, 2280, 2376, 3, 984, 492, 0, 2281, 2376, 3, 356, 178, 0, 2282, 2376, 3, 928, 464, 0, 2283, 2376, 3, 38, 19, 0, 2284, 2376, 3, 40, 20, 0, 2285, 2376, 3, 42, 21, 0, 2286, 2376, 3, 420, 210, 0, 2287, 2376, 3, 1352, 676, 0, 2288, 2376, 3, 1430, 715, 0, 2289, 2376, 3, 1412, 706, 0, 2290, 2376, 3, 586, 293, 0, 2291, 2376, 3, 590, 295, 0, 2292, 2376, 3, 410, 205, 0, 2293, 2376, 3, 798, 399, 0, 2294, 2376, 3, 1436, 718, 0, 2295, 2376, 3, 1454, 727, 0, 2296, 2376, 3, 1004, 502, 0, 2297, 2376, 3, 318, 159, 0, 2298, 2376, 3, 1026, 513, 0, 2299, 2376, 3, 1468, 734, 0, 2300, 2376, 3, 1000, 500, 0, 2301, 2376, 3, 1424, 712, 0, 2302, 2376, 3, 552, 276, 0, 2303, 2376, 3, 930, 465, 0, 2304, 2376, 3, 898, 449, 0, 2305, 2376, 3, 896, 448, 0, 2306, 2376, 3, 900, 450, 0, 2307, 2376, 3, 942, 471, 0, 2308, 2376, 3, 726, 363, 0, 2309, 2376, 3, 782, 391, 0, 2310, 2376, 3, 986, 493, 0, 2311, 2376, 3, 580, 290, 0, 2312, 2376, 3, 1496, 748, 0, 2313, 2376, 3, 1008, 504, 0, 2314, 2376, 3, 572, 286, 0, 2315, 2376, 3, 1006, 503, 0, 2316, 2376, 3, 1478, 739, 0, 2317, 2376, 3, 1380, 690, 0, 2318, 2376, 3, 84, 42, 0, 2319, 2376, 3, 60, 30, 0, 2320, 2376, 3, 94, 47, 0, 2321, 2376, 3, 1020, 510, 0, 2322, 2376, 3, 1028, 514, 0, 2323, 2376, 3, 1064, 532, 0, 2324, 2376, 3, 1068, 534, 0, 2325, 2376, 3, 1134, 567, 0, 2326, 2376, 3, 1138, 569, 0, 2327, 2376, 3, 1140, 570, 0, 2328, 2376, 3, 1148, 574, 0, 2329, 2376, 3, 1236, 618, 0, 2330, 2376, 3, 1244, 622, 0, 2331, 2376, 3, 1150, 575, 0, 2332, 2376, 3, 1160, 580, 0, 2333, 2376, 3, 1246, 623, 0, 2334, 2376, 3, 1248, 624, 0, 2335, 2376, 3, 1050, 525, 0, 2336, 2376, 3, 1098, 549, 0, 2337, 2376, 3, 1106, 553, 0, 2338, 2376, 3, 1070, 535, 0, 2339, 2376, 3, 1108, 554, 0, 2340, 2376, 3, 1130, 565, 0, 2341, 2376, 3, 1164, 582, 0, 2342, 2376, 3, 1170, 585, 0, 2343, 2376, 3, 1174, 587, 0, 2344, 2376, 3, 1182, 591, 0, 2345, 2376, 3, 1212, 606, 0, 2346, 2376, 3, 1060, 530, 0, 2347, 2376, 3, 1214, 607, 0, 2348, 2376, 3, 1216, 608, 0, 2349, 2376, 3, 1218, 609, 0, 2350, 2376, 3, 1062, 531, 0, 2351, 2376, 3, 1132, 566, 0, 2352, 2376, 3, 1226, 613, 0, 2353, 2376, 3, 1228, 614, 0, 2354, 2376, 3, 1230, 615, 0, 2355, 2376, 3, 1232, 616, 0, 2356, 2376, 3, 1234, 617, 0, 2357, 2376, 3, 1250, 625, 0, 2358, 2376, 3, 1254, 627, 0, 2359, 2376, 3, 1256, 628, 0, 2360, 2376, 3, 1258, 629, 0, 2361, 2376, 3, 1260, 630, 0, 2362, 2376, 3, 1262, 631, 0, 2363, 2376, 3, 1266, 633, 0, 2364, 2376, 3, 1268, 634, 0, 2365, 2376, 3, 1270, 635, 0, 2366, 2376, 3, 1276, 638, 0, 2367, 2376, 3, 1278, 639, 0, 2368, 2376, 3, 1280, 640, 0, 2369, 2376, 3, 1282, 641, 0, 2370, 2376, 3, 1284, 642, 0, 2371, 2376, 3, 1286, 643, 0, 2372, 2376, 3, 1288, 644, 0, 2373, 2376, 3, 1334, 667, 0, 2374, 2376, 3, 10, 5, 0, 2375, 2192, 1, 0, 0, 0, 2375, 2193, 1, 0, 0, 0, 2375, 2194, 1, 0, 0, 0, 2375, 2195, 1, 0, 0, 0, 2375, 2196, 1, 0, 0, 0, 2375, 2197, 1, 0, 0, 0, 2375, 2198, 1, 0, 0, 0, 2375, 2199, 1, 0, 0, 0, 2375, 2200, 1, 0, 0, 0, 2375, 2201, 1, 0, 0, 0, 2375, 2202, 1, 0, 0, 0, 2375, 2203, 1, 0, 0, 0, 2375, 2204, 1, 0, 0, 0, 2375, 2205, 1, 0, 0, 0, 2375, 2206, 1, 0, 0, 0, 2375, 2207, 1, 0, 0, 0, 2375, 2208, 1, 0, 0, 0, 2375, 2209, 1, 0, 0, 0, 2375, 2210, 1, 0, 0, 0, 2375, 2211, 1, 0, 0, 0, 2375, 2212, 1, 0, 0, 0, 2375, 2213, 1, 0, 0, 0, 2375, 2214, 1, 0, 0, 0, 2375, 2215, 1, 0, 0, 0, 2375, 2216, 1, 0, 0, 0, 2375, 2217, 1, 0, 0, 0, 2375, 2218, 1, 0, 0, 0, 2375, 2219, 1, 0, 0, 0, 2375, 2220, 1, 0, 0, 0, 2375, 2221, 1, 0, 0, 0, 2375, 2222, 1, 0, 0, 0, 2375, 2223, 1, 0, 0, 0, 2375, 2224, 1, 0, 0, 0, 2375, 2225, 1, 0, 0, 0, 2375, 2226, 1, 0, 0, 0, 2375, 2227, 1, 0, 0, 0, 2375, 2228, 1, 0, 0, 0, 2375, 2229, 1, 0, 0, 0, 2375, 2230, 1, 0, 0, 0, 2375, 2231, 1, 0, 0, 0, 2375, 2232, 1, 0, 0, 0, 2375, 2233, 1, 0, 0, 0, 2375, 2234, 1, 0, 0, 0, 2375, 2235, 1, 0, 0, 0, 2375, 2236, 1, 0, 0, 0, 2375, 2237, 1, 0, 0, 0, 2375, 2238, 1, 0, 0, 0, 2375, 2239, 1, 0, 0, 0, 2375, 2240, 1, 0, 0, 0, 2375, 2241, 1, 0, 0, 0, 2375, 2242, 1, 0, 0, 0, 2375, 2243, 1, 0, 0, 0, 2375, 2244, 1, 0, 0, 0, 2375, 2245, 1, 0, 0, 0, 2375, 2246, 1, 0, 0, 0, 2375, 2247, 1, 0, 0, 0, 2375, 2248, 1, 0, 0, 0, 2375, 2249, 1, 0, 0, 0, 2375, 2250, 1, 0, 0, 0, 2375, 2251, 1, 0, 0, 0, 2375, 2252, 1, 0, 0, 0, 2375, 2253, 1, 0, 0, 0, 2375, 2254, 1, 0, 0, 0, 2375, 2255, 1, 0, 0, 0, 2375, 2256, 1, 0, 0, 0, 2375, 2257, 1, 0, 0, 0, 2375, 2258, 1, 0, 0, 0, 2375, 2259, 1, 0, 0, 0, 2375, 2260, 1, 0, 0, 0, 2375, 2261, 1, 0, 0, 0, 2375, 2262, 1, 0, 0, 0, 2375, 2263, 1, 0, 0, 0, 2375, 2264, 1, 0, 0, 0, 2375, 2265, 1, 0, 0, 0, 2375, 2266, 1, 0, 0, 0, 2375, 2267, 1, 0, 0, 0, 2375, 2268, 1, 0, 0, 0, 2375, 2269, 1, 0, 0, 0, 2375, 2270, 1, 0, 0, 0, 2375, 2271, 1, 0, 0, 0, 2375, 2272, 1, 0, 0, 0, 2375, 2273, 1, 0, 0, 0, 2375, 2274, 1, 0, 0, 0, 2375, 2275, 1, 0, 0, 0, 2375, 2276, 1, 0, 0, 0, 2375, 2277, 1, 0, 0, 0, 2375, 2278, 1, 0, 0, 0, 2375, 2279, 1, 0, 0, 0, 2375, 2280, 1, 0, 0, 0, 2375, 2281, 1, 0, 0, 0, 2375, 2282, 1, 0, 0, 0, 2375, 2283, 1, 0, 0, 0, 2375, 2284, 1, 0, 0, 0, 2375, 2285, 1, 0, 0, 0, 2375, 2286, 1, 0, 0, 0, 2375, 2287, 1, 0, 0, 0, 2375, 2288, 1, 0, 0, 0, 2375, 2289, 1, 0, 0, 0, 2375, 2290, 1, 0, 0, 0, 2375, 2291, 1, 0, 0, 0, 2375, 2292, 1, 0, 0, 0, 2375, 2293, 1, 0, 0, 0, 2375, 2294, 1, 0, 0, 0, 2375, 2295, 1, 0, 0, 0, 2375, 2296, 1, 0, 0, 0, 2375, 2297, 1, 0, 0, 0, 2375, 2298, 1, 0, 0, 0, 2375, 2299, 1, 0, 0, 0, 2375, 2300, 1, 0, 0, 0, 2375, 2301, 1, 0, 0, 0, 2375, 2302, 1, 0, 0, 0, 2375, 2303, 1, 0, 0, 0, 2375, 2304, 1, 0, 0, 0, 2375, 2305, 1, 0, 0, 0, 2375, 2306, 1, 0, 0, 0, 2375, 2307, 1, 0, 0, 0, 2375, 2308, 1, 0, 0, 0, 2375, 2309, 1, 0, 0, 0, 2375, 2310, 1, 0, 0, 0, 2375, 2311, 1, 0, 0, 0, 2375, 2312, 1, 0, 0, 0, 2375, 2313, 1, 0, 0, 0, 2375, 2314, 1, 0, 0, 0, 2375, 2315, 1, 0, 0, 0, 2375, 2316, 1, 0, 0, 0, 2375, 2317, 1, 0, 0, 0, 2375, 2318, 1, 0, 0, 0, 2375, 2319, 1, 0, 0, 0, 2375, 2320, 1, 0, 0, 0, 2375, 2321, 1, 0, 0, 0, 2375, 2322, 1, 0, 0, 0, 2375, 2323, 1, 0, 0, 0, 2375, 2324, 1, 0, 0, 0, 2375, 2325, 1, 0, 0, 0, 2375, 2326, 1, 0, 0, 0, 2375, 2327, 1, 0, 0, 0, 2375, 2328, 1, 0, 0, 0, 2375, 2329, 1, 0, 0, 0, 2375, 2330, 1, 0, 0, 0, 2375, 2331, 1, 0, 0, 0, 2375, 2332, 1, 0, 0, 0, 2375, 2333, 1, 0, 0, 0, 2375, 2334, 1, 0, 0, 0, 2375, 2335, 1, 0, 0, 0, 2375, 2336, 1, 0, 0, 0, 2375, 2337, 1, 0, 0, 0, 2375, 2338, 1, 0, 0, 0, 2375, 2339, 1, 0, 0, 0, 2375, 2340, 1, 0, 0, 0, 2375, 2341, 1, 0, 0, 0, 2375, 2342, 1, 0, 0, 0, 2375, 2343, 1, 0, 0, 0, 2375, 2344, 1, 0, 0, 0, 2375, 2345, 1, 0, 0, 0, 2375, 2346, 1, 0, 0, 0, 2375, 2347, 1, 0, 0, 0, 2375, 2348, 1, 0, 0, 0, 2375, 2349, 1, 0, 0, 0, 2375, 2350, 1, 0, 0, 0, 2375, 2351, 1, 0, 0, 0, 2375, 2352, 1, 0, 0, 0, 2375, 2353, 1, 0, 0, 0, 2375, 2354, 1, 0, 0, 0, 2375, 2355, 1, 0, 0, 0, 2375, 2356, 1, 0, 0, 0, 2375, 2357, 1, 0, 0, 0, 2375, 2358, 1, 0, 0, 0, 2375, 2359, 1, 0, 0, 0, 2375, 2360, 1, 0, 0, 0, 2375, 2361, 1, 0, 0, 0, 2375, 2362, 1, 0, 0, 0, 2375, 2363, 1, 0, 0, 0, 2375, 2364, 1, 0, 0, 0, 2375, 2365, 1, 0, 0, 0, 2375, 2366, 1, 0, 0, 0, 2375, 2367, 1, 0, 0, 0, 2375, 2368, 1, 0, 0, 0, 2375, 2369, 1, 0, 0, 0, 2375, 2370, 1, 0, 0, 0, 2375, 2371, 1, 0, 0, 0, 2375, 2372, 1, 0, 0, 0, 2375, 2373, 1, 0, 0, 0, 2375, 2374, 1, 0, 0, 0, 2376, 9, 1, 0, 0, 0, 2377, 2379, 5, 885, 0, 0, 2378, 2380, 5, 886, 0, 0, 2379, 2378, 1, 0, 0, 0, 2379, 2380, 1, 0, 0, 0, 2380, 11, 1, 0, 0, 0, 2381, 2382, 5, 603, 0, 0, 2382, 2383, 3, 1760, 880, 0, 2383, 13, 1, 0, 0, 0, 2384, 2385, 5, 46, 0, 0, 2385, 2386, 5, 316, 0, 0, 2386, 2388, 3, 1918, 959, 0, 2387, 2389, 3, 16, 8, 0, 2388, 2387, 1, 0, 0, 0, 2388, 2389, 1, 0, 0, 0, 2389, 2390, 1, 0, 0, 0, 2390, 2391, 3, 18, 9, 0, 2391, 15, 1, 0, 0, 0, 2392, 2393, 5, 106, 0, 0, 2393, 17, 1, 0, 0, 0, 2394, 2396, 3, 24, 12, 0, 2395, 2394, 1, 0, 0, 0, 2396, 2399, 1, 0, 0, 0, 2397, 2395, 1, 0, 0, 0, 2397, 2398, 1, 0, 0, 0, 2398, 19, 1, 0, 0, 0, 2399, 2397, 1, 0, 0, 0, 2400, 2405, 3, 22, 11, 0, 2401, 2402, 5, 6, 0, 0, 2402, 2404, 3, 22, 11, 0, 2403, 2401, 1, 0, 0, 0, 2404, 2407, 1, 0, 0, 0, 2405, 2403, 1, 0, 0, 0, 2405, 2406, 1, 0, 0, 0, 2406, 2415, 1, 0, 0, 0, 2407, 2405, 1, 0, 0, 0, 2408, 2410, 3, 22, 11, 0, 2409, 2408, 1, 0, 0, 0, 2410, 2413, 1, 0, 0, 0, 2411, 2409, 1, 0, 0, 0, 2411, 2412, 1, 0, 0, 0, 2412, 2415, 1, 0, 0, 0, 2413, 2411, 1, 0, 0, 0, 2414, 2400, 1, 0, 0, 0, 2414, 2411, 1, 0, 0, 0, 2415, 21, 1, 0, 0, 0, 2416, 2420, 5, 284, 0, 0, 2417, 2421, 3, 1910, 955, 0, 2418, 2421, 5, 78, 0, 0, 2419, 2421, 5, 190, 0, 0, 2420, 2417, 1, 0, 0, 0, 2420, 2418, 1, 0, 0, 0, 2420, 2419, 1, 0, 0, 0, 2421, 2468, 1, 0, 0, 0, 2422, 2423, 7, 0, 0, 0, 2423, 2424, 5, 284, 0, 0, 2424, 2468, 3, 1910, 955, 0, 2425, 2468, 5, 232, 0, 0, 2426, 2427, 5, 166, 0, 0, 2427, 2430, 5, 74, 0, 0, 2428, 2431, 3, 1916, 958, 0, 2429, 2431, 5, 497, 0, 0, 2430, 2428, 1, 0, 0, 0, 2430, 2429, 1, 0, 0, 0, 2431, 2468, 1, 0, 0, 0, 2432, 2433, 5, 369, 0, 0, 2433, 2434, 5, 366, 0, 0, 2434, 2468, 3, 1910, 955, 0, 2435, 2436, 5, 100, 0, 0, 2436, 2468, 3, 1922, 961, 0, 2437, 2440, 5, 498, 0, 0, 2438, 2441, 3, 1910, 955, 0, 2439, 2441, 3, 1934, 967, 0, 2440, 2438, 1, 0, 0, 0, 2440, 2439, 1, 0, 0, 0, 2441, 2468, 1, 0, 0, 0, 2442, 2468, 5, 494, 0, 0, 2443, 2468, 5, 495, 0, 0, 2444, 2468, 5, 488, 0, 0, 2445, 2468, 5, 489, 0, 0, 2446, 2447, 5, 500, 0, 0, 2447, 2448, 5, 133, 0, 0, 2448, 2468, 7, 1, 0, 0, 2449, 2450, 5, 330, 0, 0, 2450, 2451, 5, 499, 0, 0, 2451, 2468, 3, 1908, 954, 0, 2452, 2453, 5, 311, 0, 0, 2453, 2454, 5, 330, 0, 0, 2454, 2468, 5, 499, 0, 0, 2455, 2456, 5, 311, 0, 0, 2456, 2468, 5, 30, 0, 0, 2457, 2458, 5, 331, 0, 0, 2458, 2460, 3, 68, 34, 0, 2459, 2461, 7, 2, 0, 0, 2460, 2459, 1, 0, 0, 0, 2460, 2461, 1, 0, 0, 0, 2461, 2462, 1, 0, 0, 0, 2462, 2463, 3, 70, 35, 0, 2463, 2468, 1, 0, 0, 0, 2464, 2465, 5, 311, 0, 0, 2465, 2468, 3, 68, 34, 0, 2466, 2468, 3, 1934, 967, 0, 2467, 2416, 1, 0, 0, 0, 2467, 2422, 1, 0, 0, 0, 2467, 2425, 1, 0, 0, 0, 2467, 2426, 1, 0, 0, 0, 2467, 2432, 1, 0, 0, 0, 2467, 2435, 1, 0, 0, 0, 2467, 2437, 1, 0, 0, 0, 2467, 2442, 1, 0, 0, 0, 2467, 2443, 1, 0, 0, 0, 2467, 2444, 1, 0, 0, 0, 2467, 2445, 1, 0, 0, 0, 2467, 2446, 1, 0, 0, 0, 2467, 2449, 1, 0, 0, 0, 2467, 2452, 1, 0, 0, 0, 2467, 2455, 1, 0, 0, 0, 2467, 2457, 1, 0, 0, 0, 2467, 2464, 1, 0, 0, 0, 2467, 2466, 1, 0, 0, 0, 2468, 23, 1, 0, 0, 0, 2469, 2480, 3, 22, 11, 0, 2470, 2471, 5, 346, 0, 0, 2471, 2480, 3, 1908, 954, 0, 2472, 2473, 5, 136, 0, 0, 2473, 2480, 3, 1922, 961, 0, 2474, 2475, 5, 316, 0, 0, 2475, 2480, 3, 1922, 961, 0, 2476, 2477, 5, 68, 0, 0, 2477, 2478, 7, 3, 0, 0, 2478, 2480, 3, 1922, 961, 0, 2479, 2469, 1, 0, 0, 0, 2479, 2470, 1, 0, 0, 0, 2479, 2472, 1, 0, 0, 0, 2479, 2474, 1, 0, 0, 0, 2479, 2476, 1, 0, 0, 0, 2480, 25, 1, 0, 0, 0, 2481, 2482, 5, 46, 0, 0, 2482, 2483, 5, 100, 0, 0, 2483, 2485, 3, 1918, 959, 0, 2484, 2486, 3, 16, 8, 0, 2485, 2484, 1, 0, 0, 0, 2485, 2486, 1, 0, 0, 0, 2486, 2487, 1, 0, 0, 0, 2487, 2488, 3, 18, 9, 0, 2488, 27, 1, 0, 0, 0, 2489, 2490, 5, 140, 0, 0, 2490, 2491, 5, 316, 0, 0, 2491, 2493, 3, 1920, 960, 0, 2492, 2494, 3, 16, 8, 0, 2493, 2492, 1, 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2495, 1, 0, 0, 0, 2495, 2496, 3, 30, 15, 0, 2496, 29, 1, 0, 0, 0, 2497, 2498, 5, 307, 0, 0, 2498, 2499, 5, 95, 0, 0, 2499, 2507, 3, 1924, 962, 0, 2500, 2501, 5, 279, 0, 0, 2501, 2502, 5, 95, 0, 0, 2502, 2507, 3, 1924, 962, 0, 2503, 2504, 5, 498, 0, 0, 2504, 2505, 5, 95, 0, 0, 2505, 2507, 3, 1924, 962, 0, 2506, 2497, 1, 0, 0, 0, 2506, 2500, 1, 0, 0, 0, 2506, 2503, 1, 0, 0, 0, 2507, 31, 1, 0, 0, 0, 2508, 2509, 5, 68, 0, 0, 2509, 2510, 5, 179, 0, 0, 2510, 2511, 3, 1892, 946, 0, 2511, 33, 1, 0, 0, 0, 2512, 2513, 5, 140, 0, 0, 2513, 2515, 7, 4, 0, 0, 2514, 2516, 5, 30, 0, 0, 2515, 2514, 1, 0, 0, 0, 2515, 2516, 1, 0, 0, 0, 2516, 2517, 1, 0, 0, 0, 2517, 2519, 3, 1920, 960, 0, 2518, 2520, 3, 32, 16, 0, 2519, 2518, 1, 0, 0, 0, 2519, 2520, 1, 0, 0, 0, 2520, 2521, 1, 0, 0, 0, 2521, 2522, 3, 90, 45, 0, 2522, 35, 1, 0, 0, 0, 2523, 2524, 5, 140, 0, 0, 2524, 2525, 5, 321, 0, 0, 2525, 2526, 3, 1892, 946, 0, 2526, 2532, 5, 844, 0, 0, 2527, 2529, 3, 1908, 954, 0, 2528, 2530, 7, 5, 0, 0, 2529, 2528, 1, 0, 0, 0, 2529, 2530, 1, 0, 0, 0, 2530, 2533, 1, 0, 0, 0, 2531, 2533, 5, 497, 0, 0, 2532, 2527, 1, 0, 0, 0, 2532, 2531, 1, 0, 0, 0, 2533, 37, 1, 0, 0, 0, 2534, 2535, 5, 195, 0, 0, 2535, 2536, 5, 316, 0, 0, 2536, 2538, 3, 1920, 960, 0, 2537, 2539, 7, 6, 0, 0, 2538, 2537, 1, 0, 0, 0, 2538, 2539, 1, 0, 0, 0, 2539, 39, 1, 0, 0, 0, 2540, 2541, 5, 195, 0, 0, 2541, 2543, 5, 100, 0, 0, 2542, 2544, 3, 922, 461, 0, 2543, 2542, 1, 0, 0, 0, 2543, 2544, 1, 0, 0, 0, 2544, 2545, 1, 0, 0, 0, 2545, 2546, 3, 1922, 961, 0, 2546, 41, 1, 0, 0, 0, 2547, 2548, 5, 195, 0, 0, 2548, 2549, 5, 66, 0, 0, 2549, 2550, 3, 1920, 960, 0, 2550, 43, 1, 0, 0, 0, 2551, 2552, 5, 46, 0, 0, 2552, 2553, 5, 66, 0, 0, 2553, 2555, 3, 1918, 959, 0, 2554, 2556, 3, 16, 8, 0, 2555, 2554, 1, 0, 0, 0, 2555, 2556, 1, 0, 0, 0, 2556, 2557, 1, 0, 0, 0, 2557, 2558, 3, 18, 9, 0, 2558, 45, 1, 0, 0, 0, 2559, 2560, 5, 140, 0, 0, 2560, 2561, 5, 66, 0, 0, 2561, 2562, 3, 1920, 960, 0, 2562, 2563, 3, 48, 24, 0, 2563, 2564, 5, 100, 0, 0, 2564, 2565, 3, 1922, 961, 0, 2565, 47, 1, 0, 0, 0, 2566, 2567, 7, 7, 0, 0, 2567, 49, 1, 0, 0, 0, 2568, 2569, 5, 46, 0, 0, 2569, 2571, 5, 321, 0, 0, 2570, 2572, 3, 522, 261, 0, 2571, 2570, 1, 0, 0, 0, 2571, 2572, 1, 0, 0, 0, 2572, 2573, 1, 0, 0, 0, 2573, 2575, 3, 1924, 962, 0, 2574, 2576, 3, 52, 26, 0, 2575, 2574, 1, 0, 0, 0, 2575, 2576, 1, 0, 0, 0, 2576, 2578, 1, 0, 0, 0, 2577, 2579, 3, 54, 27, 0, 2578, 2577, 1, 0, 0, 0, 2578, 2579, 1, 0, 0, 0, 2579, 2581, 1, 0, 0, 0, 2580, 2582, 3, 56, 28, 0, 2581, 2580, 1, 0, 0, 0, 2581, 2582, 1, 0, 0, 0, 2582, 2593, 1, 0, 0, 0, 2583, 2584, 5, 46, 0, 0, 2584, 2585, 5, 321, 0, 0, 2585, 2587, 3, 52, 26, 0, 2586, 2588, 3, 54, 27, 0, 2587, 2586, 1, 0, 0, 0, 2587, 2588, 1, 0, 0, 0, 2588, 2590, 1, 0, 0, 0, 2589, 2591, 3, 56, 28, 0, 2590, 2589, 1, 0, 0, 0, 2590, 2591, 1, 0, 0, 0, 2591, 2593, 1, 0, 0, 0, 2592, 2568, 1, 0, 0, 0, 2592, 2583, 1, 0, 0, 0, 2593, 51, 1, 0, 0, 0, 2594, 2595, 5, 107, 0, 0, 2595, 2596, 3, 1920, 960, 0, 2596, 53, 1, 0, 0, 0, 2597, 2606, 5, 844, 0, 0, 2598, 2601, 3, 1906, 953, 0, 2599, 2601, 3, 1908, 954, 0, 2600, 2598, 1, 0, 0, 0, 2600, 2599, 1, 0, 0, 0, 2601, 2603, 1, 0, 0, 0, 2602, 2604, 7, 5, 0, 0, 2603, 2602, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2607, 1, 0, 0, 0, 2605, 2607, 5, 497, 0, 0, 2606, 2600, 1, 0, 0, 0, 2606, 2605, 1, 0, 0, 0, 2607, 55, 1, 0, 0, 0, 2608, 2610, 3, 58, 29, 0, 2609, 2608, 1, 0, 0, 0, 2610, 2611, 1, 0, 0, 0, 2611, 2609, 1, 0, 0, 0, 2611, 2612, 1, 0, 0, 0, 2612, 57, 1, 0, 0, 0, 2613, 2620, 3, 194, 97, 0, 2614, 2620, 3, 798, 399, 0, 2615, 2620, 3, 320, 160, 0, 2616, 2620, 3, 446, 223, 0, 2617, 2620, 3, 590, 295, 0, 2618, 2620, 3, 1020, 510, 0, 2619, 2613, 1, 0, 0, 0, 2619, 2614, 1, 0, 0, 0, 2619, 2615, 1, 0, 0, 0, 2619, 2616, 1, 0, 0, 0, 2619, 2617, 1, 0, 0, 0, 2619, 2618, 1, 0, 0, 0, 2620, 59, 1, 0, 0, 0, 2621, 2623, 5, 331, 0, 0, 2622, 2624, 7, 8, 0, 0, 2623, 2622, 1, 0, 0, 0, 2623, 2624, 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2626, 3, 62, 31, 0, 2626, 61, 1, 0, 0, 0, 2627, 2628, 5, 354, 0, 0, 2628, 2636, 3, 1014, 507, 0, 2629, 2630, 5, 330, 0, 0, 2630, 2631, 5, 156, 0, 0, 2631, 2632, 5, 36, 0, 0, 2632, 2633, 5, 354, 0, 0, 2633, 2636, 3, 1014, 507, 0, 2634, 2636, 3, 66, 33, 0, 2635, 2627, 1, 0, 0, 0, 2635, 2629, 1, 0, 0, 0, 2635, 2634, 1, 0, 0, 0, 2636, 63, 1, 0, 0, 0, 2637, 2638, 3, 68, 34, 0, 2638, 2639, 7, 2, 0, 0, 2639, 2640, 3, 70, 35, 0, 2640, 65, 1, 0, 0, 0, 2641, 2669, 3, 64, 32, 0, 2642, 2643, 3, 68, 34, 0, 2643, 2644, 5, 64, 0, 0, 2644, 2645, 5, 604, 0, 0, 2645, 2669, 1, 0, 0, 0, 2646, 2647, 5, 581, 0, 0, 2647, 2648, 5, 384, 0, 0, 2648, 2669, 3, 78, 39, 0, 2649, 2650, 5, 154, 0, 0, 2650, 2669, 3, 1910, 955, 0, 2651, 2652, 5, 321, 0, 0, 2652, 2669, 3, 1910, 955, 0, 2653, 2655, 5, 264, 0, 0, 2654, 2656, 3, 80, 40, 0, 2655, 2654, 1, 0, 0, 0, 2655, 2656, 1, 0, 0, 0, 2656, 2669, 1, 0, 0, 0, 2657, 2658, 5, 316, 0, 0, 2658, 2669, 3, 82, 41, 0, 2659, 2660, 5, 330, 0, 0, 2660, 2661, 5, 107, 0, 0, 2661, 2669, 3, 82, 41, 0, 2662, 2663, 5, 381, 0, 0, 2663, 2664, 5, 276, 0, 0, 2664, 2669, 3, 1778, 889, 0, 2665, 2666, 5, 354, 0, 0, 2666, 2667, 5, 335, 0, 0, 2667, 2669, 3, 1910, 955, 0, 2668, 2641, 1, 0, 0, 0, 2668, 2642, 1, 0, 0, 0, 2668, 2646, 1, 0, 0, 0, 2668, 2649, 1, 0, 0, 0, 2668, 2651, 1, 0, 0, 0, 2668, 2653, 1, 0, 0, 0, 2668, 2657, 1, 0, 0, 0, 2668, 2659, 1, 0, 0, 0, 2668, 2662, 1, 0, 0, 0, 2668, 2665, 1, 0, 0, 0, 2669, 67, 1, 0, 0, 0, 2670, 2675, 3, 1924, 962, 0, 2671, 2672, 5, 11, 0, 0, 2672, 2674, 3, 1924, 962, 0, 2673, 2671, 1, 0, 0, 0, 2674, 2677, 1, 0, 0, 0, 2675, 2673, 1, 0, 0, 0, 2675, 2676, 1, 0, 0, 0, 2676, 69, 1, 0, 0, 0, 2677, 2675, 1, 0, 0, 0, 2678, 2683, 3, 72, 36, 0, 2679, 2680, 5, 6, 0, 0, 2680, 2682, 3, 72, 36, 0, 2681, 2679, 1, 0, 0, 0, 2682, 2685, 1, 0, 0, 0, 2683, 2681, 1, 0, 0, 0, 2683, 2684, 1, 0, 0, 0, 2684, 71, 1, 0, 0, 0, 2685, 2683, 1, 0, 0, 0, 2686, 2689, 3, 76, 38, 0, 2687, 2689, 3, 334, 167, 0, 2688, 2686, 1, 0, 0, 0, 2688, 2687, 1, 0, 0, 0, 2689, 73, 1, 0, 0, 0, 2690, 2691, 5, 298, 0, 0, 2691, 2696, 7, 9, 0, 0, 2692, 2693, 5, 308, 0, 0, 2693, 2696, 5, 298, 0, 0, 2694, 2696, 5, 328, 0, 0, 2695, 2690, 1, 0, 0, 0, 2695, 2692, 1, 0, 0, 0, 2695, 2694, 1, 0, 0, 0, 2696, 75, 1, 0, 0, 0, 2697, 2702, 5, 97, 0, 0, 2698, 2702, 5, 60, 0, 0, 2699, 2702, 5, 80, 0, 0, 2700, 2702, 3, 82, 41, 0, 2701, 2697, 1, 0, 0, 0, 2701, 2698, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2700, 1, 0, 0, 0, 2702, 77, 1, 0, 0, 0, 2703, 2720, 3, 1910, 955, 0, 2704, 2720, 3, 1934, 967, 0, 2705, 2706, 3, 1700, 850, 0, 2706, 2708, 3, 1910, 955, 0, 2707, 2709, 3, 1704, 852, 0, 2708, 2707, 1, 0, 0, 0, 2708, 2709, 1, 0, 0, 0, 2709, 2720, 1, 0, 0, 0, 2710, 2711, 3, 1700, 850, 0, 2711, 2712, 5, 2, 0, 0, 2712, 2713, 3, 1908, 954, 0, 2713, 2714, 5, 3, 0, 0, 2714, 2715, 3, 1910, 955, 0, 2715, 2720, 1, 0, 0, 0, 2716, 2720, 3, 334, 167, 0, 2717, 2720, 5, 53, 0, 0, 2718, 2720, 5, 249, 0, 0, 2719, 2703, 1, 0, 0, 0, 2719, 2704, 1, 0, 0, 0, 2719, 2705, 1, 0, 0, 0, 2719, 2710, 1, 0, 0, 0, 2719, 2716, 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2719, 2718, 1, 0, 0, 0, 2720, 79, 1, 0, 0, 0, 2721, 2724, 3, 1910, 955, 0, 2722, 2724, 5, 53, 0, 0, 2723, 2721, 1, 0, 0, 0, 2723, 2722, 1, 0, 0, 0, 2724, 81, 1, 0, 0, 0, 2725, 2728, 3, 1930, 965, 0, 2726, 2728, 3, 1910, 955, 0, 2727, 2725, 1, 0, 0, 0, 2727, 2726, 1, 0, 0, 0, 2728, 83, 1, 0, 0, 0, 2729, 2730, 5, 311, 0, 0, 2730, 2731, 3, 86, 43, 0, 2731, 85, 1, 0, 0, 0, 2732, 2741, 3, 88, 44, 0, 2733, 2734, 5, 581, 0, 0, 2734, 2741, 5, 384, 0, 0, 2735, 2736, 5, 354, 0, 0, 2736, 2737, 5, 239, 0, 0, 2737, 2741, 5, 246, 0, 0, 2738, 2739, 5, 330, 0, 0, 2739, 2741, 5, 107, 0, 0, 2740, 2732, 1, 0, 0, 0, 2740, 2733, 1, 0, 0, 0, 2740, 2735, 1, 0, 0, 0, 2740, 2738, 1, 0, 0, 0, 2741, 87, 1, 0, 0, 0, 2742, 2745, 3, 68, 34, 0, 2743, 2745, 5, 30, 0, 0, 2744, 2742, 1, 0, 0, 0, 2744, 2743, 1, 0, 0, 0, 2745, 89, 1, 0, 0, 0, 2746, 2747, 5, 331, 0, 0, 2747, 2750, 3, 62, 31, 0, 2748, 2750, 3, 84, 42, 0, 2749, 2746, 1, 0, 0, 0, 2749, 2748, 1, 0, 0, 0, 2750, 91, 1, 0, 0, 0, 2751, 2752, 5, 331, 0, 0, 2752, 2755, 3, 66, 33, 0, 2753, 2755, 3, 84, 42, 0, 2754, 2751, 1, 0, 0, 0, 2754, 2753, 1, 0, 0, 0, 2755, 93, 1, 0, 0, 0, 2756, 2769, 5, 333, 0, 0, 2757, 2770, 3, 68, 34, 0, 2758, 2759, 5, 581, 0, 0, 2759, 2770, 5, 384, 0, 0, 2760, 2761, 5, 354, 0, 0, 2761, 2762, 5, 239, 0, 0, 2762, 2770, 5, 246, 0, 0, 2763, 2764, 5, 330, 0, 0, 2764, 2770, 5, 107, 0, 0, 2765, 2770, 5, 113, 0, 0, 2766, 2770, 5, 90, 0, 0, 2767, 2770, 5, 52, 0, 0, 2768, 2770, 5, 30, 0, 0, 2769, 2757, 1, 0, 0, 0, 2769, 2758, 1, 0, 0, 0, 2769, 2760, 1, 0, 0, 0, 2769, 2763, 1, 0, 0, 0, 2769, 2765, 1, 0, 0, 0, 2769, 2766, 1, 0, 0, 0, 2769, 2767, 1, 0, 0, 0, 2769, 2768, 1, 0, 0, 0, 2770, 95, 1, 0, 0, 0, 2771, 2772, 5, 331, 0, 0, 2772, 2773, 5, 167, 0, 0, 2773, 2774, 3, 98, 49, 0, 2774, 2775, 3, 100, 50, 0, 2775, 97, 1, 0, 0, 0, 2776, 2779, 5, 30, 0, 0, 2777, 2779, 3, 1886, 943, 0, 2778, 2776, 1, 0, 0, 0, 2778, 2777, 1, 0, 0, 0, 2779, 99, 1, 0, 0, 0, 2780, 2781, 7, 10, 0, 0, 2781, 101, 1, 0, 0, 0, 2782, 2783, 5, 157, 0, 0, 2783, 103, 1, 0, 0, 0, 2784, 2785, 5, 191, 0, 0, 2785, 2786, 7, 11, 0, 0, 2786, 105, 1, 0, 0, 0, 2787, 2788, 5, 140, 0, 0, 2788, 2789, 5, 93, 0, 0, 2789, 2790, 3, 1888, 944, 0, 2790, 2795, 3, 108, 54, 0, 2791, 2792, 5, 6, 0, 0, 2792, 2794, 3, 108, 54, 0, 2793, 2791, 1, 0, 0, 0, 2794, 2797, 1, 0, 0, 0, 2795, 2793, 1, 0, 0, 0, 2795, 2796, 1, 0, 0, 0, 2796, 107, 1, 0, 0, 0, 2797, 2795, 1, 0, 0, 0, 2798, 2799, 5, 135, 0, 0, 2799, 2999, 3, 110, 55, 0, 2800, 2801, 5, 195, 0, 0, 2801, 2802, 5, 45, 0, 0, 2802, 2804, 3, 1924, 962, 0, 2803, 2805, 7, 12, 0, 0, 2804, 2803, 1, 0, 0, 0, 2804, 2805, 1, 0, 0, 0, 2805, 2999, 1, 0, 0, 0, 2806, 2807, 5, 279, 0, 0, 2807, 2808, 5, 95, 0, 0, 2808, 2999, 3, 1920, 960, 0, 2809, 2810, 5, 307, 0, 0, 2810, 2811, 5, 95, 0, 0, 2811, 2999, 3, 1924, 962, 0, 2812, 2813, 5, 307, 0, 0, 2813, 2814, 5, 44, 0, 0, 2814, 2815, 3, 1924, 962, 0, 2815, 2816, 5, 95, 0, 0, 2816, 2817, 3, 1924, 962, 0, 2817, 2999, 1, 0, 0, 0, 2818, 2819, 5, 140, 0, 0, 2819, 2820, 5, 44, 0, 0, 2820, 2821, 3, 1924, 962, 0, 2821, 2822, 5, 358, 0, 0, 2822, 2823, 3, 1662, 831, 0, 2823, 2999, 1, 0, 0, 0, 2824, 2825, 5, 140, 0, 0, 2825, 2826, 5, 44, 0, 0, 2826, 2827, 3, 1924, 962, 0, 2827, 2828, 5, 835, 0, 0, 2828, 2829, 3, 1924, 962, 0, 2829, 2999, 1, 0, 0, 0, 2830, 2831, 5, 140, 0, 0, 2831, 2832, 5, 836, 0, 0, 2832, 2999, 3, 1924, 962, 0, 2833, 2834, 5, 140, 0, 0, 2834, 2835, 5, 838, 0, 0, 2835, 2999, 5, 30, 0, 0, 2836, 2837, 5, 140, 0, 0, 2837, 2838, 5, 838, 0, 0, 2838, 2999, 5, 842, 0, 0, 2839, 2840, 5, 140, 0, 0, 2840, 2841, 5, 838, 0, 0, 2841, 2842, 5, 240, 0, 0, 2842, 2843, 5, 836, 0, 0, 2843, 2999, 3, 1924, 962, 0, 2844, 2845, 5, 140, 0, 0, 2845, 2846, 5, 838, 0, 0, 2846, 2999, 5, 420, 0, 0, 2847, 2849, 5, 140, 0, 0, 2848, 2850, 5, 840, 0, 0, 2849, 2848, 1, 0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 2851, 1, 0, 0, 0, 2851, 2852, 5, 837, 0, 0, 2852, 2853, 5, 2, 0, 0, 2853, 2854, 3, 246, 123, 0, 2854, 2855, 5, 3, 0, 0, 2855, 2999, 1, 0, 0, 0, 2856, 2857, 5, 140, 0, 0, 2857, 2858, 5, 837, 0, 0, 2858, 2999, 5, 420, 0, 0, 2859, 2860, 5, 140, 0, 0, 2860, 2861, 5, 837, 0, 0, 2861, 2999, 5, 569, 0, 0, 2862, 2863, 5, 140, 0, 0, 2863, 2864, 5, 835, 0, 0, 2864, 2999, 5, 420, 0, 0, 2865, 2867, 5, 135, 0, 0, 2866, 2868, 5, 44, 0, 0, 2867, 2866, 1, 0, 0, 0, 2867, 2868, 1, 0, 0, 0, 2868, 2869, 1, 0, 0, 0, 2869, 2870, 3, 1924, 962, 0, 2870, 2873, 3, 1662, 831, 0, 2871, 2872, 5, 53, 0, 0, 2872, 2874, 3, 1710, 855, 0, 2873, 2871, 1, 0, 0, 0, 2873, 2874, 1, 0, 0, 0, 2874, 2877, 1, 0, 0, 0, 2875, 2876, 5, 835, 0, 0, 2876, 2878, 3, 1924, 962, 0, 2877, 2875, 1, 0, 0, 0, 2877, 2878, 1, 0, 0, 0, 2878, 2883, 1, 0, 0, 0, 2879, 2881, 5, 77, 0, 0, 2880, 2879, 1, 0, 0, 0, 2880, 2881, 1, 0, 0, 0, 2881, 2882, 1, 0, 0, 0, 2882, 2884, 5, 78, 0, 0, 2883, 2880, 1, 0, 0, 0, 2883, 2884, 1, 0, 0, 0, 2884, 2887, 1, 0, 0, 0, 2885, 2886, 5, 43, 0, 0, 2886, 2888, 7, 13, 0, 0, 2887, 2885, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2999, 1, 0, 0, 0, 2889, 2891, 5, 195, 0, 0, 2890, 2892, 5, 44, 0, 0, 2891, 2890, 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, 2893, 1, 0, 0, 0, 2893, 2895, 3, 1924, 962, 0, 2894, 2896, 7, 12, 0, 0, 2895, 2894, 1, 0, 0, 0, 2895, 2896, 1, 0, 0, 0, 2896, 2999, 1, 0, 0, 0, 2897, 2898, 5, 577, 0, 0, 2898, 2899, 5, 246, 0, 0, 2899, 2900, 5, 325, 0, 0, 2900, 2904, 7, 14, 0, 0, 2901, 2902, 5, 390, 0, 0, 2902, 2903, 5, 358, 0, 0, 2903, 2905, 7, 15, 0, 0, 2904, 2901, 1, 0, 0, 0, 2904, 2905, 1, 0, 0, 0, 2905, 2908, 1, 0, 0, 0, 2906, 2907, 5, 62, 0, 0, 2907, 2909, 5, 455, 0, 0, 2908, 2906, 1, 0, 0, 0, 2908, 2909, 1, 0, 0, 0, 2909, 2999, 1, 0, 0, 0, 2910, 2911, 5, 412, 0, 0, 2911, 2912, 7, 14, 0, 0, 2912, 2913, 5, 62, 0, 0, 2913, 2999, 5, 455, 0, 0, 2914, 2915, 5, 463, 0, 0, 2915, 2916, 5, 64, 0, 0, 2916, 2918, 3, 1888, 944, 0, 2917, 2919, 7, 16, 0, 0, 2918, 2917, 1, 0, 0, 0, 2918, 2919, 1, 0, 0, 0, 2919, 2999, 1, 0, 0, 0, 2920, 2921, 5, 331, 0, 0, 2921, 2922, 5, 250, 0, 0, 2922, 2999, 5, 862, 0, 0, 2923, 2924, 5, 331, 0, 0, 2924, 2925, 5, 393, 0, 0, 2925, 2926, 5, 780, 0, 0, 2926, 2999, 3, 1924, 962, 0, 2927, 2928, 5, 331, 0, 0, 2928, 2929, 5, 93, 0, 0, 2929, 2930, 5, 512, 0, 0, 2930, 2931, 5, 2, 0, 0, 2931, 2932, 3, 1126, 563, 0, 2932, 2933, 5, 3, 0, 0, 2933, 2999, 1, 0, 0, 0, 2934, 2935, 5, 282, 0, 0, 2935, 2936, 5, 2, 0, 0, 2936, 2937, 3, 1924, 962, 0, 2937, 2938, 5, 10, 0, 0, 2938, 2939, 3, 1710, 855, 0, 2939, 2947, 1, 0, 0, 0, 2940, 2941, 5, 6, 0, 0, 2941, 2942, 3, 1924, 962, 0, 2942, 2943, 5, 10, 0, 0, 2943, 2944, 3, 1710, 855, 0, 2944, 2946, 1, 0, 0, 0, 2945, 2940, 1, 0, 0, 0, 2946, 2949, 1, 0, 0, 0, 2947, 2945, 1, 0, 0, 0, 2947, 2948, 1, 0, 0, 0, 2948, 2950, 1, 0, 0, 0, 2949, 2947, 1, 0, 0, 0, 2950, 2951, 5, 3, 0, 0, 2951, 2952, 5, 331, 0, 0, 2952, 2953, 5, 250, 0, 0, 2953, 2954, 5, 862, 0, 0, 2954, 2999, 1, 0, 0, 0, 2955, 2957, 5, 135, 0, 0, 2956, 2958, 3, 522, 261, 0, 2957, 2956, 1, 0, 0, 0, 2957, 2958, 1, 0, 0, 0, 2958, 2959, 1, 0, 0, 0, 2959, 2960, 5, 282, 0, 0, 2960, 2961, 5, 2, 0, 0, 2961, 2962, 3, 1924, 962, 0, 2962, 2963, 5, 10, 0, 0, 2963, 2964, 3, 1710, 855, 0, 2964, 2972, 1, 0, 0, 0, 2965, 2966, 5, 6, 0, 0, 2966, 2967, 3, 1924, 962, 0, 2967, 2968, 5, 10, 0, 0, 2968, 2969, 3, 1710, 855, 0, 2969, 2971, 1, 0, 0, 0, 2970, 2965, 1, 0, 0, 0, 2971, 2974, 1, 0, 0, 0, 2972, 2970, 1, 0, 0, 0, 2972, 2973, 1, 0, 0, 0, 2973, 2975, 1, 0, 0, 0, 2974, 2972, 1, 0, 0, 0, 2975, 2976, 5, 3, 0, 0, 2976, 2977, 5, 250, 0, 0, 2977, 2978, 5, 862, 0, 0, 2978, 2999, 1, 0, 0, 0, 2979, 2980, 5, 195, 0, 0, 2980, 2981, 5, 282, 0, 0, 2981, 2982, 5, 2, 0, 0, 2982, 2983, 3, 1924, 962, 0, 2983, 2984, 5, 10, 0, 0, 2984, 2985, 3, 1710, 855, 0, 2985, 2993, 1, 0, 0, 0, 2986, 2987, 5, 6, 0, 0, 2987, 2988, 3, 1924, 962, 0, 2988, 2989, 5, 10, 0, 0, 2989, 2990, 3, 1710, 855, 0, 2990, 2992, 1, 0, 0, 0, 2991, 2986, 1, 0, 0, 0, 2992, 2995, 1, 0, 0, 0, 2993, 2991, 1, 0, 0, 0, 2993, 2994, 1, 0, 0, 0, 2994, 2996, 1, 0, 0, 0, 2995, 2993, 1, 0, 0, 0, 2996, 2997, 5, 3, 0, 0, 2997, 2999, 1, 0, 0, 0, 2998, 2798, 1, 0, 0, 0, 2998, 2800, 1, 0, 0, 0, 2998, 2806, 1, 0, 0, 0, 2998, 2809, 1, 0, 0, 0, 2998, 2812, 1, 0, 0, 0, 2998, 2818, 1, 0, 0, 0, 2998, 2824, 1, 0, 0, 0, 2998, 2830, 1, 0, 0, 0, 2998, 2833, 1, 0, 0, 0, 2998, 2836, 1, 0, 0, 0, 2998, 2839, 1, 0, 0, 0, 2998, 2844, 1, 0, 0, 0, 2998, 2847, 1, 0, 0, 0, 2998, 2856, 1, 0, 0, 0, 2998, 2859, 1, 0, 0, 0, 2998, 2862, 1, 0, 0, 0, 2998, 2865, 1, 0, 0, 0, 2998, 2889, 1, 0, 0, 0, 2998, 2897, 1, 0, 0, 0, 2998, 2910, 1, 0, 0, 0, 2998, 2914, 1, 0, 0, 0, 2998, 2920, 1, 0, 0, 0, 2998, 2923, 1, 0, 0, 0, 2998, 2927, 1, 0, 0, 0, 2998, 2934, 1, 0, 0, 0, 2998, 2955, 1, 0, 0, 0, 2998, 2979, 1, 0, 0, 0, 2999, 109, 1, 0, 0, 0, 3000, 3001, 5, 45, 0, 0, 3001, 3003, 3, 1924, 962, 0, 3002, 3000, 1, 0, 0, 0, 3002, 3003, 1, 0, 0, 0, 3003, 3026, 1, 0, 0, 0, 3004, 3005, 5, 99, 0, 0, 3005, 3006, 5, 2, 0, 0, 3006, 3007, 3, 246, 123, 0, 3007, 3008, 5, 3, 0, 0, 3008, 3027, 1, 0, 0, 0, 3009, 3010, 5, 85, 0, 0, 3010, 3011, 5, 240, 0, 0, 3011, 3012, 5, 2, 0, 0, 3012, 3013, 3, 246, 123, 0, 3013, 3014, 5, 3, 0, 0, 3014, 3027, 1, 0, 0, 0, 3015, 3016, 5, 63, 0, 0, 3016, 3017, 5, 240, 0, 0, 3017, 3018, 5, 2, 0, 0, 3018, 3019, 3, 246, 123, 0, 3019, 3020, 5, 3, 0, 0, 3020, 3021, 5, 87, 0, 0, 3021, 3022, 3, 1888, 944, 0, 3022, 3023, 5, 2, 0, 0, 3023, 3024, 3, 246, 123, 0, 3024, 3025, 5, 3, 0, 0, 3025, 3027, 1, 0, 0, 0, 3026, 3004, 1, 0, 0, 0, 3026, 3009, 1, 0, 0, 0, 3026, 3015, 1, 0, 0, 0, 3027, 111, 1, 0, 0, 0, 3028, 3029, 5, 605, 0, 0, 3029, 3030, 5, 282, 0, 0, 3030, 3031, 3, 1888, 944, 0, 3031, 3032, 3, 140, 70, 0, 3032, 3037, 1, 0, 0, 0, 3033, 3034, 5, 606, 0, 0, 3034, 3035, 5, 282, 0, 0, 3035, 3037, 3, 1888, 944, 0, 3036, 3028, 1, 0, 0, 0, 3036, 3033, 1, 0, 0, 0, 3037, 113, 1, 0, 0, 0, 3038, 3039, 5, 605, 0, 0, 3039, 3040, 5, 282, 0, 0, 3040, 3041, 3, 1888, 944, 0, 3041, 115, 1, 0, 0, 0, 3042, 3043, 5, 135, 0, 0, 3043, 3345, 3, 212, 106, 0, 3044, 3045, 5, 135, 0, 0, 3045, 3046, 5, 224, 0, 0, 3046, 3047, 5, 77, 0, 0, 3047, 3048, 5, 558, 0, 0, 3048, 3345, 3, 212, 106, 0, 3049, 3050, 5, 135, 0, 0, 3050, 3051, 5, 44, 0, 0, 3051, 3345, 3, 212, 106, 0, 3052, 3053, 5, 135, 0, 0, 3053, 3054, 5, 44, 0, 0, 3054, 3055, 5, 224, 0, 0, 3055, 3056, 5, 77, 0, 0, 3056, 3057, 5, 558, 0, 0, 3057, 3345, 3, 212, 106, 0, 3058, 3060, 5, 140, 0, 0, 3059, 3061, 3, 944, 472, 0, 3060, 3059, 1, 0, 0, 0, 3060, 3061, 1, 0, 0, 0, 3061, 3062, 1, 0, 0, 0, 3062, 3063, 3, 1924, 962, 0, 3063, 3064, 3, 118, 59, 0, 3064, 3345, 1, 0, 0, 0, 3065, 3067, 5, 140, 0, 0, 3066, 3068, 3, 944, 472, 0, 3067, 3066, 1, 0, 0, 0, 3067, 3068, 1, 0, 0, 0, 3068, 3069, 1, 0, 0, 0, 3069, 3070, 3, 1924, 962, 0, 3070, 3071, 5, 195, 0, 0, 3071, 3072, 5, 77, 0, 0, 3072, 3073, 5, 78, 0, 0, 3073, 3345, 1, 0, 0, 0, 3074, 3076, 5, 140, 0, 0, 3075, 3077, 3, 944, 472, 0, 3076, 3075, 1, 0, 0, 0, 3076, 3077, 1, 0, 0, 0, 3077, 3078, 1, 0, 0, 0, 3078, 3079, 3, 1924, 962, 0, 3079, 3080, 5, 331, 0, 0, 3080, 3081, 5, 77, 0, 0, 3081, 3082, 5, 78, 0, 0, 3082, 3345, 1, 0, 0, 0, 3083, 3085, 5, 140, 0, 0, 3084, 3086, 3, 944, 472, 0, 3085, 3084, 1, 0, 0, 0, 3085, 3086, 1, 0, 0, 0, 3086, 3087, 1, 0, 0, 0, 3087, 3088, 3, 1924, 962, 0, 3088, 3089, 5, 195, 0, 0, 3089, 3090, 5, 607, 0, 0, 3090, 3345, 1, 0, 0, 0, 3091, 3093, 5, 140, 0, 0, 3092, 3094, 3, 944, 472, 0, 3093, 3092, 1, 0, 0, 0, 3093, 3094, 1, 0, 0, 0, 3094, 3095, 1, 0, 0, 0, 3095, 3096, 3, 1924, 962, 0, 3096, 3097, 5, 195, 0, 0, 3097, 3098, 5, 607, 0, 0, 3098, 3099, 5, 224, 0, 0, 3099, 3100, 5, 558, 0, 0, 3100, 3345, 1, 0, 0, 0, 3101, 3103, 5, 140, 0, 0, 3102, 3104, 3, 944, 472, 0, 3103, 3102, 1, 0, 0, 0, 3103, 3104, 1, 0, 0, 0, 3104, 3105, 1, 0, 0, 0, 3105, 3106, 3, 1924, 962, 0, 3106, 3107, 5, 331, 0, 0, 3107, 3108, 5, 340, 0, 0, 3108, 3109, 3, 1916, 958, 0, 3109, 3345, 1, 0, 0, 0, 3110, 3112, 5, 140, 0, 0, 3111, 3113, 3, 944, 472, 0, 3112, 3111, 1, 0, 0, 0, 3112, 3113, 1, 0, 0, 0, 3113, 3114, 1, 0, 0, 0, 3114, 3115, 3, 1908, 954, 0, 3115, 3116, 5, 331, 0, 0, 3116, 3117, 5, 340, 0, 0, 3117, 3118, 3, 1916, 958, 0, 3118, 3345, 1, 0, 0, 0, 3119, 3121, 5, 140, 0, 0, 3120, 3122, 3, 944, 472, 0, 3121, 3120, 1, 0, 0, 0, 3121, 3122, 1, 0, 0, 0, 3122, 3123, 1, 0, 0, 0, 3123, 3124, 3, 1924, 962, 0, 3124, 3125, 5, 331, 0, 0, 3125, 3126, 3, 128, 64, 0, 3126, 3345, 1, 0, 0, 0, 3127, 3129, 5, 140, 0, 0, 3128, 3130, 3, 944, 472, 0, 3129, 3128, 1, 0, 0, 0, 3129, 3130, 1, 0, 0, 0, 3130, 3131, 1, 0, 0, 0, 3131, 3132, 3, 1924, 962, 0, 3132, 3133, 5, 311, 0, 0, 3133, 3134, 3, 128, 64, 0, 3134, 3345, 1, 0, 0, 0, 3135, 3137, 5, 140, 0, 0, 3136, 3138, 3, 944, 472, 0, 3137, 3136, 1, 0, 0, 0, 3137, 3138, 1, 0, 0, 0, 3138, 3139, 1, 0, 0, 0, 3139, 3140, 3, 1924, 962, 0, 3140, 3141, 5, 331, 0, 0, 3141, 3142, 5, 343, 0, 0, 3142, 3143, 3, 1924, 962, 0, 3143, 3345, 1, 0, 0, 0, 3144, 3146, 5, 140, 0, 0, 3145, 3147, 3, 944, 472, 0, 3146, 3145, 1, 0, 0, 0, 3146, 3147, 1, 0, 0, 0, 3147, 3148, 1, 0, 0, 0, 3148, 3149, 3, 1924, 962, 0, 3149, 3150, 5, 135, 0, 0, 3150, 3151, 5, 608, 0, 0, 3151, 3152, 3, 228, 114, 0, 3152, 3153, 5, 36, 0, 0, 3153, 3155, 5, 223, 0, 0, 3154, 3156, 3, 326, 163, 0, 3155, 3154, 1, 0, 0, 0, 3155, 3156, 1, 0, 0, 0, 3156, 3345, 1, 0, 0, 0, 3157, 3159, 5, 140, 0, 0, 3158, 3160, 3, 944, 472, 0, 3159, 3158, 1, 0, 0, 0, 3159, 3160, 1, 0, 0, 0, 3160, 3161, 1, 0, 0, 0, 3161, 3162, 3, 1924, 962, 0, 3162, 3163, 3, 136, 68, 0, 3163, 3345, 1, 0, 0, 0, 3164, 3166, 5, 140, 0, 0, 3165, 3167, 3, 944, 472, 0, 3166, 3165, 1, 0, 0, 0, 3166, 3167, 1, 0, 0, 0, 3167, 3168, 1, 0, 0, 0, 3168, 3169, 3, 1924, 962, 0, 3169, 3170, 5, 195, 0, 0, 3170, 3171, 5, 223, 0, 0, 3171, 3345, 1, 0, 0, 0, 3172, 3174, 5, 140, 0, 0, 3173, 3175, 3, 944, 472, 0, 3174, 3173, 1, 0, 0, 0, 3174, 3175, 1, 0, 0, 0, 3175, 3176, 1, 0, 0, 0, 3176, 3177, 3, 1924, 962, 0, 3177, 3178, 5, 195, 0, 0, 3178, 3179, 5, 223, 0, 0, 3179, 3180, 5, 224, 0, 0, 3180, 3181, 5, 558, 0, 0, 3181, 3345, 1, 0, 0, 0, 3182, 3184, 5, 195, 0, 0, 3183, 3185, 3, 944, 472, 0, 3184, 3183, 1, 0, 0, 0, 3184, 3185, 1, 0, 0, 0, 3185, 3186, 1, 0, 0, 0, 3186, 3187, 5, 224, 0, 0, 3187, 3188, 5, 558, 0, 0, 3188, 3190, 3, 1924, 962, 0, 3189, 3191, 3, 120, 60, 0, 3190, 3189, 1, 0, 0, 0, 3190, 3191, 1, 0, 0, 0, 3191, 3345, 1, 0, 0, 0, 3192, 3194, 5, 195, 0, 0, 3193, 3195, 3, 944, 472, 0, 3194, 3193, 1, 0, 0, 0, 3194, 3195, 1, 0, 0, 0, 3195, 3196, 1, 0, 0, 0, 3196, 3198, 3, 1924, 962, 0, 3197, 3199, 3, 120, 60, 0, 3198, 3197, 1, 0, 0, 0, 3198, 3199, 1, 0, 0, 0, 3199, 3345, 1, 0, 0, 0, 3200, 3202, 5, 140, 0, 0, 3201, 3203, 3, 944, 472, 0, 3202, 3201, 1, 0, 0, 0, 3202, 3203, 1, 0, 0, 0, 3203, 3204, 1, 0, 0, 0, 3204, 3206, 3, 1924, 962, 0, 3205, 3207, 3, 946, 473, 0, 3206, 3205, 1, 0, 0, 0, 3206, 3207, 1, 0, 0, 0, 3207, 3208, 1, 0, 0, 0, 3208, 3209, 5, 358, 0, 0, 3209, 3211, 3, 1662, 831, 0, 3210, 3212, 3, 122, 61, 0, 3211, 3210, 1, 0, 0, 0, 3211, 3212, 1, 0, 0, 0, 3212, 3214, 1, 0, 0, 0, 3213, 3215, 3, 124, 62, 0, 3214, 3213, 1, 0, 0, 0, 3214, 3215, 1, 0, 0, 0, 3215, 3345, 1, 0, 0, 0, 3216, 3218, 5, 140, 0, 0, 3217, 3219, 3, 944, 472, 0, 3218, 3217, 1, 0, 0, 0, 3218, 3219, 1, 0, 0, 0, 3219, 3220, 1, 0, 0, 0, 3220, 3221, 3, 1924, 962, 0, 3221, 3222, 3, 386, 193, 0, 3222, 3345, 1, 0, 0, 0, 3223, 3224, 5, 135, 0, 0, 3224, 3345, 3, 238, 119, 0, 3225, 3226, 5, 140, 0, 0, 3226, 3227, 5, 45, 0, 0, 3227, 3228, 3, 1892, 946, 0, 3228, 3229, 3, 482, 241, 0, 3229, 3345, 1, 0, 0, 0, 3230, 3231, 5, 370, 0, 0, 3231, 3232, 5, 45, 0, 0, 3232, 3345, 3, 1892, 946, 0, 3233, 3234, 5, 195, 0, 0, 3234, 3235, 5, 45, 0, 0, 3235, 3236, 5, 224, 0, 0, 3236, 3237, 5, 558, 0, 0, 3237, 3239, 3, 1892, 946, 0, 3238, 3240, 3, 120, 60, 0, 3239, 3238, 1, 0, 0, 0, 3239, 3240, 1, 0, 0, 0, 3240, 3345, 1, 0, 0, 0, 3241, 3242, 5, 195, 0, 0, 3242, 3243, 5, 45, 0, 0, 3243, 3245, 3, 1892, 946, 0, 3244, 3246, 3, 120, 60, 0, 3245, 3244, 1, 0, 0, 0, 3245, 3246, 1, 0, 0, 0, 3246, 3345, 1, 0, 0, 0, 3247, 3248, 5, 331, 0, 0, 3248, 3249, 5, 377, 0, 0, 3249, 3345, 5, 274, 0, 0, 3250, 3251, 5, 160, 0, 0, 3251, 3252, 5, 80, 0, 0, 3252, 3345, 3, 1892, 946, 0, 3253, 3254, 5, 331, 0, 0, 3254, 3255, 5, 377, 0, 0, 3255, 3345, 5, 160, 0, 0, 3256, 3257, 5, 331, 0, 0, 3257, 3345, 5, 609, 0, 0, 3258, 3259, 5, 331, 0, 0, 3259, 3345, 5, 365, 0, 0, 3260, 3261, 5, 197, 0, 0, 3261, 3262, 5, 355, 0, 0, 3262, 3345, 3, 1892, 946, 0, 3263, 3264, 5, 197, 0, 0, 3264, 3265, 5, 141, 0, 0, 3265, 3266, 5, 355, 0, 0, 3266, 3345, 3, 1892, 946, 0, 3267, 3268, 5, 197, 0, 0, 3268, 3269, 5, 310, 0, 0, 3269, 3270, 5, 355, 0, 0, 3270, 3345, 3, 1892, 946, 0, 3271, 3272, 5, 197, 0, 0, 3272, 3273, 5, 355, 0, 0, 3273, 3345, 5, 30, 0, 0, 3274, 3275, 5, 197, 0, 0, 3275, 3276, 5, 355, 0, 0, 3276, 3345, 5, 100, 0, 0, 3277, 3278, 5, 190, 0, 0, 3278, 3279, 5, 355, 0, 0, 3279, 3345, 3, 1892, 946, 0, 3280, 3281, 5, 190, 0, 0, 3281, 3282, 5, 355, 0, 0, 3282, 3345, 5, 30, 0, 0, 3283, 3284, 5, 190, 0, 0, 3284, 3285, 5, 355, 0, 0, 3285, 3345, 5, 100, 0, 0, 3286, 3287, 5, 197, 0, 0, 3287, 3288, 5, 319, 0, 0, 3288, 3345, 3, 1892, 946, 0, 3289, 3290, 5, 197, 0, 0, 3290, 3291, 5, 141, 0, 0, 3291, 3292, 5, 319, 0, 0, 3292, 3345, 3, 1892, 946, 0, 3293, 3294, 5, 197, 0, 0, 3294, 3295, 5, 310, 0, 0, 3295, 3296, 5, 319, 0, 0, 3296, 3345, 3, 1892, 946, 0, 3297, 3298, 5, 190, 0, 0, 3298, 3299, 5, 319, 0, 0, 3299, 3345, 3, 1892, 946, 0, 3300, 3301, 5, 232, 0, 0, 3301, 3345, 3, 1888, 944, 0, 3302, 3303, 5, 266, 0, 0, 3303, 3304, 5, 232, 0, 0, 3304, 3345, 3, 1888, 944, 0, 3305, 3306, 5, 272, 0, 0, 3306, 3345, 3, 566, 283, 0, 3307, 3308, 5, 77, 0, 0, 3308, 3345, 5, 272, 0, 0, 3309, 3310, 5, 279, 0, 0, 3310, 3311, 5, 95, 0, 0, 3311, 3345, 3, 1920, 960, 0, 3312, 3313, 5, 331, 0, 0, 3313, 3314, 5, 133, 0, 0, 3314, 3315, 5, 645, 0, 0, 3315, 3345, 3, 1892, 946, 0, 3316, 3317, 5, 331, 0, 0, 3317, 3318, 5, 349, 0, 0, 3318, 3345, 3, 1892, 946, 0, 3319, 3320, 5, 331, 0, 0, 3320, 3345, 3, 128, 64, 0, 3321, 3322, 5, 311, 0, 0, 3322, 3345, 3, 128, 64, 0, 3323, 3324, 5, 310, 0, 0, 3324, 3325, 5, 223, 0, 0, 3325, 3345, 3, 126, 63, 0, 3326, 3327, 5, 197, 0, 0, 3327, 3328, 5, 577, 0, 0, 3328, 3329, 5, 246, 0, 0, 3329, 3345, 5, 325, 0, 0, 3330, 3331, 5, 190, 0, 0, 3331, 3332, 5, 577, 0, 0, 3332, 3333, 5, 246, 0, 0, 3333, 3345, 5, 325, 0, 0, 3334, 3335, 5, 213, 0, 0, 3335, 3336, 5, 577, 0, 0, 3336, 3337, 5, 246, 0, 0, 3337, 3345, 5, 325, 0, 0, 3338, 3339, 5, 266, 0, 0, 3339, 3340, 5, 213, 0, 0, 3340, 3341, 5, 577, 0, 0, 3341, 3342, 5, 246, 0, 0, 3342, 3345, 5, 325, 0, 0, 3343, 3345, 3, 386, 193, 0, 3344, 3042, 1, 0, 0, 0, 3344, 3044, 1, 0, 0, 0, 3344, 3049, 1, 0, 0, 0, 3344, 3052, 1, 0, 0, 0, 3344, 3058, 1, 0, 0, 0, 3344, 3065, 1, 0, 0, 0, 3344, 3074, 1, 0, 0, 0, 3344, 3083, 1, 0, 0, 0, 3344, 3091, 1, 0, 0, 0, 3344, 3101, 1, 0, 0, 0, 3344, 3110, 1, 0, 0, 0, 3344, 3119, 1, 0, 0, 0, 3344, 3127, 1, 0, 0, 0, 3344, 3135, 1, 0, 0, 0, 3344, 3144, 1, 0, 0, 0, 3344, 3157, 1, 0, 0, 0, 3344, 3164, 1, 0, 0, 0, 3344, 3172, 1, 0, 0, 0, 3344, 3182, 1, 0, 0, 0, 3344, 3192, 1, 0, 0, 0, 3344, 3200, 1, 0, 0, 0, 3344, 3216, 1, 0, 0, 0, 3344, 3223, 1, 0, 0, 0, 3344, 3225, 1, 0, 0, 0, 3344, 3230, 1, 0, 0, 0, 3344, 3233, 1, 0, 0, 0, 3344, 3241, 1, 0, 0, 0, 3344, 3247, 1, 0, 0, 0, 3344, 3250, 1, 0, 0, 0, 3344, 3253, 1, 0, 0, 0, 3344, 3256, 1, 0, 0, 0, 3344, 3258, 1, 0, 0, 0, 3344, 3260, 1, 0, 0, 0, 3344, 3263, 1, 0, 0, 0, 3344, 3267, 1, 0, 0, 0, 3344, 3271, 1, 0, 0, 0, 3344, 3274, 1, 0, 0, 0, 3344, 3277, 1, 0, 0, 0, 3344, 3280, 1, 0, 0, 0, 3344, 3283, 1, 0, 0, 0, 3344, 3286, 1, 0, 0, 0, 3344, 3289, 1, 0, 0, 0, 3344, 3293, 1, 0, 0, 0, 3344, 3297, 1, 0, 0, 0, 3344, 3300, 1, 0, 0, 0, 3344, 3302, 1, 0, 0, 0, 3344, 3305, 1, 0, 0, 0, 3344, 3307, 1, 0, 0, 0, 3344, 3309, 1, 0, 0, 0, 3344, 3312, 1, 0, 0, 0, 3344, 3316, 1, 0, 0, 0, 3344, 3319, 1, 0, 0, 0, 3344, 3321, 1, 0, 0, 0, 3344, 3323, 1, 0, 0, 0, 3344, 3326, 1, 0, 0, 0, 3344, 3330, 1, 0, 0, 0, 3344, 3334, 1, 0, 0, 0, 3344, 3338, 1, 0, 0, 0, 3344, 3343, 1, 0, 0, 0, 3345, 117, 1, 0, 0, 0, 3346, 3347, 5, 331, 0, 0, 3347, 3348, 5, 53, 0, 0, 3348, 3352, 3, 1710, 855, 0, 3349, 3350, 5, 195, 0, 0, 3350, 3352, 5, 53, 0, 0, 3351, 3346, 1, 0, 0, 0, 3351, 3349, 1, 0, 0, 0, 3352, 119, 1, 0, 0, 0, 3353, 3354, 7, 12, 0, 0, 3354, 121, 1, 0, 0, 0, 3355, 3356, 5, 43, 0, 0, 3356, 3357, 3, 566, 283, 0, 3357, 123, 1, 0, 0, 0, 3358, 3359, 5, 101, 0, 0, 3359, 3360, 3, 1710, 855, 0, 3360, 125, 1, 0, 0, 0, 3361, 3368, 5, 267, 0, 0, 3362, 3368, 5, 115, 0, 0, 3363, 3368, 5, 53, 0, 0, 3364, 3365, 5, 101, 0, 0, 3365, 3366, 5, 230, 0, 0, 3366, 3368, 3, 1892, 946, 0, 3367, 3361, 1, 0, 0, 0, 3367, 3362, 1, 0, 0, 0, 3367, 3363, 1, 0, 0, 0, 3367, 3364, 1, 0, 0, 0, 3368, 127, 1, 0, 0, 0, 3369, 3370, 5, 2, 0, 0, 3370, 3371, 3, 132, 66, 0, 3371, 3372, 5, 3, 0, 0, 3372, 129, 1, 0, 0, 0, 3373, 3374, 5, 106, 0, 0, 3374, 3375, 3, 128, 64, 0, 3375, 131, 1, 0, 0, 0, 3376, 3381, 3, 134, 67, 0, 3377, 3378, 5, 6, 0, 0, 3378, 3380, 3, 134, 67, 0, 3379, 3377, 1, 0, 0, 0, 3380, 3383, 1, 0, 0, 0, 3381, 3379, 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, 133, 1, 0, 0, 0, 3383, 3381, 1, 0, 0, 0, 3384, 3393, 3, 1932, 966, 0, 3385, 3386, 5, 10, 0, 0, 3386, 3394, 3, 508, 254, 0, 3387, 3388, 5, 11, 0, 0, 3388, 3391, 3, 1932, 966, 0, 3389, 3390, 5, 10, 0, 0, 3390, 3392, 3, 508, 254, 0, 3391, 3389, 1, 0, 0, 0, 3391, 3392, 1, 0, 0, 0, 3392, 3394, 1, 0, 0, 0, 3393, 3385, 1, 0, 0, 0, 3393, 3387, 1, 0, 0, 0, 3393, 3394, 1, 0, 0, 0, 3394, 135, 1, 0, 0, 0, 3395, 3397, 3, 138, 69, 0, 3396, 3395, 1, 0, 0, 0, 3397, 3398, 1, 0, 0, 0, 3398, 3396, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0, 3399, 137, 1, 0, 0, 0, 3400, 3405, 5, 312, 0, 0, 3401, 3403, 3, 16, 8, 0, 3402, 3401, 1, 0, 0, 0, 3402, 3403, 1, 0, 0, 0, 3403, 3404, 1, 0, 0, 0, 3404, 3406, 3, 334, 167, 0, 3405, 3402, 1, 0, 0, 0, 3405, 3406, 1, 0, 0, 0, 3406, 3414, 1, 0, 0, 0, 3407, 3411, 5, 331, 0, 0, 3408, 3412, 3, 330, 165, 0, 3409, 3410, 5, 608, 0, 0, 3410, 3412, 3, 228, 114, 0, 3411, 3408, 1, 0, 0, 0, 3411, 3409, 1, 0, 0, 0, 3412, 3414, 1, 0, 0, 0, 3413, 3400, 1, 0, 0, 0, 3413, 3407, 1, 0, 0, 0, 3414, 139, 1, 0, 0, 0, 3415, 3416, 5, 62, 0, 0, 3416, 3417, 5, 585, 0, 0, 3417, 3418, 5, 106, 0, 0, 3418, 3419, 5, 2, 0, 0, 3419, 3420, 3, 144, 72, 0, 3420, 3421, 5, 3, 0, 0, 3421, 3442, 1, 0, 0, 0, 3422, 3423, 5, 62, 0, 0, 3423, 3424, 5, 585, 0, 0, 3424, 3425, 5, 68, 0, 0, 3425, 3426, 5, 2, 0, 0, 3426, 3427, 3, 1830, 915, 0, 3427, 3428, 5, 3, 0, 0, 3428, 3442, 1, 0, 0, 0, 3429, 3430, 5, 62, 0, 0, 3430, 3431, 5, 585, 0, 0, 3431, 3432, 5, 64, 0, 0, 3432, 3433, 5, 2, 0, 0, 3433, 3434, 3, 1830, 915, 0, 3434, 3435, 5, 3, 0, 0, 3435, 3436, 5, 95, 0, 0, 3436, 3437, 5, 2, 0, 0, 3437, 3438, 3, 1830, 915, 0, 3438, 3439, 5, 3, 0, 0, 3439, 3442, 1, 0, 0, 0, 3440, 3442, 5, 53, 0, 0, 3441, 3415, 1, 0, 0, 0, 3441, 3422, 1, 0, 0, 0, 3441, 3429, 1, 0, 0, 0, 3441, 3440, 1, 0, 0, 0, 3442, 141, 1, 0, 0, 0, 3443, 3444, 3, 1930, 965, 0, 3444, 3445, 3, 1908, 954, 0, 3445, 143, 1, 0, 0, 0, 3446, 3451, 3, 142, 71, 0, 3447, 3448, 5, 6, 0, 0, 3448, 3450, 3, 142, 71, 0, 3449, 3447, 1, 0, 0, 0, 3450, 3453, 1, 0, 0, 0, 3451, 3449, 1, 0, 0, 0, 3451, 3452, 1, 0, 0, 0, 3452, 145, 1, 0, 0, 0, 3453, 3451, 1, 0, 0, 0, 3454, 3455, 5, 140, 0, 0, 3455, 3456, 5, 358, 0, 0, 3456, 3457, 3, 566, 283, 0, 3457, 3458, 3, 148, 74, 0, 3458, 147, 1, 0, 0, 0, 3459, 3464, 3, 150, 75, 0, 3460, 3461, 5, 6, 0, 0, 3461, 3463, 3, 150, 75, 0, 3462, 3460, 1, 0, 0, 0, 3463, 3466, 1, 0, 0, 0, 3464, 3462, 1, 0, 0, 0, 3464, 3465, 1, 0, 0, 0, 3465, 149, 1, 0, 0, 0, 3466, 3464, 1, 0, 0, 0, 3467, 3468, 5, 135, 0, 0, 3468, 3469, 5, 145, 0, 0, 3469, 3471, 3, 1646, 823, 0, 3470, 3472, 3, 120, 60, 0, 3471, 3470, 1, 0, 0, 0, 3471, 3472, 1, 0, 0, 0, 3472, 3498, 1, 0, 0, 0, 3473, 3474, 5, 195, 0, 0, 3474, 3477, 5, 145, 0, 0, 3475, 3476, 5, 224, 0, 0, 3476, 3478, 5, 558, 0, 0, 3477, 3475, 1, 0, 0, 0, 3477, 3478, 1, 0, 0, 0, 3478, 3479, 1, 0, 0, 0, 3479, 3481, 3, 1924, 962, 0, 3480, 3482, 3, 120, 60, 0, 3481, 3480, 1, 0, 0, 0, 3481, 3482, 1, 0, 0, 0, 3482, 3498, 1, 0, 0, 0, 3483, 3484, 5, 140, 0, 0, 3484, 3485, 5, 145, 0, 0, 3485, 3487, 3, 1924, 962, 0, 3486, 3488, 3, 946, 473, 0, 3487, 3486, 1, 0, 0, 0, 3487, 3488, 1, 0, 0, 0, 3488, 3489, 1, 0, 0, 0, 3489, 3490, 5, 358, 0, 0, 3490, 3492, 3, 1662, 831, 0, 3491, 3493, 3, 122, 61, 0, 3492, 3491, 1, 0, 0, 0, 3492, 3493, 1, 0, 0, 0, 3493, 3495, 1, 0, 0, 0, 3494, 3496, 3, 120, 60, 0, 3495, 3494, 1, 0, 0, 0, 3495, 3496, 1, 0, 0, 0, 3496, 3498, 1, 0, 0, 0, 3497, 3467, 1, 0, 0, 0, 3497, 3473, 1, 0, 0, 0, 3497, 3483, 1, 0, 0, 0, 3498, 151, 1, 0, 0, 0, 3499, 3502, 5, 159, 0, 0, 3500, 3503, 3, 1490, 745, 0, 3501, 3503, 5, 30, 0, 0, 3502, 3500, 1, 0, 0, 0, 3502, 3501, 1, 0, 0, 0, 3503, 153, 1, 0, 0, 0, 3504, 3506, 5, 171, 0, 0, 3505, 3507, 3, 178, 89, 0, 3506, 3505, 1, 0, 0, 0, 3506, 3507, 1, 0, 0, 0, 3507, 3508, 1, 0, 0, 0, 3508, 3510, 3, 1888, 944, 0, 3509, 3511, 3, 244, 122, 0, 3510, 3509, 1, 0, 0, 0, 3510, 3511, 1, 0, 0, 0, 3511, 3512, 1, 0, 0, 0, 3512, 3514, 3, 166, 83, 0, 3513, 3515, 3, 168, 84, 0, 3514, 3513, 1, 0, 0, 0, 3514, 3515, 1, 0, 0, 0, 3515, 3516, 1, 0, 0, 0, 3516, 3518, 3, 170, 85, 0, 3517, 3519, 3, 180, 90, 0, 3518, 3517, 1, 0, 0, 0, 3518, 3519, 1, 0, 0, 0, 3519, 3521, 1, 0, 0, 0, 3520, 3522, 3, 16, 8, 0, 3521, 3520, 1, 0, 0, 0, 3521, 3522, 1, 0, 0, 0, 3522, 3523, 1, 0, 0, 0, 3523, 3525, 3, 172, 86, 0, 3524, 3526, 3, 1638, 819, 0, 3525, 3524, 1, 0, 0, 0, 3525, 3526, 1, 0, 0, 0, 3526, 3559, 1, 0, 0, 0, 3527, 3528, 5, 171, 0, 0, 3528, 3529, 5, 2, 0, 0, 3529, 3530, 3, 1428, 714, 0, 3530, 3531, 5, 3, 0, 0, 3531, 3533, 5, 95, 0, 0, 3532, 3534, 3, 168, 84, 0, 3533, 3532, 1, 0, 0, 0, 3533, 3534, 1, 0, 0, 0, 3534, 3535, 1, 0, 0, 0, 3535, 3537, 3, 170, 85, 0, 3536, 3538, 3, 16, 8, 0, 3537, 3536, 1, 0, 0, 0, 3537, 3538, 1, 0, 0, 0, 3538, 3539, 1, 0, 0, 0, 3539, 3540, 3, 172, 86, 0, 3540, 3559, 1, 0, 0, 0, 3541, 3542, 5, 171, 0, 0, 3542, 3544, 3, 1888, 944, 0, 3543, 3545, 3, 244, 122, 0, 3544, 3543, 1, 0, 0, 0, 3544, 3545, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 3547, 5, 64, 0, 0, 3547, 3548, 3, 1910, 955, 0, 3548, 3550, 3, 156, 78, 0, 3549, 3551, 3, 158, 79, 0, 3550, 3549, 1, 0, 0, 0, 3550, 3551, 1, 0, 0, 0, 3551, 3555, 1, 0, 0, 0, 3552, 3554, 3, 160, 80, 0, 3553, 3552, 1, 0, 0, 0, 3554, 3557, 1, 0, 0, 0, 3555, 3553, 1, 0, 0, 0, 3555, 3556, 1, 0, 0, 0, 3556, 3559, 1, 0, 0, 0, 3557, 3555, 1, 0, 0, 0, 3558, 3504, 1, 0, 0, 0, 3558, 3527, 1, 0, 0, 0, 3558, 3541, 1, 0, 0, 0, 3559, 155, 1, 0, 0, 0, 3560, 3563, 5, 396, 0, 0, 3561, 3564, 5, 53, 0, 0, 3562, 3564, 3, 1910, 955, 0, 3563, 3561, 1, 0, 0, 0, 3563, 3562, 1, 0, 0, 0, 3564, 3576, 1, 0, 0, 0, 3565, 3566, 5, 501, 0, 0, 3566, 3576, 3, 1910, 955, 0, 3567, 3568, 5, 542, 0, 0, 3568, 3569, 3, 1910, 955, 0, 3569, 3570, 5, 543, 0, 0, 3570, 3573, 3, 1910, 955, 0, 3571, 3572, 5, 544, 0, 0, 3572, 3574, 3, 1910, 955, 0, 3573, 3571, 1, 0, 0, 0, 3573, 3574, 1, 0, 0, 0, 3574, 3576, 1, 0, 0, 0, 3575, 3560, 1, 0, 0, 0, 3575, 3565, 1, 0, 0, 0, 3575, 3567, 1, 0, 0, 0, 3576, 157, 1, 0, 0, 0, 3577, 3579, 5, 780, 0, 0, 3578, 3577, 1, 0, 0, 0, 3578, 3579, 1, 0, 0, 0, 3579, 3581, 1, 0, 0, 0, 3580, 3582, 5, 36, 0, 0, 3581, 3580, 1, 0, 0, 0, 3581, 3582, 1, 0, 0, 0, 3582, 3583, 1, 0, 0, 0, 3583, 3585, 7, 17, 0, 0, 3584, 3586, 3, 1910, 955, 0, 3585, 3584, 1, 0, 0, 0, 3585, 3586, 1, 0, 0, 0, 3586, 159, 1, 0, 0, 0, 3587, 3592, 3, 162, 81, 0, 3588, 3590, 5, 36, 0, 0, 3589, 3588, 1, 0, 0, 0, 3589, 3590, 1, 0, 0, 0, 3590, 3591, 1, 0, 0, 0, 3591, 3593, 3, 164, 82, 0, 3592, 3589, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 161, 1, 0, 0, 0, 3594, 3597, 3, 1924, 962, 0, 3595, 3597, 5, 78, 0, 0, 3596, 3594, 1, 0, 0, 0, 3596, 3595, 1, 0, 0, 0, 3597, 163, 1, 0, 0, 0, 3598, 3610, 3, 1910, 955, 0, 3599, 3610, 3, 1908, 954, 0, 3600, 3610, 3, 1924, 962, 0, 3601, 3610, 5, 80, 0, 0, 3602, 3610, 5, 273, 0, 0, 3603, 3610, 5, 97, 0, 0, 3604, 3610, 5, 60, 0, 0, 3605, 3610, 5, 541, 0, 0, 3606, 3610, 5, 420, 0, 0, 3607, 3610, 5, 53, 0, 0, 3608, 3610, 5, 569, 0, 0, 3609, 3598, 1, 0, 0, 0, 3609, 3599, 1, 0, 0, 0, 3609, 3600, 1, 0, 0, 0, 3609, 3601, 1, 0, 0, 0, 3609, 3602, 1, 0, 0, 0, 3609, 3603, 1, 0, 0, 0, 3609, 3604, 1, 0, 0, 0, 3609, 3605, 1, 0, 0, 0, 3609, 3606, 1, 0, 0, 0, 3609, 3607, 1, 0, 0, 0, 3609, 3608, 1, 0, 0, 0, 3610, 165, 1, 0, 0, 0, 3611, 3612, 7, 18, 0, 0, 3612, 167, 1, 0, 0, 0, 3613, 3614, 5, 295, 0, 0, 3614, 169, 1, 0, 0, 0, 3615, 3619, 3, 1910, 955, 0, 3616, 3619, 5, 341, 0, 0, 3617, 3619, 5, 342, 0, 0, 3618, 3615, 1, 0, 0, 0, 3618, 3616, 1, 0, 0, 0, 3618, 3617, 1, 0, 0, 0, 3619, 171, 1, 0, 0, 0, 3620, 3626, 3, 174, 87, 0, 3621, 3622, 5, 2, 0, 0, 3622, 3623, 3, 184, 92, 0, 3623, 3624, 5, 3, 0, 0, 3624, 3626, 1, 0, 0, 0, 3625, 3620, 1, 0, 0, 0, 3625, 3621, 1, 0, 0, 0, 3626, 173, 1, 0, 0, 0, 3627, 3629, 3, 176, 88, 0, 3628, 3627, 1, 0, 0, 0, 3629, 3632, 1, 0, 0, 0, 3630, 3628, 1, 0, 0, 0, 3630, 3631, 1, 0, 0, 0, 3631, 175, 1, 0, 0, 0, 3632, 3630, 1, 0, 0, 0, 3633, 3673, 5, 108, 0, 0, 3634, 3673, 5, 114, 0, 0, 3635, 3637, 5, 187, 0, 0, 3636, 3638, 3, 1366, 683, 0, 3637, 3636, 1, 0, 0, 0, 3637, 3638, 1, 0, 0, 0, 3638, 3639, 1, 0, 0, 0, 3639, 3673, 3, 1910, 955, 0, 3640, 3642, 5, 78, 0, 0, 3641, 3643, 3, 1366, 683, 0, 3642, 3641, 1, 0, 0, 0, 3642, 3643, 1, 0, 0, 0, 3643, 3644, 1, 0, 0, 0, 3644, 3673, 3, 1910, 955, 0, 3645, 3673, 5, 173, 0, 0, 3646, 3673, 5, 220, 0, 0, 3647, 3649, 5, 296, 0, 0, 3648, 3650, 3, 1366, 683, 0, 3649, 3648, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, 3651, 1, 0, 0, 0, 3651, 3673, 3, 1910, 955, 0, 3652, 3654, 5, 201, 0, 0, 3653, 3655, 3, 1366, 683, 0, 3654, 3653, 1, 0, 0, 0, 3654, 3655, 1, 0, 0, 0, 3655, 3656, 1, 0, 0, 0, 3656, 3673, 3, 1910, 955, 0, 3657, 3658, 5, 213, 0, 0, 3658, 3659, 5, 296, 0, 0, 3659, 3673, 3, 246, 123, 0, 3660, 3661, 5, 213, 0, 0, 3661, 3662, 5, 296, 0, 0, 3662, 3673, 5, 9, 0, 0, 3663, 3664, 5, 213, 0, 0, 3664, 3665, 5, 77, 0, 0, 3665, 3666, 5, 78, 0, 0, 3666, 3673, 3, 246, 123, 0, 3667, 3668, 5, 213, 0, 0, 3668, 3669, 5, 78, 0, 0, 3669, 3673, 3, 246, 123, 0, 3670, 3671, 5, 198, 0, 0, 3671, 3673, 3, 1910, 955, 0, 3672, 3633, 1, 0, 0, 0, 3672, 3634, 1, 0, 0, 0, 3672, 3635, 1, 0, 0, 0, 3672, 3640, 1, 0, 0, 0, 3672, 3645, 1, 0, 0, 0, 3672, 3646, 1, 0, 0, 0, 3672, 3647, 1, 0, 0, 0, 3672, 3652, 1, 0, 0, 0, 3672, 3657, 1, 0, 0, 0, 3672, 3660, 1, 0, 0, 0, 3672, 3663, 1, 0, 0, 0, 3672, 3667, 1, 0, 0, 0, 3672, 3670, 1, 0, 0, 0, 3673, 177, 1, 0, 0, 0, 3674, 3675, 5, 108, 0, 0, 3675, 179, 1, 0, 0, 0, 3676, 3678, 3, 182, 91, 0, 3677, 3676, 1, 0, 0, 0, 3677, 3678, 1, 0, 0, 0, 3678, 3679, 1, 0, 0, 0, 3679, 3680, 5, 188, 0, 0, 3680, 3681, 3, 1910, 955, 0, 3681, 181, 1, 0, 0, 0, 3682, 3683, 5, 101, 0, 0, 3683, 183, 1, 0, 0, 0, 3684, 3689, 3, 186, 93, 0, 3685, 3686, 5, 6, 0, 0, 3686, 3688, 3, 186, 93, 0, 3687, 3685, 1, 0, 0, 0, 3688, 3691, 1, 0, 0, 0, 3689, 3687, 1, 0, 0, 0, 3689, 3690, 1, 0, 0, 0, 3690, 185, 1, 0, 0, 0, 3691, 3689, 1, 0, 0, 0, 3692, 3694, 3, 1932, 966, 0, 3693, 3695, 3, 188, 94, 0, 3694, 3693, 1, 0, 0, 0, 3694, 3695, 1, 0, 0, 0, 3695, 187, 1, 0, 0, 0, 3696, 3704, 3, 76, 38, 0, 3697, 3704, 3, 334, 167, 0, 3698, 3704, 5, 9, 0, 0, 3699, 3700, 5, 2, 0, 0, 3700, 3701, 3, 190, 95, 0, 3701, 3702, 5, 3, 0, 0, 3702, 3704, 1, 0, 0, 0, 3703, 3696, 1, 0, 0, 0, 3703, 3697, 1, 0, 0, 0, 3703, 3698, 1, 0, 0, 0, 3703, 3699, 1, 0, 0, 0, 3704, 189, 1, 0, 0, 0, 3705, 3710, 3, 192, 96, 0, 3706, 3707, 5, 6, 0, 0, 3707, 3709, 3, 192, 96, 0, 3708, 3706, 1, 0, 0, 0, 3709, 3712, 1, 0, 0, 0, 3710, 3708, 1, 0, 0, 0, 3710, 3711, 1, 0, 0, 0, 3711, 191, 1, 0, 0, 0, 3712, 3710, 1, 0, 0, 0, 3713, 3714, 3, 76, 38, 0, 3714, 193, 1, 0, 0, 0, 3715, 3717, 5, 46, 0, 0, 3716, 3718, 3, 198, 99, 0, 3717, 3716, 1, 0, 0, 0, 3717, 3718, 1, 0, 0, 0, 3718, 3719, 1, 0, 0, 0, 3719, 3723, 5, 93, 0, 0, 3720, 3721, 5, 224, 0, 0, 3721, 3722, 5, 77, 0, 0, 3722, 3724, 5, 558, 0, 0, 3723, 3720, 1, 0, 0, 0, 3723, 3724, 1, 0, 0, 0, 3724, 3725, 1, 0, 0, 0, 3725, 3726, 3, 1040, 520, 0, 3726, 3728, 5, 2, 0, 0, 3727, 3729, 3, 200, 100, 0, 3728, 3727, 1, 0, 0, 0, 3728, 3729, 1, 0, 0, 0, 3729, 3730, 1, 0, 0, 0, 3730, 3732, 5, 3, 0, 0, 3731, 3733, 3, 310, 155, 0, 3732, 3731, 1, 0, 0, 0, 3732, 3733, 1, 0, 0, 0, 3733, 3737, 1, 0, 0, 0, 3734, 3736, 3, 196, 98, 0, 3735, 3734, 1, 0, 0, 0, 3736, 3739, 1, 0, 0, 0, 3737, 3735, 1, 0, 0, 0, 3737, 3738, 1, 0, 0, 0, 3738, 195, 1, 0, 0, 0, 3739, 3737, 1, 0, 0, 0, 3740, 3741, 5, 838, 0, 0, 3741, 3758, 7, 19, 0, 0, 3742, 3743, 5, 836, 0, 0, 3743, 3744, 5, 2, 0, 0, 3744, 3745, 3, 1924, 962, 0, 3745, 3746, 5, 3, 0, 0, 3746, 3758, 1, 0, 0, 0, 3747, 3749, 7, 20, 0, 0, 3748, 3747, 1, 0, 0, 0, 3748, 3749, 1, 0, 0, 0, 3749, 3750, 1, 0, 0, 0, 3750, 3751, 5, 837, 0, 0, 3751, 3752, 5, 2, 0, 0, 3752, 3753, 3, 246, 123, 0, 3753, 3754, 5, 3, 0, 0, 3754, 3758, 1, 0, 0, 0, 3755, 3756, 5, 835, 0, 0, 3756, 3758, 5, 420, 0, 0, 3757, 3740, 1, 0, 0, 0, 3757, 3742, 1, 0, 0, 0, 3757, 3748, 1, 0, 0, 0, 3757, 3755, 1, 0, 0, 0, 3758, 197, 1, 0, 0, 0, 3759, 3761, 5, 249, 0, 0, 3760, 3759, 1, 0, 0, 0, 3760, 3761, 1, 0, 0, 0, 3761, 3762, 1, 0, 0, 0, 3762, 3763, 7, 21, 0, 0, 3763, 199, 1, 0, 0, 0, 3764, 3765, 3, 204, 102, 0, 3765, 201, 1, 0, 0, 0, 3766, 3767, 5, 2, 0, 0, 3767, 3768, 3, 206, 103, 0, 3768, 3769, 5, 3, 0, 0, 3769, 203, 1, 0, 0, 0, 3770, 3775, 3, 208, 104, 0, 3771, 3772, 5, 6, 0, 0, 3772, 3774, 3, 208, 104, 0, 3773, 3771, 1, 0, 0, 0, 3774, 3777, 1, 0, 0, 0, 3775, 3773, 1, 0, 0, 0, 3775, 3776, 1, 0, 0, 0, 3776, 205, 1, 0, 0, 0, 3777, 3775, 1, 0, 0, 0, 3778, 3783, 3, 210, 105, 0, 3779, 3780, 5, 6, 0, 0, 3780, 3782, 3, 210, 105, 0, 3781, 3779, 1, 0, 0, 0, 3782, 3785, 1, 0, 0, 0, 3783, 3781, 1, 0, 0, 0, 3783, 3784, 1, 0, 0, 0, 3784, 207, 1, 0, 0, 0, 3785, 3783, 1, 0, 0, 0, 3786, 3790, 3, 238, 119, 0, 3787, 3790, 3, 232, 116, 0, 3788, 3790, 3, 212, 106, 0, 3789, 3786, 1, 0, 0, 0, 3789, 3787, 1, 0, 0, 0, 3789, 3788, 1, 0, 0, 0, 3790, 209, 1, 0, 0, 0, 3791, 3794, 3, 218, 109, 0, 3792, 3794, 3, 238, 119, 0, 3793, 3791, 1, 0, 0, 0, 3793, 3792, 1, 0, 0, 0, 3794, 211, 1, 0, 0, 0, 3795, 3796, 3, 1924, 962, 0, 3796, 3798, 3, 1114, 557, 0, 3797, 3799, 3, 382, 191, 0, 3798, 3797, 1, 0, 0, 0, 3798, 3799, 1, 0, 0, 0, 3799, 3801, 1, 0, 0, 0, 3800, 3802, 3, 214, 107, 0, 3801, 3800, 1, 0, 0, 0, 3801, 3802, 1, 0, 0, 0, 3802, 213, 1, 0, 0, 0, 3803, 3805, 3, 216, 108, 0, 3804, 3803, 1, 0, 0, 0, 3805, 3806, 1, 0, 0, 0, 3806, 3804, 1, 0, 0, 0, 3806, 3807, 1, 0, 0, 0, 3807, 215, 1, 0, 0, 0, 3808, 3809, 5, 53, 0, 0, 3809, 3847, 3, 1754, 877, 0, 3810, 3811, 5, 223, 0, 0, 3811, 3812, 5, 2, 0, 0, 3812, 3813, 3, 1908, 954, 0, 3813, 3814, 5, 6, 0, 0, 3814, 3815, 3, 1908, 954, 0, 3815, 3816, 5, 3, 0, 0, 3816, 3847, 1, 0, 0, 0, 3817, 3818, 5, 608, 0, 0, 3818, 3819, 3, 228, 114, 0, 3819, 3820, 5, 36, 0, 0, 3820, 3827, 5, 223, 0, 0, 3821, 3822, 5, 2, 0, 0, 3822, 3823, 3, 1908, 954, 0, 3823, 3824, 5, 6, 0, 0, 3824, 3825, 3, 1908, 954, 0, 3825, 3826, 5, 3, 0, 0, 3826, 3828, 1, 0, 0, 0, 3827, 3821, 1, 0, 0, 0, 3827, 3828, 1, 0, 0, 0, 3828, 3847, 1, 0, 0, 0, 3829, 3830, 5, 835, 0, 0, 3830, 3847, 3, 1924, 962, 0, 3831, 3847, 5, 836, 0, 0, 3832, 3847, 5, 837, 0, 0, 3833, 3834, 5, 43, 0, 0, 3834, 3847, 7, 22, 0, 0, 3835, 3836, 5, 77, 0, 0, 3836, 3847, 5, 78, 0, 0, 3837, 3847, 5, 78, 0, 0, 3838, 3847, 5, 99, 0, 0, 3839, 3840, 5, 85, 0, 0, 3840, 3847, 5, 240, 0, 0, 3841, 3842, 5, 87, 0, 0, 3842, 3844, 3, 1888, 944, 0, 3843, 3845, 3, 244, 122, 0, 3844, 3843, 1, 0, 0, 0, 3844, 3845, 1, 0, 0, 0, 3845, 3847, 1, 0, 0, 0, 3846, 3808, 1, 0, 0, 0, 3846, 3810, 1, 0, 0, 0, 3846, 3817, 1, 0, 0, 0, 3846, 3829, 1, 0, 0, 0, 3846, 3831, 1, 0, 0, 0, 3846, 3832, 1, 0, 0, 0, 3846, 3833, 1, 0, 0, 0, 3846, 3835, 1, 0, 0, 0, 3846, 3837, 1, 0, 0, 0, 3846, 3838, 1, 0, 0, 0, 3846, 3839, 1, 0, 0, 0, 3846, 3841, 1, 0, 0, 0, 3847, 217, 1, 0, 0, 0, 3848, 3851, 3, 1924, 962, 0, 3849, 3850, 5, 106, 0, 0, 3850, 3852, 5, 277, 0, 0, 3851, 3849, 1, 0, 0, 0, 3851, 3852, 1, 0, 0, 0, 3852, 3853, 1, 0, 0, 0, 3853, 3854, 3, 220, 110, 0, 3854, 219, 1, 0, 0, 0, 3855, 3857, 3, 222, 111, 0, 3856, 3855, 1, 0, 0, 0, 3857, 3860, 1, 0, 0, 0, 3858, 3856, 1, 0, 0, 0, 3858, 3859, 1, 0, 0, 0, 3859, 221, 1, 0, 0, 0, 3860, 3858, 1, 0, 0, 0, 3861, 3862, 5, 45, 0, 0, 3862, 3863, 3, 1892, 946, 0, 3863, 3864, 3, 224, 112, 0, 3864, 3870, 1, 0, 0, 0, 3865, 3870, 3, 224, 112, 0, 3866, 3870, 3, 230, 115, 0, 3867, 3868, 5, 43, 0, 0, 3868, 3870, 3, 566, 283, 0, 3869, 3861, 1, 0, 0, 0, 3869, 3865, 1, 0, 0, 0, 3869, 3866, 1, 0, 0, 0, 3869, 3867, 1, 0, 0, 0, 3870, 223, 1, 0, 0, 0, 3871, 3872, 5, 77, 0, 0, 3872, 3927, 5, 78, 0, 0, 3873, 3927, 5, 78, 0, 0, 3874, 3876, 5, 99, 0, 0, 3875, 3877, 3, 226, 113, 0, 3876, 3875, 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, 3879, 1, 0, 0, 0, 3878, 3880, 3, 882, 441, 0, 3879, 3878, 1, 0, 0, 0, 3879, 3880, 1, 0, 0, 0, 3880, 3882, 1, 0, 0, 0, 3881, 3883, 3, 294, 147, 0, 3882, 3881, 1, 0, 0, 0, 3882, 3883, 1, 0, 0, 0, 3883, 3927, 1, 0, 0, 0, 3884, 3885, 5, 85, 0, 0, 3885, 3887, 5, 240, 0, 0, 3886, 3888, 3, 882, 441, 0, 3887, 3886, 1, 0, 0, 0, 3887, 3888, 1, 0, 0, 0, 3888, 3890, 1, 0, 0, 0, 3889, 3891, 3, 294, 147, 0, 3890, 3889, 1, 0, 0, 0, 3890, 3891, 1, 0, 0, 0, 3891, 3927, 1, 0, 0, 0, 3892, 3893, 5, 42, 0, 0, 3893, 3894, 5, 2, 0, 0, 3894, 3895, 3, 1710, 855, 0, 3895, 3897, 5, 3, 0, 0, 3896, 3898, 3, 242, 121, 0, 3897, 3896, 1, 0, 0, 0, 3897, 3898, 1, 0, 0, 0, 3898, 3927, 1, 0, 0, 0, 3899, 3900, 5, 53, 0, 0, 3900, 3927, 3, 1754, 877, 0, 3901, 3902, 5, 608, 0, 0, 3902, 3903, 3, 228, 114, 0, 3903, 3913, 5, 36, 0, 0, 3904, 3906, 5, 223, 0, 0, 3905, 3907, 3, 326, 163, 0, 3906, 3905, 1, 0, 0, 0, 3906, 3907, 1, 0, 0, 0, 3907, 3914, 1, 0, 0, 0, 3908, 3909, 5, 2, 0, 0, 3909, 3910, 3, 1710, 855, 0, 3910, 3911, 5, 3, 0, 0, 3911, 3912, 5, 610, 0, 0, 3912, 3914, 1, 0, 0, 0, 3913, 3904, 1, 0, 0, 0, 3913, 3908, 1, 0, 0, 0, 3914, 3927, 1, 0, 0, 0, 3915, 3916, 5, 87, 0, 0, 3916, 3918, 3, 1888, 944, 0, 3917, 3919, 3, 244, 122, 0, 3918, 3917, 1, 0, 0, 0, 3918, 3919, 1, 0, 0, 0, 3919, 3921, 1, 0, 0, 0, 3920, 3922, 3, 252, 126, 0, 3921, 3920, 1, 0, 0, 0, 3921, 3922, 1, 0, 0, 0, 3922, 3924, 1, 0, 0, 0, 3923, 3925, 3, 260, 130, 0, 3924, 3923, 1, 0, 0, 0, 3924, 3925, 1, 0, 0, 0, 3925, 3927, 1, 0, 0, 0, 3926, 3871, 1, 0, 0, 0, 3926, 3873, 1, 0, 0, 0, 3926, 3874, 1, 0, 0, 0, 3926, 3884, 1, 0, 0, 0, 3926, 3892, 1, 0, 0, 0, 3926, 3899, 1, 0, 0, 0, 3926, 3901, 1, 0, 0, 0, 3926, 3915, 1, 0, 0, 0, 3927, 225, 1, 0, 0, 0, 3928, 3930, 5, 270, 0, 0, 3929, 3931, 5, 77, 0, 0, 3930, 3929, 1, 0, 0, 0, 3930, 3931, 1, 0, 0, 0, 3931, 3932, 1, 0, 0, 0, 3932, 3933, 5, 56, 0, 0, 3933, 227, 1, 0, 0, 0, 3934, 3938, 5, 141, 0, 0, 3935, 3936, 5, 149, 0, 0, 3936, 3938, 5, 53, 0, 0, 3937, 3934, 1, 0, 0, 0, 3937, 3935, 1, 0, 0, 0, 3938, 229, 1, 0, 0, 0, 3939, 3945, 5, 54, 0, 0, 3940, 3941, 5, 77, 0, 0, 3941, 3945, 5, 54, 0, 0, 3942, 3943, 5, 69, 0, 0, 3943, 3945, 7, 10, 0, 0, 3944, 3939, 1, 0, 0, 0, 3944, 3940, 1, 0, 0, 0, 3944, 3942, 1, 0, 0, 0, 3945, 231, 1, 0, 0, 0, 3946, 3947, 5, 122, 0, 0, 3947, 3948, 3, 1888, 944, 0, 3948, 3949, 3, 234, 117, 0, 3949, 233, 1, 0, 0, 0, 3950, 3951, 7, 23, 0, 0, 3951, 3953, 3, 236, 118, 0, 3952, 3950, 1, 0, 0, 0, 3953, 3956, 1, 0, 0, 0, 3954, 3952, 1, 0, 0, 0, 3954, 3955, 1, 0, 0, 0, 3955, 235, 1, 0, 0, 0, 3956, 3954, 1, 0, 0, 0, 3957, 3958, 7, 24, 0, 0, 3958, 237, 1, 0, 0, 0, 3959, 3960, 5, 45, 0, 0, 3960, 3961, 3, 1892, 946, 0, 3961, 3962, 3, 240, 120, 0, 3962, 3965, 1, 0, 0, 0, 3963, 3965, 3, 240, 120, 0, 3964, 3959, 1, 0, 0, 0, 3964, 3963, 1, 0, 0, 0, 3965, 239, 1, 0, 0, 0, 3966, 3967, 5, 42, 0, 0, 3967, 3968, 5, 2, 0, 0, 3968, 3969, 3, 1710, 855, 0, 3969, 3970, 5, 3, 0, 0, 3970, 3971, 3, 482, 241, 0, 3971, 4056, 1, 0, 0, 0, 3972, 3974, 5, 99, 0, 0, 3973, 3975, 3, 226, 113, 0, 3974, 3973, 1, 0, 0, 0, 3974, 3975, 1, 0, 0, 0, 3975, 3993, 1, 0, 0, 0, 3976, 3977, 5, 2, 0, 0, 3977, 3978, 3, 246, 123, 0, 3978, 3980, 5, 3, 0, 0, 3979, 3981, 3, 250, 125, 0, 3980, 3979, 1, 0, 0, 0, 3980, 3981, 1, 0, 0, 0, 3981, 3983, 1, 0, 0, 0, 3982, 3984, 3, 882, 441, 0, 3983, 3982, 1, 0, 0, 0, 3983, 3984, 1, 0, 0, 0, 3984, 3986, 1, 0, 0, 0, 3985, 3987, 3, 294, 147, 0, 3986, 3985, 1, 0, 0, 0, 3986, 3987, 1, 0, 0, 0, 3987, 3988, 1, 0, 0, 0, 3988, 3989, 3, 482, 241, 0, 3989, 3994, 1, 0, 0, 0, 3990, 3991, 3, 296, 148, 0, 3991, 3992, 3, 482, 241, 0, 3992, 3994, 1, 0, 0, 0, 3993, 3976, 1, 0, 0, 0, 3993, 3990, 1, 0, 0, 0, 3994, 4056, 1, 0, 0, 0, 3995, 3996, 5, 85, 0, 0, 3996, 4014, 5, 240, 0, 0, 3997, 3998, 5, 2, 0, 0, 3998, 3999, 3, 246, 123, 0, 3999, 4001, 5, 3, 0, 0, 4000, 4002, 3, 250, 125, 0, 4001, 4000, 1, 0, 0, 0, 4001, 4002, 1, 0, 0, 0, 4002, 4004, 1, 0, 0, 0, 4003, 4005, 3, 882, 441, 0, 4004, 4003, 1, 0, 0, 0, 4004, 4005, 1, 0, 0, 0, 4005, 4007, 1, 0, 0, 0, 4006, 4008, 3, 294, 147, 0, 4007, 4006, 1, 0, 0, 0, 4007, 4008, 1, 0, 0, 0, 4008, 4009, 1, 0, 0, 0, 4009, 4010, 3, 482, 241, 0, 4010, 4015, 1, 0, 0, 0, 4011, 4012, 3, 296, 148, 0, 4012, 4013, 3, 482, 241, 0, 4013, 4015, 1, 0, 0, 0, 4014, 3997, 1, 0, 0, 0, 4014, 4011, 1, 0, 0, 0, 4015, 4056, 1, 0, 0, 0, 4016, 4018, 5, 203, 0, 0, 4017, 4019, 3, 806, 403, 0, 4018, 4017, 1, 0, 0, 0, 4018, 4019, 1, 0, 0, 0, 4019, 4020, 1, 0, 0, 0, 4020, 4021, 5, 2, 0, 0, 4021, 4022, 3, 254, 127, 0, 4022, 4024, 5, 3, 0, 0, 4023, 4025, 3, 250, 125, 0, 4024, 4023, 1, 0, 0, 0, 4024, 4025, 1, 0, 0, 0, 4025, 4027, 1, 0, 0, 0, 4026, 4028, 3, 882, 441, 0, 4027, 4026, 1, 0, 0, 0, 4027, 4028, 1, 0, 0, 0, 4028, 4030, 1, 0, 0, 0, 4029, 4031, 3, 294, 147, 0, 4030, 4029, 1, 0, 0, 0, 4030, 4031, 1, 0, 0, 0, 4031, 4033, 1, 0, 0, 0, 4032, 4034, 3, 258, 129, 0, 4033, 4032, 1, 0, 0, 0, 4033, 4034, 1, 0, 0, 0, 4034, 4035, 1, 0, 0, 0, 4035, 4036, 3, 482, 241, 0, 4036, 4056, 1, 0, 0, 0, 4037, 4038, 5, 63, 0, 0, 4038, 4039, 5, 240, 0, 0, 4039, 4040, 5, 2, 0, 0, 4040, 4041, 3, 246, 123, 0, 4041, 4042, 5, 3, 0, 0, 4042, 4043, 5, 87, 0, 0, 4043, 4045, 3, 1888, 944, 0, 4044, 4046, 3, 244, 122, 0, 4045, 4044, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4048, 1, 0, 0, 0, 4047, 4049, 3, 252, 126, 0, 4048, 4047, 1, 0, 0, 0, 4048, 4049, 1, 0, 0, 0, 4049, 4051, 1, 0, 0, 0, 4050, 4052, 3, 260, 130, 0, 4051, 4050, 1, 0, 0, 0, 4051, 4052, 1, 0, 0, 0, 4052, 4053, 1, 0, 0, 0, 4053, 4054, 3, 482, 241, 0, 4054, 4056, 1, 0, 0, 0, 4055, 3966, 1, 0, 0, 0, 4055, 3972, 1, 0, 0, 0, 4055, 3995, 1, 0, 0, 0, 4055, 4016, 1, 0, 0, 0, 4055, 4037, 1, 0, 0, 0, 4056, 241, 1, 0, 0, 0, 4057, 4058, 5, 266, 0, 0, 4058, 4059, 5, 232, 0, 0, 4059, 243, 1, 0, 0, 0, 4060, 4061, 5, 2, 0, 0, 4061, 4062, 3, 246, 123, 0, 4062, 4063, 5, 3, 0, 0, 4063, 245, 1, 0, 0, 0, 4064, 4069, 3, 248, 124, 0, 4065, 4066, 5, 6, 0, 0, 4066, 4068, 3, 248, 124, 0, 4067, 4065, 1, 0, 0, 0, 4068, 4071, 1, 0, 0, 0, 4069, 4067, 1, 0, 0, 0, 4069, 4070, 1, 0, 0, 0, 4070, 247, 1, 0, 0, 0, 4071, 4069, 1, 0, 0, 0, 4072, 4073, 3, 1924, 962, 0, 4073, 249, 1, 0, 0, 0, 4074, 4075, 5, 639, 0, 0, 4075, 4076, 5, 2, 0, 0, 4076, 4077, 3, 246, 123, 0, 4077, 4078, 5, 3, 0, 0, 4078, 251, 1, 0, 0, 0, 4079, 4080, 5, 253, 0, 0, 4080, 4081, 7, 25, 0, 0, 4081, 253, 1, 0, 0, 0, 4082, 4087, 3, 256, 128, 0, 4083, 4084, 5, 6, 0, 0, 4084, 4086, 3, 256, 128, 0, 4085, 4083, 1, 0, 0, 0, 4086, 4089, 1, 0, 0, 0, 4087, 4085, 1, 0, 0, 0, 4087, 4088, 1, 0, 0, 0, 4088, 255, 1, 0, 0, 0, 4089, 4087, 1, 0, 0, 0, 4090, 4091, 3, 812, 406, 0, 4091, 4098, 5, 106, 0, 0, 4092, 4099, 3, 904, 452, 0, 4093, 4094, 5, 275, 0, 0, 4094, 4095, 5, 2, 0, 0, 4095, 4096, 3, 904, 452, 0, 4096, 4097, 5, 3, 0, 0, 4097, 4099, 1, 0, 0, 0, 4098, 4092, 1, 0, 0, 0, 4098, 4093, 1, 0, 0, 0, 4099, 257, 1, 0, 0, 0, 4100, 4101, 5, 104, 0, 0, 4101, 4102, 5, 2, 0, 0, 4102, 4103, 3, 1710, 855, 0, 4103, 4104, 5, 3, 0, 0, 4104, 259, 1, 0, 0, 0, 4105, 4114, 3, 262, 131, 0, 4106, 4114, 3, 264, 132, 0, 4107, 4108, 3, 262, 131, 0, 4108, 4109, 3, 264, 132, 0, 4109, 4114, 1, 0, 0, 0, 4110, 4111, 3, 264, 132, 0, 4111, 4112, 3, 262, 131, 0, 4112, 4114, 1, 0, 0, 0, 4113, 4105, 1, 0, 0, 0, 4113, 4106, 1, 0, 0, 0, 4113, 4107, 1, 0, 0, 0, 4113, 4110, 1, 0, 0, 0, 4114, 261, 1, 0, 0, 0, 4115, 4116, 5, 80, 0, 0, 4116, 4117, 5, 367, 0, 0, 4117, 4118, 3, 266, 133, 0, 4118, 263, 1, 0, 0, 0, 4119, 4120, 5, 80, 0, 0, 4120, 4121, 5, 186, 0, 0, 4121, 4122, 3, 266, 133, 0, 4122, 265, 1, 0, 0, 0, 4123, 4124, 5, 266, 0, 0, 4124, 4133, 5, 134, 0, 0, 4125, 4133, 5, 313, 0, 0, 4126, 4133, 5, 152, 0, 0, 4127, 4128, 5, 331, 0, 0, 4128, 4130, 7, 26, 0, 0, 4129, 4131, 3, 244, 122, 0, 4130, 4129, 1, 0, 0, 0, 4130, 4131, 1, 0, 0, 0, 4131, 4133, 1, 0, 0, 0, 4132, 4123, 1, 0, 0, 0, 4132, 4125, 1, 0, 0, 0, 4132, 4126, 1, 0, 0, 0, 4132, 4127, 1, 0, 0, 0, 4133, 267, 1, 0, 0, 0, 4134, 4135, 5, 233, 0, 0, 4135, 4136, 5, 2, 0, 0, 4136, 4137, 3, 1886, 943, 0, 4137, 4138, 5, 3, 0, 0, 4138, 269, 1, 0, 0, 0, 4139, 4140, 3, 272, 136, 0, 4140, 271, 1, 0, 0, 0, 4141, 4142, 5, 282, 0, 0, 4142, 4143, 5, 149, 0, 0, 4143, 4144, 3, 1924, 962, 0, 4144, 4145, 5, 2, 0, 0, 4145, 4146, 3, 274, 137, 0, 4146, 4147, 5, 3, 0, 0, 4147, 273, 1, 0, 0, 0, 4148, 4153, 3, 276, 138, 0, 4149, 4150, 5, 6, 0, 0, 4150, 4152, 3, 276, 138, 0, 4151, 4149, 1, 0, 0, 0, 4152, 4155, 1, 0, 0, 0, 4153, 4151, 1, 0, 0, 0, 4153, 4154, 1, 0, 0, 0, 4154, 275, 1, 0, 0, 0, 4155, 4153, 1, 0, 0, 0, 4156, 4158, 3, 1924, 962, 0, 4157, 4159, 3, 818, 409, 0, 4158, 4157, 1, 0, 0, 0, 4158, 4159, 1, 0, 0, 0, 4159, 4161, 1, 0, 0, 0, 4160, 4162, 3, 820, 410, 0, 4161, 4160, 1, 0, 0, 0, 4161, 4162, 1, 0, 0, 0, 4162, 4180, 1, 0, 0, 0, 4163, 4165, 3, 1764, 882, 0, 4164, 4166, 3, 818, 409, 0, 4165, 4164, 1, 0, 0, 0, 4165, 4166, 1, 0, 0, 0, 4166, 4168, 1, 0, 0, 0, 4167, 4169, 3, 820, 410, 0, 4168, 4167, 1, 0, 0, 0, 4168, 4169, 1, 0, 0, 0, 4169, 4180, 1, 0, 0, 0, 4170, 4171, 5, 2, 0, 0, 4171, 4172, 3, 1710, 855, 0, 4172, 4174, 5, 3, 0, 0, 4173, 4175, 3, 818, 409, 0, 4174, 4173, 1, 0, 0, 0, 4174, 4175, 1, 0, 0, 0, 4175, 4177, 1, 0, 0, 0, 4176, 4178, 3, 820, 410, 0, 4177, 4176, 1, 0, 0, 0, 4177, 4178, 1, 0, 0, 0, 4178, 4180, 1, 0, 0, 0, 4179, 4156, 1, 0, 0, 0, 4179, 4163, 1, 0, 0, 0, 4179, 4170, 1, 0, 0, 0, 4180, 277, 1, 0, 0, 0, 4181, 4182, 5, 101, 0, 0, 4182, 4183, 3, 1892, 946, 0, 4183, 279, 1, 0, 0, 0, 4184, 4185, 5, 106, 0, 0, 4185, 4189, 3, 128, 64, 0, 4186, 4187, 5, 377, 0, 0, 4187, 4189, 5, 274, 0, 0, 4188, 4184, 1, 0, 0, 0, 4188, 4186, 1, 0, 0, 0, 4189, 281, 1, 0, 0, 0, 4190, 4191, 5, 80, 0, 0, 4191, 4197, 5, 163, 0, 0, 4192, 4198, 5, 195, 0, 0, 4193, 4194, 5, 186, 0, 0, 4194, 4198, 5, 318, 0, 0, 4195, 4196, 5, 290, 0, 0, 4196, 4198, 5, 318, 0, 0, 4197, 4192, 1, 0, 0, 0, 4197, 4193, 1, 0, 0, 0, 4197, 4195, 1, 0, 0, 0, 4198, 283, 1, 0, 0, 0, 4199, 4200, 5, 349, 0, 0, 4200, 4201, 3, 1892, 946, 0, 4201, 285, 1, 0, 0, 0, 4202, 4204, 3, 288, 144, 0, 4203, 4202, 1, 0, 0, 0, 4204, 4205, 1, 0, 0, 0, 4205, 4203, 1, 0, 0, 0, 4205, 4206, 1, 0, 0, 0, 4206, 287, 1, 0, 0, 0, 4207, 4208, 5, 839, 0, 0, 4208, 4220, 7, 27, 0, 0, 4209, 4210, 5, 838, 0, 0, 4210, 4220, 7, 19, 0, 0, 4211, 4212, 5, 836, 0, 0, 4212, 4213, 5, 2, 0, 0, 4213, 4214, 3, 1924, 962, 0, 4214, 4215, 5, 3, 0, 0, 4215, 4220, 1, 0, 0, 0, 4216, 4220, 3, 290, 145, 0, 4217, 4218, 5, 835, 0, 0, 4218, 4220, 5, 420, 0, 0, 4219, 4207, 1, 0, 0, 0, 4219, 4209, 1, 0, 0, 0, 4219, 4211, 1, 0, 0, 0, 4219, 4216, 1, 0, 0, 0, 4219, 4217, 1, 0, 0, 0, 4220, 289, 1, 0, 0, 0, 4221, 4223, 3, 292, 146, 0, 4222, 4221, 1, 0, 0, 0, 4222, 4223, 1, 0, 0, 0, 4223, 4224, 1, 0, 0, 0, 4224, 4225, 5, 837, 0, 0, 4225, 4226, 5, 2, 0, 0, 4226, 4227, 3, 246, 123, 0, 4227, 4228, 5, 3, 0, 0, 4228, 291, 1, 0, 0, 0, 4229, 4230, 7, 20, 0, 0, 4230, 293, 1, 0, 0, 0, 4231, 4232, 5, 101, 0, 0, 4232, 4233, 5, 230, 0, 0, 4233, 4234, 5, 349, 0, 0, 4234, 4235, 3, 1892, 946, 0, 4235, 295, 1, 0, 0, 0, 4236, 4237, 5, 101, 0, 0, 4237, 4238, 5, 230, 0, 0, 4238, 4239, 3, 1892, 946, 0, 4239, 297, 1, 0, 0, 0, 4240, 4241, 5, 46, 0, 0, 4241, 4245, 5, 340, 0, 0, 4242, 4243, 5, 224, 0, 0, 4243, 4244, 5, 77, 0, 0, 4244, 4246, 5, 558, 0, 0, 4245, 4242, 1, 0, 0, 0, 4245, 4246, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4249, 3, 566, 283, 0, 4248, 4250, 3, 1404, 702, 0, 4249, 4248, 1, 0, 0, 0, 4249, 4250, 1, 0, 0, 0, 4250, 4251, 1, 0, 0, 0, 4251, 4252, 5, 80, 0, 0, 4252, 4253, 3, 1830, 915, 0, 4253, 4254, 5, 64, 0, 0, 4254, 4255, 3, 1600, 800, 0, 4255, 299, 1, 0, 0, 0, 4256, 4257, 5, 140, 0, 0, 4257, 4260, 5, 340, 0, 0, 4258, 4259, 5, 224, 0, 0, 4259, 4261, 5, 558, 0, 0, 4260, 4258, 1, 0, 0, 0, 4260, 4261, 1, 0, 0, 0, 4261, 4262, 1, 0, 0, 0, 4262, 4263, 3, 566, 283, 0, 4263, 4264, 5, 331, 0, 0, 4264, 4265, 5, 340, 0, 0, 4265, 4266, 3, 1916, 958, 0, 4266, 301, 1, 0, 0, 0, 4267, 4269, 5, 46, 0, 0, 4268, 4270, 3, 198, 99, 0, 4269, 4268, 1, 0, 0, 0, 4269, 4270, 1, 0, 0, 0, 4270, 4271, 1, 0, 0, 0, 4271, 4272, 5, 93, 0, 0, 4272, 4273, 3, 304, 152, 0, 4273, 4274, 5, 36, 0, 0, 4274, 4275, 3, 1496, 748, 0, 4275, 303, 1, 0, 0, 0, 4276, 4278, 3, 1040, 520, 0, 4277, 4279, 3, 244, 122, 0, 4278, 4277, 1, 0, 0, 0, 4278, 4279, 1, 0, 0, 0, 4279, 4281, 1, 0, 0, 0, 4280, 4282, 3, 306, 153, 0, 4281, 4280, 1, 0, 0, 0, 4281, 4282, 1, 0, 0, 0, 4282, 305, 1, 0, 0, 0, 4283, 4287, 3, 310, 155, 0, 4284, 4286, 3, 196, 98, 0, 4285, 4284, 1, 0, 0, 0, 4286, 4289, 1, 0, 0, 0, 4287, 4285, 1, 0, 0, 0, 4287, 4288, 1, 0, 0, 0, 4288, 4305, 1, 0, 0, 0, 4289, 4287, 1, 0, 0, 0, 4290, 4292, 3, 196, 98, 0, 4291, 4290, 1, 0, 0, 0, 4292, 4293, 1, 0, 0, 0, 4293, 4291, 1, 0, 0, 0, 4293, 4294, 1, 0, 0, 0, 4294, 4296, 1, 0, 0, 0, 4295, 4297, 3, 310, 155, 0, 4296, 4295, 1, 0, 0, 0, 4296, 4297, 1, 0, 0, 0, 4297, 4301, 1, 0, 0, 0, 4298, 4300, 3, 196, 98, 0, 4299, 4298, 1, 0, 0, 0, 4300, 4303, 1, 0, 0, 0, 4301, 4299, 1, 0, 0, 0, 4301, 4302, 1, 0, 0, 0, 4302, 4305, 1, 0, 0, 0, 4303, 4301, 1, 0, 0, 0, 4304, 4283, 1, 0, 0, 0, 4304, 4291, 1, 0, 0, 0, 4305, 307, 1, 0, 0, 0, 4306, 4307, 5, 838, 0, 0, 4307, 4322, 7, 19, 0, 0, 4308, 4309, 5, 836, 0, 0, 4309, 4310, 5, 2, 0, 0, 4310, 4311, 3, 1924, 962, 0, 4311, 4312, 5, 3, 0, 0, 4312, 4322, 1, 0, 0, 0, 4313, 4315, 7, 20, 0, 0, 4314, 4313, 1, 0, 0, 0, 4314, 4315, 1, 0, 0, 0, 4315, 4316, 1, 0, 0, 0, 4316, 4317, 5, 837, 0, 0, 4317, 4318, 5, 2, 0, 0, 4318, 4319, 3, 246, 123, 0, 4319, 4320, 5, 3, 0, 0, 4320, 4322, 1, 0, 0, 0, 4321, 4306, 1, 0, 0, 0, 4321, 4308, 1, 0, 0, 0, 4321, 4314, 1, 0, 0, 0, 4322, 309, 1, 0, 0, 0, 4323, 4324, 5, 839, 0, 0, 4324, 4325, 7, 27, 0, 0, 4325, 311, 1, 0, 0, 0, 4326, 4330, 5, 106, 0, 0, 4327, 4331, 5, 177, 0, 0, 4328, 4329, 5, 266, 0, 0, 4329, 4331, 5, 177, 0, 0, 4330, 4327, 1, 0, 0, 0, 4330, 4328, 1, 0, 0, 0, 4331, 313, 1, 0, 0, 0, 4332, 4333, 5, 46, 0, 0, 4333, 4334, 5, 255, 0, 0, 4334, 4335, 5, 374, 0, 0, 4335, 4337, 3, 1888, 944, 0, 4336, 4338, 3, 310, 155, 0, 4337, 4336, 1, 0, 0, 0, 4337, 4338, 1, 0, 0, 0, 4338, 4342, 1, 0, 0, 0, 4339, 4341, 3, 196, 98, 0, 4340, 4339, 1, 0, 0, 0, 4341, 4344, 1, 0, 0, 0, 4342, 4340, 1, 0, 0, 0, 4342, 4343, 1, 0, 0, 0, 4343, 4346, 1, 0, 0, 0, 4344, 4342, 1, 0, 0, 0, 4345, 4347, 3, 316, 158, 0, 4346, 4345, 1, 0, 0, 0, 4346, 4347, 1, 0, 0, 0, 4347, 4348, 1, 0, 0, 0, 4348, 4349, 5, 36, 0, 0, 4349, 4350, 3, 1496, 748, 0, 4350, 315, 1, 0, 0, 0, 4351, 4352, 5, 420, 0, 0, 4352, 4353, 5, 303, 0, 0, 4353, 4354, 7, 27, 0, 0, 4354, 317, 1, 0, 0, 0, 4355, 4356, 5, 303, 0, 0, 4356, 4357, 5, 255, 0, 0, 4357, 4359, 5, 374, 0, 0, 4358, 4360, 3, 802, 401, 0, 4359, 4358, 1, 0, 0, 0, 4359, 4360, 1, 0, 0, 0, 4360, 4361, 1, 0, 0, 0, 4361, 4363, 3, 1888, 944, 0, 4362, 4364, 3, 312, 156, 0, 4363, 4362, 1, 0, 0, 0, 4363, 4364, 1, 0, 0, 0, 4364, 4366, 1, 0, 0, 0, 4365, 4367, 7, 12, 0, 0, 4366, 4365, 1, 0, 0, 0, 4366, 4367, 1, 0, 0, 0, 4367, 319, 1, 0, 0, 0, 4368, 4370, 5, 46, 0, 0, 4369, 4371, 3, 198, 99, 0, 4370, 4369, 1, 0, 0, 0, 4370, 4371, 1, 0, 0, 0, 4371, 4372, 1, 0, 0, 0, 4372, 4376, 5, 326, 0, 0, 4373, 4374, 5, 224, 0, 0, 4374, 4375, 5, 77, 0, 0, 4375, 4377, 5, 558, 0, 0, 4376, 4373, 1, 0, 0, 0, 4376, 4377, 1, 0, 0, 0, 4377, 4378, 1, 0, 0, 0, 4378, 4380, 3, 1888, 944, 0, 4379, 4381, 3, 324, 162, 0, 4380, 4379, 1, 0, 0, 0, 4380, 4381, 1, 0, 0, 0, 4381, 321, 1, 0, 0, 0, 4382, 4383, 5, 140, 0, 0, 4383, 4386, 5, 326, 0, 0, 4384, 4385, 5, 224, 0, 0, 4385, 4387, 5, 558, 0, 0, 4386, 4384, 1, 0, 0, 0, 4386, 4387, 1, 0, 0, 0, 4387, 4388, 1, 0, 0, 0, 4388, 4389, 3, 1888, 944, 0, 4389, 4390, 3, 328, 164, 0, 4390, 323, 1, 0, 0, 0, 4391, 4392, 3, 328, 164, 0, 4392, 325, 1, 0, 0, 0, 4393, 4394, 5, 2, 0, 0, 4394, 4395, 3, 328, 164, 0, 4395, 4396, 5, 3, 0, 0, 4396, 327, 1, 0, 0, 0, 4397, 4399, 3, 330, 165, 0, 4398, 4397, 1, 0, 0, 0, 4399, 4400, 1, 0, 0, 0, 4400, 4398, 1, 0, 0, 0, 4400, 4401, 1, 0, 0, 0, 4401, 329, 1, 0, 0, 0, 4402, 4403, 5, 36, 0, 0, 4403, 4439, 3, 1666, 833, 0, 4404, 4405, 5, 150, 0, 0, 4405, 4439, 3, 334, 167, 0, 4406, 4439, 5, 176, 0, 0, 4407, 4409, 5, 229, 0, 0, 4408, 4410, 3, 332, 166, 0, 4409, 4408, 1, 0, 0, 0, 4409, 4410, 1, 0, 0, 0, 4410, 4411, 1, 0, 0, 0, 4411, 4439, 3, 334, 167, 0, 4412, 4439, 5, 609, 0, 0, 4413, 4414, 5, 256, 0, 0, 4414, 4439, 3, 334, 167, 0, 4415, 4416, 5, 259, 0, 0, 4416, 4439, 3, 334, 167, 0, 4417, 4418, 5, 266, 0, 0, 4418, 4439, 7, 28, 0, 0, 4419, 4420, 5, 278, 0, 0, 4420, 4421, 5, 149, 0, 0, 4421, 4439, 3, 566, 283, 0, 4422, 4423, 5, 326, 0, 0, 4423, 4424, 5, 263, 0, 0, 4424, 4439, 3, 566, 283, 0, 4425, 4427, 5, 338, 0, 0, 4426, 4428, 3, 16, 8, 0, 4427, 4426, 1, 0, 0, 0, 4427, 4428, 1, 0, 0, 0, 4428, 4429, 1, 0, 0, 0, 4429, 4439, 3, 334, 167, 0, 4430, 4432, 5, 312, 0, 0, 4431, 4433, 3, 16, 8, 0, 4432, 4431, 1, 0, 0, 0, 4432, 4433, 1, 0, 0, 0, 4433, 4435, 1, 0, 0, 0, 4434, 4436, 3, 334, 167, 0, 4435, 4434, 1, 0, 0, 0, 4435, 4436, 1, 0, 0, 0, 4436, 4439, 1, 0, 0, 0, 4437, 4439, 5, 365, 0, 0, 4438, 4402, 1, 0, 0, 0, 4438, 4404, 1, 0, 0, 0, 4438, 4406, 1, 0, 0, 0, 4438, 4407, 1, 0, 0, 0, 4438, 4412, 1, 0, 0, 0, 4438, 4413, 1, 0, 0, 0, 4438, 4415, 1, 0, 0, 0, 4438, 4417, 1, 0, 0, 0, 4438, 4419, 1, 0, 0, 0, 4438, 4422, 1, 0, 0, 0, 4438, 4425, 1, 0, 0, 0, 4438, 4430, 1, 0, 0, 0, 4438, 4437, 1, 0, 0, 0, 4439, 331, 1, 0, 0, 0, 4440, 4441, 5, 149, 0, 0, 4441, 333, 1, 0, 0, 0, 4442, 4449, 3, 1906, 953, 0, 4443, 4444, 5, 12, 0, 0, 4444, 4449, 3, 1906, 953, 0, 4445, 4446, 5, 13, 0, 0, 4446, 4449, 3, 1906, 953, 0, 4447, 4449, 3, 1916, 958, 0, 4448, 4442, 1, 0, 0, 0, 4448, 4443, 1, 0, 0, 0, 4448, 4445, 1, 0, 0, 0, 4448, 4447, 1, 0, 0, 0, 4449, 335, 1, 0, 0, 0, 4450, 4455, 3, 334, 167, 0, 4451, 4452, 5, 6, 0, 0, 4452, 4454, 3, 334, 167, 0, 4453, 4451, 1, 0, 0, 0, 4454, 4457, 1, 0, 0, 0, 4455, 4453, 1, 0, 0, 0, 4455, 4456, 1, 0, 0, 0, 4456, 337, 1, 0, 0, 0, 4457, 4455, 1, 0, 0, 0, 4458, 4460, 5, 46, 0, 0, 4459, 4461, 3, 832, 416, 0, 4460, 4459, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, 4463, 1, 0, 0, 0, 4462, 4464, 3, 340, 170, 0, 4463, 4462, 1, 0, 0, 0, 4463, 4464, 1, 0, 0, 0, 4464, 4466, 1, 0, 0, 0, 4465, 4467, 3, 350, 175, 0, 4466, 4465, 1, 0, 0, 0, 4466, 4467, 1, 0, 0, 0, 4467, 4468, 1, 0, 0, 0, 4468, 4469, 5, 242, 0, 0, 4469, 4478, 3, 1892, 946, 0, 4470, 4471, 5, 219, 0, 0, 4471, 4473, 3, 342, 171, 0, 4472, 4474, 3, 344, 172, 0, 4473, 4472, 1, 0, 0, 0, 4473, 4474, 1, 0, 0, 0, 4474, 4476, 1, 0, 0, 0, 4475, 4477, 3, 348, 174, 0, 4476, 4475, 1, 0, 0, 0, 4476, 4477, 1, 0, 0, 0, 4477, 4479, 1, 0, 0, 0, 4478, 4470, 1, 0, 0, 0, 4478, 4479, 1, 0, 0, 0, 4479, 339, 1, 0, 0, 0, 4480, 4481, 5, 357, 0, 0, 4481, 341, 1, 0, 0, 0, 4482, 4484, 3, 1892, 946, 0, 4483, 4485, 3, 568, 284, 0, 4484, 4483, 1, 0, 0, 0, 4484, 4485, 1, 0, 0, 0, 4485, 343, 1, 0, 0, 0, 4486, 4487, 5, 234, 0, 0, 4487, 4488, 3, 342, 171, 0, 4488, 345, 1, 0, 0, 0, 4489, 4490, 5, 371, 0, 0, 4490, 4494, 3, 342, 171, 0, 4491, 4492, 5, 266, 0, 0, 4492, 4494, 5, 371, 0, 0, 4493, 4489, 1, 0, 0, 0, 4493, 4491, 1, 0, 0, 0, 4494, 347, 1, 0, 0, 0, 4495, 4496, 3, 346, 173, 0, 4496, 349, 1, 0, 0, 0, 4497, 4498, 5, 293, 0, 0, 4498, 351, 1, 0, 0, 0, 4499, 4500, 5, 46, 0, 0, 4500, 4501, 5, 349, 0, 0, 4501, 4503, 3, 1892, 946, 0, 4502, 4504, 3, 354, 177, 0, 4503, 4502, 1, 0, 0, 0, 4503, 4504, 1, 0, 0, 0, 4504, 4505, 1, 0, 0, 0, 4505, 4506, 5, 250, 0, 0, 4506, 4508, 3, 1910, 955, 0, 4507, 4509, 3, 130, 65, 0, 4508, 4507, 1, 0, 0, 0, 4508, 4509, 1, 0, 0, 0, 4509, 353, 1, 0, 0, 0, 4510, 4511, 5, 279, 0, 0, 4511, 4512, 3, 1920, 960, 0, 4512, 355, 1, 0, 0, 0, 4513, 4514, 5, 195, 0, 0, 4514, 4517, 5, 349, 0, 0, 4515, 4516, 5, 224, 0, 0, 4516, 4518, 5, 558, 0, 0, 4517, 4515, 1, 0, 0, 0, 4517, 4518, 1, 0, 0, 0, 4518, 4519, 1, 0, 0, 0, 4519, 4520, 3, 1892, 946, 0, 4520, 357, 1, 0, 0, 0, 4521, 4522, 5, 46, 0, 0, 4522, 4526, 5, 208, 0, 0, 4523, 4524, 5, 224, 0, 0, 4524, 4525, 5, 77, 0, 0, 4525, 4527, 5, 558, 0, 0, 4526, 4523, 1, 0, 0, 0, 4526, 4527, 1, 0, 0, 0, 4527, 4528, 1, 0, 0, 0, 4528, 4530, 3, 1892, 946, 0, 4529, 4531, 3, 16, 8, 0, 4530, 4529, 1, 0, 0, 0, 4530, 4531, 1, 0, 0, 0, 4531, 4532, 1, 0, 0, 0, 4532, 4533, 3, 360, 180, 0, 4533, 359, 1, 0, 0, 0, 4534, 4536, 3, 362, 181, 0, 4535, 4534, 1, 0, 0, 0, 4536, 4539, 1, 0, 0, 0, 4537, 4535, 1, 0, 0, 0, 4537, 4538, 1, 0, 0, 0, 4538, 361, 1, 0, 0, 0, 4539, 4537, 1, 0, 0, 0, 4540, 4541, 5, 321, 0, 0, 4541, 4548, 3, 1892, 946, 0, 4542, 4543, 5, 373, 0, 0, 4543, 4548, 3, 82, 41, 0, 4544, 4545, 5, 64, 0, 0, 4545, 4548, 3, 82, 41, 0, 4546, 4548, 5, 152, 0, 0, 4547, 4540, 1, 0, 0, 0, 4547, 4542, 1, 0, 0, 0, 4547, 4544, 1, 0, 0, 0, 4547, 4546, 1, 0, 0, 0, 4548, 363, 1, 0, 0, 0, 4549, 4550, 5, 140, 0, 0, 4550, 4551, 5, 208, 0, 0, 4551, 4552, 3, 1892, 946, 0, 4552, 4553, 5, 367, 0, 0, 4553, 4554, 3, 366, 183, 0, 4554, 365, 1, 0, 0, 0, 4555, 4557, 3, 368, 184, 0, 4556, 4555, 1, 0, 0, 0, 4557, 4560, 1, 0, 0, 0, 4558, 4556, 1, 0, 0, 0, 4558, 4559, 1, 0, 0, 0, 4559, 367, 1, 0, 0, 0, 4560, 4558, 1, 0, 0, 0, 4561, 4562, 5, 95, 0, 0, 4562, 4563, 3, 82, 41, 0, 4563, 369, 1, 0, 0, 0, 4564, 4565, 5, 140, 0, 0, 4565, 4566, 5, 208, 0, 0, 4566, 4567, 3, 1892, 946, 0, 4567, 4568, 3, 48, 24, 0, 4568, 4569, 3, 558, 279, 0, 4569, 4570, 3, 1892, 946, 0, 4570, 4669, 1, 0, 0, 0, 4571, 4572, 5, 140, 0, 0, 4572, 4573, 5, 208, 0, 0, 4573, 4574, 3, 1892, 946, 0, 4574, 4575, 3, 48, 24, 0, 4575, 4576, 3, 556, 278, 0, 4576, 4577, 3, 566, 283, 0, 4577, 4669, 1, 0, 0, 0, 4578, 4579, 5, 140, 0, 0, 4579, 4580, 5, 208, 0, 0, 4580, 4581, 3, 1892, 946, 0, 4581, 4582, 3, 48, 24, 0, 4582, 4583, 5, 138, 0, 0, 4583, 4584, 3, 868, 434, 0, 4584, 4669, 1, 0, 0, 0, 4585, 4586, 5, 140, 0, 0, 4586, 4587, 5, 208, 0, 0, 4587, 4588, 3, 1892, 946, 0, 4588, 4589, 3, 48, 24, 0, 4589, 4590, 5, 41, 0, 0, 4590, 4591, 5, 2, 0, 0, 4591, 4592, 3, 1662, 831, 0, 4592, 4593, 5, 36, 0, 0, 4593, 4594, 3, 1662, 831, 0, 4594, 4595, 5, 3, 0, 0, 4595, 4669, 1, 0, 0, 0, 4596, 4597, 5, 140, 0, 0, 4597, 4598, 5, 208, 0, 0, 4598, 4599, 3, 1892, 946, 0, 4599, 4600, 3, 48, 24, 0, 4600, 4601, 5, 193, 0, 0, 4601, 4602, 3, 1662, 831, 0, 4602, 4669, 1, 0, 0, 0, 4603, 4604, 5, 140, 0, 0, 4604, 4605, 5, 208, 0, 0, 4605, 4606, 3, 1892, 946, 0, 4606, 4607, 3, 48, 24, 0, 4607, 4608, 5, 215, 0, 0, 4608, 4609, 3, 844, 422, 0, 4609, 4669, 1, 0, 0, 0, 4610, 4611, 5, 140, 0, 0, 4611, 4612, 5, 208, 0, 0, 4612, 4613, 3, 1892, 946, 0, 4613, 4614, 3, 48, 24, 0, 4614, 4615, 5, 275, 0, 0, 4615, 4616, 3, 908, 454, 0, 4616, 4669, 1, 0, 0, 0, 4617, 4618, 5, 140, 0, 0, 4618, 4619, 5, 208, 0, 0, 4619, 4620, 3, 1892, 946, 0, 4620, 4621, 3, 48, 24, 0, 4621, 4622, 5, 275, 0, 0, 4622, 4623, 5, 158, 0, 0, 4623, 4624, 3, 566, 283, 0, 4624, 4625, 5, 101, 0, 0, 4625, 4626, 3, 1892, 946, 0, 4626, 4669, 1, 0, 0, 0, 4627, 4628, 5, 140, 0, 0, 4628, 4629, 5, 208, 0, 0, 4629, 4630, 3, 1892, 946, 0, 4630, 4631, 3, 48, 24, 0, 4631, 4632, 5, 275, 0, 0, 4632, 4633, 5, 210, 0, 0, 4633, 4634, 3, 566, 283, 0, 4634, 4635, 5, 101, 0, 0, 4635, 4636, 3, 1892, 946, 0, 4636, 4669, 1, 0, 0, 0, 4637, 4638, 5, 140, 0, 0, 4638, 4639, 5, 208, 0, 0, 4639, 4640, 3, 1892, 946, 0, 4640, 4641, 3, 48, 24, 0, 4641, 4642, 5, 294, 0, 0, 4642, 4643, 3, 844, 422, 0, 4643, 4669, 1, 0, 0, 0, 4644, 4645, 5, 140, 0, 0, 4645, 4646, 5, 208, 0, 0, 4646, 4647, 3, 1892, 946, 0, 4647, 4648, 3, 48, 24, 0, 4648, 4649, 5, 640, 0, 0, 4649, 4650, 3, 844, 422, 0, 4650, 4669, 1, 0, 0, 0, 4651, 4652, 5, 140, 0, 0, 4652, 4653, 5, 208, 0, 0, 4653, 4654, 3, 1892, 946, 0, 4654, 4655, 3, 48, 24, 0, 4655, 4656, 5, 641, 0, 0, 4656, 4657, 5, 62, 0, 0, 4657, 4658, 3, 1662, 831, 0, 4658, 4659, 5, 242, 0, 0, 4659, 4660, 3, 1892, 946, 0, 4660, 4669, 1, 0, 0, 0, 4661, 4662, 5, 140, 0, 0, 4662, 4663, 5, 208, 0, 0, 4663, 4664, 3, 1892, 946, 0, 4664, 4665, 3, 48, 24, 0, 4665, 4666, 5, 358, 0, 0, 4666, 4667, 3, 1662, 831, 0, 4667, 4669, 1, 0, 0, 0, 4668, 4564, 1, 0, 0, 0, 4668, 4571, 1, 0, 0, 0, 4668, 4578, 1, 0, 0, 0, 4668, 4585, 1, 0, 0, 0, 4668, 4596, 1, 0, 0, 0, 4668, 4603, 1, 0, 0, 0, 4668, 4610, 1, 0, 0, 0, 4668, 4617, 1, 0, 0, 0, 4668, 4627, 1, 0, 0, 0, 4668, 4637, 1, 0, 0, 0, 4668, 4644, 1, 0, 0, 0, 4668, 4651, 1, 0, 0, 0, 4668, 4661, 1, 0, 0, 0, 4669, 371, 1, 0, 0, 0, 4670, 4671, 5, 46, 0, 0, 4671, 4672, 5, 63, 0, 0, 4672, 4673, 5, 177, 0, 0, 4673, 4674, 5, 379, 0, 0, 4674, 4676, 3, 1892, 946, 0, 4675, 4677, 3, 378, 189, 0, 4676, 4675, 1, 0, 0, 0, 4676, 4677, 1, 0, 0, 0, 4677, 4679, 1, 0, 0, 0, 4678, 4680, 3, 382, 191, 0, 4679, 4678, 1, 0, 0, 0, 4679, 4680, 1, 0, 0, 0, 4680, 373, 1, 0, 0, 0, 4681, 4682, 5, 219, 0, 0, 4682, 4690, 3, 342, 171, 0, 4683, 4684, 5, 266, 0, 0, 4684, 4690, 5, 219, 0, 0, 4685, 4686, 5, 371, 0, 0, 4686, 4690, 3, 342, 171, 0, 4687, 4688, 5, 266, 0, 0, 4688, 4690, 5, 371, 0, 0, 4689, 4681, 1, 0, 0, 0, 4689, 4683, 1, 0, 0, 0, 4689, 4685, 1, 0, 0, 0, 4689, 4687, 1, 0, 0, 0, 4690, 375, 1, 0, 0, 0, 4691, 4693, 3, 374, 187, 0, 4692, 4691, 1, 0, 0, 0, 4693, 4694, 1, 0, 0, 0, 4694, 4692, 1, 0, 0, 0, 4694, 4695, 1, 0, 0, 0, 4695, 377, 1, 0, 0, 0, 4696, 4697, 3, 376, 188, 0, 4697, 379, 1, 0, 0, 0, 4698, 4699, 5, 140, 0, 0, 4699, 4700, 5, 63, 0, 0, 4700, 4701, 5, 177, 0, 0, 4701, 4702, 5, 379, 0, 0, 4702, 4704, 3, 1892, 946, 0, 4703, 4705, 3, 378, 189, 0, 4704, 4703, 1, 0, 0, 0, 4704, 4705, 1, 0, 0, 0, 4705, 4706, 1, 0, 0, 0, 4706, 4707, 3, 386, 193, 0, 4707, 4716, 1, 0, 0, 0, 4708, 4709, 5, 140, 0, 0, 4709, 4710, 5, 63, 0, 0, 4710, 4711, 5, 177, 0, 0, 4711, 4712, 5, 379, 0, 0, 4712, 4713, 3, 1892, 946, 0, 4713, 4714, 3, 376, 188, 0, 4714, 4716, 1, 0, 0, 0, 4715, 4698, 1, 0, 0, 0, 4715, 4708, 1, 0, 0, 0, 4716, 381, 1, 0, 0, 0, 4717, 4718, 5, 277, 0, 0, 4718, 4719, 5, 2, 0, 0, 4719, 4720, 3, 384, 192, 0, 4720, 4721, 5, 3, 0, 0, 4721, 383, 1, 0, 0, 0, 4722, 4727, 3, 392, 196, 0, 4723, 4724, 5, 6, 0, 0, 4724, 4726, 3, 392, 196, 0, 4725, 4723, 1, 0, 0, 0, 4726, 4729, 1, 0, 0, 0, 4727, 4725, 1, 0, 0, 0, 4727, 4728, 1, 0, 0, 0, 4728, 385, 1, 0, 0, 0, 4729, 4727, 1, 0, 0, 0, 4730, 4731, 5, 277, 0, 0, 4731, 4732, 5, 2, 0, 0, 4732, 4733, 3, 388, 194, 0, 4733, 4734, 5, 3, 0, 0, 4734, 387, 1, 0, 0, 0, 4735, 4740, 3, 390, 195, 0, 4736, 4737, 5, 6, 0, 0, 4737, 4739, 3, 390, 195, 0, 4738, 4736, 1, 0, 0, 0, 4739, 4742, 1, 0, 0, 0, 4740, 4738, 1, 0, 0, 0, 4740, 4741, 1, 0, 0, 0, 4741, 389, 1, 0, 0, 0, 4742, 4740, 1, 0, 0, 0, 4743, 4751, 3, 392, 196, 0, 4744, 4745, 5, 331, 0, 0, 4745, 4751, 3, 392, 196, 0, 4746, 4747, 5, 135, 0, 0, 4747, 4751, 3, 392, 196, 0, 4748, 4749, 5, 195, 0, 0, 4749, 4751, 3, 394, 197, 0, 4750, 4743, 1, 0, 0, 0, 4750, 4744, 1, 0, 0, 0, 4750, 4746, 1, 0, 0, 0, 4750, 4748, 1, 0, 0, 0, 4751, 391, 1, 0, 0, 0, 4752, 4753, 3, 394, 197, 0, 4753, 4754, 3, 396, 198, 0, 4754, 393, 1, 0, 0, 0, 4755, 4756, 3, 1932, 966, 0, 4756, 395, 1, 0, 0, 0, 4757, 4758, 3, 1910, 955, 0, 4758, 397, 1, 0, 0, 0, 4759, 4760, 5, 46, 0, 0, 4760, 4761, 5, 329, 0, 0, 4761, 4763, 3, 1892, 946, 0, 4762, 4764, 3, 400, 200, 0, 4763, 4762, 1, 0, 0, 0, 4763, 4764, 1, 0, 0, 0, 4764, 4766, 1, 0, 0, 0, 4765, 4767, 3, 404, 202, 0, 4766, 4765, 1, 0, 0, 0, 4766, 4767, 1, 0, 0, 0, 4767, 4768, 1, 0, 0, 0, 4768, 4769, 5, 63, 0, 0, 4769, 4770, 5, 177, 0, 0, 4770, 4771, 5, 379, 0, 0, 4771, 4773, 3, 1892, 946, 0, 4772, 4774, 3, 382, 191, 0, 4773, 4772, 1, 0, 0, 0, 4773, 4774, 1, 0, 0, 0, 4774, 4795, 1, 0, 0, 0, 4775, 4776, 5, 46, 0, 0, 4776, 4777, 5, 329, 0, 0, 4777, 4778, 5, 224, 0, 0, 4778, 4779, 5, 77, 0, 0, 4779, 4780, 5, 558, 0, 0, 4780, 4782, 3, 1892, 946, 0, 4781, 4783, 3, 400, 200, 0, 4782, 4781, 1, 0, 0, 0, 4782, 4783, 1, 0, 0, 0, 4783, 4785, 1, 0, 0, 0, 4784, 4786, 3, 404, 202, 0, 4785, 4784, 1, 0, 0, 0, 4785, 4786, 1, 0, 0, 0, 4786, 4787, 1, 0, 0, 0, 4787, 4788, 5, 63, 0, 0, 4788, 4789, 5, 177, 0, 0, 4789, 4790, 5, 379, 0, 0, 4790, 4792, 3, 1892, 946, 0, 4791, 4793, 3, 382, 191, 0, 4792, 4791, 1, 0, 0, 0, 4792, 4793, 1, 0, 0, 0, 4793, 4795, 1, 0, 0, 0, 4794, 4759, 1, 0, 0, 0, 4794, 4775, 1, 0, 0, 0, 4795, 399, 1, 0, 0, 0, 4796, 4797, 5, 358, 0, 0, 4797, 4798, 3, 1910, 955, 0, 4798, 401, 1, 0, 0, 0, 4799, 4802, 5, 373, 0, 0, 4800, 4803, 3, 1910, 955, 0, 4801, 4803, 5, 78, 0, 0, 4802, 4800, 1, 0, 0, 0, 4802, 4801, 1, 0, 0, 0, 4803, 403, 1, 0, 0, 0, 4804, 4805, 3, 402, 201, 0, 4805, 405, 1, 0, 0, 0, 4806, 4807, 5, 140, 0, 0, 4807, 4808, 5, 329, 0, 0, 4808, 4814, 3, 1892, 946, 0, 4809, 4815, 3, 386, 193, 0, 4810, 4812, 3, 402, 201, 0, 4811, 4813, 3, 386, 193, 0, 4812, 4811, 1, 0, 0, 0, 4812, 4813, 1, 0, 0, 0, 4813, 4815, 1, 0, 0, 0, 4814, 4809, 1, 0, 0, 0, 4814, 4810, 1, 0, 0, 0, 4815, 407, 1, 0, 0, 0, 4816, 4817, 5, 46, 0, 0, 4817, 4818, 5, 63, 0, 0, 4818, 4819, 5, 93, 0, 0, 4819, 4820, 3, 1888, 944, 0, 4820, 4822, 5, 2, 0, 0, 4821, 4823, 3, 200, 100, 0, 4822, 4821, 1, 0, 0, 0, 4822, 4823, 1, 0, 0, 0, 4823, 4824, 1, 0, 0, 0, 4824, 4826, 5, 3, 0, 0, 4825, 4827, 3, 268, 134, 0, 4826, 4825, 1, 0, 0, 0, 4826, 4827, 1, 0, 0, 0, 4827, 4828, 1, 0, 0, 0, 4828, 4829, 5, 329, 0, 0, 4829, 4831, 3, 1892, 946, 0, 4830, 4832, 3, 382, 191, 0, 4831, 4830, 1, 0, 0, 0, 4831, 4832, 1, 0, 0, 0, 4832, 4889, 1, 0, 0, 0, 4833, 4834, 5, 46, 0, 0, 4834, 4835, 5, 63, 0, 0, 4835, 4836, 5, 93, 0, 0, 4836, 4837, 5, 224, 0, 0, 4837, 4838, 5, 77, 0, 0, 4838, 4839, 5, 558, 0, 0, 4839, 4840, 3, 1888, 944, 0, 4840, 4842, 5, 2, 0, 0, 4841, 4843, 3, 200, 100, 0, 4842, 4841, 1, 0, 0, 0, 4842, 4843, 1, 0, 0, 0, 4843, 4844, 1, 0, 0, 0, 4844, 4846, 5, 3, 0, 0, 4845, 4847, 3, 268, 134, 0, 4846, 4845, 1, 0, 0, 0, 4846, 4847, 1, 0, 0, 0, 4847, 4848, 1, 0, 0, 0, 4848, 4849, 5, 329, 0, 0, 4849, 4851, 3, 1892, 946, 0, 4850, 4852, 3, 382, 191, 0, 4851, 4850, 1, 0, 0, 0, 4851, 4852, 1, 0, 0, 0, 4852, 4889, 1, 0, 0, 0, 4853, 4854, 5, 46, 0, 0, 4854, 4855, 5, 63, 0, 0, 4855, 4856, 5, 93, 0, 0, 4856, 4857, 3, 1888, 944, 0, 4857, 4858, 5, 282, 0, 0, 4858, 4859, 5, 272, 0, 0, 4859, 4861, 3, 1888, 944, 0, 4860, 4862, 3, 202, 101, 0, 4861, 4860, 1, 0, 0, 0, 4861, 4862, 1, 0, 0, 0, 4862, 4863, 1, 0, 0, 0, 4863, 4864, 3, 140, 70, 0, 4864, 4865, 5, 329, 0, 0, 4865, 4867, 3, 1892, 946, 0, 4866, 4868, 3, 382, 191, 0, 4867, 4866, 1, 0, 0, 0, 4867, 4868, 1, 0, 0, 0, 4868, 4889, 1, 0, 0, 0, 4869, 4870, 5, 46, 0, 0, 4870, 4871, 5, 63, 0, 0, 4871, 4872, 5, 93, 0, 0, 4872, 4873, 5, 224, 0, 0, 4873, 4874, 5, 77, 0, 0, 4874, 4875, 5, 558, 0, 0, 4875, 4876, 3, 1888, 944, 0, 4876, 4877, 5, 282, 0, 0, 4877, 4878, 5, 272, 0, 0, 4878, 4880, 3, 1888, 944, 0, 4879, 4881, 3, 202, 101, 0, 4880, 4879, 1, 0, 0, 0, 4880, 4881, 1, 0, 0, 0, 4881, 4882, 1, 0, 0, 0, 4882, 4883, 3, 140, 70, 0, 4883, 4884, 5, 329, 0, 0, 4884, 4886, 3, 1892, 946, 0, 4885, 4887, 3, 382, 191, 0, 4886, 4885, 1, 0, 0, 0, 4886, 4887, 1, 0, 0, 0, 4887, 4889, 1, 0, 0, 0, 4888, 4816, 1, 0, 0, 0, 4888, 4833, 1, 0, 0, 0, 4888, 4853, 1, 0, 0, 0, 4888, 4869, 1, 0, 0, 0, 4889, 409, 1, 0, 0, 0, 4890, 4891, 5, 642, 0, 0, 4891, 4892, 5, 63, 0, 0, 4892, 4893, 5, 321, 0, 0, 4893, 4895, 3, 1892, 946, 0, 4894, 4896, 3, 414, 207, 0, 4895, 4894, 1, 0, 0, 0, 4895, 4896, 1, 0, 0, 0, 4896, 4897, 1, 0, 0, 0, 4897, 4898, 5, 64, 0, 0, 4898, 4899, 5, 329, 0, 0, 4899, 4900, 3, 1892, 946, 0, 4900, 4901, 5, 71, 0, 0, 4901, 4903, 3, 1892, 946, 0, 4902, 4904, 3, 382, 191, 0, 4903, 4902, 1, 0, 0, 0, 4903, 4904, 1, 0, 0, 0, 4904, 411, 1, 0, 0, 0, 4905, 4906, 5, 74, 0, 0, 4906, 4909, 5, 95, 0, 0, 4907, 4909, 5, 59, 0, 0, 4908, 4905, 1, 0, 0, 0, 4908, 4907, 1, 0, 0, 0, 4909, 413, 1, 0, 0, 0, 4910, 4911, 3, 412, 206, 0, 4911, 4912, 5, 2, 0, 0, 4912, 4913, 3, 1620, 810, 0, 4913, 4914, 5, 3, 0, 0, 4914, 415, 1, 0, 0, 0, 4915, 4916, 5, 46, 0, 0, 4916, 4917, 5, 100, 0, 0, 4917, 4918, 5, 252, 0, 0, 4918, 4919, 5, 62, 0, 0, 4919, 4920, 3, 418, 209, 0, 4920, 4921, 5, 329, 0, 0, 4921, 4923, 3, 1892, 946, 0, 4922, 4924, 3, 382, 191, 0, 4923, 4922, 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4939, 1, 0, 0, 0, 4925, 4926, 5, 46, 0, 0, 4926, 4927, 5, 100, 0, 0, 4927, 4928, 5, 252, 0, 0, 4928, 4929, 5, 224, 0, 0, 4929, 4930, 5, 77, 0, 0, 4930, 4931, 5, 558, 0, 0, 4931, 4932, 5, 62, 0, 0, 4932, 4933, 3, 418, 209, 0, 4933, 4934, 5, 329, 0, 0, 4934, 4936, 3, 1892, 946, 0, 4935, 4937, 3, 382, 191, 0, 4936, 4935, 1, 0, 0, 0, 4936, 4937, 1, 0, 0, 0, 4937, 4939, 1, 0, 0, 0, 4938, 4915, 1, 0, 0, 0, 4938, 4925, 1, 0, 0, 0, 4939, 417, 1, 0, 0, 0, 4940, 4943, 3, 1920, 960, 0, 4941, 4943, 5, 100, 0, 0, 4942, 4940, 1, 0, 0, 0, 4942, 4941, 1, 0, 0, 0, 4943, 419, 1, 0, 0, 0, 4944, 4945, 5, 195, 0, 0, 4945, 4946, 5, 100, 0, 0, 4946, 4947, 5, 252, 0, 0, 4947, 4948, 5, 62, 0, 0, 4948, 4949, 3, 418, 209, 0, 4949, 4950, 5, 329, 0, 0, 4950, 4951, 3, 1892, 946, 0, 4951, 4963, 1, 0, 0, 0, 4952, 4953, 5, 195, 0, 0, 4953, 4954, 5, 100, 0, 0, 4954, 4955, 5, 252, 0, 0, 4955, 4956, 5, 224, 0, 0, 4956, 4957, 5, 558, 0, 0, 4957, 4958, 5, 62, 0, 0, 4958, 4959, 3, 418, 209, 0, 4959, 4960, 5, 329, 0, 0, 4960, 4961, 3, 1892, 946, 0, 4961, 4963, 1, 0, 0, 0, 4962, 4944, 1, 0, 0, 0, 4962, 4952, 1, 0, 0, 0, 4963, 421, 1, 0, 0, 0, 4964, 4965, 5, 140, 0, 0, 4965, 4966, 5, 100, 0, 0, 4966, 4967, 5, 252, 0, 0, 4967, 4968, 5, 62, 0, 0, 4968, 4969, 3, 418, 209, 0, 4969, 4970, 5, 329, 0, 0, 4970, 4971, 3, 1892, 946, 0, 4971, 4972, 3, 386, 193, 0, 4972, 423, 1, 0, 0, 0, 4973, 4974, 5, 46, 0, 0, 4974, 4975, 5, 643, 0, 0, 4975, 4976, 3, 1892, 946, 0, 4976, 4977, 5, 80, 0, 0, 4977, 4979, 3, 1888, 944, 0, 4978, 4980, 3, 436, 218, 0, 4979, 4978, 1, 0, 0, 0, 4979, 4980, 1, 0, 0, 0, 4980, 4982, 1, 0, 0, 0, 4981, 4983, 3, 438, 219, 0, 4982, 4981, 1, 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 4985, 1, 0, 0, 0, 4984, 4986, 3, 432, 216, 0, 4985, 4984, 1, 0, 0, 0, 4985, 4986, 1, 0, 0, 0, 4986, 4988, 1, 0, 0, 0, 4987, 4989, 3, 428, 214, 0, 4988, 4987, 1, 0, 0, 0, 4988, 4989, 1, 0, 0, 0, 4989, 4991, 1, 0, 0, 0, 4990, 4992, 3, 430, 215, 0, 4991, 4990, 1, 0, 0, 0, 4991, 4992, 1, 0, 0, 0, 4992, 425, 1, 0, 0, 0, 4993, 4994, 5, 140, 0, 0, 4994, 4995, 5, 643, 0, 0, 4995, 4996, 3, 1892, 946, 0, 4996, 4997, 5, 80, 0, 0, 4997, 4999, 3, 1888, 944, 0, 4998, 5000, 3, 434, 217, 0, 4999, 4998, 1, 0, 0, 0, 4999, 5000, 1, 0, 0, 0, 5000, 5002, 1, 0, 0, 0, 5001, 5003, 3, 428, 214, 0, 5002, 5001, 1, 0, 0, 0, 5002, 5003, 1, 0, 0, 0, 5003, 5005, 1, 0, 0, 0, 5004, 5006, 3, 430, 215, 0, 5005, 5004, 1, 0, 0, 0, 5005, 5006, 1, 0, 0, 0, 5006, 427, 1, 0, 0, 0, 5007, 5008, 5, 101, 0, 0, 5008, 5009, 5, 2, 0, 0, 5009, 5010, 3, 1710, 855, 0, 5010, 5011, 5, 3, 0, 0, 5011, 429, 1, 0, 0, 0, 5012, 5013, 5, 106, 0, 0, 5013, 5014, 5, 42, 0, 0, 5014, 5015, 5, 2, 0, 0, 5015, 5016, 3, 1710, 855, 0, 5016, 5017, 5, 3, 0, 0, 5017, 431, 1, 0, 0, 0, 5018, 5019, 5, 95, 0, 0, 5019, 5020, 3, 1922, 961, 0, 5020, 433, 1, 0, 0, 0, 5021, 5022, 5, 95, 0, 0, 5022, 5023, 3, 1922, 961, 0, 5023, 435, 1, 0, 0, 0, 5024, 5025, 5, 36, 0, 0, 5025, 5026, 3, 1934, 967, 0, 5026, 437, 1, 0, 0, 0, 5027, 5028, 5, 62, 0, 0, 5028, 5029, 3, 440, 220, 0, 5029, 439, 1, 0, 0, 0, 5030, 5031, 7, 29, 0, 0, 5031, 441, 1, 0, 0, 0, 5032, 5033, 5, 46, 0, 0, 5033, 5034, 5, 133, 0, 0, 5034, 5035, 5, 645, 0, 0, 5035, 5036, 3, 1892, 946, 0, 5036, 5037, 5, 358, 0, 0, 5037, 5038, 3, 444, 222, 0, 5038, 5039, 5, 219, 0, 0, 5039, 5040, 3, 342, 171, 0, 5040, 443, 1, 0, 0, 0, 5041, 5042, 7, 30, 0, 0, 5042, 445, 1, 0, 0, 0, 5043, 5044, 5, 46, 0, 0, 5044, 5045, 5, 355, 0, 0, 5045, 5046, 3, 1892, 946, 0, 5046, 5047, 3, 448, 224, 0, 5047, 5048, 3, 450, 225, 0, 5048, 5049, 5, 80, 0, 0, 5049, 5051, 3, 1888, 944, 0, 5050, 5052, 3, 454, 227, 0, 5051, 5050, 1, 0, 0, 0, 5051, 5052, 1, 0, 0, 0, 5052, 5054, 1, 0, 0, 0, 5053, 5055, 3, 466, 233, 0, 5054, 5053, 1, 0, 0, 0, 5054, 5055, 1, 0, 0, 0, 5055, 5057, 1, 0, 0, 0, 5056, 5058, 3, 472, 236, 0, 5057, 5056, 1, 0, 0, 0, 5057, 5058, 1, 0, 0, 0, 5058, 5059, 1, 0, 0, 0, 5059, 5060, 5, 206, 0, 0, 5060, 5061, 3, 474, 237, 0, 5061, 5062, 3, 1898, 949, 0, 5062, 5063, 5, 2, 0, 0, 5063, 5064, 3, 476, 238, 0, 5064, 5065, 5, 3, 0, 0, 5065, 5092, 1, 0, 0, 0, 5066, 5067, 5, 46, 0, 0, 5067, 5068, 5, 45, 0, 0, 5068, 5069, 5, 355, 0, 0, 5069, 5070, 3, 1892, 946, 0, 5070, 5071, 5, 137, 0, 0, 5071, 5072, 3, 450, 225, 0, 5072, 5073, 5, 80, 0, 0, 5073, 5075, 3, 1888, 944, 0, 5074, 5076, 3, 480, 240, 0, 5075, 5074, 1, 0, 0, 0, 5075, 5076, 1, 0, 0, 0, 5076, 5077, 1, 0, 0, 0, 5077, 5078, 3, 482, 241, 0, 5078, 5079, 5, 62, 0, 0, 5079, 5080, 5, 196, 0, 0, 5080, 5082, 5, 577, 0, 0, 5081, 5083, 3, 472, 236, 0, 5082, 5081, 1, 0, 0, 0, 5082, 5083, 1, 0, 0, 0, 5083, 5084, 1, 0, 0, 0, 5084, 5085, 5, 206, 0, 0, 5085, 5086, 3, 474, 237, 0, 5086, 5087, 3, 1898, 949, 0, 5087, 5088, 5, 2, 0, 0, 5088, 5089, 3, 476, 238, 0, 5089, 5090, 5, 3, 0, 0, 5090, 5092, 1, 0, 0, 0, 5091, 5043, 1, 0, 0, 0, 5091, 5066, 1, 0, 0, 0, 5092, 447, 1, 0, 0, 0, 5093, 5098, 5, 147, 0, 0, 5094, 5098, 5, 137, 0, 0, 5095, 5096, 5, 237, 0, 0, 5096, 5098, 5, 272, 0, 0, 5097, 5093, 1, 0, 0, 0, 5097, 5094, 1, 0, 0, 0, 5097, 5095, 1, 0, 0, 0, 5098, 449, 1, 0, 0, 0, 5099, 5104, 3, 452, 226, 0, 5100, 5101, 5, 82, 0, 0, 5101, 5103, 3, 452, 226, 0, 5102, 5100, 1, 0, 0, 0, 5103, 5106, 1, 0, 0, 0, 5104, 5102, 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 451, 1, 0, 0, 0, 5106, 5104, 1, 0, 0, 0, 5107, 5115, 5, 236, 0, 0, 5108, 5115, 5, 186, 0, 0, 5109, 5115, 5, 367, 0, 0, 5110, 5111, 5, 367, 0, 0, 5111, 5112, 5, 272, 0, 0, 5112, 5115, 3, 246, 123, 0, 5113, 5115, 5, 356, 0, 0, 5114, 5107, 1, 0, 0, 0, 5114, 5108, 1, 0, 0, 0, 5114, 5109, 1, 0, 0, 0, 5114, 5110, 1, 0, 0, 0, 5114, 5113, 1, 0, 0, 0, 5115, 453, 1, 0, 0, 0, 5116, 5117, 5, 646, 0, 0, 5117, 5118, 3, 456, 228, 0, 5118, 455, 1, 0, 0, 0, 5119, 5121, 3, 458, 229, 0, 5120, 5119, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, 0, 5122, 5120, 1, 0, 0, 0, 5122, 5123, 1, 0, 0, 0, 5123, 457, 1, 0, 0, 0, 5124, 5125, 3, 460, 230, 0, 5125, 5127, 3, 462, 231, 0, 5126, 5128, 3, 1366, 683, 0, 5127, 5126, 1, 0, 0, 0, 5127, 5128, 1, 0, 0, 0, 5128, 5129, 1, 0, 0, 0, 5129, 5130, 3, 464, 232, 0, 5130, 459, 1, 0, 0, 0, 5131, 5132, 7, 31, 0, 0, 5132, 461, 1, 0, 0, 0, 5133, 5134, 7, 32, 0, 0, 5134, 463, 1, 0, 0, 0, 5135, 5136, 3, 1924, 962, 0, 5136, 465, 1, 0, 0, 0, 5137, 5139, 5, 62, 0, 0, 5138, 5140, 3, 468, 234, 0, 5139, 5138, 1, 0, 0, 0, 5139, 5140, 1, 0, 0, 0, 5140, 5141, 1, 0, 0, 0, 5141, 5142, 3, 470, 235, 0, 5142, 467, 1, 0, 0, 0, 5143, 5144, 5, 196, 0, 0, 5144, 469, 1, 0, 0, 0, 5145, 5146, 7, 33, 0, 0, 5146, 471, 1, 0, 0, 0, 5147, 5148, 5, 103, 0, 0, 5148, 5149, 5, 2, 0, 0, 5149, 5150, 3, 1710, 855, 0, 5150, 5151, 5, 3, 0, 0, 5151, 473, 1, 0, 0, 0, 5152, 5153, 7, 34, 0, 0, 5153, 475, 1, 0, 0, 0, 5154, 5157, 3, 478, 239, 0, 5155, 5157, 1, 0, 0, 0, 5156, 5154, 1, 0, 0, 0, 5156, 5155, 1, 0, 0, 0, 5157, 5162, 1, 0, 0, 0, 5158, 5159, 5, 6, 0, 0, 5159, 5161, 3, 478, 239, 0, 5160, 5158, 1, 0, 0, 0, 5161, 5164, 1, 0, 0, 0, 5162, 5160, 1, 0, 0, 0, 5162, 5163, 1, 0, 0, 0, 5163, 477, 1, 0, 0, 0, 5164, 5162, 1, 0, 0, 0, 5165, 5170, 3, 1908, 954, 0, 5166, 5170, 3, 1906, 953, 0, 5167, 5170, 3, 1910, 955, 0, 5168, 5170, 3, 1932, 966, 0, 5169, 5165, 1, 0, 0, 0, 5169, 5166, 1, 0, 0, 0, 5169, 5167, 1, 0, 0, 0, 5169, 5168, 1, 0, 0, 0, 5170, 479, 1, 0, 0, 0, 5171, 5172, 5, 64, 0, 0, 5172, 5173, 3, 1888, 944, 0, 5173, 481, 1, 0, 0, 0, 5174, 5176, 3, 484, 242, 0, 5175, 5174, 1, 0, 0, 0, 5176, 5179, 1, 0, 0, 0, 5177, 5175, 1, 0, 0, 0, 5177, 5178, 1, 0, 0, 0, 5178, 483, 1, 0, 0, 0, 5179, 5177, 1, 0, 0, 0, 5180, 5181, 5, 77, 0, 0, 5181, 5192, 5, 54, 0, 0, 5182, 5192, 5, 54, 0, 0, 5183, 5184, 5, 69, 0, 0, 5184, 5192, 5, 225, 0, 0, 5185, 5186, 5, 69, 0, 0, 5186, 5192, 5, 184, 0, 0, 5187, 5188, 5, 77, 0, 0, 5188, 5192, 5, 369, 0, 0, 5189, 5190, 5, 266, 0, 0, 5190, 5192, 5, 232, 0, 0, 5191, 5180, 1, 0, 0, 0, 5191, 5182, 1, 0, 0, 0, 5191, 5183, 1, 0, 0, 0, 5191, 5185, 1, 0, 0, 0, 5191, 5187, 1, 0, 0, 0, 5191, 5189, 1, 0, 0, 0, 5192, 485, 1, 0, 0, 0, 5193, 5194, 5, 46, 0, 0, 5194, 5195, 5, 202, 0, 0, 5195, 5196, 5, 355, 0, 0, 5196, 5197, 3, 1892, 946, 0, 5197, 5198, 5, 80, 0, 0, 5198, 5199, 3, 1932, 966, 0, 5199, 5200, 5, 206, 0, 0, 5200, 5201, 3, 474, 237, 0, 5201, 5202, 3, 1898, 949, 0, 5202, 5203, 5, 2, 0, 0, 5203, 5204, 5, 3, 0, 0, 5204, 5220, 1, 0, 0, 0, 5205, 5206, 5, 46, 0, 0, 5206, 5207, 5, 202, 0, 0, 5207, 5208, 5, 355, 0, 0, 5208, 5209, 3, 1892, 946, 0, 5209, 5210, 5, 80, 0, 0, 5210, 5211, 3, 1932, 966, 0, 5211, 5212, 5, 103, 0, 0, 5212, 5213, 3, 488, 244, 0, 5213, 5214, 5, 206, 0, 0, 5214, 5215, 3, 474, 237, 0, 5215, 5216, 3, 1898, 949, 0, 5216, 5217, 5, 2, 0, 0, 5217, 5218, 5, 3, 0, 0, 5218, 5220, 1, 0, 0, 0, 5219, 5193, 1, 0, 0, 0, 5219, 5205, 1, 0, 0, 0, 5220, 487, 1, 0, 0, 0, 5221, 5226, 3, 490, 245, 0, 5222, 5223, 5, 33, 0, 0, 5223, 5225, 3, 490, 245, 0, 5224, 5222, 1, 0, 0, 0, 5225, 5228, 1, 0, 0, 0, 5226, 5224, 1, 0, 0, 0, 5226, 5227, 1, 0, 0, 0, 5227, 489, 1, 0, 0, 0, 5228, 5226, 1, 0, 0, 0, 5229, 5230, 3, 1924, 962, 0, 5230, 5231, 5, 68, 0, 0, 5231, 5232, 5, 2, 0, 0, 5232, 5233, 3, 492, 246, 0, 5233, 5234, 5, 3, 0, 0, 5234, 491, 1, 0, 0, 0, 5235, 5240, 3, 1910, 955, 0, 5236, 5237, 5, 6, 0, 0, 5237, 5239, 3, 1910, 955, 0, 5238, 5236, 1, 0, 0, 0, 5239, 5242, 1, 0, 0, 0, 5240, 5238, 1, 0, 0, 0, 5240, 5241, 1, 0, 0, 0, 5241, 493, 1, 0, 0, 0, 5242, 5240, 1, 0, 0, 0, 5243, 5244, 5, 140, 0, 0, 5244, 5245, 5, 202, 0, 0, 5245, 5246, 5, 355, 0, 0, 5246, 5247, 3, 1892, 946, 0, 5247, 5248, 3, 496, 248, 0, 5248, 495, 1, 0, 0, 0, 5249, 5256, 5, 197, 0, 0, 5250, 5251, 5, 197, 0, 0, 5251, 5256, 5, 310, 0, 0, 5252, 5253, 5, 197, 0, 0, 5253, 5256, 5, 141, 0, 0, 5254, 5256, 5, 190, 0, 0, 5255, 5249, 1, 0, 0, 0, 5255, 5250, 1, 0, 0, 0, 5255, 5252, 1, 0, 0, 0, 5255, 5254, 1, 0, 0, 0, 5256, 497, 1, 0, 0, 0, 5257, 5258, 5, 46, 0, 0, 5258, 5259, 5, 142, 0, 0, 5259, 5260, 3, 566, 283, 0, 5260, 5261, 5, 42, 0, 0, 5261, 5262, 5, 2, 0, 0, 5262, 5263, 3, 1710, 855, 0, 5263, 5264, 5, 3, 0, 0, 5264, 5265, 3, 482, 241, 0, 5265, 499, 1, 0, 0, 0, 5266, 5268, 5, 46, 0, 0, 5267, 5269, 3, 832, 416, 0, 5268, 5267, 1, 0, 0, 0, 5268, 5269, 1, 0, 0, 0, 5269, 5270, 1, 0, 0, 0, 5270, 5271, 5, 138, 0, 0, 5271, 5272, 3, 1898, 949, 0, 5272, 5273, 3, 864, 432, 0, 5273, 5274, 3, 502, 251, 0, 5274, 5381, 1, 0, 0, 0, 5275, 5277, 5, 46, 0, 0, 5276, 5278, 3, 832, 416, 0, 5277, 5276, 1, 0, 0, 0, 5277, 5278, 1, 0, 0, 0, 5278, 5279, 1, 0, 0, 0, 5279, 5280, 5, 138, 0, 0, 5280, 5281, 3, 1898, 949, 0, 5281, 5282, 3, 510, 255, 0, 5282, 5381, 1, 0, 0, 0, 5283, 5284, 5, 46, 0, 0, 5284, 5285, 5, 275, 0, 0, 5285, 5286, 3, 904, 452, 0, 5286, 5287, 3, 502, 251, 0, 5287, 5381, 1, 0, 0, 0, 5288, 5289, 5, 46, 0, 0, 5289, 5290, 5, 358, 0, 0, 5290, 5291, 3, 566, 283, 0, 5291, 5292, 3, 502, 251, 0, 5292, 5381, 1, 0, 0, 0, 5293, 5294, 5, 46, 0, 0, 5294, 5295, 5, 358, 0, 0, 5295, 5381, 3, 566, 283, 0, 5296, 5297, 5, 46, 0, 0, 5297, 5298, 5, 358, 0, 0, 5298, 5299, 3, 566, 283, 0, 5299, 5300, 5, 36, 0, 0, 5300, 5302, 5, 2, 0, 0, 5301, 5303, 3, 1642, 821, 0, 5302, 5301, 1, 0, 0, 0, 5302, 5303, 1, 0, 0, 0, 5303, 5304, 1, 0, 0, 0, 5304, 5305, 5, 3, 0, 0, 5305, 5381, 1, 0, 0, 0, 5306, 5307, 5, 46, 0, 0, 5307, 5308, 5, 358, 0, 0, 5308, 5309, 3, 566, 283, 0, 5309, 5310, 5, 36, 0, 0, 5310, 5311, 5, 200, 0, 0, 5311, 5313, 5, 2, 0, 0, 5312, 5314, 3, 516, 258, 0, 5313, 5312, 1, 0, 0, 0, 5313, 5314, 1, 0, 0, 0, 5314, 5315, 1, 0, 0, 0, 5315, 5316, 5, 3, 0, 0, 5316, 5381, 1, 0, 0, 0, 5317, 5318, 5, 46, 0, 0, 5318, 5319, 5, 358, 0, 0, 5319, 5320, 3, 566, 283, 0, 5320, 5321, 5, 36, 0, 0, 5321, 5322, 5, 297, 0, 0, 5322, 5323, 3, 502, 251, 0, 5323, 5381, 1, 0, 0, 0, 5324, 5325, 5, 46, 0, 0, 5325, 5326, 5, 353, 0, 0, 5326, 5327, 5, 323, 0, 0, 5327, 5328, 5, 280, 0, 0, 5328, 5329, 3, 566, 283, 0, 5329, 5330, 3, 502, 251, 0, 5330, 5381, 1, 0, 0, 0, 5331, 5332, 5, 46, 0, 0, 5332, 5333, 5, 353, 0, 0, 5333, 5334, 5, 323, 0, 0, 5334, 5335, 5, 189, 0, 0, 5335, 5336, 3, 566, 283, 0, 5336, 5337, 3, 502, 251, 0, 5337, 5381, 1, 0, 0, 0, 5338, 5339, 5, 46, 0, 0, 5339, 5340, 5, 353, 0, 0, 5340, 5341, 5, 323, 0, 0, 5341, 5342, 5, 351, 0, 0, 5342, 5343, 3, 566, 283, 0, 5343, 5344, 3, 502, 251, 0, 5344, 5381, 1, 0, 0, 0, 5345, 5346, 5, 46, 0, 0, 5346, 5347, 5, 353, 0, 0, 5347, 5348, 5, 323, 0, 0, 5348, 5349, 5, 165, 0, 0, 5349, 5350, 3, 566, 283, 0, 5350, 5351, 3, 502, 251, 0, 5351, 5381, 1, 0, 0, 0, 5352, 5353, 5, 46, 0, 0, 5353, 5354, 5, 110, 0, 0, 5354, 5355, 3, 566, 283, 0, 5355, 5356, 3, 502, 251, 0, 5356, 5381, 1, 0, 0, 0, 5357, 5358, 5, 46, 0, 0, 5358, 5359, 5, 110, 0, 0, 5359, 5360, 5, 224, 0, 0, 5360, 5361, 5, 77, 0, 0, 5361, 5362, 5, 558, 0, 0, 5362, 5363, 3, 566, 283, 0, 5363, 5364, 3, 502, 251, 0, 5364, 5381, 1, 0, 0, 0, 5365, 5366, 5, 46, 0, 0, 5366, 5367, 5, 110, 0, 0, 5367, 5368, 3, 566, 283, 0, 5368, 5369, 5, 64, 0, 0, 5369, 5370, 3, 566, 283, 0, 5370, 5381, 1, 0, 0, 0, 5371, 5372, 5, 46, 0, 0, 5372, 5373, 5, 110, 0, 0, 5373, 5374, 5, 224, 0, 0, 5374, 5375, 5, 77, 0, 0, 5375, 5376, 5, 558, 0, 0, 5376, 5377, 3, 566, 283, 0, 5377, 5378, 5, 64, 0, 0, 5378, 5379, 3, 566, 283, 0, 5379, 5381, 1, 0, 0, 0, 5380, 5266, 1, 0, 0, 0, 5380, 5275, 1, 0, 0, 0, 5380, 5283, 1, 0, 0, 0, 5380, 5288, 1, 0, 0, 0, 5380, 5293, 1, 0, 0, 0, 5380, 5296, 1, 0, 0, 0, 5380, 5306, 1, 0, 0, 0, 5380, 5317, 1, 0, 0, 0, 5380, 5324, 1, 0, 0, 0, 5380, 5331, 1, 0, 0, 0, 5380, 5338, 1, 0, 0, 0, 5380, 5345, 1, 0, 0, 0, 5380, 5352, 1, 0, 0, 0, 5380, 5357, 1, 0, 0, 0, 5380, 5365, 1, 0, 0, 0, 5380, 5371, 1, 0, 0, 0, 5381, 501, 1, 0, 0, 0, 5382, 5383, 5, 2, 0, 0, 5383, 5384, 3, 504, 252, 0, 5384, 5385, 5, 3, 0, 0, 5385, 503, 1, 0, 0, 0, 5386, 5391, 3, 506, 253, 0, 5387, 5388, 5, 6, 0, 0, 5388, 5390, 3, 506, 253, 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, 505, 1, 0, 0, 0, 5393, 5391, 1, 0, 0, 0, 5394, 5397, 3, 1932, 966, 0, 5395, 5396, 5, 10, 0, 0, 5396, 5398, 3, 508, 254, 0, 5397, 5395, 1, 0, 0, 0, 5397, 5398, 1, 0, 0, 0, 5398, 507, 1, 0, 0, 0, 5399, 5406, 3, 858, 429, 0, 5400, 5406, 3, 1944, 972, 0, 5401, 5406, 3, 1826, 913, 0, 5402, 5406, 3, 334, 167, 0, 5403, 5406, 3, 1910, 955, 0, 5404, 5406, 5, 569, 0, 0, 5405, 5399, 1, 0, 0, 0, 5405, 5400, 1, 0, 0, 0, 5405, 5401, 1, 0, 0, 0, 5405, 5402, 1, 0, 0, 0, 5405, 5403, 1, 0, 0, 0, 5405, 5404, 1, 0, 0, 0, 5406, 509, 1, 0, 0, 0, 5407, 5408, 5, 2, 0, 0, 5408, 5409, 3, 512, 256, 0, 5409, 5410, 5, 3, 0, 0, 5410, 511, 1, 0, 0, 0, 5411, 5416, 3, 514, 257, 0, 5412, 5413, 5, 6, 0, 0, 5413, 5415, 3, 514, 257, 0, 5414, 5412, 1, 0, 0, 0, 5415, 5418, 1, 0, 0, 0, 5416, 5414, 1, 0, 0, 0, 5416, 5417, 1, 0, 0, 0, 5417, 513, 1, 0, 0, 0, 5418, 5416, 1, 0, 0, 0, 5419, 5420, 3, 1934, 967, 0, 5420, 5421, 5, 10, 0, 0, 5421, 5422, 3, 508, 254, 0, 5422, 515, 1, 0, 0, 0, 5423, 5424, 3, 518, 259, 0, 5424, 517, 1, 0, 0, 0, 5425, 5430, 3, 1910, 955, 0, 5426, 5427, 5, 6, 0, 0, 5427, 5429, 3, 1910, 955, 0, 5428, 5426, 1, 0, 0, 0, 5429, 5432, 1, 0, 0, 0, 5430, 5428, 1, 0, 0, 0, 5430, 5431, 1, 0, 0, 0, 5431, 519, 1, 0, 0, 0, 5432, 5430, 1, 0, 0, 0, 5433, 5434, 5, 140, 0, 0, 5434, 5435, 5, 358, 0, 0, 5435, 5436, 3, 566, 283, 0, 5436, 5437, 5, 135, 0, 0, 5437, 5439, 5, 649, 0, 0, 5438, 5440, 3, 522, 261, 0, 5439, 5438, 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5441, 1, 0, 0, 0, 5441, 5442, 3, 1910, 955, 0, 5442, 5477, 1, 0, 0, 0, 5443, 5444, 5, 140, 0, 0, 5444, 5445, 5, 358, 0, 0, 5445, 5446, 3, 566, 283, 0, 5446, 5447, 5, 135, 0, 0, 5447, 5449, 5, 649, 0, 0, 5448, 5450, 3, 522, 261, 0, 5449, 5448, 1, 0, 0, 0, 5449, 5450, 1, 0, 0, 0, 5450, 5451, 1, 0, 0, 0, 5451, 5452, 3, 1910, 955, 0, 5452, 5453, 5, 147, 0, 0, 5453, 5454, 3, 1910, 955, 0, 5454, 5477, 1, 0, 0, 0, 5455, 5456, 5, 140, 0, 0, 5456, 5457, 5, 358, 0, 0, 5457, 5458, 3, 566, 283, 0, 5458, 5459, 5, 135, 0, 0, 5459, 5461, 5, 649, 0, 0, 5460, 5462, 3, 522, 261, 0, 5461, 5460, 1, 0, 0, 0, 5461, 5462, 1, 0, 0, 0, 5462, 5463, 1, 0, 0, 0, 5463, 5464, 3, 1910, 955, 0, 5464, 5465, 5, 137, 0, 0, 5465, 5466, 3, 1910, 955, 0, 5466, 5477, 1, 0, 0, 0, 5467, 5468, 5, 140, 0, 0, 5468, 5469, 5, 358, 0, 0, 5469, 5470, 3, 566, 283, 0, 5470, 5471, 5, 307, 0, 0, 5471, 5472, 5, 649, 0, 0, 5472, 5473, 3, 1910, 955, 0, 5473, 5474, 5, 95, 0, 0, 5474, 5475, 3, 1910, 955, 0, 5475, 5477, 1, 0, 0, 0, 5476, 5433, 1, 0, 0, 0, 5476, 5443, 1, 0, 0, 0, 5476, 5455, 1, 0, 0, 0, 5476, 5467, 1, 0, 0, 0, 5477, 521, 1, 0, 0, 0, 5478, 5479, 5, 224, 0, 0, 5479, 5480, 5, 77, 0, 0, 5480, 5481, 5, 558, 0, 0, 5481, 523, 1, 0, 0, 0, 5482, 5483, 5, 46, 0, 0, 5483, 5484, 5, 275, 0, 0, 5484, 5485, 5, 158, 0, 0, 5485, 5487, 3, 566, 283, 0, 5486, 5488, 3, 530, 265, 0, 5487, 5486, 1, 0, 0, 0, 5487, 5488, 1, 0, 0, 0, 5488, 5489, 1, 0, 0, 0, 5489, 5490, 5, 62, 0, 0, 5490, 5491, 5, 358, 0, 0, 5491, 5492, 3, 1662, 831, 0, 5492, 5493, 5, 101, 0, 0, 5493, 5495, 3, 1892, 946, 0, 5494, 5496, 3, 532, 266, 0, 5495, 5494, 1, 0, 0, 0, 5495, 5496, 1, 0, 0, 0, 5496, 5497, 1, 0, 0, 0, 5497, 5498, 5, 36, 0, 0, 5498, 5499, 3, 526, 263, 0, 5499, 525, 1, 0, 0, 0, 5500, 5505, 3, 528, 264, 0, 5501, 5502, 5, 6, 0, 0, 5502, 5504, 3, 528, 264, 0, 5503, 5501, 1, 0, 0, 0, 5504, 5507, 1, 0, 0, 0, 5505, 5503, 1, 0, 0, 0, 5505, 5506, 1, 0, 0, 0, 5506, 527, 1, 0, 0, 0, 5507, 5505, 1, 0, 0, 0, 5508, 5509, 5, 275, 0, 0, 5509, 5510, 3, 1908, 954, 0, 5510, 5512, 3, 904, 452, 0, 5511, 5513, 3, 534, 267, 0, 5512, 5511, 1, 0, 0, 0, 5512, 5513, 1, 0, 0, 0, 5513, 5515, 1, 0, 0, 0, 5514, 5516, 3, 536, 268, 0, 5515, 5514, 1, 0, 0, 0, 5515, 5516, 1, 0, 0, 0, 5516, 5540, 1, 0, 0, 0, 5517, 5518, 5, 275, 0, 0, 5518, 5519, 3, 1908, 954, 0, 5519, 5521, 3, 908, 454, 0, 5520, 5522, 3, 534, 267, 0, 5521, 5520, 1, 0, 0, 0, 5521, 5522, 1, 0, 0, 0, 5522, 5524, 1, 0, 0, 0, 5523, 5525, 3, 536, 268, 0, 5524, 5523, 1, 0, 0, 0, 5524, 5525, 1, 0, 0, 0, 5525, 5540, 1, 0, 0, 0, 5526, 5527, 5, 215, 0, 0, 5527, 5528, 3, 1908, 954, 0, 5528, 5529, 3, 844, 422, 0, 5529, 5540, 1, 0, 0, 0, 5530, 5531, 5, 215, 0, 0, 5531, 5532, 3, 1908, 954, 0, 5532, 5533, 5, 2, 0, 0, 5533, 5534, 3, 1836, 918, 0, 5534, 5535, 5, 3, 0, 0, 5535, 5536, 3, 844, 422, 0, 5536, 5540, 1, 0, 0, 0, 5537, 5538, 5, 343, 0, 0, 5538, 5540, 3, 1662, 831, 0, 5539, 5508, 1, 0, 0, 0, 5539, 5517, 1, 0, 0, 0, 5539, 5526, 1, 0, 0, 0, 5539, 5530, 1, 0, 0, 0, 5539, 5537, 1, 0, 0, 0, 5540, 529, 1, 0, 0, 0, 5541, 5542, 5, 53, 0, 0, 5542, 531, 1, 0, 0, 0, 5543, 5544, 5, 210, 0, 0, 5544, 5545, 3, 566, 283, 0, 5545, 533, 1, 0, 0, 0, 5546, 5547, 5, 62, 0, 0, 5547, 5553, 5, 323, 0, 0, 5548, 5549, 5, 62, 0, 0, 5549, 5550, 5, 83, 0, 0, 5550, 5551, 5, 149, 0, 0, 5551, 5553, 3, 566, 283, 0, 5552, 5546, 1, 0, 0, 0, 5552, 5548, 1, 0, 0, 0, 5553, 535, 1, 0, 0, 0, 5554, 5555, 5, 300, 0, 0, 5555, 537, 1, 0, 0, 0, 5556, 5557, 5, 46, 0, 0, 5557, 5558, 5, 275, 0, 0, 5558, 5559, 5, 210, 0, 0, 5559, 5560, 3, 566, 283, 0, 5560, 5561, 5, 101, 0, 0, 5561, 5562, 3, 1892, 946, 0, 5562, 539, 1, 0, 0, 0, 5563, 5564, 5, 140, 0, 0, 5564, 5565, 5, 275, 0, 0, 5565, 5566, 5, 210, 0, 0, 5566, 5567, 3, 566, 283, 0, 5567, 5568, 5, 101, 0, 0, 5568, 5569, 3, 1892, 946, 0, 5569, 5570, 5, 135, 0, 0, 5570, 5571, 3, 526, 263, 0, 5571, 5582, 1, 0, 0, 0, 5572, 5573, 5, 140, 0, 0, 5573, 5574, 5, 275, 0, 0, 5574, 5575, 5, 210, 0, 0, 5575, 5576, 3, 566, 283, 0, 5576, 5577, 5, 101, 0, 0, 5577, 5578, 3, 1892, 946, 0, 5578, 5579, 5, 195, 0, 0, 5579, 5580, 3, 542, 271, 0, 5580, 5582, 1, 0, 0, 0, 5581, 5563, 1, 0, 0, 0, 5581, 5572, 1, 0, 0, 0, 5582, 541, 1, 0, 0, 0, 5583, 5588, 3, 544, 272, 0, 5584, 5585, 5, 6, 0, 0, 5585, 5587, 3, 544, 272, 0, 5586, 5584, 1, 0, 0, 0, 5587, 5590, 1, 0, 0, 0, 5588, 5586, 1, 0, 0, 0, 5588, 5589, 1, 0, 0, 0, 5589, 543, 1, 0, 0, 0, 5590, 5588, 1, 0, 0, 0, 5591, 5592, 5, 275, 0, 0, 5592, 5593, 3, 1908, 954, 0, 5593, 5594, 5, 2, 0, 0, 5594, 5595, 3, 1836, 918, 0, 5595, 5596, 5, 3, 0, 0, 5596, 5604, 1, 0, 0, 0, 5597, 5598, 5, 215, 0, 0, 5598, 5599, 3, 1908, 954, 0, 5599, 5600, 5, 2, 0, 0, 5600, 5601, 3, 1836, 918, 0, 5601, 5602, 5, 3, 0, 0, 5602, 5604, 1, 0, 0, 0, 5603, 5591, 1, 0, 0, 0, 5603, 5597, 1, 0, 0, 0, 5604, 545, 1, 0, 0, 0, 5605, 5606, 5, 195, 0, 0, 5606, 5607, 5, 275, 0, 0, 5607, 5608, 5, 158, 0, 0, 5608, 5609, 3, 566, 283, 0, 5609, 5610, 5, 101, 0, 0, 5610, 5612, 3, 1892, 946, 0, 5611, 5613, 3, 120, 60, 0, 5612, 5611, 1, 0, 0, 0, 5612, 5613, 1, 0, 0, 0, 5613, 5626, 1, 0, 0, 0, 5614, 5615, 5, 195, 0, 0, 5615, 5616, 5, 275, 0, 0, 5616, 5617, 5, 158, 0, 0, 5617, 5618, 5, 224, 0, 0, 5618, 5619, 5, 558, 0, 0, 5619, 5620, 3, 566, 283, 0, 5620, 5621, 5, 101, 0, 0, 5621, 5623, 3, 1892, 946, 0, 5622, 5624, 3, 120, 60, 0, 5623, 5622, 1, 0, 0, 0, 5623, 5624, 1, 0, 0, 0, 5624, 5626, 1, 0, 0, 0, 5625, 5605, 1, 0, 0, 0, 5625, 5614, 1, 0, 0, 0, 5626, 547, 1, 0, 0, 0, 5627, 5628, 5, 195, 0, 0, 5628, 5629, 5, 275, 0, 0, 5629, 5630, 5, 210, 0, 0, 5630, 5631, 3, 566, 283, 0, 5631, 5632, 5, 101, 0, 0, 5632, 5634, 3, 1892, 946, 0, 5633, 5635, 3, 120, 60, 0, 5634, 5633, 1, 0, 0, 0, 5634, 5635, 1, 0, 0, 0, 5635, 5648, 1, 0, 0, 0, 5636, 5637, 5, 195, 0, 0, 5637, 5638, 5, 275, 0, 0, 5638, 5639, 5, 210, 0, 0, 5639, 5640, 5, 224, 0, 0, 5640, 5641, 5, 558, 0, 0, 5641, 5642, 3, 566, 283, 0, 5642, 5643, 5, 101, 0, 0, 5643, 5645, 3, 1892, 946, 0, 5644, 5646, 3, 120, 60, 0, 5645, 5644, 1, 0, 0, 0, 5645, 5646, 1, 0, 0, 0, 5646, 5648, 1, 0, 0, 0, 5647, 5627, 1, 0, 0, 0, 5647, 5636, 1, 0, 0, 0, 5648, 549, 1, 0, 0, 0, 5649, 5650, 5, 195, 0, 0, 5650, 5651, 5, 278, 0, 0, 5651, 5652, 5, 149, 0, 0, 5652, 5654, 3, 1922, 961, 0, 5653, 5655, 3, 120, 60, 0, 5654, 5653, 1, 0, 0, 0, 5654, 5655, 1, 0, 0, 0, 5655, 551, 1, 0, 0, 0, 5656, 5657, 5, 299, 0, 0, 5657, 5658, 5, 278, 0, 0, 5658, 5659, 5, 149, 0, 0, 5659, 5660, 3, 1922, 961, 0, 5660, 5661, 5, 95, 0, 0, 5661, 5662, 3, 1920, 960, 0, 5662, 553, 1, 0, 0, 0, 5663, 5664, 5, 195, 0, 0, 5664, 5665, 3, 556, 278, 0, 5665, 5666, 5, 224, 0, 0, 5666, 5667, 5, 558, 0, 0, 5667, 5669, 3, 564, 282, 0, 5668, 5670, 3, 120, 60, 0, 5669, 5668, 1, 0, 0, 0, 5669, 5670, 1, 0, 0, 0, 5670, 5754, 1, 0, 0, 0, 5671, 5672, 5, 195, 0, 0, 5672, 5673, 3, 556, 278, 0, 5673, 5675, 3, 564, 282, 0, 5674, 5676, 3, 120, 60, 0, 5675, 5674, 1, 0, 0, 0, 5675, 5676, 1, 0, 0, 0, 5676, 5754, 1, 0, 0, 0, 5677, 5678, 5, 195, 0, 0, 5678, 5679, 3, 560, 280, 0, 5679, 5680, 5, 224, 0, 0, 5680, 5681, 5, 558, 0, 0, 5681, 5683, 3, 1890, 945, 0, 5682, 5684, 3, 120, 60, 0, 5683, 5682, 1, 0, 0, 0, 5683, 5684, 1, 0, 0, 0, 5684, 5754, 1, 0, 0, 0, 5685, 5686, 5, 195, 0, 0, 5686, 5687, 3, 560, 280, 0, 5687, 5689, 3, 1890, 945, 0, 5688, 5690, 3, 120, 60, 0, 5689, 5688, 1, 0, 0, 0, 5689, 5690, 1, 0, 0, 0, 5690, 5754, 1, 0, 0, 0, 5691, 5692, 5, 195, 0, 0, 5692, 5693, 3, 562, 281, 0, 5693, 5694, 3, 1892, 946, 0, 5694, 5695, 5, 80, 0, 0, 5695, 5697, 3, 566, 283, 0, 5696, 5698, 3, 120, 60, 0, 5697, 5696, 1, 0, 0, 0, 5697, 5698, 1, 0, 0, 0, 5698, 5754, 1, 0, 0, 0, 5699, 5700, 5, 195, 0, 0, 5700, 5701, 3, 562, 281, 0, 5701, 5702, 5, 224, 0, 0, 5702, 5703, 5, 558, 0, 0, 5703, 5704, 3, 1892, 946, 0, 5704, 5705, 5, 80, 0, 0, 5705, 5707, 3, 566, 283, 0, 5706, 5708, 3, 120, 60, 0, 5707, 5706, 1, 0, 0, 0, 5707, 5708, 1, 0, 0, 0, 5708, 5754, 1, 0, 0, 0, 5709, 5710, 5, 195, 0, 0, 5710, 5711, 5, 358, 0, 0, 5711, 5713, 3, 570, 285, 0, 5712, 5714, 3, 120, 60, 0, 5713, 5712, 1, 0, 0, 0, 5713, 5714, 1, 0, 0, 0, 5714, 5754, 1, 0, 0, 0, 5715, 5716, 5, 195, 0, 0, 5716, 5717, 5, 358, 0, 0, 5717, 5718, 5, 224, 0, 0, 5718, 5719, 5, 558, 0, 0, 5719, 5721, 3, 570, 285, 0, 5720, 5722, 3, 120, 60, 0, 5721, 5720, 1, 0, 0, 0, 5721, 5722, 1, 0, 0, 0, 5722, 5754, 1, 0, 0, 0, 5723, 5724, 5, 195, 0, 0, 5724, 5725, 5, 193, 0, 0, 5725, 5727, 3, 570, 285, 0, 5726, 5728, 3, 120, 60, 0, 5727, 5726, 1, 0, 0, 0, 5727, 5728, 1, 0, 0, 0, 5728, 5754, 1, 0, 0, 0, 5729, 5730, 5, 195, 0, 0, 5730, 5731, 5, 193, 0, 0, 5731, 5732, 5, 224, 0, 0, 5732, 5733, 5, 558, 0, 0, 5733, 5735, 3, 570, 285, 0, 5734, 5736, 3, 120, 60, 0, 5735, 5734, 1, 0, 0, 0, 5735, 5736, 1, 0, 0, 0, 5736, 5754, 1, 0, 0, 0, 5737, 5738, 5, 195, 0, 0, 5738, 5739, 5, 230, 0, 0, 5739, 5740, 5, 111, 0, 0, 5740, 5742, 3, 564, 282, 0, 5741, 5743, 3, 120, 60, 0, 5742, 5741, 1, 0, 0, 0, 5742, 5743, 1, 0, 0, 0, 5743, 5754, 1, 0, 0, 0, 5744, 5745, 5, 195, 0, 0, 5745, 5746, 5, 230, 0, 0, 5746, 5747, 5, 111, 0, 0, 5747, 5748, 5, 224, 0, 0, 5748, 5749, 5, 558, 0, 0, 5749, 5751, 3, 564, 282, 0, 5750, 5752, 3, 120, 60, 0, 5751, 5750, 1, 0, 0, 0, 5751, 5752, 1, 0, 0, 0, 5752, 5754, 1, 0, 0, 0, 5753, 5663, 1, 0, 0, 0, 5753, 5671, 1, 0, 0, 0, 5753, 5677, 1, 0, 0, 0, 5753, 5685, 1, 0, 0, 0, 5753, 5691, 1, 0, 0, 0, 5753, 5699, 1, 0, 0, 0, 5753, 5709, 1, 0, 0, 0, 5753, 5715, 1, 0, 0, 0, 5753, 5723, 1, 0, 0, 0, 5753, 5729, 1, 0, 0, 0, 5753, 5737, 1, 0, 0, 0, 5753, 5744, 1, 0, 0, 0, 5754, 555, 1, 0, 0, 0, 5755, 5779, 5, 93, 0, 0, 5756, 5779, 5, 326, 0, 0, 5757, 5779, 5, 374, 0, 0, 5758, 5759, 5, 255, 0, 0, 5759, 5779, 5, 374, 0, 0, 5760, 5779, 5, 230, 0, 0, 5761, 5762, 5, 63, 0, 0, 5762, 5779, 5, 93, 0, 0, 5763, 5779, 5, 110, 0, 0, 5764, 5779, 5, 170, 0, 0, 5765, 5779, 5, 340, 0, 0, 5766, 5767, 5, 353, 0, 0, 5767, 5768, 5, 323, 0, 0, 5768, 5779, 5, 280, 0, 0, 5769, 5770, 5, 353, 0, 0, 5770, 5771, 5, 323, 0, 0, 5771, 5779, 5, 189, 0, 0, 5772, 5773, 5, 353, 0, 0, 5773, 5774, 5, 323, 0, 0, 5774, 5779, 5, 351, 0, 0, 5775, 5776, 5, 353, 0, 0, 5776, 5777, 5, 323, 0, 0, 5777, 5779, 5, 165, 0, 0, 5778, 5755, 1, 0, 0, 0, 5778, 5756, 1, 0, 0, 0, 5778, 5757, 1, 0, 0, 0, 5778, 5758, 1, 0, 0, 0, 5778, 5760, 1, 0, 0, 0, 5778, 5761, 1, 0, 0, 0, 5778, 5763, 1, 0, 0, 0, 5778, 5764, 1, 0, 0, 0, 5778, 5765, 1, 0, 0, 0, 5778, 5766, 1, 0, 0, 0, 5778, 5769, 1, 0, 0, 0, 5778, 5772, 1, 0, 0, 0, 5778, 5775, 1, 0, 0, 0, 5779, 557, 1, 0, 0, 0, 5780, 5787, 3, 560, 280, 0, 5781, 5787, 5, 321, 0, 0, 5782, 5787, 5, 179, 0, 0, 5783, 5787, 5, 316, 0, 0, 5784, 5787, 5, 650, 0, 0, 5785, 5787, 5, 349, 0, 0, 5786, 5780, 1, 0, 0, 0, 5786, 5781, 1, 0, 0, 0, 5786, 5782, 1, 0, 0, 0, 5786, 5783, 1, 0, 0, 0, 5786, 5784, 1, 0, 0, 0, 5786, 5785, 1, 0, 0, 0, 5787, 559, 1, 0, 0, 0, 5788, 5789, 5, 133, 0, 0, 5789, 5803, 5, 645, 0, 0, 5790, 5791, 5, 202, 0, 0, 5791, 5803, 5, 355, 0, 0, 5792, 5803, 5, 208, 0, 0, 5793, 5794, 5, 63, 0, 0, 5794, 5795, 5, 177, 0, 0, 5795, 5803, 5, 379, 0, 0, 5796, 5798, 3, 350, 175, 0, 5797, 5796, 1, 0, 0, 0, 5797, 5798, 1, 0, 0, 0, 5798, 5799, 1, 0, 0, 0, 5799, 5803, 5, 242, 0, 0, 5800, 5803, 5, 651, 0, 0, 5801, 5803, 5, 329, 0, 0, 5802, 5788, 1, 0, 0, 0, 5802, 5790, 1, 0, 0, 0, 5802, 5792, 1, 0, 0, 0, 5802, 5793, 1, 0, 0, 0, 5802, 5797, 1, 0, 0, 0, 5802, 5800, 1, 0, 0, 0, 5802, 5801, 1, 0, 0, 0, 5803, 561, 1, 0, 0, 0, 5804, 5805, 7, 35, 0, 0, 5805, 563, 1, 0, 0, 0, 5806, 5811, 3, 566, 283, 0, 5807, 5808, 5, 6, 0, 0, 5808, 5810, 3, 566, 283, 0, 5809, 5807, 1, 0, 0, 0, 5810, 5813, 1, 0, 0, 0, 5811, 5809, 1, 0, 0, 0, 5811, 5812, 1, 0, 0, 0, 5812, 565, 1, 0, 0, 0, 5813, 5811, 1, 0, 0, 0, 5814, 5816, 3, 1924, 962, 0, 5815, 5817, 3, 568, 284, 0, 5816, 5815, 1, 0, 0, 0, 5816, 5817, 1, 0, 0, 0, 5817, 567, 1, 0, 0, 0, 5818, 5819, 5, 11, 0, 0, 5819, 5821, 3, 1894, 947, 0, 5820, 5818, 1, 0, 0, 0, 5821, 5822, 1, 0, 0, 0, 5822, 5820, 1, 0, 0, 0, 5822, 5823, 1, 0, 0, 0, 5823, 569, 1, 0, 0, 0, 5824, 5829, 3, 1662, 831, 0, 5825, 5826, 5, 6, 0, 0, 5826, 5828, 3, 1662, 831, 0, 5827, 5825, 1, 0, 0, 0, 5828, 5831, 1, 0, 0, 0, 5829, 5827, 1, 0, 0, 0, 5829, 5830, 1, 0, 0, 0, 5830, 571, 1, 0, 0, 0, 5831, 5829, 1, 0, 0, 0, 5832, 5834, 5, 356, 0, 0, 5833, 5835, 3, 1532, 766, 0, 5834, 5833, 1, 0, 0, 0, 5834, 5835, 1, 0, 0, 0, 5835, 5836, 1, 0, 0, 0, 5836, 5838, 3, 1620, 810, 0, 5837, 5839, 3, 574, 287, 0, 5838, 5837, 1, 0, 0, 0, 5838, 5839, 1, 0, 0, 0, 5839, 5841, 1, 0, 0, 0, 5840, 5842, 3, 120, 60, 0, 5841, 5840, 1, 0, 0, 0, 5841, 5842, 1, 0, 0, 0, 5842, 573, 1, 0, 0, 0, 5843, 5844, 5, 169, 0, 0, 5844, 5848, 5, 223, 0, 0, 5845, 5846, 5, 312, 0, 0, 5846, 5848, 5, 223, 0, 0, 5847, 5843, 1, 0, 0, 0, 5847, 5845, 1, 0, 0, 0, 5848, 575, 1, 0, 0, 0, 5849, 5850, 5, 161, 0, 0, 5850, 5851, 5, 80, 0, 0, 5851, 5852, 3, 556, 278, 0, 5852, 5853, 3, 566, 283, 0, 5853, 5854, 5, 118, 0, 0, 5854, 5855, 3, 578, 289, 0, 5855, 5997, 1, 0, 0, 0, 5856, 5857, 5, 161, 0, 0, 5857, 5858, 5, 80, 0, 0, 5858, 5859, 5, 44, 0, 0, 5859, 5860, 3, 566, 283, 0, 5860, 5861, 5, 118, 0, 0, 5861, 5862, 3, 578, 289, 0, 5862, 5997, 1, 0, 0, 0, 5863, 5864, 5, 161, 0, 0, 5864, 5865, 5, 80, 0, 0, 5865, 5866, 3, 558, 279, 0, 5866, 5867, 3, 1892, 946, 0, 5867, 5868, 5, 118, 0, 0, 5868, 5869, 3, 578, 289, 0, 5869, 5997, 1, 0, 0, 0, 5870, 5871, 5, 161, 0, 0, 5871, 5872, 5, 80, 0, 0, 5872, 5873, 5, 358, 0, 0, 5873, 5874, 3, 1662, 831, 0, 5874, 5875, 5, 118, 0, 0, 5875, 5876, 3, 578, 289, 0, 5876, 5997, 1, 0, 0, 0, 5877, 5878, 5, 161, 0, 0, 5878, 5879, 5, 80, 0, 0, 5879, 5880, 5, 193, 0, 0, 5880, 5881, 3, 1662, 831, 0, 5881, 5882, 5, 118, 0, 0, 5882, 5883, 3, 578, 289, 0, 5883, 5997, 1, 0, 0, 0, 5884, 5885, 5, 161, 0, 0, 5885, 5886, 5, 80, 0, 0, 5886, 5887, 5, 138, 0, 0, 5887, 5888, 3, 868, 434, 0, 5888, 5889, 5, 118, 0, 0, 5889, 5890, 3, 578, 289, 0, 5890, 5997, 1, 0, 0, 0, 5891, 5892, 5, 161, 0, 0, 5892, 5893, 5, 80, 0, 0, 5893, 5894, 5, 215, 0, 0, 5894, 5895, 3, 844, 422, 0, 5895, 5896, 5, 118, 0, 0, 5896, 5897, 3, 578, 289, 0, 5897, 5997, 1, 0, 0, 0, 5898, 5899, 5, 161, 0, 0, 5899, 5900, 5, 80, 0, 0, 5900, 5901, 5, 275, 0, 0, 5901, 5902, 3, 908, 454, 0, 5902, 5903, 5, 118, 0, 0, 5903, 5904, 3, 578, 289, 0, 5904, 5997, 1, 0, 0, 0, 5905, 5906, 5, 161, 0, 0, 5906, 5907, 5, 80, 0, 0, 5907, 5908, 5, 45, 0, 0, 5908, 5909, 3, 1892, 946, 0, 5909, 5910, 5, 80, 0, 0, 5910, 5911, 3, 566, 283, 0, 5911, 5912, 5, 118, 0, 0, 5912, 5913, 3, 578, 289, 0, 5913, 5997, 1, 0, 0, 0, 5914, 5915, 5, 161, 0, 0, 5915, 5916, 5, 80, 0, 0, 5916, 5917, 5, 45, 0, 0, 5917, 5918, 3, 1892, 946, 0, 5918, 5919, 5, 80, 0, 0, 5919, 5920, 5, 193, 0, 0, 5920, 5921, 3, 566, 283, 0, 5921, 5922, 5, 118, 0, 0, 5922, 5923, 3, 578, 289, 0, 5923, 5997, 1, 0, 0, 0, 5924, 5925, 5, 161, 0, 0, 5925, 5926, 5, 80, 0, 0, 5926, 5927, 3, 562, 281, 0, 5927, 5928, 3, 1892, 946, 0, 5928, 5929, 5, 80, 0, 0, 5929, 5930, 3, 566, 283, 0, 5930, 5931, 5, 118, 0, 0, 5931, 5932, 3, 578, 289, 0, 5932, 5997, 1, 0, 0, 0, 5933, 5934, 5, 161, 0, 0, 5934, 5935, 5, 80, 0, 0, 5935, 5936, 5, 294, 0, 0, 5936, 5937, 3, 844, 422, 0, 5937, 5938, 5, 118, 0, 0, 5938, 5939, 3, 578, 289, 0, 5939, 5997, 1, 0, 0, 0, 5940, 5941, 5, 161, 0, 0, 5941, 5942, 5, 80, 0, 0, 5942, 5943, 5, 640, 0, 0, 5943, 5944, 3, 844, 422, 0, 5944, 5945, 5, 118, 0, 0, 5945, 5946, 3, 578, 289, 0, 5946, 5997, 1, 0, 0, 0, 5947, 5948, 5, 161, 0, 0, 5948, 5949, 5, 80, 0, 0, 5949, 5950, 5, 641, 0, 0, 5950, 5951, 5, 62, 0, 0, 5951, 5952, 3, 1662, 831, 0, 5952, 5953, 5, 242, 0, 0, 5953, 5954, 3, 1892, 946, 0, 5954, 5955, 5, 118, 0, 0, 5955, 5956, 3, 578, 289, 0, 5956, 5997, 1, 0, 0, 0, 5957, 5958, 5, 161, 0, 0, 5958, 5959, 5, 80, 0, 0, 5959, 5960, 5, 275, 0, 0, 5960, 5961, 5, 158, 0, 0, 5961, 5962, 3, 566, 283, 0, 5962, 5963, 5, 101, 0, 0, 5963, 5964, 3, 1892, 946, 0, 5964, 5965, 5, 118, 0, 0, 5965, 5966, 3, 578, 289, 0, 5966, 5997, 1, 0, 0, 0, 5967, 5968, 5, 161, 0, 0, 5968, 5969, 5, 80, 0, 0, 5969, 5970, 5, 275, 0, 0, 5970, 5971, 5, 210, 0, 0, 5971, 5972, 3, 566, 283, 0, 5972, 5973, 5, 101, 0, 0, 5973, 5974, 3, 1892, 946, 0, 5974, 5975, 5, 118, 0, 0, 5975, 5976, 3, 578, 289, 0, 5976, 5997, 1, 0, 0, 0, 5977, 5978, 5, 161, 0, 0, 5978, 5979, 5, 80, 0, 0, 5979, 5980, 5, 243, 0, 0, 5980, 5981, 5, 271, 0, 0, 5981, 5982, 3, 334, 167, 0, 5982, 5983, 5, 118, 0, 0, 5983, 5984, 3, 578, 289, 0, 5984, 5997, 1, 0, 0, 0, 5985, 5986, 5, 161, 0, 0, 5986, 5987, 5, 80, 0, 0, 5987, 5988, 5, 41, 0, 0, 5988, 5989, 5, 2, 0, 0, 5989, 5990, 3, 1662, 831, 0, 5990, 5991, 5, 36, 0, 0, 5991, 5992, 3, 1662, 831, 0, 5992, 5993, 5, 3, 0, 0, 5993, 5994, 5, 118, 0, 0, 5994, 5995, 3, 578, 289, 0, 5995, 5997, 1, 0, 0, 0, 5996, 5849, 1, 0, 0, 0, 5996, 5856, 1, 0, 0, 0, 5996, 5863, 1, 0, 0, 0, 5996, 5870, 1, 0, 0, 0, 5996, 5877, 1, 0, 0, 0, 5996, 5884, 1, 0, 0, 0, 5996, 5891, 1, 0, 0, 0, 5996, 5898, 1, 0, 0, 0, 5996, 5905, 1, 0, 0, 0, 5996, 5914, 1, 0, 0, 0, 5996, 5924, 1, 0, 0, 0, 5996, 5933, 1, 0, 0, 0, 5996, 5940, 1, 0, 0, 0, 5996, 5947, 1, 0, 0, 0, 5996, 5957, 1, 0, 0, 0, 5996, 5967, 1, 0, 0, 0, 5996, 5977, 1, 0, 0, 0, 5996, 5985, 1, 0, 0, 0, 5997, 577, 1, 0, 0, 0, 5998, 6001, 3, 1910, 955, 0, 5999, 6001, 5, 78, 0, 0, 6000, 5998, 1, 0, 0, 0, 6000, 5999, 1, 0, 0, 0, 6001, 579, 1, 0, 0, 0, 6002, 6003, 5, 325, 0, 0, 6003, 6005, 5, 241, 0, 0, 6004, 6006, 3, 582, 291, 0, 6005, 6004, 1, 0, 0, 0, 6005, 6006, 1, 0, 0, 0, 6006, 6007, 1, 0, 0, 0, 6007, 6008, 5, 80, 0, 0, 6008, 6009, 3, 556, 278, 0, 6009, 6010, 3, 566, 283, 0, 6010, 6011, 5, 118, 0, 0, 6011, 6012, 3, 584, 292, 0, 6012, 6114, 1, 0, 0, 0, 6013, 6014, 5, 325, 0, 0, 6014, 6016, 5, 241, 0, 0, 6015, 6017, 3, 582, 291, 0, 6016, 6015, 1, 0, 0, 0, 6016, 6017, 1, 0, 0, 0, 6017, 6018, 1, 0, 0, 0, 6018, 6019, 5, 80, 0, 0, 6019, 6020, 5, 44, 0, 0, 6020, 6021, 3, 566, 283, 0, 6021, 6022, 5, 118, 0, 0, 6022, 6023, 3, 584, 292, 0, 6023, 6114, 1, 0, 0, 0, 6024, 6025, 5, 325, 0, 0, 6025, 6027, 5, 241, 0, 0, 6026, 6028, 3, 582, 291, 0, 6027, 6026, 1, 0, 0, 0, 6027, 6028, 1, 0, 0, 0, 6028, 6029, 1, 0, 0, 0, 6029, 6030, 5, 80, 0, 0, 6030, 6031, 3, 558, 279, 0, 6031, 6032, 3, 1892, 946, 0, 6032, 6033, 5, 118, 0, 0, 6033, 6034, 3, 584, 292, 0, 6034, 6114, 1, 0, 0, 0, 6035, 6036, 5, 325, 0, 0, 6036, 6038, 5, 241, 0, 0, 6037, 6039, 3, 582, 291, 0, 6038, 6037, 1, 0, 0, 0, 6038, 6039, 1, 0, 0, 0, 6039, 6040, 1, 0, 0, 0, 6040, 6041, 5, 80, 0, 0, 6041, 6042, 5, 358, 0, 0, 6042, 6043, 3, 1662, 831, 0, 6043, 6044, 5, 118, 0, 0, 6044, 6045, 3, 584, 292, 0, 6045, 6114, 1, 0, 0, 0, 6046, 6047, 5, 325, 0, 0, 6047, 6049, 5, 241, 0, 0, 6048, 6050, 3, 582, 291, 0, 6049, 6048, 1, 0, 0, 0, 6049, 6050, 1, 0, 0, 0, 6050, 6051, 1, 0, 0, 0, 6051, 6052, 5, 80, 0, 0, 6052, 6053, 5, 193, 0, 0, 6053, 6054, 3, 1662, 831, 0, 6054, 6055, 5, 118, 0, 0, 6055, 6056, 3, 584, 292, 0, 6056, 6114, 1, 0, 0, 0, 6057, 6058, 5, 325, 0, 0, 6058, 6060, 5, 241, 0, 0, 6059, 6061, 3, 582, 291, 0, 6060, 6059, 1, 0, 0, 0, 6060, 6061, 1, 0, 0, 0, 6061, 6062, 1, 0, 0, 0, 6062, 6063, 5, 80, 0, 0, 6063, 6064, 5, 138, 0, 0, 6064, 6065, 3, 868, 434, 0, 6065, 6066, 5, 118, 0, 0, 6066, 6067, 3, 584, 292, 0, 6067, 6114, 1, 0, 0, 0, 6068, 6069, 5, 325, 0, 0, 6069, 6071, 5, 241, 0, 0, 6070, 6072, 3, 582, 291, 0, 6071, 6070, 1, 0, 0, 0, 6071, 6072, 1, 0, 0, 0, 6072, 6073, 1, 0, 0, 0, 6073, 6074, 5, 80, 0, 0, 6074, 6075, 5, 215, 0, 0, 6075, 6076, 3, 844, 422, 0, 6076, 6077, 5, 118, 0, 0, 6077, 6078, 3, 584, 292, 0, 6078, 6114, 1, 0, 0, 0, 6079, 6080, 5, 325, 0, 0, 6080, 6082, 5, 241, 0, 0, 6081, 6083, 3, 582, 291, 0, 6082, 6081, 1, 0, 0, 0, 6082, 6083, 1, 0, 0, 0, 6083, 6084, 1, 0, 0, 0, 6084, 6085, 5, 80, 0, 0, 6085, 6086, 5, 243, 0, 0, 6086, 6087, 5, 271, 0, 0, 6087, 6088, 3, 334, 167, 0, 6088, 6089, 5, 118, 0, 0, 6089, 6090, 3, 584, 292, 0, 6090, 6114, 1, 0, 0, 0, 6091, 6092, 5, 325, 0, 0, 6092, 6094, 5, 241, 0, 0, 6093, 6095, 3, 582, 291, 0, 6094, 6093, 1, 0, 0, 0, 6094, 6095, 1, 0, 0, 0, 6095, 6096, 1, 0, 0, 0, 6096, 6097, 5, 80, 0, 0, 6097, 6098, 5, 294, 0, 0, 6098, 6099, 3, 844, 422, 0, 6099, 6100, 5, 118, 0, 0, 6100, 6101, 3, 584, 292, 0, 6101, 6114, 1, 0, 0, 0, 6102, 6103, 5, 325, 0, 0, 6103, 6105, 5, 241, 0, 0, 6104, 6106, 3, 582, 291, 0, 6105, 6104, 1, 0, 0, 0, 6105, 6106, 1, 0, 0, 0, 6106, 6107, 1, 0, 0, 0, 6107, 6108, 5, 80, 0, 0, 6108, 6109, 5, 640, 0, 0, 6109, 6110, 3, 844, 422, 0, 6110, 6111, 5, 118, 0, 0, 6111, 6112, 3, 584, 292, 0, 6112, 6114, 1, 0, 0, 0, 6113, 6002, 1, 0, 0, 0, 6113, 6013, 1, 0, 0, 0, 6113, 6024, 1, 0, 0, 0, 6113, 6035, 1, 0, 0, 0, 6113, 6046, 1, 0, 0, 0, 6113, 6057, 1, 0, 0, 0, 6113, 6068, 1, 0, 0, 0, 6113, 6079, 1, 0, 0, 0, 6113, 6091, 1, 0, 0, 0, 6113, 6102, 1, 0, 0, 0, 6114, 581, 1, 0, 0, 0, 6115, 6116, 5, 62, 0, 0, 6116, 6117, 3, 82, 41, 0, 6117, 583, 1, 0, 0, 0, 6118, 6121, 3, 1910, 955, 0, 6119, 6121, 5, 78, 0, 0, 6120, 6118, 1, 0, 0, 0, 6120, 6119, 1, 0, 0, 0, 6121, 585, 1, 0, 0, 0, 6122, 6123, 5, 61, 0, 0, 6123, 6124, 3, 588, 294, 0, 6124, 587, 1, 0, 0, 0, 6125, 6126, 5, 265, 0, 0, 6126, 6127, 5, 64, 0, 0, 6127, 6141, 3, 1490, 745, 0, 6128, 6129, 5, 30, 0, 0, 6129, 6130, 5, 64, 0, 0, 6130, 6141, 3, 1490, 745, 0, 6131, 6134, 5, 214, 0, 0, 6132, 6135, 3, 1916, 958, 0, 6133, 6135, 5, 30, 0, 0, 6134, 6132, 1, 0, 0, 0, 6134, 6133, 1, 0, 0, 0, 6134, 6135, 1, 0, 0, 0, 6135, 6136, 1, 0, 0, 0, 6136, 6137, 5, 64, 0, 0, 6137, 6141, 3, 1490, 745, 0, 6138, 6139, 5, 64, 0, 0, 6139, 6141, 3, 1490, 745, 0, 6140, 6125, 1, 0, 0, 0, 6140, 6128, 1, 0, 0, 0, 6140, 6131, 1, 0, 0, 0, 6140, 6138, 1, 0, 0, 0, 6141, 589, 1, 0, 0, 0, 6142, 6153, 3, 668, 334, 0, 6143, 6153, 3, 658, 329, 0, 6144, 6153, 3, 650, 325, 0, 6145, 6153, 3, 630, 315, 0, 6146, 6153, 3, 628, 314, 0, 6147, 6153, 3, 610, 305, 0, 6148, 6153, 3, 596, 298, 0, 6149, 6153, 3, 598, 299, 0, 6150, 6153, 3, 594, 297, 0, 6151, 6153, 3, 592, 296, 0, 6152, 6142, 1, 0, 0, 0, 6152, 6143, 1, 0, 0, 0, 6152, 6144, 1, 0, 0, 0, 6152, 6145, 1, 0, 0, 0, 6152, 6146, 1, 0, 0, 0, 6152, 6147, 1, 0, 0, 0, 6152, 6148, 1, 0, 0, 0, 6152, 6149, 1, 0, 0, 0, 6152, 6150, 1, 0, 0, 0, 6152, 6151, 1, 0, 0, 0, 6153, 591, 1, 0, 0, 0, 6154, 6155, 5, 65, 0, 0, 6155, 6156, 5, 89, 0, 0, 6156, 6158, 5, 80, 0, 0, 6157, 6159, 5, 93, 0, 0, 6158, 6157, 1, 0, 0, 0, 6158, 6159, 1, 0, 0, 0, 6159, 6160, 1, 0, 0, 0, 6160, 6161, 3, 1886, 943, 0, 6161, 6162, 5, 95, 0, 0, 6162, 6163, 5, 413, 0, 0, 6163, 6164, 5, 643, 0, 0, 6164, 6165, 3, 246, 123, 0, 6165, 593, 1, 0, 0, 0, 6166, 6167, 5, 65, 0, 0, 6167, 6168, 7, 36, 0, 0, 6168, 6169, 5, 413, 0, 0, 6169, 6170, 5, 95, 0, 0, 6170, 6171, 5, 316, 0, 0, 6171, 6172, 3, 1920, 960, 0, 6172, 595, 1, 0, 0, 0, 6173, 6174, 5, 65, 0, 0, 6174, 6175, 5, 46, 0, 0, 6175, 6176, 5, 417, 0, 0, 6176, 6177, 5, 95, 0, 0, 6177, 6187, 3, 716, 358, 0, 6178, 6179, 5, 65, 0, 0, 6179, 6180, 3, 688, 344, 0, 6180, 6181, 5, 80, 0, 0, 6181, 6182, 5, 417, 0, 0, 6182, 6183, 3, 246, 123, 0, 6183, 6184, 5, 95, 0, 0, 6184, 6185, 3, 716, 358, 0, 6185, 6187, 1, 0, 0, 0, 6186, 6173, 1, 0, 0, 0, 6186, 6178, 1, 0, 0, 0, 6187, 597, 1, 0, 0, 0, 6188, 6189, 5, 65, 0, 0, 6189, 6190, 5, 316, 0, 0, 6190, 6196, 3, 1920, 960, 0, 6191, 6192, 5, 6, 0, 0, 6192, 6193, 5, 316, 0, 0, 6193, 6195, 3, 1920, 960, 0, 6194, 6191, 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, 95, 0, 0, 6200, 6201, 3, 600, 300, 0, 6201, 6209, 1, 0, 0, 0, 6202, 6203, 5, 65, 0, 0, 6203, 6204, 3, 604, 302, 0, 6204, 6205, 5, 95, 0, 0, 6205, 6206, 5, 316, 0, 0, 6206, 6207, 3, 1922, 961, 0, 6207, 6209, 1, 0, 0, 0, 6208, 6188, 1, 0, 0, 0, 6208, 6202, 1, 0, 0, 0, 6209, 599, 1, 0, 0, 0, 6210, 6215, 3, 602, 301, 0, 6211, 6212, 5, 6, 0, 0, 6212, 6214, 3, 602, 301, 0, 6213, 6211, 1, 0, 0, 0, 6214, 6217, 1, 0, 0, 0, 6215, 6213, 1, 0, 0, 0, 6215, 6216, 1, 0, 0, 0, 6216, 601, 1, 0, 0, 0, 6217, 6215, 1, 0, 0, 0, 6218, 6220, 3, 1920, 960, 0, 6219, 6221, 3, 608, 304, 0, 6220, 6219, 1, 0, 0, 0, 6220, 6221, 1, 0, 0, 0, 6221, 6225, 1, 0, 0, 0, 6222, 6223, 5, 316, 0, 0, 6223, 6225, 3, 1920, 960, 0, 6224, 6218, 1, 0, 0, 0, 6224, 6222, 1, 0, 0, 0, 6225, 603, 1, 0, 0, 0, 6226, 6231, 3, 606, 303, 0, 6227, 6228, 5, 6, 0, 0, 6228, 6230, 3, 606, 303, 0, 6229, 6227, 1, 0, 0, 0, 6230, 6233, 1, 0, 0, 0, 6231, 6229, 1, 0, 0, 0, 6231, 6232, 1, 0, 0, 0, 6232, 6236, 1, 0, 0, 0, 6233, 6231, 1, 0, 0, 0, 6234, 6236, 3, 714, 357, 0, 6235, 6226, 1, 0, 0, 0, 6235, 6234, 1, 0, 0, 0, 6236, 605, 1, 0, 0, 0, 6237, 6238, 7, 37, 0, 0, 6238, 6294, 5, 100, 0, 0, 6239, 6240, 7, 38, 0, 0, 6240, 6294, 5, 321, 0, 0, 6241, 6242, 5, 140, 0, 0, 6242, 6243, 5, 53, 0, 0, 6243, 6294, 5, 292, 0, 0, 6244, 6248, 5, 133, 0, 0, 6245, 6249, 5, 154, 0, 0, 6246, 6247, 5, 347, 0, 0, 6247, 6249, 5, 93, 0, 0, 6248, 6245, 1, 0, 0, 0, 6248, 6246, 1, 0, 0, 0, 6249, 6294, 1, 0, 0, 0, 6250, 6251, 7, 37, 0, 0, 6251, 6294, 5, 93, 0, 0, 6252, 6253, 5, 46, 0, 0, 6253, 6254, 5, 82, 0, 0, 6254, 6258, 5, 309, 0, 0, 6255, 6259, 5, 215, 0, 0, 6256, 6257, 5, 209, 0, 0, 6257, 6259, 5, 215, 0, 0, 6258, 6255, 1, 0, 0, 0, 6258, 6256, 1, 0, 0, 0, 6259, 6294, 1, 0, 0, 0, 6260, 6261, 5, 195, 0, 0, 6261, 6294, 5, 215, 0, 0, 6262, 6263, 5, 46, 0, 0, 6263, 6264, 5, 82, 0, 0, 6264, 6267, 5, 309, 0, 0, 6265, 6267, 5, 195, 0, 0, 6266, 6262, 1, 0, 0, 0, 6266, 6265, 1, 0, 0, 0, 6267, 6268, 1, 0, 0, 0, 6268, 6294, 5, 294, 0, 0, 6269, 6270, 5, 46, 0, 0, 6270, 6271, 5, 82, 0, 0, 6271, 6274, 5, 309, 0, 0, 6272, 6274, 5, 195, 0, 0, 6273, 6269, 1, 0, 0, 0, 6273, 6272, 1, 0, 0, 0, 6274, 6275, 1, 0, 0, 0, 6275, 6294, 5, 374, 0, 0, 6276, 6277, 7, 38, 0, 0, 6277, 6294, 5, 417, 0, 0, 6278, 6279, 7, 37, 0, 0, 6279, 6294, 5, 392, 0, 0, 6280, 6281, 7, 38, 0, 0, 6281, 6294, 5, 462, 0, 0, 6282, 6283, 7, 38, 0, 0, 6283, 6294, 5, 316, 0, 0, 6284, 6285, 5, 356, 0, 0, 6285, 6294, 5, 93, 0, 0, 6286, 6294, 5, 368, 0, 0, 6287, 6294, 5, 32, 0, 0, 6288, 6294, 5, 458, 0, 0, 6289, 6290, 7, 36, 0, 0, 6290, 6294, 5, 413, 0, 0, 6291, 6292, 5, 207, 0, 0, 6292, 6294, 5, 412, 0, 0, 6293, 6237, 1, 0, 0, 0, 6293, 6239, 1, 0, 0, 0, 6293, 6241, 1, 0, 0, 0, 6293, 6244, 1, 0, 0, 0, 6293, 6250, 1, 0, 0, 0, 6293, 6252, 1, 0, 0, 0, 6293, 6260, 1, 0, 0, 0, 6293, 6266, 1, 0, 0, 0, 6293, 6273, 1, 0, 0, 0, 6293, 6276, 1, 0, 0, 0, 6293, 6278, 1, 0, 0, 0, 6293, 6280, 1, 0, 0, 0, 6293, 6282, 1, 0, 0, 0, 6293, 6284, 1, 0, 0, 0, 6293, 6286, 1, 0, 0, 0, 6293, 6287, 1, 0, 0, 0, 6293, 6288, 1, 0, 0, 0, 6293, 6289, 1, 0, 0, 0, 6293, 6291, 1, 0, 0, 0, 6294, 607, 1, 0, 0, 0, 6295, 6296, 5, 106, 0, 0, 6296, 6297, 5, 136, 0, 0, 6297, 6298, 5, 276, 0, 0, 6298, 609, 1, 0, 0, 0, 6299, 6306, 3, 612, 306, 0, 6300, 6306, 3, 614, 307, 0, 6301, 6306, 3, 616, 308, 0, 6302, 6306, 3, 618, 309, 0, 6303, 6306, 3, 620, 310, 0, 6304, 6306, 3, 622, 311, 0, 6305, 6299, 1, 0, 0, 0, 6305, 6300, 1, 0, 0, 0, 6305, 6301, 1, 0, 0, 0, 6305, 6302, 1, 0, 0, 0, 6305, 6303, 1, 0, 0, 0, 6305, 6304, 1, 0, 0, 0, 6306, 611, 1, 0, 0, 0, 6307, 6308, 5, 65, 0, 0, 6308, 6309, 3, 698, 349, 0, 6309, 6310, 5, 62, 0, 0, 6310, 6311, 5, 655, 0, 0, 6311, 6312, 5, 68, 0, 0, 6312, 6313, 5, 179, 0, 0, 6313, 6314, 3, 1924, 962, 0, 6314, 6315, 5, 95, 0, 0, 6315, 6316, 3, 624, 312, 0, 6316, 613, 1, 0, 0, 0, 6317, 6318, 5, 65, 0, 0, 6318, 6319, 3, 724, 362, 0, 6319, 6320, 5, 62, 0, 0, 6320, 6321, 5, 348, 0, 0, 6321, 6330, 5, 68, 0, 0, 6322, 6323, 5, 321, 0, 0, 6323, 6326, 3, 1924, 962, 0, 6324, 6325, 5, 179, 0, 0, 6325, 6327, 3, 1924, 962, 0, 6326, 6324, 1, 0, 0, 0, 6326, 6327, 1, 0, 0, 0, 6327, 6331, 1, 0, 0, 0, 6328, 6329, 5, 179, 0, 0, 6329, 6331, 3, 1924, 962, 0, 6330, 6322, 1, 0, 0, 0, 6330, 6328, 1, 0, 0, 0, 6331, 6332, 1, 0, 0, 0, 6332, 6333, 5, 95, 0, 0, 6333, 6334, 3, 624, 312, 0, 6334, 615, 1, 0, 0, 0, 6335, 6336, 5, 65, 0, 0, 6336, 6337, 3, 688, 344, 0, 6337, 6338, 5, 62, 0, 0, 6338, 6339, 5, 216, 0, 0, 6339, 6348, 5, 68, 0, 0, 6340, 6341, 5, 321, 0, 0, 6341, 6344, 3, 1924, 962, 0, 6342, 6343, 5, 179, 0, 0, 6343, 6345, 3, 1924, 962, 0, 6344, 6342, 1, 0, 0, 0, 6344, 6345, 1, 0, 0, 0, 6345, 6349, 1, 0, 0, 0, 6346, 6347, 5, 179, 0, 0, 6347, 6349, 3, 1924, 962, 0, 6348, 6340, 1, 0, 0, 0, 6348, 6346, 1, 0, 0, 0, 6349, 6350, 1, 0, 0, 0, 6350, 6351, 5, 95, 0, 0, 6351, 6352, 3, 624, 312, 0, 6352, 617, 1, 0, 0, 0, 6353, 6354, 5, 65, 0, 0, 6354, 6355, 3, 684, 342, 0, 6355, 6356, 5, 62, 0, 0, 6356, 6357, 5, 656, 0, 0, 6357, 6366, 5, 68, 0, 0, 6358, 6359, 5, 321, 0, 0, 6359, 6362, 3, 1924, 962, 0, 6360, 6361, 5, 179, 0, 0, 6361, 6363, 3, 1924, 962, 0, 6362, 6360, 1, 0, 0, 0, 6362, 6363, 1, 0, 0, 0, 6363, 6367, 1, 0, 0, 0, 6364, 6365, 5, 179, 0, 0, 6365, 6367, 3, 1924, 962, 0, 6366, 6358, 1, 0, 0, 0, 6366, 6364, 1, 0, 0, 0, 6367, 6368, 1, 0, 0, 0, 6368, 6369, 5, 95, 0, 0, 6369, 6370, 3, 624, 312, 0, 6370, 619, 1, 0, 0, 0, 6371, 6372, 5, 65, 0, 0, 6372, 6373, 3, 678, 339, 0, 6373, 6374, 5, 62, 0, 0, 6374, 6375, 5, 630, 0, 0, 6375, 6376, 5, 68, 0, 0, 6376, 6377, 5, 179, 0, 0, 6377, 6378, 3, 1924, 962, 0, 6378, 6379, 5, 95, 0, 0, 6379, 6380, 3, 624, 312, 0, 6380, 621, 1, 0, 0, 0, 6381, 6382, 5, 65, 0, 0, 6382, 6383, 3, 670, 335, 0, 6383, 6384, 5, 62, 0, 0, 6384, 6385, 5, 171, 0, 0, 6385, 6386, 5, 632, 0, 0, 6386, 6395, 5, 68, 0, 0, 6387, 6388, 5, 321, 0, 0, 6388, 6391, 3, 1924, 962, 0, 6389, 6390, 5, 179, 0, 0, 6390, 6392, 3, 1924, 962, 0, 6391, 6389, 1, 0, 0, 0, 6391, 6392, 1, 0, 0, 0, 6392, 6396, 1, 0, 0, 0, 6393, 6394, 5, 179, 0, 0, 6394, 6396, 3, 1924, 962, 0, 6395, 6387, 1, 0, 0, 0, 6395, 6393, 1, 0, 0, 0, 6396, 6397, 1, 0, 0, 0, 6397, 6398, 5, 95, 0, 0, 6398, 6399, 3, 624, 312, 0, 6399, 623, 1, 0, 0, 0, 6400, 6405, 3, 626, 313, 0, 6401, 6402, 5, 6, 0, 0, 6402, 6404, 3, 626, 313, 0, 6403, 6401, 1, 0, 0, 0, 6404, 6407, 1, 0, 0, 0, 6405, 6403, 1, 0, 0, 0, 6405, 6406, 1, 0, 0, 0, 6406, 625, 1, 0, 0, 0, 6407, 6405, 1, 0, 0, 0, 6408, 6410, 3, 1920, 960, 0, 6409, 6411, 3, 720, 360, 0, 6410, 6409, 1, 0, 0, 0, 6410, 6411, 1, 0, 0, 0, 6411, 6415, 1, 0, 0, 0, 6412, 6413, 5, 316, 0, 0, 6413, 6415, 3, 1920, 960, 0, 6414, 6408, 1, 0, 0, 0, 6414, 6412, 1, 0, 0, 0, 6415, 627, 1, 0, 0, 0, 6416, 6417, 5, 65, 0, 0, 6417, 6418, 7, 39, 0, 0, 6418, 6419, 5, 80, 0, 0, 6419, 6420, 5, 392, 0, 0, 6420, 6421, 3, 1924, 962, 0, 6421, 6422, 5, 95, 0, 0, 6422, 6423, 3, 716, 358, 0, 6423, 6454, 1, 0, 0, 0, 6424, 6425, 5, 65, 0, 0, 6425, 6426, 5, 628, 0, 0, 6426, 6427, 5, 80, 0, 0, 6427, 6428, 5, 392, 0, 0, 6428, 6429, 3, 1924, 962, 0, 6429, 6439, 5, 95, 0, 0, 6430, 6431, 5, 467, 0, 0, 6431, 6440, 3, 1910, 955, 0, 6432, 6433, 5, 466, 0, 0, 6433, 6437, 3, 1910, 955, 0, 6434, 6435, 5, 633, 0, 0, 6435, 6436, 5, 177, 0, 0, 6436, 6438, 5, 154, 0, 0, 6437, 6434, 1, 0, 0, 0, 6437, 6438, 1, 0, 0, 0, 6438, 6440, 1, 0, 0, 0, 6439, 6430, 1, 0, 0, 0, 6439, 6432, 1, 0, 0, 0, 6440, 6454, 1, 0, 0, 0, 6441, 6442, 5, 65, 0, 0, 6442, 6443, 5, 628, 0, 0, 6443, 6448, 5, 80, 0, 0, 6444, 6445, 5, 179, 0, 0, 6445, 6449, 3, 246, 123, 0, 6446, 6447, 5, 321, 0, 0, 6447, 6449, 3, 1924, 962, 0, 6448, 6444, 1, 0, 0, 0, 6448, 6446, 1, 0, 0, 0, 6449, 6450, 1, 0, 0, 0, 6450, 6451, 5, 95, 0, 0, 6451, 6452, 3, 716, 358, 0, 6452, 6454, 1, 0, 0, 0, 6453, 6416, 1, 0, 0, 0, 6453, 6424, 1, 0, 0, 0, 6453, 6441, 1, 0, 0, 0, 6454, 629, 1, 0, 0, 0, 6455, 6459, 3, 644, 322, 0, 6456, 6459, 3, 638, 319, 0, 6457, 6459, 3, 632, 316, 0, 6458, 6455, 1, 0, 0, 0, 6458, 6456, 1, 0, 0, 0, 6458, 6457, 1, 0, 0, 0, 6459, 631, 1, 0, 0, 0, 6460, 6461, 5, 65, 0, 0, 6461, 6462, 3, 634, 317, 0, 6462, 6463, 5, 80, 0, 0, 6463, 6464, 5, 209, 0, 0, 6464, 6465, 5, 321, 0, 0, 6465, 6466, 3, 246, 123, 0, 6466, 6467, 5, 95, 0, 0, 6467, 6469, 3, 646, 323, 0, 6468, 6470, 3, 720, 360, 0, 6469, 6468, 1, 0, 0, 0, 6469, 6470, 1, 0, 0, 0, 6470, 633, 1, 0, 0, 0, 6471, 6476, 3, 636, 318, 0, 6472, 6473, 5, 6, 0, 0, 6473, 6475, 3, 636, 318, 0, 6474, 6472, 1, 0, 0, 0, 6475, 6478, 1, 0, 0, 0, 6476, 6474, 1, 0, 0, 0, 6476, 6477, 1, 0, 0, 0, 6477, 6481, 1, 0, 0, 0, 6478, 6476, 1, 0, 0, 0, 6479, 6481, 3, 714, 357, 0, 6480, 6471, 1, 0, 0, 0, 6480, 6479, 1, 0, 0, 0, 6481, 635, 1, 0, 0, 0, 6482, 6483, 7, 37, 0, 0, 6483, 637, 1, 0, 0, 0, 6484, 6485, 5, 65, 0, 0, 6485, 6486, 3, 642, 321, 0, 6486, 6487, 5, 80, 0, 0, 6487, 6488, 5, 209, 0, 0, 6488, 6489, 5, 93, 0, 0, 6489, 6490, 3, 1886, 943, 0, 6490, 6491, 5, 95, 0, 0, 6491, 6493, 3, 646, 323, 0, 6492, 6494, 3, 720, 360, 0, 6493, 6492, 1, 0, 0, 0, 6493, 6494, 1, 0, 0, 0, 6494, 639, 1, 0, 0, 0, 6495, 6502, 5, 89, 0, 0, 6496, 6502, 5, 140, 0, 0, 6497, 6502, 5, 195, 0, 0, 6498, 6502, 5, 186, 0, 0, 6499, 6502, 5, 236, 0, 0, 6500, 6502, 3, 714, 357, 0, 6501, 6495, 1, 0, 0, 0, 6501, 6496, 1, 0, 0, 0, 6501, 6497, 1, 0, 0, 0, 6501, 6498, 1, 0, 0, 0, 6501, 6499, 1, 0, 0, 0, 6501, 6500, 1, 0, 0, 0, 6502, 641, 1, 0, 0, 0, 6503, 6508, 3, 640, 320, 0, 6504, 6505, 5, 6, 0, 0, 6505, 6507, 3, 640, 320, 0, 6506, 6504, 1, 0, 0, 0, 6507, 6510, 1, 0, 0, 0, 6508, 6506, 1, 0, 0, 0, 6508, 6509, 1, 0, 0, 0, 6509, 643, 1, 0, 0, 0, 6510, 6508, 1, 0, 0, 0, 6511, 6514, 5, 65, 0, 0, 6512, 6515, 5, 89, 0, 0, 6513, 6515, 3, 714, 357, 0, 6514, 6512, 1, 0, 0, 0, 6514, 6513, 1, 0, 0, 0, 6515, 6516, 1, 0, 0, 0, 6516, 6517, 5, 2, 0, 0, 6517, 6518, 3, 246, 123, 0, 6518, 6519, 5, 3, 0, 0, 6519, 6520, 5, 80, 0, 0, 6520, 6521, 5, 209, 0, 0, 6521, 6522, 5, 93, 0, 0, 6522, 6523, 3, 1888, 944, 0, 6523, 6524, 5, 95, 0, 0, 6524, 6526, 3, 646, 323, 0, 6525, 6527, 3, 720, 360, 0, 6526, 6525, 1, 0, 0, 0, 6526, 6527, 1, 0, 0, 0, 6527, 645, 1, 0, 0, 0, 6528, 6531, 3, 648, 324, 0, 6529, 6531, 5, 86, 0, 0, 6530, 6528, 1, 0, 0, 0, 6530, 6529, 1, 0, 0, 0, 6531, 647, 1, 0, 0, 0, 6532, 6533, 5, 396, 0, 0, 6533, 6539, 3, 1092, 546, 0, 6534, 6535, 5, 6, 0, 0, 6535, 6536, 5, 396, 0, 0, 6536, 6538, 3, 1092, 546, 0, 6537, 6534, 1, 0, 0, 0, 6538, 6541, 1, 0, 0, 0, 6539, 6537, 1, 0, 0, 0, 6539, 6540, 1, 0, 0, 0, 6540, 649, 1, 0, 0, 0, 6541, 6539, 1, 0, 0, 0, 6542, 6543, 5, 65, 0, 0, 6543, 6544, 5, 634, 0, 0, 6544, 6545, 3, 656, 328, 0, 6545, 6546, 5, 95, 0, 0, 6546, 6547, 3, 716, 358, 0, 6547, 6548, 5, 62, 0, 0, 6548, 6549, 3, 652, 326, 0, 6549, 651, 1, 0, 0, 0, 6550, 6555, 3, 654, 327, 0, 6551, 6552, 5, 6, 0, 0, 6552, 6554, 3, 654, 327, 0, 6553, 6551, 1, 0, 0, 0, 6554, 6557, 1, 0, 0, 0, 6555, 6553, 1, 0, 0, 0, 6555, 6556, 1, 0, 0, 0, 6556, 653, 1, 0, 0, 0, 6557, 6555, 1, 0, 0, 0, 6558, 6566, 5, 30, 0, 0, 6559, 6566, 5, 171, 0, 0, 6560, 6566, 5, 444, 0, 0, 6561, 6562, 5, 209, 0, 0, 6562, 6566, 5, 215, 0, 0, 6563, 6564, 5, 46, 0, 0, 6564, 6566, 5, 417, 0, 0, 6565, 6558, 1, 0, 0, 0, 6565, 6559, 1, 0, 0, 0, 6565, 6560, 1, 0, 0, 0, 6565, 6561, 1, 0, 0, 0, 6565, 6563, 1, 0, 0, 0, 6566, 655, 1, 0, 0, 0, 6567, 6572, 3, 1910, 955, 0, 6568, 6569, 5, 6, 0, 0, 6569, 6571, 3, 1910, 955, 0, 6570, 6568, 1, 0, 0, 0, 6571, 6574, 1, 0, 0, 0, 6572, 6570, 1, 0, 0, 0, 6572, 6573, 1, 0, 0, 0, 6573, 6578, 1, 0, 0, 0, 6574, 6572, 1, 0, 0, 0, 6575, 6578, 5, 53, 0, 0, 6576, 6578, 5, 30, 0, 0, 6577, 6567, 1, 0, 0, 0, 6577, 6575, 1, 0, 0, 0, 6577, 6576, 1, 0, 0, 0, 6578, 657, 1, 0, 0, 0, 6579, 6580, 5, 65, 0, 0, 6580, 6581, 3, 662, 331, 0, 6581, 6582, 5, 80, 0, 0, 6582, 6583, 3, 660, 330, 0, 6583, 6584, 5, 95, 0, 0, 6584, 6585, 3, 716, 358, 0, 6585, 659, 1, 0, 0, 0, 6586, 6588, 5, 93, 0, 0, 6587, 6586, 1, 0, 0, 0, 6587, 6588, 1, 0, 0, 0, 6588, 6589, 1, 0, 0, 0, 6589, 6590, 3, 1886, 943, 0, 6590, 661, 1, 0, 0, 0, 6591, 6596, 3, 666, 333, 0, 6592, 6593, 5, 6, 0, 0, 6593, 6595, 3, 666, 333, 0, 6594, 6592, 1, 0, 0, 0, 6595, 6598, 1, 0, 0, 0, 6596, 6594, 1, 0, 0, 0, 6596, 6597, 1, 0, 0, 0, 6597, 6608, 1, 0, 0, 0, 6598, 6596, 1, 0, 0, 0, 6599, 6604, 3, 664, 332, 0, 6600, 6601, 5, 6, 0, 0, 6601, 6603, 3, 664, 332, 0, 6602, 6600, 1, 0, 0, 0, 6603, 6606, 1, 0, 0, 0, 6604, 6602, 1, 0, 0, 0, 6604, 6605, 1, 0, 0, 0, 6605, 6608, 1, 0, 0, 0, 6606, 6604, 1, 0, 0, 0, 6607, 6591, 1, 0, 0, 0, 6607, 6599, 1, 0, 0, 0, 6608, 663, 1, 0, 0, 0, 6609, 6611, 5, 30, 0, 0, 6610, 6612, 5, 292, 0, 0, 6611, 6610, 1, 0, 0, 0, 6611, 6612, 1, 0, 0, 0, 6612, 6613, 1, 0, 0, 0, 6613, 6615, 5, 2, 0, 0, 6614, 6616, 3, 246, 123, 0, 6615, 6614, 1, 0, 0, 0, 6615, 6616, 1, 0, 0, 0, 6616, 6617, 1, 0, 0, 0, 6617, 6618, 5, 3, 0, 0, 6618, 665, 1, 0, 0, 0, 6619, 6620, 7, 40, 0, 0, 6620, 6622, 5, 2, 0, 0, 6621, 6623, 3, 246, 123, 0, 6622, 6621, 1, 0, 0, 0, 6622, 6623, 1, 0, 0, 0, 6623, 6624, 1, 0, 0, 0, 6624, 6625, 5, 3, 0, 0, 6625, 667, 1, 0, 0, 0, 6626, 6627, 5, 65, 0, 0, 6627, 6628, 3, 724, 362, 0, 6628, 6629, 5, 80, 0, 0, 6629, 6630, 3, 708, 354, 0, 6630, 6631, 5, 95, 0, 0, 6631, 6632, 3, 716, 358, 0, 6632, 6676, 1, 0, 0, 0, 6633, 6634, 5, 65, 0, 0, 6634, 6635, 3, 702, 351, 0, 6635, 6636, 5, 80, 0, 0, 6636, 6637, 3, 706, 353, 0, 6637, 6638, 5, 95, 0, 0, 6638, 6639, 3, 716, 358, 0, 6639, 6676, 1, 0, 0, 0, 6640, 6641, 5, 65, 0, 0, 6641, 6642, 3, 698, 349, 0, 6642, 6643, 5, 80, 0, 0, 6643, 6644, 3, 694, 347, 0, 6644, 6645, 5, 95, 0, 0, 6645, 6646, 3, 716, 358, 0, 6646, 6676, 1, 0, 0, 0, 6647, 6648, 5, 65, 0, 0, 6648, 6649, 3, 688, 344, 0, 6649, 6650, 5, 80, 0, 0, 6650, 6651, 3, 692, 346, 0, 6651, 6652, 5, 95, 0, 0, 6652, 6653, 3, 716, 358, 0, 6653, 6676, 1, 0, 0, 0, 6654, 6655, 5, 65, 0, 0, 6655, 6656, 3, 684, 342, 0, 6656, 6657, 5, 80, 0, 0, 6657, 6658, 3, 682, 341, 0, 6658, 6659, 5, 95, 0, 0, 6659, 6660, 3, 716, 358, 0, 6660, 6676, 1, 0, 0, 0, 6661, 6662, 5, 65, 0, 0, 6662, 6663, 3, 678, 339, 0, 6663, 6664, 5, 80, 0, 0, 6664, 6665, 3, 680, 340, 0, 6665, 6666, 5, 95, 0, 0, 6666, 6667, 3, 716, 358, 0, 6667, 6676, 1, 0, 0, 0, 6668, 6669, 5, 65, 0, 0, 6669, 6670, 3, 670, 335, 0, 6670, 6671, 5, 80, 0, 0, 6671, 6672, 3, 674, 337, 0, 6672, 6673, 5, 95, 0, 0, 6673, 6674, 3, 716, 358, 0, 6674, 6676, 1, 0, 0, 0, 6675, 6626, 1, 0, 0, 0, 6675, 6633, 1, 0, 0, 0, 6675, 6640, 1, 0, 0, 0, 6675, 6647, 1, 0, 0, 0, 6675, 6654, 1, 0, 0, 0, 6675, 6661, 1, 0, 0, 0, 6675, 6668, 1, 0, 0, 0, 6676, 669, 1, 0, 0, 0, 6677, 6682, 3, 672, 336, 0, 6678, 6679, 5, 6, 0, 0, 6679, 6681, 3, 672, 336, 0, 6680, 6678, 1, 0, 0, 0, 6681, 6684, 1, 0, 0, 0, 6682, 6680, 1, 0, 0, 0, 6682, 6683, 1, 0, 0, 0, 6683, 6687, 1, 0, 0, 0, 6684, 6682, 1, 0, 0, 0, 6685, 6687, 3, 714, 357, 0, 6686, 6677, 1, 0, 0, 0, 6686, 6685, 1, 0, 0, 0, 6687, 671, 1, 0, 0, 0, 6688, 6689, 7, 41, 0, 0, 6689, 673, 1, 0, 0, 0, 6690, 6691, 5, 171, 0, 0, 6691, 6692, 5, 631, 0, 0, 6692, 6697, 3, 676, 338, 0, 6693, 6694, 5, 6, 0, 0, 6694, 6696, 3, 676, 338, 0, 6695, 6693, 1, 0, 0, 0, 6696, 6699, 1, 0, 0, 0, 6697, 6695, 1, 0, 0, 0, 6697, 6698, 1, 0, 0, 0, 6698, 675, 1, 0, 0, 0, 6699, 6697, 1, 0, 0, 0, 6700, 6701, 3, 1924, 962, 0, 6701, 677, 1, 0, 0, 0, 6702, 6703, 5, 628, 0, 0, 6703, 679, 1, 0, 0, 0, 6704, 6705, 5, 242, 0, 0, 6705, 6706, 3, 246, 123, 0, 6706, 681, 1, 0, 0, 0, 6707, 6708, 5, 294, 0, 0, 6708, 6713, 3, 842, 421, 0, 6709, 6710, 5, 6, 0, 0, 6710, 6712, 3, 842, 421, 0, 6711, 6709, 1, 0, 0, 0, 6712, 6715, 1, 0, 0, 0, 6713, 6711, 1, 0, 0, 0, 6713, 6714, 1, 0, 0, 0, 6714, 6722, 1, 0, 0, 0, 6715, 6713, 1, 0, 0, 0, 6716, 6717, 5, 30, 0, 0, 6717, 6718, 5, 656, 0, 0, 6718, 6719, 5, 68, 0, 0, 6719, 6720, 5, 321, 0, 0, 6720, 6722, 3, 246, 123, 0, 6721, 6707, 1, 0, 0, 0, 6721, 6716, 1, 0, 0, 0, 6722, 683, 1, 0, 0, 0, 6723, 6726, 3, 686, 343, 0, 6724, 6726, 3, 714, 357, 0, 6725, 6723, 1, 0, 0, 0, 6725, 6724, 1, 0, 0, 0, 6726, 685, 1, 0, 0, 0, 6727, 6730, 5, 206, 0, 0, 6728, 6730, 3, 714, 357, 0, 6729, 6727, 1, 0, 0, 0, 6729, 6728, 1, 0, 0, 0, 6730, 687, 1, 0, 0, 0, 6731, 6734, 3, 690, 345, 0, 6732, 6734, 3, 714, 357, 0, 6733, 6731, 1, 0, 0, 0, 6733, 6732, 1, 0, 0, 0, 6734, 689, 1, 0, 0, 0, 6735, 6738, 5, 206, 0, 0, 6736, 6738, 3, 714, 357, 0, 6737, 6735, 1, 0, 0, 0, 6737, 6736, 1, 0, 0, 0, 6738, 691, 1, 0, 0, 0, 6739, 6740, 5, 215, 0, 0, 6740, 6745, 3, 842, 421, 0, 6741, 6742, 5, 6, 0, 0, 6742, 6744, 3, 842, 421, 0, 6743, 6741, 1, 0, 0, 0, 6744, 6747, 1, 0, 0, 0, 6745, 6743, 1, 0, 0, 0, 6745, 6746, 1, 0, 0, 0, 6746, 6754, 1, 0, 0, 0, 6747, 6745, 1, 0, 0, 0, 6748, 6749, 5, 30, 0, 0, 6749, 6750, 5, 216, 0, 0, 6750, 6751, 5, 68, 0, 0, 6751, 6752, 5, 321, 0, 0, 6752, 6754, 3, 246, 123, 0, 6753, 6739, 1, 0, 0, 0, 6753, 6748, 1, 0, 0, 0, 6754, 693, 1, 0, 0, 0, 6755, 6756, 5, 321, 0, 0, 6756, 6761, 3, 1924, 962, 0, 6757, 6758, 5, 6, 0, 0, 6758, 6760, 3, 1924, 962, 0, 6759, 6757, 1, 0, 0, 0, 6760, 6763, 1, 0, 0, 0, 6761, 6759, 1, 0, 0, 0, 6761, 6762, 1, 0, 0, 0, 6762, 695, 1, 0, 0, 0, 6763, 6761, 1, 0, 0, 0, 6764, 6767, 5, 321, 0, 0, 6765, 6766, 5, 224, 0, 0, 6766, 6768, 5, 558, 0, 0, 6767, 6765, 1, 0, 0, 0, 6767, 6768, 1, 0, 0, 0, 6768, 6769, 1, 0, 0, 0, 6769, 6774, 3, 1924, 962, 0, 6770, 6771, 5, 6, 0, 0, 6771, 6773, 3, 1924, 962, 0, 6772, 6770, 1, 0, 0, 0, 6773, 6776, 1, 0, 0, 0, 6774, 6772, 1, 0, 0, 0, 6774, 6775, 1, 0, 0, 0, 6775, 697, 1, 0, 0, 0, 6776, 6774, 1, 0, 0, 0, 6777, 6782, 3, 700, 350, 0, 6778, 6779, 5, 6, 0, 0, 6779, 6781, 3, 700, 350, 0, 6780, 6778, 1, 0, 0, 0, 6781, 6784, 1, 0, 0, 0, 6782, 6780, 1, 0, 0, 0, 6782, 6783, 1, 0, 0, 0, 6783, 6787, 1, 0, 0, 0, 6784, 6782, 1, 0, 0, 0, 6785, 6787, 3, 714, 357, 0, 6786, 6777, 1, 0, 0, 0, 6786, 6785, 1, 0, 0, 0, 6787, 699, 1, 0, 0, 0, 6788, 6789, 7, 42, 0, 0, 6789, 701, 1, 0, 0, 0, 6790, 6795, 3, 704, 352, 0, 6791, 6792, 5, 6, 0, 0, 6792, 6794, 3, 704, 352, 0, 6793, 6791, 1, 0, 0, 0, 6794, 6797, 1, 0, 0, 0, 6795, 6793, 1, 0, 0, 0, 6795, 6796, 1, 0, 0, 0, 6796, 6800, 1, 0, 0, 0, 6797, 6795, 1, 0, 0, 0, 6798, 6800, 3, 714, 357, 0, 6799, 6790, 1, 0, 0, 0, 6799, 6798, 1, 0, 0, 0, 6800, 703, 1, 0, 0, 0, 6801, 6802, 7, 43, 0, 0, 6802, 705, 1, 0, 0, 0, 6803, 6804, 5, 179, 0, 0, 6804, 6809, 3, 1924, 962, 0, 6805, 6806, 5, 6, 0, 0, 6806, 6808, 3, 1924, 962, 0, 6807, 6805, 1, 0, 0, 0, 6808, 6811, 1, 0, 0, 0, 6809, 6807, 1, 0, 0, 0, 6809, 6810, 1, 0, 0, 0, 6810, 707, 1, 0, 0, 0, 6811, 6809, 1, 0, 0, 0, 6812, 6814, 5, 93, 0, 0, 6813, 6812, 1, 0, 0, 0, 6813, 6814, 1, 0, 0, 0, 6814, 6815, 1, 0, 0, 0, 6815, 6818, 3, 1886, 943, 0, 6816, 6818, 3, 712, 356, 0, 6817, 6813, 1, 0, 0, 0, 6817, 6816, 1, 0, 0, 0, 6818, 709, 1, 0, 0, 0, 6819, 6821, 5, 93, 0, 0, 6820, 6819, 1, 0, 0, 0, 6820, 6821, 1, 0, 0, 0, 6821, 6824, 1, 0, 0, 0, 6822, 6823, 5, 224, 0, 0, 6823, 6825, 5, 558, 0, 0, 6824, 6822, 1, 0, 0, 0, 6824, 6825, 1, 0, 0, 0, 6825, 6826, 1, 0, 0, 0, 6826, 6829, 3, 1886, 943, 0, 6827, 6829, 3, 712, 356, 0, 6828, 6820, 1, 0, 0, 0, 6828, 6827, 1, 0, 0, 0, 6829, 711, 1, 0, 0, 0, 6830, 6831, 5, 30, 0, 0, 6831, 6832, 5, 348, 0, 0, 6832, 6833, 5, 68, 0, 0, 6833, 6834, 5, 321, 0, 0, 6834, 6835, 3, 1886, 943, 0, 6835, 713, 1, 0, 0, 0, 6836, 6838, 5, 30, 0, 0, 6837, 6839, 5, 292, 0, 0, 6838, 6837, 1, 0, 0, 0, 6838, 6839, 1, 0, 0, 0, 6839, 715, 1, 0, 0, 0, 6840, 6845, 3, 718, 359, 0, 6841, 6842, 5, 6, 0, 0, 6842, 6844, 3, 718, 359, 0, 6843, 6841, 1, 0, 0, 0, 6844, 6847, 1, 0, 0, 0, 6845, 6843, 1, 0, 0, 0, 6845, 6846, 1, 0, 0, 0, 6846, 717, 1, 0, 0, 0, 6847, 6845, 1, 0, 0, 0, 6848, 6850, 3, 1920, 960, 0, 6849, 6851, 3, 720, 360, 0, 6850, 6849, 1, 0, 0, 0, 6850, 6851, 1, 0, 0, 0, 6851, 6858, 1, 0, 0, 0, 6852, 6853, 5, 66, 0, 0, 6853, 6858, 3, 1920, 960, 0, 6854, 6855, 5, 316, 0, 0, 6855, 6858, 3, 1920, 960, 0, 6856, 6858, 5, 86, 0, 0, 6857, 6848, 1, 0, 0, 0, 6857, 6852, 1, 0, 0, 0, 6857, 6854, 1, 0, 0, 0, 6857, 6856, 1, 0, 0, 0, 6858, 719, 1, 0, 0, 0, 6859, 6860, 5, 106, 0, 0, 6860, 6861, 5, 65, 0, 0, 6861, 6862, 5, 276, 0, 0, 6862, 721, 1, 0, 0, 0, 6863, 6864, 7, 44, 0, 0, 6864, 723, 1, 0, 0, 0, 6865, 6870, 3, 722, 361, 0, 6866, 6867, 5, 6, 0, 0, 6867, 6869, 3, 722, 361, 0, 6868, 6866, 1, 0, 0, 0, 6869, 6872, 1, 0, 0, 0, 6870, 6868, 1, 0, 0, 0, 6870, 6871, 1, 0, 0, 0, 6871, 6875, 1, 0, 0, 0, 6872, 6870, 1, 0, 0, 0, 6873, 6875, 3, 714, 357, 0, 6874, 6865, 1, 0, 0, 0, 6874, 6873, 1, 0, 0, 0, 6875, 725, 1, 0, 0, 0, 6876, 6887, 3, 764, 382, 0, 6877, 6887, 3, 762, 381, 0, 6878, 6887, 3, 760, 380, 0, 6879, 6887, 3, 752, 376, 0, 6880, 6887, 3, 750, 375, 0, 6881, 6887, 3, 736, 368, 0, 6882, 6887, 3, 732, 366, 0, 6883, 6887, 3, 734, 367, 0, 6884, 6887, 3, 730, 365, 0, 6885, 6887, 3, 728, 364, 0, 6886, 6876, 1, 0, 0, 0, 6886, 6877, 1, 0, 0, 0, 6886, 6878, 1, 0, 0, 0, 6886, 6879, 1, 0, 0, 0, 6886, 6880, 1, 0, 0, 0, 6886, 6881, 1, 0, 0, 0, 6886, 6882, 1, 0, 0, 0, 6886, 6883, 1, 0, 0, 0, 6886, 6884, 1, 0, 0, 0, 6886, 6885, 1, 0, 0, 0, 6887, 727, 1, 0, 0, 0, 6888, 6889, 5, 315, 0, 0, 6889, 6890, 5, 89, 0, 0, 6890, 6892, 5, 80, 0, 0, 6891, 6893, 5, 93, 0, 0, 6892, 6891, 1, 0, 0, 0, 6892, 6893, 1, 0, 0, 0, 6893, 6894, 1, 0, 0, 0, 6894, 6895, 3, 1886, 943, 0, 6895, 6896, 5, 64, 0, 0, 6896, 6897, 5, 413, 0, 0, 6897, 6898, 5, 643, 0, 0, 6898, 6900, 3, 246, 123, 0, 6899, 6901, 3, 120, 60, 0, 6900, 6899, 1, 0, 0, 0, 6900, 6901, 1, 0, 0, 0, 6901, 729, 1, 0, 0, 0, 6902, 6903, 5, 315, 0, 0, 6903, 6904, 7, 36, 0, 0, 6904, 6905, 5, 413, 0, 0, 6905, 6906, 5, 64, 0, 0, 6906, 6907, 5, 316, 0, 0, 6907, 6909, 3, 1920, 960, 0, 6908, 6910, 3, 120, 60, 0, 6909, 6908, 1, 0, 0, 0, 6909, 6910, 1, 0, 0, 0, 6910, 731, 1, 0, 0, 0, 6911, 6912, 5, 315, 0, 0, 6912, 6913, 5, 46, 0, 0, 6913, 6914, 5, 417, 0, 0, 6914, 6915, 5, 64, 0, 0, 6915, 6917, 3, 716, 358, 0, 6916, 6918, 3, 120, 60, 0, 6917, 6916, 1, 0, 0, 0, 6917, 6918, 1, 0, 0, 0, 6918, 6930, 1, 0, 0, 0, 6919, 6920, 5, 315, 0, 0, 6920, 6921, 3, 688, 344, 0, 6921, 6922, 5, 80, 0, 0, 6922, 6923, 5, 417, 0, 0, 6923, 6924, 3, 246, 123, 0, 6924, 6925, 5, 64, 0, 0, 6925, 6927, 3, 716, 358, 0, 6926, 6928, 3, 120, 60, 0, 6927, 6926, 1, 0, 0, 0, 6927, 6928, 1, 0, 0, 0, 6928, 6930, 1, 0, 0, 0, 6929, 6911, 1, 0, 0, 0, 6929, 6919, 1, 0, 0, 0, 6930, 733, 1, 0, 0, 0, 6931, 6932, 5, 315, 0, 0, 6932, 6933, 5, 316, 0, 0, 6933, 6939, 3, 1920, 960, 0, 6934, 6935, 5, 6, 0, 0, 6935, 6936, 5, 316, 0, 0, 6936, 6938, 3, 1920, 960, 0, 6937, 6934, 1, 0, 0, 0, 6938, 6941, 1, 0, 0, 0, 6939, 6937, 1, 0, 0, 0, 6939, 6940, 1, 0, 0, 0, 6940, 6942, 1, 0, 0, 0, 6941, 6939, 1, 0, 0, 0, 6942, 6943, 5, 64, 0, 0, 6943, 6945, 3, 600, 300, 0, 6944, 6946, 3, 120, 60, 0, 6945, 6944, 1, 0, 0, 0, 6945, 6946, 1, 0, 0, 0, 6946, 6975, 1, 0, 0, 0, 6947, 6948, 5, 315, 0, 0, 6948, 6949, 3, 604, 302, 0, 6949, 6950, 5, 64, 0, 0, 6950, 6951, 5, 316, 0, 0, 6951, 6953, 3, 1922, 961, 0, 6952, 6954, 3, 120, 60, 0, 6953, 6952, 1, 0, 0, 0, 6953, 6954, 1, 0, 0, 0, 6954, 6975, 1, 0, 0, 0, 6955, 6956, 5, 315, 0, 0, 6956, 6957, 5, 136, 0, 0, 6957, 6958, 5, 276, 0, 0, 6958, 6959, 5, 62, 0, 0, 6959, 6960, 5, 316, 0, 0, 6960, 6966, 3, 1920, 960, 0, 6961, 6962, 5, 6, 0, 0, 6962, 6963, 5, 316, 0, 0, 6963, 6965, 3, 1920, 960, 0, 6964, 6961, 1, 0, 0, 0, 6965, 6968, 1, 0, 0, 0, 6966, 6964, 1, 0, 0, 0, 6966, 6967, 1, 0, 0, 0, 6967, 6969, 1, 0, 0, 0, 6968, 6966, 1, 0, 0, 0, 6969, 6970, 5, 64, 0, 0, 6970, 6972, 3, 600, 300, 0, 6971, 6973, 3, 120, 60, 0, 6972, 6971, 1, 0, 0, 0, 6972, 6973, 1, 0, 0, 0, 6973, 6975, 1, 0, 0, 0, 6974, 6931, 1, 0, 0, 0, 6974, 6947, 1, 0, 0, 0, 6974, 6955, 1, 0, 0, 0, 6975, 735, 1, 0, 0, 0, 6976, 6983, 3, 738, 369, 0, 6977, 6983, 3, 740, 370, 0, 6978, 6983, 3, 742, 371, 0, 6979, 6983, 3, 744, 372, 0, 6980, 6983, 3, 746, 373, 0, 6981, 6983, 3, 748, 374, 0, 6982, 6976, 1, 0, 0, 0, 6982, 6977, 1, 0, 0, 0, 6982, 6978, 1, 0, 0, 0, 6982, 6979, 1, 0, 0, 0, 6982, 6980, 1, 0, 0, 0, 6982, 6981, 1, 0, 0, 0, 6983, 737, 1, 0, 0, 0, 6984, 6985, 5, 315, 0, 0, 6985, 6986, 3, 698, 349, 0, 6986, 6987, 5, 62, 0, 0, 6987, 6988, 5, 655, 0, 0, 6988, 6989, 5, 68, 0, 0, 6989, 6990, 5, 179, 0, 0, 6990, 6991, 3, 1924, 962, 0, 6991, 6992, 5, 64, 0, 0, 6992, 6994, 3, 624, 312, 0, 6993, 6995, 3, 120, 60, 0, 6994, 6993, 1, 0, 0, 0, 6994, 6995, 1, 0, 0, 0, 6995, 739, 1, 0, 0, 0, 6996, 6997, 5, 315, 0, 0, 6997, 6998, 3, 724, 362, 0, 6998, 6999, 5, 62, 0, 0, 6999, 7000, 5, 348, 0, 0, 7000, 7009, 5, 68, 0, 0, 7001, 7002, 5, 321, 0, 0, 7002, 7005, 3, 1924, 962, 0, 7003, 7004, 5, 179, 0, 0, 7004, 7006, 3, 1924, 962, 0, 7005, 7003, 1, 0, 0, 0, 7005, 7006, 1, 0, 0, 0, 7006, 7010, 1, 0, 0, 0, 7007, 7008, 5, 179, 0, 0, 7008, 7010, 3, 1924, 962, 0, 7009, 7001, 1, 0, 0, 0, 7009, 7007, 1, 0, 0, 0, 7010, 7011, 1, 0, 0, 0, 7011, 7012, 5, 64, 0, 0, 7012, 7014, 3, 624, 312, 0, 7013, 7015, 3, 120, 60, 0, 7014, 7013, 1, 0, 0, 0, 7014, 7015, 1, 0, 0, 0, 7015, 741, 1, 0, 0, 0, 7016, 7017, 5, 315, 0, 0, 7017, 7018, 3, 688, 344, 0, 7018, 7019, 5, 62, 0, 0, 7019, 7020, 5, 216, 0, 0, 7020, 7029, 5, 68, 0, 0, 7021, 7022, 5, 321, 0, 0, 7022, 7025, 3, 1924, 962, 0, 7023, 7024, 5, 179, 0, 0, 7024, 7026, 3, 1924, 962, 0, 7025, 7023, 1, 0, 0, 0, 7025, 7026, 1, 0, 0, 0, 7026, 7030, 1, 0, 0, 0, 7027, 7028, 5, 179, 0, 0, 7028, 7030, 3, 1924, 962, 0, 7029, 7021, 1, 0, 0, 0, 7029, 7027, 1, 0, 0, 0, 7030, 7031, 1, 0, 0, 0, 7031, 7032, 5, 64, 0, 0, 7032, 7034, 3, 624, 312, 0, 7033, 7035, 3, 120, 60, 0, 7034, 7033, 1, 0, 0, 0, 7034, 7035, 1, 0, 0, 0, 7035, 743, 1, 0, 0, 0, 7036, 7037, 5, 315, 0, 0, 7037, 7038, 3, 684, 342, 0, 7038, 7039, 5, 62, 0, 0, 7039, 7040, 5, 656, 0, 0, 7040, 7049, 5, 68, 0, 0, 7041, 7042, 5, 321, 0, 0, 7042, 7045, 3, 1924, 962, 0, 7043, 7044, 5, 179, 0, 0, 7044, 7046, 3, 1924, 962, 0, 7045, 7043, 1, 0, 0, 0, 7045, 7046, 1, 0, 0, 0, 7046, 7050, 1, 0, 0, 0, 7047, 7048, 5, 179, 0, 0, 7048, 7050, 3, 1924, 962, 0, 7049, 7041, 1, 0, 0, 0, 7049, 7047, 1, 0, 0, 0, 7050, 7051, 1, 0, 0, 0, 7051, 7052, 5, 64, 0, 0, 7052, 7054, 3, 624, 312, 0, 7053, 7055, 3, 120, 60, 0, 7054, 7053, 1, 0, 0, 0, 7054, 7055, 1, 0, 0, 0, 7055, 745, 1, 0, 0, 0, 7056, 7057, 5, 315, 0, 0, 7057, 7058, 3, 678, 339, 0, 7058, 7059, 5, 62, 0, 0, 7059, 7060, 5, 630, 0, 0, 7060, 7061, 5, 68, 0, 0, 7061, 7062, 5, 179, 0, 0, 7062, 7063, 3, 1924, 962, 0, 7063, 7064, 5, 64, 0, 0, 7064, 7066, 3, 624, 312, 0, 7065, 7067, 3, 120, 60, 0, 7066, 7065, 1, 0, 0, 0, 7066, 7067, 1, 0, 0, 0, 7067, 747, 1, 0, 0, 0, 7068, 7069, 5, 315, 0, 0, 7069, 7070, 3, 670, 335, 0, 7070, 7071, 5, 62, 0, 0, 7071, 7072, 5, 171, 0, 0, 7072, 7073, 5, 632, 0, 0, 7073, 7082, 5, 68, 0, 0, 7074, 7075, 5, 321, 0, 0, 7075, 7078, 3, 1924, 962, 0, 7076, 7077, 5, 179, 0, 0, 7077, 7079, 3, 1924, 962, 0, 7078, 7076, 1, 0, 0, 0, 7078, 7079, 1, 0, 0, 0, 7079, 7083, 1, 0, 0, 0, 7080, 7081, 5, 179, 0, 0, 7081, 7083, 3, 1924, 962, 0, 7082, 7074, 1, 0, 0, 0, 7082, 7080, 1, 0, 0, 0, 7083, 7084, 1, 0, 0, 0, 7084, 7085, 5, 64, 0, 0, 7085, 7087, 3, 624, 312, 0, 7086, 7088, 3, 120, 60, 0, 7087, 7086, 1, 0, 0, 0, 7087, 7088, 1, 0, 0, 0, 7088, 749, 1, 0, 0, 0, 7089, 7093, 5, 315, 0, 0, 7090, 7091, 5, 65, 0, 0, 7091, 7092, 5, 276, 0, 0, 7092, 7094, 5, 62, 0, 0, 7093, 7090, 1, 0, 0, 0, 7093, 7094, 1, 0, 0, 0, 7094, 7095, 1, 0, 0, 0, 7095, 7096, 7, 39, 0, 0, 7096, 7097, 5, 80, 0, 0, 7097, 7098, 5, 392, 0, 0, 7098, 7099, 3, 1924, 962, 0, 7099, 7100, 5, 64, 0, 0, 7100, 7102, 3, 716, 358, 0, 7101, 7103, 3, 120, 60, 0, 7102, 7101, 1, 0, 0, 0, 7102, 7103, 1, 0, 0, 0, 7103, 7148, 1, 0, 0, 0, 7104, 7108, 5, 315, 0, 0, 7105, 7106, 5, 65, 0, 0, 7106, 7107, 5, 276, 0, 0, 7107, 7109, 5, 62, 0, 0, 7108, 7105, 1, 0, 0, 0, 7108, 7109, 1, 0, 0, 0, 7109, 7110, 1, 0, 0, 0, 7110, 7111, 5, 628, 0, 0, 7111, 7112, 5, 80, 0, 0, 7112, 7113, 5, 392, 0, 0, 7113, 7114, 3, 1924, 962, 0, 7114, 7123, 5, 64, 0, 0, 7115, 7116, 5, 467, 0, 0, 7116, 7124, 3, 1910, 955, 0, 7117, 7118, 5, 466, 0, 0, 7118, 7121, 3, 1910, 955, 0, 7119, 7120, 5, 633, 0, 0, 7120, 7122, 5, 178, 0, 0, 7121, 7119, 1, 0, 0, 0, 7121, 7122, 1, 0, 0, 0, 7122, 7124, 1, 0, 0, 0, 7123, 7115, 1, 0, 0, 0, 7123, 7117, 1, 0, 0, 0, 7124, 7126, 1, 0, 0, 0, 7125, 7127, 3, 120, 60, 0, 7126, 7125, 1, 0, 0, 0, 7126, 7127, 1, 0, 0, 0, 7127, 7148, 1, 0, 0, 0, 7128, 7132, 5, 315, 0, 0, 7129, 7130, 5, 65, 0, 0, 7130, 7131, 5, 276, 0, 0, 7131, 7133, 5, 62, 0, 0, 7132, 7129, 1, 0, 0, 0, 7132, 7133, 1, 0, 0, 0, 7133, 7134, 1, 0, 0, 0, 7134, 7135, 5, 628, 0, 0, 7135, 7140, 5, 80, 0, 0, 7136, 7137, 5, 179, 0, 0, 7137, 7141, 3, 246, 123, 0, 7138, 7139, 5, 321, 0, 0, 7139, 7141, 3, 1924, 962, 0, 7140, 7136, 1, 0, 0, 0, 7140, 7138, 1, 0, 0, 0, 7141, 7142, 1, 0, 0, 0, 7142, 7143, 5, 64, 0, 0, 7143, 7145, 3, 716, 358, 0, 7144, 7146, 3, 120, 60, 0, 7145, 7144, 1, 0, 0, 0, 7145, 7146, 1, 0, 0, 0, 7146, 7148, 1, 0, 0, 0, 7147, 7089, 1, 0, 0, 0, 7147, 7104, 1, 0, 0, 0, 7147, 7128, 1, 0, 0, 0, 7148, 751, 1, 0, 0, 0, 7149, 7153, 3, 758, 379, 0, 7150, 7153, 3, 756, 378, 0, 7151, 7153, 3, 754, 377, 0, 7152, 7149, 1, 0, 0, 0, 7152, 7150, 1, 0, 0, 0, 7152, 7151, 1, 0, 0, 0, 7153, 753, 1, 0, 0, 0, 7154, 7155, 5, 315, 0, 0, 7155, 7156, 3, 634, 317, 0, 7156, 7157, 5, 80, 0, 0, 7157, 7158, 5, 209, 0, 0, 7158, 7159, 5, 321, 0, 0, 7159, 7160, 3, 246, 123, 0, 7160, 7161, 5, 64, 0, 0, 7161, 7163, 3, 648, 324, 0, 7162, 7164, 3, 120, 60, 0, 7163, 7162, 1, 0, 0, 0, 7163, 7164, 1, 0, 0, 0, 7164, 755, 1, 0, 0, 0, 7165, 7166, 5, 315, 0, 0, 7166, 7167, 3, 642, 321, 0, 7167, 7168, 5, 80, 0, 0, 7168, 7169, 5, 209, 0, 0, 7169, 7170, 5, 93, 0, 0, 7170, 7171, 3, 1886, 943, 0, 7171, 7172, 5, 64, 0, 0, 7172, 7174, 3, 646, 323, 0, 7173, 7175, 3, 120, 60, 0, 7174, 7173, 1, 0, 0, 0, 7174, 7175, 1, 0, 0, 0, 7175, 757, 1, 0, 0, 0, 7176, 7179, 5, 315, 0, 0, 7177, 7180, 5, 89, 0, 0, 7178, 7180, 3, 714, 357, 0, 7179, 7177, 1, 0, 0, 0, 7179, 7178, 1, 0, 0, 0, 7180, 7181, 1, 0, 0, 0, 7181, 7182, 5, 2, 0, 0, 7182, 7183, 3, 246, 123, 0, 7183, 7184, 5, 3, 0, 0, 7184, 7185, 5, 80, 0, 0, 7185, 7186, 5, 209, 0, 0, 7186, 7187, 5, 93, 0, 0, 7187, 7188, 3, 1888, 944, 0, 7188, 7189, 5, 64, 0, 0, 7189, 7191, 3, 648, 324, 0, 7190, 7192, 3, 120, 60, 0, 7191, 7190, 1, 0, 0, 0, 7191, 7192, 1, 0, 0, 0, 7192, 759, 1, 0, 0, 0, 7193, 7194, 5, 315, 0, 0, 7194, 7195, 5, 634, 0, 0, 7195, 7196, 3, 656, 328, 0, 7196, 7197, 5, 64, 0, 0, 7197, 7198, 3, 716, 358, 0, 7198, 7199, 5, 62, 0, 0, 7199, 7201, 3, 652, 326, 0, 7200, 7202, 3, 120, 60, 0, 7201, 7200, 1, 0, 0, 0, 7201, 7202, 1, 0, 0, 0, 7202, 761, 1, 0, 0, 0, 7203, 7204, 5, 315, 0, 0, 7204, 7205, 3, 662, 331, 0, 7205, 7206, 5, 80, 0, 0, 7206, 7207, 3, 660, 330, 0, 7207, 7208, 5, 64, 0, 0, 7208, 7210, 3, 716, 358, 0, 7209, 7211, 3, 120, 60, 0, 7210, 7209, 1, 0, 0, 0, 7210, 7211, 1, 0, 0, 0, 7211, 7225, 1, 0, 0, 0, 7212, 7213, 5, 315, 0, 0, 7213, 7214, 5, 65, 0, 0, 7214, 7215, 5, 276, 0, 0, 7215, 7216, 5, 62, 0, 0, 7216, 7217, 3, 662, 331, 0, 7217, 7218, 5, 80, 0, 0, 7218, 7219, 3, 660, 330, 0, 7219, 7220, 5, 64, 0, 0, 7220, 7222, 3, 716, 358, 0, 7221, 7223, 3, 120, 60, 0, 7222, 7221, 1, 0, 0, 0, 7222, 7223, 1, 0, 0, 0, 7223, 7225, 1, 0, 0, 0, 7224, 7203, 1, 0, 0, 0, 7224, 7212, 1, 0, 0, 0, 7225, 763, 1, 0, 0, 0, 7226, 7230, 5, 315, 0, 0, 7227, 7228, 5, 65, 0, 0, 7228, 7229, 5, 276, 0, 0, 7229, 7231, 5, 62, 0, 0, 7230, 7227, 1, 0, 0, 0, 7230, 7231, 1, 0, 0, 0, 7231, 7232, 1, 0, 0, 0, 7232, 7233, 3, 724, 362, 0, 7233, 7234, 5, 80, 0, 0, 7234, 7235, 3, 710, 355, 0, 7235, 7236, 5, 64, 0, 0, 7236, 7238, 3, 716, 358, 0, 7237, 7239, 3, 120, 60, 0, 7238, 7237, 1, 0, 0, 0, 7238, 7239, 1, 0, 0, 0, 7239, 7325, 1, 0, 0, 0, 7240, 7244, 5, 315, 0, 0, 7241, 7242, 5, 65, 0, 0, 7242, 7243, 5, 276, 0, 0, 7243, 7245, 5, 62, 0, 0, 7244, 7241, 1, 0, 0, 0, 7244, 7245, 1, 0, 0, 0, 7245, 7246, 1, 0, 0, 0, 7246, 7247, 3, 702, 351, 0, 7247, 7248, 5, 80, 0, 0, 7248, 7249, 3, 706, 353, 0, 7249, 7250, 5, 64, 0, 0, 7250, 7252, 3, 716, 358, 0, 7251, 7253, 3, 120, 60, 0, 7252, 7251, 1, 0, 0, 0, 7252, 7253, 1, 0, 0, 0, 7253, 7325, 1, 0, 0, 0, 7254, 7258, 5, 315, 0, 0, 7255, 7256, 5, 65, 0, 0, 7256, 7257, 5, 276, 0, 0, 7257, 7259, 5, 62, 0, 0, 7258, 7255, 1, 0, 0, 0, 7258, 7259, 1, 0, 0, 0, 7259, 7260, 1, 0, 0, 0, 7260, 7261, 3, 698, 349, 0, 7261, 7262, 5, 80, 0, 0, 7262, 7263, 3, 696, 348, 0, 7263, 7264, 5, 64, 0, 0, 7264, 7266, 3, 716, 358, 0, 7265, 7267, 3, 120, 60, 0, 7266, 7265, 1, 0, 0, 0, 7266, 7267, 1, 0, 0, 0, 7267, 7325, 1, 0, 0, 0, 7268, 7272, 5, 315, 0, 0, 7269, 7270, 5, 65, 0, 0, 7270, 7271, 5, 276, 0, 0, 7271, 7273, 5, 62, 0, 0, 7272, 7269, 1, 0, 0, 0, 7272, 7273, 1, 0, 0, 0, 7273, 7274, 1, 0, 0, 0, 7274, 7275, 3, 688, 344, 0, 7275, 7276, 5, 80, 0, 0, 7276, 7277, 3, 692, 346, 0, 7277, 7278, 5, 64, 0, 0, 7278, 7280, 3, 716, 358, 0, 7279, 7281, 3, 120, 60, 0, 7280, 7279, 1, 0, 0, 0, 7280, 7281, 1, 0, 0, 0, 7281, 7325, 1, 0, 0, 0, 7282, 7286, 5, 315, 0, 0, 7283, 7284, 5, 65, 0, 0, 7284, 7285, 5, 276, 0, 0, 7285, 7287, 5, 62, 0, 0, 7286, 7283, 1, 0, 0, 0, 7286, 7287, 1, 0, 0, 0, 7287, 7288, 1, 0, 0, 0, 7288, 7289, 3, 684, 342, 0, 7289, 7290, 5, 80, 0, 0, 7290, 7291, 3, 682, 341, 0, 7291, 7292, 5, 64, 0, 0, 7292, 7294, 3, 716, 358, 0, 7293, 7295, 3, 120, 60, 0, 7294, 7293, 1, 0, 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 7325, 1, 0, 0, 0, 7296, 7300, 5, 315, 0, 0, 7297, 7298, 5, 65, 0, 0, 7298, 7299, 5, 276, 0, 0, 7299, 7301, 5, 62, 0, 0, 7300, 7297, 1, 0, 0, 0, 7300, 7301, 1, 0, 0, 0, 7301, 7302, 1, 0, 0, 0, 7302, 7303, 3, 678, 339, 0, 7303, 7304, 5, 80, 0, 0, 7304, 7305, 3, 680, 340, 0, 7305, 7306, 5, 64, 0, 0, 7306, 7308, 3, 716, 358, 0, 7307, 7309, 3, 120, 60, 0, 7308, 7307, 1, 0, 0, 0, 7308, 7309, 1, 0, 0, 0, 7309, 7325, 1, 0, 0, 0, 7310, 7314, 5, 315, 0, 0, 7311, 7312, 5, 65, 0, 0, 7312, 7313, 5, 276, 0, 0, 7313, 7315, 5, 62, 0, 0, 7314, 7311, 1, 0, 0, 0, 7314, 7315, 1, 0, 0, 0, 7315, 7316, 1, 0, 0, 0, 7316, 7317, 3, 670, 335, 0, 7317, 7318, 5, 80, 0, 0, 7318, 7319, 3, 674, 337, 0, 7319, 7320, 5, 64, 0, 0, 7320, 7322, 3, 716, 358, 0, 7321, 7323, 3, 120, 60, 0, 7322, 7321, 1, 0, 0, 0, 7322, 7323, 1, 0, 0, 0, 7323, 7325, 1, 0, 0, 0, 7324, 7226, 1, 0, 0, 0, 7324, 7240, 1, 0, 0, 0, 7324, 7254, 1, 0, 0, 0, 7324, 7268, 1, 0, 0, 0, 7324, 7282, 1, 0, 0, 0, 7324, 7296, 1, 0, 0, 0, 7324, 7310, 1, 0, 0, 0, 7325, 765, 1, 0, 0, 0, 7326, 7342, 3, 768, 384, 0, 7327, 7342, 5, 30, 0, 0, 7328, 7329, 5, 30, 0, 0, 7329, 7342, 5, 292, 0, 0, 7330, 7331, 5, 30, 0, 0, 7331, 7332, 5, 2, 0, 0, 7332, 7333, 3, 246, 123, 0, 7333, 7334, 5, 3, 0, 0, 7334, 7342, 1, 0, 0, 0, 7335, 7336, 5, 30, 0, 0, 7336, 7337, 5, 292, 0, 0, 7337, 7338, 5, 2, 0, 0, 7338, 7339, 3, 246, 123, 0, 7339, 7340, 5, 3, 0, 0, 7340, 7342, 1, 0, 0, 0, 7341, 7326, 1, 0, 0, 0, 7341, 7327, 1, 0, 0, 0, 7341, 7328, 1, 0, 0, 0, 7341, 7330, 1, 0, 0, 0, 7341, 7335, 1, 0, 0, 0, 7342, 767, 1, 0, 0, 0, 7343, 7348, 3, 770, 385, 0, 7344, 7345, 5, 6, 0, 0, 7345, 7347, 3, 770, 385, 0, 7346, 7344, 1, 0, 0, 0, 7347, 7350, 1, 0, 0, 0, 7348, 7346, 1, 0, 0, 0, 7348, 7349, 1, 0, 0, 0, 7349, 769, 1, 0, 0, 0, 7350, 7348, 1, 0, 0, 0, 7351, 7353, 5, 89, 0, 0, 7352, 7354, 3, 244, 122, 0, 7353, 7352, 1, 0, 0, 0, 7353, 7354, 1, 0, 0, 0, 7354, 7370, 1, 0, 0, 0, 7355, 7357, 5, 87, 0, 0, 7356, 7358, 3, 244, 122, 0, 7357, 7356, 1, 0, 0, 0, 7357, 7358, 1, 0, 0, 0, 7358, 7370, 1, 0, 0, 0, 7359, 7361, 5, 46, 0, 0, 7360, 7362, 3, 244, 122, 0, 7361, 7360, 1, 0, 0, 0, 7361, 7362, 1, 0, 0, 0, 7362, 7370, 1, 0, 0, 0, 7363, 7364, 5, 140, 0, 0, 7364, 7370, 5, 347, 0, 0, 7365, 7367, 3, 1924, 962, 0, 7366, 7368, 3, 244, 122, 0, 7367, 7366, 1, 0, 0, 0, 7367, 7368, 1, 0, 0, 0, 7368, 7370, 1, 0, 0, 0, 7369, 7351, 1, 0, 0, 0, 7369, 7355, 1, 0, 0, 0, 7369, 7359, 1, 0, 0, 0, 7369, 7363, 1, 0, 0, 0, 7369, 7365, 1, 0, 0, 0, 7370, 771, 1, 0, 0, 0, 7371, 7432, 3, 1886, 943, 0, 7372, 7373, 5, 93, 0, 0, 7373, 7432, 3, 1886, 943, 0, 7374, 7375, 5, 326, 0, 0, 7375, 7432, 3, 1886, 943, 0, 7376, 7377, 5, 63, 0, 0, 7377, 7378, 5, 177, 0, 0, 7378, 7379, 5, 379, 0, 0, 7379, 7432, 3, 1890, 945, 0, 7380, 7381, 5, 63, 0, 0, 7381, 7382, 5, 329, 0, 0, 7382, 7432, 3, 1890, 945, 0, 7383, 7384, 5, 215, 0, 0, 7384, 7432, 3, 842, 421, 0, 7385, 7386, 5, 294, 0, 0, 7386, 7432, 3, 842, 421, 0, 7387, 7388, 5, 640, 0, 0, 7388, 7432, 3, 842, 421, 0, 7389, 7390, 5, 179, 0, 0, 7390, 7432, 3, 1890, 945, 0, 7391, 7392, 5, 193, 0, 0, 7392, 7432, 3, 564, 282, 0, 7393, 7394, 5, 242, 0, 0, 7394, 7432, 3, 1890, 945, 0, 7395, 7396, 5, 243, 0, 0, 7396, 7397, 5, 271, 0, 0, 7397, 7432, 3, 336, 168, 0, 7398, 7399, 5, 573, 0, 0, 7399, 7432, 3, 774, 387, 0, 7400, 7401, 5, 321, 0, 0, 7401, 7432, 3, 1890, 945, 0, 7402, 7403, 5, 349, 0, 0, 7403, 7432, 3, 1890, 945, 0, 7404, 7405, 5, 358, 0, 0, 7405, 7432, 3, 564, 282, 0, 7406, 7407, 5, 30, 0, 0, 7407, 7408, 5, 348, 0, 0, 7408, 7409, 5, 68, 0, 0, 7409, 7410, 5, 321, 0, 0, 7410, 7432, 3, 1890, 945, 0, 7411, 7412, 5, 30, 0, 0, 7412, 7413, 5, 327, 0, 0, 7413, 7414, 5, 68, 0, 0, 7414, 7415, 5, 321, 0, 0, 7415, 7432, 3, 1890, 945, 0, 7416, 7417, 5, 30, 0, 0, 7417, 7418, 5, 216, 0, 0, 7418, 7419, 5, 68, 0, 0, 7419, 7420, 5, 321, 0, 0, 7420, 7432, 3, 1890, 945, 0, 7421, 7422, 5, 30, 0, 0, 7422, 7423, 5, 656, 0, 0, 7423, 7424, 5, 68, 0, 0, 7424, 7425, 5, 321, 0, 0, 7425, 7432, 3, 1890, 945, 0, 7426, 7427, 5, 30, 0, 0, 7427, 7428, 5, 654, 0, 0, 7428, 7429, 5, 68, 0, 0, 7429, 7430, 5, 321, 0, 0, 7430, 7432, 3, 1890, 945, 0, 7431, 7371, 1, 0, 0, 0, 7431, 7372, 1, 0, 0, 0, 7431, 7374, 1, 0, 0, 0, 7431, 7376, 1, 0, 0, 0, 7431, 7380, 1, 0, 0, 0, 7431, 7383, 1, 0, 0, 0, 7431, 7385, 1, 0, 0, 0, 7431, 7387, 1, 0, 0, 0, 7431, 7389, 1, 0, 0, 0, 7431, 7391, 1, 0, 0, 0, 7431, 7393, 1, 0, 0, 0, 7431, 7395, 1, 0, 0, 0, 7431, 7398, 1, 0, 0, 0, 7431, 7400, 1, 0, 0, 0, 7431, 7402, 1, 0, 0, 0, 7431, 7404, 1, 0, 0, 0, 7431, 7406, 1, 0, 0, 0, 7431, 7411, 1, 0, 0, 0, 7431, 7416, 1, 0, 0, 0, 7431, 7421, 1, 0, 0, 0, 7431, 7426, 1, 0, 0, 0, 7432, 773, 1, 0, 0, 0, 7433, 7438, 3, 776, 388, 0, 7434, 7435, 5, 6, 0, 0, 7435, 7437, 3, 776, 388, 0, 7436, 7434, 1, 0, 0, 0, 7437, 7440, 1, 0, 0, 0, 7438, 7436, 1, 0, 0, 0, 7438, 7439, 1, 0, 0, 0, 7439, 775, 1, 0, 0, 0, 7440, 7438, 1, 0, 0, 0, 7441, 7444, 3, 1924, 962, 0, 7442, 7443, 5, 11, 0, 0, 7443, 7445, 3, 1924, 962, 0, 7444, 7442, 1, 0, 0, 0, 7444, 7445, 1, 0, 0, 0, 7445, 777, 1, 0, 0, 0, 7446, 7447, 5, 106, 0, 0, 7447, 7448, 5, 65, 0, 0, 7448, 7449, 5, 276, 0, 0, 7449, 779, 1, 0, 0, 0, 7450, 7451, 5, 65, 0, 0, 7451, 7452, 3, 768, 384, 0, 7452, 7453, 5, 95, 0, 0, 7453, 7455, 3, 1922, 961, 0, 7454, 7456, 3, 784, 392, 0, 7455, 7454, 1, 0, 0, 0, 7455, 7456, 1, 0, 0, 0, 7456, 7458, 1, 0, 0, 0, 7457, 7459, 3, 786, 393, 0, 7458, 7457, 1, 0, 0, 0, 7458, 7459, 1, 0, 0, 0, 7459, 781, 1, 0, 0, 0, 7460, 7461, 5, 315, 0, 0, 7461, 7462, 3, 768, 384, 0, 7462, 7463, 5, 64, 0, 0, 7463, 7465, 3, 1922, 961, 0, 7464, 7466, 3, 786, 393, 0, 7465, 7464, 1, 0, 0, 0, 7465, 7466, 1, 0, 0, 0, 7466, 7468, 1, 0, 0, 0, 7467, 7469, 3, 120, 60, 0, 7468, 7467, 1, 0, 0, 0, 7468, 7469, 1, 0, 0, 0, 7469, 7484, 1, 0, 0, 0, 7470, 7471, 5, 315, 0, 0, 7471, 7472, 5, 136, 0, 0, 7472, 7473, 5, 276, 0, 0, 7473, 7474, 5, 62, 0, 0, 7474, 7475, 3, 768, 384, 0, 7475, 7476, 5, 64, 0, 0, 7476, 7478, 3, 1922, 961, 0, 7477, 7479, 3, 786, 393, 0, 7478, 7477, 1, 0, 0, 0, 7478, 7479, 1, 0, 0, 0, 7479, 7481, 1, 0, 0, 0, 7480, 7482, 3, 120, 60, 0, 7481, 7480, 1, 0, 0, 0, 7481, 7482, 1, 0, 0, 0, 7482, 7484, 1, 0, 0, 0, 7483, 7460, 1, 0, 0, 0, 7483, 7470, 1, 0, 0, 0, 7484, 783, 1, 0, 0, 0, 7485, 7486, 5, 106, 0, 0, 7486, 7487, 5, 136, 0, 0, 7487, 7488, 5, 276, 0, 0, 7488, 785, 1, 0, 0, 0, 7489, 7490, 5, 218, 0, 0, 7490, 7491, 5, 149, 0, 0, 7491, 7492, 3, 1920, 960, 0, 7492, 787, 1, 0, 0, 0, 7493, 7494, 5, 140, 0, 0, 7494, 7495, 5, 53, 0, 0, 7495, 7496, 5, 292, 0, 0, 7496, 7497, 3, 790, 395, 0, 7497, 7498, 3, 794, 397, 0, 7498, 789, 1, 0, 0, 0, 7499, 7501, 3, 792, 396, 0, 7500, 7499, 1, 0, 0, 0, 7501, 7504, 1, 0, 0, 0, 7502, 7500, 1, 0, 0, 0, 7502, 7503, 1, 0, 0, 0, 7503, 791, 1, 0, 0, 0, 7504, 7502, 1, 0, 0, 0, 7505, 7506, 5, 68, 0, 0, 7506, 7507, 5, 321, 0, 0, 7507, 7515, 3, 1890, 945, 0, 7508, 7509, 5, 62, 0, 0, 7509, 7510, 5, 316, 0, 0, 7510, 7515, 3, 1922, 961, 0, 7511, 7512, 5, 62, 0, 0, 7512, 7513, 5, 100, 0, 0, 7513, 7515, 3, 1922, 961, 0, 7514, 7505, 1, 0, 0, 0, 7514, 7508, 1, 0, 0, 0, 7514, 7511, 1, 0, 0, 0, 7515, 793, 1, 0, 0, 0, 7516, 7517, 5, 65, 0, 0, 7517, 7518, 3, 766, 383, 0, 7518, 7519, 5, 80, 0, 0, 7519, 7520, 3, 796, 398, 0, 7520, 7521, 5, 95, 0, 0, 7521, 7523, 3, 716, 358, 0, 7522, 7524, 3, 778, 389, 0, 7523, 7522, 1, 0, 0, 0, 7523, 7524, 1, 0, 0, 0, 7524, 7547, 1, 0, 0, 0, 7525, 7526, 5, 315, 0, 0, 7526, 7527, 3, 766, 383, 0, 7527, 7528, 5, 80, 0, 0, 7528, 7529, 3, 796, 398, 0, 7529, 7530, 5, 64, 0, 0, 7530, 7532, 3, 716, 358, 0, 7531, 7533, 3, 120, 60, 0, 7532, 7531, 1, 0, 0, 0, 7532, 7533, 1, 0, 0, 0, 7533, 7547, 1, 0, 0, 0, 7534, 7535, 5, 315, 0, 0, 7535, 7536, 5, 65, 0, 0, 7536, 7537, 5, 276, 0, 0, 7537, 7538, 5, 62, 0, 0, 7538, 7539, 3, 766, 383, 0, 7539, 7540, 5, 80, 0, 0, 7540, 7541, 3, 796, 398, 0, 7541, 7542, 5, 64, 0, 0, 7542, 7544, 3, 716, 358, 0, 7543, 7545, 3, 120, 60, 0, 7544, 7543, 1, 0, 0, 0, 7544, 7545, 1, 0, 0, 0, 7545, 7547, 1, 0, 0, 0, 7546, 7516, 1, 0, 0, 0, 7546, 7525, 1, 0, 0, 0, 7546, 7534, 1, 0, 0, 0, 7547, 795, 1, 0, 0, 0, 7548, 7549, 7, 45, 0, 0, 7549, 797, 1, 0, 0, 0, 7550, 7552, 5, 46, 0, 0, 7551, 7553, 3, 800, 400, 0, 7552, 7551, 1, 0, 0, 0, 7552, 7553, 1, 0, 0, 0, 7553, 7554, 1, 0, 0, 0, 7554, 7556, 5, 230, 0, 0, 7555, 7557, 3, 802, 401, 0, 7556, 7555, 1, 0, 0, 0, 7556, 7557, 1, 0, 0, 0, 7557, 7564, 1, 0, 0, 0, 7558, 7559, 5, 224, 0, 0, 7559, 7560, 5, 77, 0, 0, 7560, 7562, 5, 558, 0, 0, 7561, 7558, 1, 0, 0, 0, 7561, 7562, 1, 0, 0, 0, 7562, 7563, 1, 0, 0, 0, 7563, 7565, 3, 1892, 946, 0, 7564, 7561, 1, 0, 0, 0, 7564, 7565, 1, 0, 0, 0, 7565, 7566, 1, 0, 0, 0, 7566, 7567, 5, 80, 0, 0, 7567, 7569, 3, 1618, 809, 0, 7568, 7570, 3, 806, 403, 0, 7569, 7568, 1, 0, 0, 0, 7569, 7570, 1, 0, 0, 0, 7570, 7571, 1, 0, 0, 0, 7571, 7572, 5, 2, 0, 0, 7572, 7573, 3, 808, 404, 0, 7573, 7575, 5, 3, 0, 0, 7574, 7576, 3, 814, 407, 0, 7575, 7574, 1, 0, 0, 0, 7575, 7576, 1, 0, 0, 0, 7576, 7578, 1, 0, 0, 0, 7577, 7579, 3, 226, 113, 0, 7578, 7577, 1, 0, 0, 0, 7578, 7579, 1, 0, 0, 0, 7579, 7581, 1, 0, 0, 0, 7580, 7582, 3, 130, 65, 0, 7581, 7580, 1, 0, 0, 0, 7581, 7582, 1, 0, 0, 0, 7582, 7584, 1, 0, 0, 0, 7583, 7585, 3, 284, 142, 0, 7584, 7583, 1, 0, 0, 0, 7584, 7585, 1, 0, 0, 0, 7585, 7587, 1, 0, 0, 0, 7586, 7588, 3, 1638, 819, 0, 7587, 7586, 1, 0, 0, 0, 7587, 7588, 1, 0, 0, 0, 7588, 799, 1, 0, 0, 0, 7589, 7590, 5, 99, 0, 0, 7590, 801, 1, 0, 0, 0, 7591, 7592, 5, 111, 0, 0, 7592, 803, 1, 0, 0, 0, 7593, 7594, 3, 1892, 946, 0, 7594, 805, 1, 0, 0, 0, 7595, 7596, 5, 101, 0, 0, 7596, 7597, 3, 1892, 946, 0, 7597, 807, 1, 0, 0, 0, 7598, 7603, 3, 812, 406, 0, 7599, 7600, 5, 6, 0, 0, 7600, 7602, 3, 812, 406, 0, 7601, 7599, 1, 0, 0, 0, 7602, 7605, 1, 0, 0, 0, 7603, 7601, 1, 0, 0, 0, 7603, 7604, 1, 0, 0, 0, 7604, 809, 1, 0, 0, 0, 7605, 7603, 1, 0, 0, 0, 7606, 7608, 3, 818, 409, 0, 7607, 7606, 1, 0, 0, 0, 7607, 7608, 1, 0, 0, 0, 7608, 7610, 1, 0, 0, 0, 7609, 7611, 3, 820, 410, 0, 7610, 7609, 1, 0, 0, 0, 7610, 7611, 1, 0, 0, 0, 7611, 7613, 1, 0, 0, 0, 7612, 7614, 3, 822, 411, 0, 7613, 7612, 1, 0, 0, 0, 7613, 7614, 1, 0, 0, 0, 7614, 7616, 1, 0, 0, 0, 7615, 7617, 3, 824, 412, 0, 7616, 7615, 1, 0, 0, 0, 7616, 7617, 1, 0, 0, 0, 7617, 7630, 1, 0, 0, 0, 7618, 7620, 3, 818, 409, 0, 7619, 7618, 1, 0, 0, 0, 7619, 7620, 1, 0, 0, 0, 7620, 7621, 1, 0, 0, 0, 7621, 7622, 3, 566, 283, 0, 7622, 7624, 3, 128, 64, 0, 7623, 7625, 3, 822, 411, 0, 7624, 7623, 1, 0, 0, 0, 7624, 7625, 1, 0, 0, 0, 7625, 7627, 1, 0, 0, 0, 7626, 7628, 3, 824, 412, 0, 7627, 7626, 1, 0, 0, 0, 7627, 7628, 1, 0, 0, 0, 7628, 7630, 1, 0, 0, 0, 7629, 7607, 1, 0, 0, 0, 7629, 7619, 1, 0, 0, 0, 7630, 811, 1, 0, 0, 0, 7631, 7632, 3, 1924, 962, 0, 7632, 7633, 3, 810, 405, 0, 7633, 7643, 1, 0, 0, 0, 7634, 7635, 3, 1764, 882, 0, 7635, 7636, 3, 810, 405, 0, 7636, 7643, 1, 0, 0, 0, 7637, 7638, 5, 2, 0, 0, 7638, 7639, 3, 1710, 855, 0, 7639, 7640, 5, 3, 0, 0, 7640, 7641, 3, 810, 405, 0, 7641, 7643, 1, 0, 0, 0, 7642, 7631, 1, 0, 0, 0, 7642, 7634, 1, 0, 0, 0, 7642, 7637, 1, 0, 0, 0, 7643, 813, 1, 0, 0, 0, 7644, 7645, 5, 639, 0, 0, 7645, 7646, 5, 2, 0, 0, 7646, 7647, 3, 816, 408, 0, 7647, 7648, 5, 3, 0, 0, 7648, 815, 1, 0, 0, 0, 7649, 7654, 3, 812, 406, 0, 7650, 7651, 5, 6, 0, 0, 7651, 7653, 3, 812, 406, 0, 7652, 7650, 1, 0, 0, 0, 7653, 7656, 1, 0, 0, 0, 7654, 7652, 1, 0, 0, 0, 7654, 7655, 1, 0, 0, 0, 7655, 817, 1, 0, 0, 0, 7656, 7654, 1, 0, 0, 0, 7657, 7658, 5, 43, 0, 0, 7658, 7659, 3, 566, 283, 0, 7659, 819, 1, 0, 0, 0, 7660, 7661, 3, 566, 283, 0, 7661, 821, 1, 0, 0, 0, 7662, 7663, 7, 46, 0, 0, 7663, 823, 1, 0, 0, 0, 7664, 7665, 5, 270, 0, 0, 7665, 7669, 5, 211, 0, 0, 7666, 7667, 5, 270, 0, 0, 7667, 7669, 5, 244, 0, 0, 7668, 7664, 1, 0, 0, 0, 7668, 7666, 1, 0, 0, 0, 7669, 825, 1, 0, 0, 0, 7670, 7672, 5, 46, 0, 0, 7671, 7673, 3, 832, 416, 0, 7672, 7671, 1, 0, 0, 0, 7672, 7673, 1, 0, 0, 0, 7673, 7674, 1, 0, 0, 0, 7674, 7675, 5, 215, 0, 0, 7675, 7676, 3, 1898, 949, 0, 7676, 7686, 3, 834, 417, 0, 7677, 7684, 5, 314, 0, 0, 7678, 7685, 3, 856, 428, 0, 7679, 7680, 5, 93, 0, 0, 7680, 7681, 5, 2, 0, 0, 7681, 7682, 3, 886, 443, 0, 7682, 7683, 5, 3, 0, 0, 7683, 7685, 1, 0, 0, 0, 7684, 7678, 1, 0, 0, 0, 7684, 7679, 1, 0, 0, 0, 7685, 7687, 1, 0, 0, 0, 7686, 7677, 1, 0, 0, 0, 7686, 7687, 1, 0, 0, 0, 7687, 7688, 1, 0, 0, 0, 7688, 7689, 7, 47, 0, 0, 7689, 7690, 3, 872, 436, 0, 7690, 827, 1, 0, 0, 0, 7691, 7693, 5, 46, 0, 0, 7692, 7694, 3, 832, 416, 0, 7693, 7692, 1, 0, 0, 0, 7693, 7694, 1, 0, 0, 0, 7694, 7695, 1, 0, 0, 0, 7695, 7696, 5, 294, 0, 0, 7696, 7697, 3, 1898, 949, 0, 7697, 7707, 3, 838, 419, 0, 7698, 7705, 5, 314, 0, 0, 7699, 7706, 3, 856, 428, 0, 7700, 7701, 5, 93, 0, 0, 7701, 7702, 5, 2, 0, 0, 7702, 7703, 3, 886, 443, 0, 7703, 7704, 5, 3, 0, 0, 7704, 7706, 1, 0, 0, 0, 7705, 7699, 1, 0, 0, 0, 7705, 7700, 1, 0, 0, 0, 7706, 7708, 1, 0, 0, 0, 7707, 7698, 1, 0, 0, 0, 7707, 7708, 1, 0, 0, 0, 7708, 7710, 1, 0, 0, 0, 7709, 7711, 3, 830, 415, 0, 7710, 7709, 1, 0, 0, 0, 7710, 7711, 1, 0, 0, 0, 7711, 7712, 1, 0, 0, 0, 7712, 7713, 3, 872, 436, 0, 7713, 829, 1, 0, 0, 0, 7714, 7715, 5, 469, 0, 0, 7715, 831, 1, 0, 0, 0, 7716, 7717, 5, 82, 0, 0, 7717, 7718, 5, 309, 0, 0, 7718, 833, 1, 0, 0, 0, 7719, 7721, 5, 2, 0, 0, 7720, 7722, 3, 836, 418, 0, 7721, 7720, 1, 0, 0, 0, 7721, 7722, 1, 0, 0, 0, 7722, 7723, 1, 0, 0, 0, 7723, 7724, 5, 3, 0, 0, 7724, 835, 1, 0, 0, 0, 7725, 7726, 3, 854, 427, 0, 7726, 7733, 3, 858, 429, 0, 7727, 7728, 5, 6, 0, 0, 7728, 7729, 3, 854, 427, 0, 7729, 7730, 3, 858, 429, 0, 7730, 7732, 1, 0, 0, 0, 7731, 7727, 1, 0, 0, 0, 7732, 7735, 1, 0, 0, 0, 7733, 7731, 1, 0, 0, 0, 7733, 7734, 1, 0, 0, 0, 7734, 7745, 1, 0, 0, 0, 7735, 7733, 1, 0, 0, 0, 7736, 7741, 3, 858, 429, 0, 7737, 7738, 5, 6, 0, 0, 7738, 7740, 3, 858, 429, 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, 7745, 1, 0, 0, 0, 7743, 7741, 1, 0, 0, 0, 7744, 7725, 1, 0, 0, 0, 7744, 7736, 1, 0, 0, 0, 7745, 837, 1, 0, 0, 0, 7746, 7748, 5, 2, 0, 0, 7747, 7749, 3, 840, 420, 0, 7748, 7747, 1, 0, 0, 0, 7748, 7749, 1, 0, 0, 0, 7749, 7750, 1, 0, 0, 0, 7750, 7751, 5, 3, 0, 0, 7751, 839, 1, 0, 0, 0, 7752, 7757, 3, 850, 425, 0, 7753, 7754, 5, 6, 0, 0, 7754, 7756, 3, 850, 425, 0, 7755, 7753, 1, 0, 0, 0, 7756, 7759, 1, 0, 0, 0, 7757, 7755, 1, 0, 0, 0, 7757, 7758, 1, 0, 0, 0, 7758, 841, 1, 0, 0, 0, 7759, 7757, 1, 0, 0, 0, 7760, 7765, 3, 844, 422, 0, 7761, 7762, 5, 6, 0, 0, 7762, 7764, 3, 844, 422, 0, 7763, 7761, 1, 0, 0, 0, 7764, 7767, 1, 0, 0, 0, 7765, 7763, 1, 0, 0, 0, 7765, 7766, 1, 0, 0, 0, 7766, 843, 1, 0, 0, 0, 7767, 7765, 1, 0, 0, 0, 7768, 7769, 3, 1898, 949, 0, 7769, 7770, 3, 838, 419, 0, 7770, 7777, 1, 0, 0, 0, 7771, 7777, 3, 1942, 971, 0, 7772, 7774, 3, 1924, 962, 0, 7773, 7775, 3, 1874, 937, 0, 7774, 7773, 1, 0, 0, 0, 7774, 7775, 1, 0, 0, 0, 7775, 7777, 1, 0, 0, 0, 7776, 7768, 1, 0, 0, 0, 7776, 7771, 1, 0, 0, 0, 7776, 7772, 1, 0, 0, 0, 7777, 845, 1, 0, 0, 0, 7778, 7780, 5, 2, 0, 0, 7779, 7781, 3, 848, 424, 0, 7780, 7779, 1, 0, 0, 0, 7780, 7781, 1, 0, 0, 0, 7781, 7782, 1, 0, 0, 0, 7782, 7783, 5, 3, 0, 0, 7783, 847, 1, 0, 0, 0, 7784, 7789, 3, 860, 430, 0, 7785, 7786, 5, 6, 0, 0, 7786, 7788, 3, 860, 430, 0, 7787, 7785, 1, 0, 0, 0, 7788, 7791, 1, 0, 0, 0, 7789, 7787, 1, 0, 0, 0, 7789, 7790, 1, 0, 0, 0, 7790, 849, 1, 0, 0, 0, 7791, 7789, 1, 0, 0, 0, 7792, 7794, 3, 852, 426, 0, 7793, 7795, 3, 854, 427, 0, 7794, 7793, 1, 0, 0, 0, 7794, 7795, 1, 0, 0, 0, 7795, 7796, 1, 0, 0, 0, 7796, 7797, 3, 858, 429, 0, 7797, 7806, 1, 0, 0, 0, 7798, 7800, 3, 854, 427, 0, 7799, 7801, 3, 852, 426, 0, 7800, 7799, 1, 0, 0, 0, 7800, 7801, 1, 0, 0, 0, 7801, 7802, 1, 0, 0, 0, 7802, 7803, 3, 858, 429, 0, 7803, 7806, 1, 0, 0, 0, 7804, 7806, 3, 858, 429, 0, 7805, 7792, 1, 0, 0, 0, 7805, 7798, 1, 0, 0, 0, 7805, 7804, 1, 0, 0, 0, 7806, 851, 1, 0, 0, 0, 7807, 7808, 7, 48, 0, 0, 7808, 853, 1, 0, 0, 0, 7809, 7814, 3, 1928, 964, 0, 7810, 7814, 3, 1946, 973, 0, 7811, 7814, 5, 121, 0, 0, 7812, 7814, 5, 128, 0, 0, 7813, 7809, 1, 0, 0, 0, 7813, 7810, 1, 0, 0, 0, 7813, 7811, 1, 0, 0, 0, 7813, 7812, 1, 0, 0, 0, 7814, 855, 1, 0, 0, 0, 7815, 7816, 3, 858, 429, 0, 7816, 857, 1, 0, 0, 0, 7817, 7832, 3, 1662, 831, 0, 7818, 7820, 5, 578, 0, 0, 7819, 7818, 1, 0, 0, 0, 7819, 7820, 1, 0, 0, 0, 7820, 7825, 1, 0, 0, 0, 7821, 7826, 3, 1946, 973, 0, 7822, 7826, 3, 1928, 964, 0, 7823, 7826, 5, 121, 0, 0, 7824, 7826, 5, 128, 0, 0, 7825, 7821, 1, 0, 0, 0, 7825, 7822, 1, 0, 0, 0, 7825, 7823, 1, 0, 0, 0, 7825, 7824, 1, 0, 0, 0, 7826, 7827, 1, 0, 0, 0, 7827, 7828, 3, 568, 284, 0, 7828, 7829, 5, 27, 0, 0, 7829, 7830, 5, 358, 0, 0, 7830, 7832, 1, 0, 0, 0, 7831, 7817, 1, 0, 0, 0, 7831, 7819, 1, 0, 0, 0, 7832, 859, 1, 0, 0, 0, 7833, 7836, 3, 850, 425, 0, 7834, 7835, 7, 49, 0, 0, 7835, 7837, 3, 1710, 855, 0, 7836, 7834, 1, 0, 0, 0, 7836, 7837, 1, 0, 0, 0, 7837, 861, 1, 0, 0, 0, 7838, 7839, 3, 850, 425, 0, 7839, 863, 1, 0, 0, 0, 7840, 7851, 5, 2, 0, 0, 7841, 7852, 5, 9, 0, 0, 7842, 7852, 3, 866, 433, 0, 7843, 7844, 5, 83, 0, 0, 7844, 7845, 5, 149, 0, 0, 7845, 7852, 3, 866, 433, 0, 7846, 7847, 3, 866, 433, 0, 7847, 7848, 5, 83, 0, 0, 7848, 7849, 5, 149, 0, 0, 7849, 7850, 3, 866, 433, 0, 7850, 7852, 1, 0, 0, 0, 7851, 7841, 1, 0, 0, 0, 7851, 7842, 1, 0, 0, 0, 7851, 7843, 1, 0, 0, 0, 7851, 7846, 1, 0, 0, 0, 7852, 7853, 1, 0, 0, 0, 7853, 7854, 5, 3, 0, 0, 7854, 865, 1, 0, 0, 0, 7855, 7860, 3, 862, 431, 0, 7856, 7857, 5, 6, 0, 0, 7857, 7859, 3, 862, 431, 0, 7858, 7856, 1, 0, 0, 0, 7859, 7862, 1, 0, 0, 0, 7860, 7858, 1, 0, 0, 0, 7860, 7861, 1, 0, 0, 0, 7861, 867, 1, 0, 0, 0, 7862, 7860, 1, 0, 0, 0, 7863, 7864, 3, 1898, 949, 0, 7864, 7865, 3, 864, 432, 0, 7865, 869, 1, 0, 0, 0, 7866, 7871, 3, 868, 434, 0, 7867, 7868, 5, 6, 0, 0, 7868, 7870, 3, 868, 434, 0, 7869, 7867, 1, 0, 0, 0, 7870, 7873, 1, 0, 0, 0, 7871, 7869, 1, 0, 0, 0, 7871, 7872, 1, 0, 0, 0, 7872, 871, 1, 0, 0, 0, 7873, 7871, 1, 0, 0, 0, 7874, 7876, 3, 876, 438, 0, 7875, 7874, 1, 0, 0, 0, 7876, 7877, 1, 0, 0, 0, 7877, 7875, 1, 0, 0, 0, 7877, 7878, 1, 0, 0, 0, 7878, 7879, 1, 0, 0, 0, 7879, 7880, 6, 436, -1, 0, 7880, 873, 1, 0, 0, 0, 7881, 7882, 5, 151, 0, 0, 7882, 7883, 5, 80, 0, 0, 7883, 7884, 5, 78, 0, 0, 7884, 7917, 5, 657, 0, 0, 7885, 7886, 5, 314, 0, 0, 7886, 7887, 5, 78, 0, 0, 7887, 7888, 5, 80, 0, 0, 7888, 7889, 5, 78, 0, 0, 7889, 7917, 5, 657, 0, 0, 7890, 7917, 5, 344, 0, 0, 7891, 7917, 5, 226, 0, 0, 7892, 7917, 5, 336, 0, 0, 7893, 7917, 5, 375, 0, 0, 7894, 7895, 5, 209, 0, 0, 7895, 7896, 5, 325, 0, 0, 7896, 7917, 5, 185, 0, 0, 7897, 7898, 5, 209, 0, 0, 7898, 7899, 5, 325, 0, 0, 7899, 7917, 5, 238, 0, 0, 7900, 7901, 5, 325, 0, 0, 7901, 7917, 5, 185, 0, 0, 7902, 7903, 5, 325, 0, 0, 7903, 7917, 5, 238, 0, 0, 7904, 7917, 5, 245, 0, 0, 7905, 7906, 5, 77, 0, 0, 7906, 7917, 5, 245, 0, 0, 7907, 7908, 5, 172, 0, 0, 7908, 7917, 3, 334, 167, 0, 7909, 7910, 5, 318, 0, 0, 7910, 7917, 3, 334, 167, 0, 7911, 7912, 5, 658, 0, 0, 7912, 7917, 3, 566, 283, 0, 7913, 7917, 3, 92, 46, 0, 7914, 7915, 5, 659, 0, 0, 7915, 7917, 3, 1924, 962, 0, 7916, 7881, 1, 0, 0, 0, 7916, 7885, 1, 0, 0, 0, 7916, 7890, 1, 0, 0, 0, 7916, 7891, 1, 0, 0, 0, 7916, 7892, 1, 0, 0, 0, 7916, 7893, 1, 0, 0, 0, 7916, 7894, 1, 0, 0, 0, 7916, 7897, 1, 0, 0, 0, 7916, 7900, 1, 0, 0, 0, 7916, 7902, 1, 0, 0, 0, 7916, 7904, 1, 0, 0, 0, 7916, 7905, 1, 0, 0, 0, 7916, 7907, 1, 0, 0, 0, 7916, 7909, 1, 0, 0, 0, 7916, 7911, 1, 0, 0, 0, 7916, 7913, 1, 0, 0, 0, 7916, 7914, 1, 0, 0, 0, 7917, 875, 1, 0, 0, 0, 7918, 7919, 5, 36, 0, 0, 7919, 7932, 3, 878, 439, 0, 7920, 7921, 5, 148, 0, 0, 7921, 7922, 5, 548, 0, 0, 7922, 7923, 3, 6, 3, 0, 7923, 7924, 5, 653, 0, 0, 7924, 7932, 1, 0, 0, 0, 7925, 7926, 5, 242, 0, 0, 7926, 7932, 3, 82, 41, 0, 7927, 7928, 5, 641, 0, 0, 7928, 7932, 3, 880, 440, 0, 7929, 7932, 5, 105, 0, 0, 7930, 7932, 3, 874, 437, 0, 7931, 7918, 1, 0, 0, 0, 7931, 7920, 1, 0, 0, 0, 7931, 7925, 1, 0, 0, 0, 7931, 7927, 1, 0, 0, 0, 7931, 7929, 1, 0, 0, 0, 7931, 7930, 1, 0, 0, 0, 7932, 877, 1, 0, 0, 0, 7933, 7939, 3, 1910, 955, 0, 7934, 7935, 3, 1910, 955, 0, 7935, 7936, 5, 6, 0, 0, 7936, 7937, 3, 1910, 955, 0, 7937, 7939, 1, 0, 0, 0, 7938, 7933, 1, 0, 0, 0, 7938, 7934, 1, 0, 0, 0, 7939, 879, 1, 0, 0, 0, 7940, 7941, 5, 62, 0, 0, 7941, 7942, 5, 358, 0, 0, 7942, 7949, 3, 1662, 831, 0, 7943, 7944, 5, 6, 0, 0, 7944, 7945, 5, 62, 0, 0, 7945, 7946, 5, 358, 0, 0, 7946, 7948, 3, 1662, 831, 0, 7947, 7943, 1, 0, 0, 0, 7948, 7951, 1, 0, 0, 0, 7949, 7947, 1, 0, 0, 0, 7949, 7950, 1, 0, 0, 0, 7950, 881, 1, 0, 0, 0, 7951, 7949, 1, 0, 0, 0, 7952, 7953, 5, 106, 0, 0, 7953, 7954, 3, 502, 251, 0, 7954, 883, 1, 0, 0, 0, 7955, 7956, 3, 854, 427, 0, 7956, 7957, 3, 858, 429, 0, 7957, 885, 1, 0, 0, 0, 7958, 7963, 3, 884, 442, 0, 7959, 7960, 5, 6, 0, 0, 7960, 7962, 3, 884, 442, 0, 7961, 7959, 1, 0, 0, 0, 7962, 7965, 1, 0, 0, 0, 7963, 7961, 1, 0, 0, 0, 7963, 7964, 1, 0, 0, 0, 7964, 887, 1, 0, 0, 0, 7965, 7963, 1, 0, 0, 0, 7966, 7967, 5, 140, 0, 0, 7967, 7968, 5, 215, 0, 0, 7968, 7969, 3, 1898, 949, 0, 7969, 7976, 3, 834, 417, 0, 7970, 7971, 5, 307, 0, 0, 7971, 7972, 5, 95, 0, 0, 7972, 7977, 3, 1898, 949, 0, 7973, 7974, 5, 279, 0, 0, 7974, 7975, 5, 95, 0, 0, 7975, 7977, 3, 1920, 960, 0, 7976, 7970, 1, 0, 0, 0, 7976, 7973, 1, 0, 0, 0, 7977, 889, 1, 0, 0, 0, 7978, 7979, 5, 140, 0, 0, 7979, 7980, 5, 294, 0, 0, 7980, 7981, 3, 1898, 949, 0, 7981, 7988, 3, 838, 419, 0, 7982, 7983, 5, 307, 0, 0, 7983, 7984, 5, 95, 0, 0, 7984, 7989, 3, 1898, 949, 0, 7985, 7986, 5, 279, 0, 0, 7986, 7987, 5, 95, 0, 0, 7987, 7989, 3, 1920, 960, 0, 7988, 7982, 1, 0, 0, 0, 7988, 7985, 1, 0, 0, 0, 7989, 891, 1, 0, 0, 0, 7990, 7992, 3, 874, 437, 0, 7991, 7990, 1, 0, 0, 0, 7992, 7993, 1, 0, 0, 0, 7993, 7991, 1, 0, 0, 0, 7993, 7994, 1, 0, 0, 0, 7994, 893, 1, 0, 0, 0, 7995, 7996, 5, 313, 0, 0, 7996, 895, 1, 0, 0, 0, 7997, 7998, 5, 195, 0, 0, 7998, 7999, 5, 215, 0, 0, 7999, 8001, 3, 842, 421, 0, 8000, 8002, 3, 120, 60, 0, 8001, 8000, 1, 0, 0, 0, 8001, 8002, 1, 0, 0, 0, 8002, 8040, 1, 0, 0, 0, 8003, 8004, 5, 195, 0, 0, 8004, 8005, 5, 215, 0, 0, 8005, 8006, 5, 224, 0, 0, 8006, 8007, 5, 558, 0, 0, 8007, 8009, 3, 842, 421, 0, 8008, 8010, 3, 120, 60, 0, 8009, 8008, 1, 0, 0, 0, 8009, 8010, 1, 0, 0, 0, 8010, 8040, 1, 0, 0, 0, 8011, 8012, 5, 195, 0, 0, 8012, 8013, 5, 294, 0, 0, 8013, 8015, 3, 842, 421, 0, 8014, 8016, 3, 120, 60, 0, 8015, 8014, 1, 0, 0, 0, 8015, 8016, 1, 0, 0, 0, 8016, 8040, 1, 0, 0, 0, 8017, 8018, 5, 195, 0, 0, 8018, 8019, 5, 294, 0, 0, 8019, 8020, 5, 224, 0, 0, 8020, 8021, 5, 558, 0, 0, 8021, 8023, 3, 842, 421, 0, 8022, 8024, 3, 120, 60, 0, 8023, 8022, 1, 0, 0, 0, 8023, 8024, 1, 0, 0, 0, 8024, 8040, 1, 0, 0, 0, 8025, 8026, 5, 195, 0, 0, 8026, 8027, 5, 640, 0, 0, 8027, 8029, 3, 842, 421, 0, 8028, 8030, 3, 120, 60, 0, 8029, 8028, 1, 0, 0, 0, 8029, 8030, 1, 0, 0, 0, 8030, 8040, 1, 0, 0, 0, 8031, 8032, 5, 195, 0, 0, 8032, 8033, 5, 640, 0, 0, 8033, 8034, 5, 224, 0, 0, 8034, 8035, 5, 558, 0, 0, 8035, 8037, 3, 842, 421, 0, 8036, 8038, 3, 120, 60, 0, 8037, 8036, 1, 0, 0, 0, 8037, 8038, 1, 0, 0, 0, 8038, 8040, 1, 0, 0, 0, 8039, 7997, 1, 0, 0, 0, 8039, 8003, 1, 0, 0, 0, 8039, 8011, 1, 0, 0, 0, 8039, 8017, 1, 0, 0, 0, 8039, 8025, 1, 0, 0, 0, 8039, 8031, 1, 0, 0, 0, 8040, 897, 1, 0, 0, 0, 8041, 8042, 5, 195, 0, 0, 8042, 8043, 5, 138, 0, 0, 8043, 8045, 3, 870, 435, 0, 8044, 8046, 3, 120, 60, 0, 8045, 8044, 1, 0, 0, 0, 8045, 8046, 1, 0, 0, 0, 8046, 8056, 1, 0, 0, 0, 8047, 8048, 5, 195, 0, 0, 8048, 8049, 5, 138, 0, 0, 8049, 8050, 5, 224, 0, 0, 8050, 8051, 5, 558, 0, 0, 8051, 8053, 3, 870, 435, 0, 8052, 8054, 3, 120, 60, 0, 8053, 8052, 1, 0, 0, 0, 8053, 8054, 1, 0, 0, 0, 8054, 8056, 1, 0, 0, 0, 8055, 8041, 1, 0, 0, 0, 8055, 8047, 1, 0, 0, 0, 8056, 899, 1, 0, 0, 0, 8057, 8058, 5, 195, 0, 0, 8058, 8059, 5, 275, 0, 0, 8059, 8061, 3, 906, 453, 0, 8060, 8062, 3, 120, 60, 0, 8061, 8060, 1, 0, 0, 0, 8061, 8062, 1, 0, 0, 0, 8062, 8072, 1, 0, 0, 0, 8063, 8064, 5, 195, 0, 0, 8064, 8065, 5, 275, 0, 0, 8065, 8066, 5, 224, 0, 0, 8066, 8067, 5, 558, 0, 0, 8067, 8069, 3, 906, 453, 0, 8068, 8070, 3, 120, 60, 0, 8069, 8068, 1, 0, 0, 0, 8069, 8070, 1, 0, 0, 0, 8070, 8072, 1, 0, 0, 0, 8071, 8057, 1, 0, 0, 0, 8071, 8063, 1, 0, 0, 0, 8072, 901, 1, 0, 0, 0, 8073, 8074, 5, 2, 0, 0, 8074, 8075, 3, 1662, 831, 0, 8075, 8076, 5, 3, 0, 0, 8076, 8096, 1, 0, 0, 0, 8077, 8078, 5, 2, 0, 0, 8078, 8079, 3, 1662, 831, 0, 8079, 8080, 5, 6, 0, 0, 8080, 8081, 3, 1662, 831, 0, 8081, 8082, 5, 3, 0, 0, 8082, 8096, 1, 0, 0, 0, 8083, 8084, 5, 2, 0, 0, 8084, 8085, 5, 569, 0, 0, 8085, 8086, 5, 6, 0, 0, 8086, 8087, 3, 1662, 831, 0, 8087, 8088, 5, 3, 0, 0, 8088, 8096, 1, 0, 0, 0, 8089, 8090, 5, 2, 0, 0, 8090, 8091, 3, 1662, 831, 0, 8091, 8092, 5, 6, 0, 0, 8092, 8093, 5, 569, 0, 0, 8093, 8094, 5, 3, 0, 0, 8094, 8096, 1, 0, 0, 0, 8095, 8073, 1, 0, 0, 0, 8095, 8077, 1, 0, 0, 0, 8095, 8083, 1, 0, 0, 0, 8095, 8089, 1, 0, 0, 0, 8096, 903, 1, 0, 0, 0, 8097, 8098, 3, 1924, 962, 0, 8098, 8099, 5, 11, 0, 0, 8099, 8101, 1, 0, 0, 0, 8100, 8097, 1, 0, 0, 0, 8101, 8104, 1, 0, 0, 0, 8102, 8100, 1, 0, 0, 0, 8102, 8103, 1, 0, 0, 0, 8103, 8105, 1, 0, 0, 0, 8104, 8102, 1, 0, 0, 0, 8105, 8106, 3, 1820, 910, 0, 8106, 905, 1, 0, 0, 0, 8107, 8112, 3, 908, 454, 0, 8108, 8109, 5, 6, 0, 0, 8109, 8111, 3, 908, 454, 0, 8110, 8108, 1, 0, 0, 0, 8111, 8114, 1, 0, 0, 0, 8112, 8110, 1, 0, 0, 0, 8112, 8113, 1, 0, 0, 0, 8113, 907, 1, 0, 0, 0, 8114, 8112, 1, 0, 0, 0, 8115, 8116, 3, 904, 452, 0, 8116, 8117, 3, 902, 451, 0, 8117, 909, 1, 0, 0, 0, 8118, 8119, 5, 57, 0, 0, 8119, 8120, 3, 912, 456, 0, 8120, 911, 1, 0, 0, 0, 8121, 8123, 3, 914, 457, 0, 8122, 8121, 1, 0, 0, 0, 8123, 8124, 1, 0, 0, 0, 8124, 8122, 1, 0, 0, 0, 8124, 8125, 1, 0, 0, 0, 8125, 913, 1, 0, 0, 0, 8126, 8130, 3, 1910, 955, 0, 8127, 8128, 5, 242, 0, 0, 8128, 8130, 3, 82, 41, 0, 8129, 8126, 1, 0, 0, 0, 8129, 8127, 1, 0, 0, 0, 8130, 915, 1, 0, 0, 0, 8131, 8132, 5, 46, 0, 0, 8132, 8133, 5, 41, 0, 0, 8133, 8134, 5, 2, 0, 0, 8134, 8135, 3, 1662, 831, 0, 8135, 8136, 5, 36, 0, 0, 8136, 8137, 3, 1662, 831, 0, 8137, 8138, 5, 3, 0, 0, 8138, 8139, 5, 106, 0, 0, 8139, 8140, 5, 215, 0, 0, 8140, 8142, 3, 844, 422, 0, 8141, 8143, 3, 918, 459, 0, 8142, 8141, 1, 0, 0, 0, 8142, 8143, 1, 0, 0, 0, 8143, 8169, 1, 0, 0, 0, 8144, 8145, 5, 46, 0, 0, 8145, 8146, 5, 41, 0, 0, 8146, 8147, 5, 2, 0, 0, 8147, 8148, 3, 1662, 831, 0, 8148, 8149, 5, 36, 0, 0, 8149, 8150, 3, 1662, 831, 0, 8150, 8151, 5, 3, 0, 0, 8151, 8152, 5, 377, 0, 0, 8152, 8154, 5, 215, 0, 0, 8153, 8155, 3, 918, 459, 0, 8154, 8153, 1, 0, 0, 0, 8154, 8155, 1, 0, 0, 0, 8155, 8169, 1, 0, 0, 0, 8156, 8157, 5, 46, 0, 0, 8157, 8158, 5, 41, 0, 0, 8158, 8159, 5, 2, 0, 0, 8159, 8160, 3, 1662, 831, 0, 8160, 8161, 5, 36, 0, 0, 8161, 8162, 3, 1662, 831, 0, 8162, 8163, 5, 3, 0, 0, 8163, 8164, 5, 106, 0, 0, 8164, 8166, 5, 562, 0, 0, 8165, 8167, 3, 918, 459, 0, 8166, 8165, 1, 0, 0, 0, 8166, 8167, 1, 0, 0, 0, 8167, 8169, 1, 0, 0, 0, 8168, 8131, 1, 0, 0, 0, 8168, 8144, 1, 0, 0, 0, 8168, 8156, 1, 0, 0, 0, 8169, 917, 1, 0, 0, 0, 8170, 8171, 5, 36, 0, 0, 8171, 8175, 5, 227, 0, 0, 8172, 8173, 5, 36, 0, 0, 8173, 8175, 5, 143, 0, 0, 8174, 8170, 1, 0, 0, 0, 8174, 8172, 1, 0, 0, 0, 8175, 919, 1, 0, 0, 0, 8176, 8177, 5, 195, 0, 0, 8177, 8179, 5, 41, 0, 0, 8178, 8180, 3, 922, 461, 0, 8179, 8178, 1, 0, 0, 0, 8179, 8180, 1, 0, 0, 0, 8180, 8181, 1, 0, 0, 0, 8181, 8182, 5, 2, 0, 0, 8182, 8183, 3, 1662, 831, 0, 8183, 8184, 5, 36, 0, 0, 8184, 8185, 3, 1662, 831, 0, 8185, 8187, 5, 3, 0, 0, 8186, 8188, 3, 120, 60, 0, 8187, 8186, 1, 0, 0, 0, 8187, 8188, 1, 0, 0, 0, 8188, 921, 1, 0, 0, 0, 8189, 8190, 5, 224, 0, 0, 8190, 8191, 5, 558, 0, 0, 8191, 923, 1, 0, 0, 0, 8192, 8194, 5, 46, 0, 0, 8193, 8195, 3, 832, 416, 0, 8194, 8193, 1, 0, 0, 0, 8194, 8195, 1, 0, 0, 0, 8195, 8196, 1, 0, 0, 0, 8196, 8197, 5, 641, 0, 0, 8197, 8198, 5, 62, 0, 0, 8198, 8199, 3, 1662, 831, 0, 8199, 8200, 5, 242, 0, 0, 8200, 8201, 3, 1892, 946, 0, 8201, 8202, 5, 2, 0, 0, 8202, 8203, 3, 926, 463, 0, 8203, 8204, 5, 3, 0, 0, 8204, 925, 1, 0, 0, 0, 8205, 8206, 5, 64, 0, 0, 8206, 8207, 5, 660, 0, 0, 8207, 8208, 5, 106, 0, 0, 8208, 8209, 5, 215, 0, 0, 8209, 8210, 3, 844, 422, 0, 8210, 8211, 5, 6, 0, 0, 8211, 8212, 5, 95, 0, 0, 8212, 8213, 5, 660, 0, 0, 8213, 8214, 5, 106, 0, 0, 8214, 8215, 5, 215, 0, 0, 8215, 8216, 3, 844, 422, 0, 8216, 8240, 1, 0, 0, 0, 8217, 8218, 5, 95, 0, 0, 8218, 8219, 5, 660, 0, 0, 8219, 8220, 5, 106, 0, 0, 8220, 8221, 5, 215, 0, 0, 8221, 8222, 3, 844, 422, 0, 8222, 8223, 5, 6, 0, 0, 8223, 8224, 5, 64, 0, 0, 8224, 8225, 5, 660, 0, 0, 8225, 8226, 5, 106, 0, 0, 8226, 8227, 5, 215, 0, 0, 8227, 8228, 3, 844, 422, 0, 8228, 8240, 1, 0, 0, 0, 8229, 8230, 5, 64, 0, 0, 8230, 8231, 5, 660, 0, 0, 8231, 8232, 5, 106, 0, 0, 8232, 8233, 5, 215, 0, 0, 8233, 8240, 3, 844, 422, 0, 8234, 8235, 5, 95, 0, 0, 8235, 8236, 5, 660, 0, 0, 8236, 8237, 5, 106, 0, 0, 8237, 8238, 5, 215, 0, 0, 8238, 8240, 3, 844, 422, 0, 8239, 8205, 1, 0, 0, 0, 8239, 8217, 1, 0, 0, 0, 8239, 8229, 1, 0, 0, 0, 8239, 8234, 1, 0, 0, 0, 8240, 927, 1, 0, 0, 0, 8241, 8242, 5, 195, 0, 0, 8242, 8244, 5, 641, 0, 0, 8243, 8245, 3, 922, 461, 0, 8244, 8243, 1, 0, 0, 0, 8244, 8245, 1, 0, 0, 0, 8245, 8246, 1, 0, 0, 0, 8246, 8247, 5, 62, 0, 0, 8247, 8248, 3, 1662, 831, 0, 8248, 8249, 5, 242, 0, 0, 8249, 8251, 3, 1892, 946, 0, 8250, 8252, 3, 120, 60, 0, 8251, 8250, 1, 0, 0, 0, 8251, 8252, 1, 0, 0, 0, 8252, 929, 1, 0, 0, 0, 8253, 8254, 5, 304, 0, 0, 8254, 8256, 3, 932, 466, 0, 8255, 8257, 3, 802, 401, 0, 8256, 8255, 1, 0, 0, 0, 8256, 8257, 1, 0, 0, 0, 8257, 8258, 1, 0, 0, 0, 8258, 8259, 3, 1888, 944, 0, 8259, 8288, 1, 0, 0, 0, 8260, 8261, 5, 304, 0, 0, 8261, 8263, 3, 934, 467, 0, 8262, 8264, 3, 802, 401, 0, 8263, 8262, 1, 0, 0, 0, 8263, 8264, 1, 0, 0, 0, 8264, 8265, 1, 0, 0, 0, 8265, 8266, 3, 1892, 946, 0, 8266, 8288, 1, 0, 0, 0, 8267, 8268, 5, 304, 0, 0, 8268, 8269, 5, 2, 0, 0, 8269, 8270, 3, 936, 468, 0, 8270, 8271, 5, 3, 0, 0, 8271, 8273, 3, 932, 466, 0, 8272, 8274, 3, 802, 401, 0, 8273, 8272, 1, 0, 0, 0, 8273, 8274, 1, 0, 0, 0, 8274, 8275, 1, 0, 0, 0, 8275, 8276, 3, 1888, 944, 0, 8276, 8288, 1, 0, 0, 0, 8277, 8278, 5, 304, 0, 0, 8278, 8279, 5, 2, 0, 0, 8279, 8280, 3, 936, 468, 0, 8280, 8281, 5, 3, 0, 0, 8281, 8283, 3, 934, 467, 0, 8282, 8284, 3, 802, 401, 0, 8283, 8282, 1, 0, 0, 0, 8283, 8284, 1, 0, 0, 0, 8284, 8285, 1, 0, 0, 0, 8285, 8286, 3, 1892, 946, 0, 8286, 8288, 1, 0, 0, 0, 8287, 8253, 1, 0, 0, 0, 8287, 8260, 1, 0, 0, 0, 8287, 8267, 1, 0, 0, 0, 8287, 8277, 1, 0, 0, 0, 8288, 931, 1, 0, 0, 0, 8289, 8290, 7, 50, 0, 0, 8290, 933, 1, 0, 0, 0, 8291, 8292, 7, 51, 0, 0, 8292, 935, 1, 0, 0, 0, 8293, 8298, 3, 938, 469, 0, 8294, 8295, 5, 6, 0, 0, 8295, 8297, 3, 938, 469, 0, 8296, 8294, 1, 0, 0, 0, 8297, 8300, 1, 0, 0, 0, 8298, 8296, 1, 0, 0, 0, 8298, 8299, 1, 0, 0, 0, 8299, 937, 1, 0, 0, 0, 8300, 8298, 1, 0, 0, 0, 8301, 8302, 7, 52, 0, 0, 8302, 939, 1, 0, 0, 0, 8303, 8304, 5, 140, 0, 0, 8304, 8305, 5, 349, 0, 0, 8305, 8306, 3, 1892, 946, 0, 8306, 8307, 5, 331, 0, 0, 8307, 8308, 3, 128, 64, 0, 8308, 8316, 1, 0, 0, 0, 8309, 8310, 5, 140, 0, 0, 8310, 8311, 5, 349, 0, 0, 8311, 8312, 3, 1892, 946, 0, 8312, 8313, 5, 311, 0, 0, 8313, 8314, 3, 128, 64, 0, 8314, 8316, 1, 0, 0, 0, 8315, 8303, 1, 0, 0, 0, 8315, 8309, 1, 0, 0, 0, 8316, 941, 1, 0, 0, 0, 8317, 8318, 5, 140, 0, 0, 8318, 8319, 5, 138, 0, 0, 8319, 8320, 3, 868, 434, 0, 8320, 8321, 5, 307, 0, 0, 8321, 8322, 5, 95, 0, 0, 8322, 8323, 3, 1892, 946, 0, 8323, 8805, 1, 0, 0, 0, 8324, 8325, 5, 140, 0, 0, 8325, 8326, 5, 110, 0, 0, 8326, 8327, 3, 566, 283, 0, 8327, 8328, 5, 307, 0, 0, 8328, 8329, 5, 95, 0, 0, 8329, 8330, 3, 1892, 946, 0, 8330, 8805, 1, 0, 0, 0, 8331, 8332, 5, 140, 0, 0, 8332, 8333, 5, 170, 0, 0, 8333, 8334, 3, 566, 283, 0, 8334, 8335, 5, 307, 0, 0, 8335, 8336, 5, 95, 0, 0, 8336, 8337, 3, 1892, 946, 0, 8337, 8805, 1, 0, 0, 0, 8338, 8339, 5, 140, 0, 0, 8339, 8340, 5, 179, 0, 0, 8340, 8341, 3, 1892, 946, 0, 8341, 8342, 5, 307, 0, 0, 8342, 8343, 5, 95, 0, 0, 8343, 8344, 3, 1892, 946, 0, 8344, 8805, 1, 0, 0, 0, 8345, 8346, 5, 140, 0, 0, 8346, 8347, 5, 193, 0, 0, 8347, 8348, 3, 566, 283, 0, 8348, 8349, 5, 307, 0, 0, 8349, 8350, 5, 95, 0, 0, 8350, 8351, 3, 1892, 946, 0, 8351, 8805, 1, 0, 0, 0, 8352, 8353, 5, 140, 0, 0, 8353, 8354, 5, 193, 0, 0, 8354, 8355, 3, 566, 283, 0, 8355, 8356, 5, 307, 0, 0, 8356, 8357, 5, 45, 0, 0, 8357, 8358, 3, 1892, 946, 0, 8358, 8359, 5, 95, 0, 0, 8359, 8360, 3, 1892, 946, 0, 8360, 8805, 1, 0, 0, 0, 8361, 8362, 5, 140, 0, 0, 8362, 8363, 5, 63, 0, 0, 8363, 8364, 5, 177, 0, 0, 8364, 8365, 5, 379, 0, 0, 8365, 8366, 3, 1892, 946, 0, 8366, 8367, 5, 307, 0, 0, 8367, 8368, 5, 95, 0, 0, 8368, 8369, 3, 1892, 946, 0, 8369, 8805, 1, 0, 0, 0, 8370, 8371, 5, 140, 0, 0, 8371, 8372, 5, 215, 0, 0, 8372, 8373, 3, 844, 422, 0, 8373, 8374, 5, 307, 0, 0, 8374, 8375, 5, 95, 0, 0, 8375, 8376, 3, 1892, 946, 0, 8376, 8805, 1, 0, 0, 0, 8377, 8378, 5, 140, 0, 0, 8378, 8379, 5, 66, 0, 0, 8379, 8380, 3, 1918, 959, 0, 8380, 8381, 5, 307, 0, 0, 8381, 8382, 5, 95, 0, 0, 8382, 8383, 3, 1918, 959, 0, 8383, 8805, 1, 0, 0, 0, 8384, 8386, 5, 140, 0, 0, 8385, 8387, 3, 350, 175, 0, 8386, 8385, 1, 0, 0, 0, 8386, 8387, 1, 0, 0, 0, 8387, 8388, 1, 0, 0, 0, 8388, 8389, 5, 242, 0, 0, 8389, 8390, 3, 1892, 946, 0, 8390, 8391, 5, 307, 0, 0, 8391, 8392, 5, 95, 0, 0, 8392, 8393, 3, 1892, 946, 0, 8393, 8805, 1, 0, 0, 0, 8394, 8395, 5, 140, 0, 0, 8395, 8396, 5, 275, 0, 0, 8396, 8397, 5, 158, 0, 0, 8397, 8398, 3, 566, 283, 0, 8398, 8399, 5, 101, 0, 0, 8399, 8400, 3, 1892, 946, 0, 8400, 8401, 5, 307, 0, 0, 8401, 8402, 5, 95, 0, 0, 8402, 8403, 3, 1892, 946, 0, 8403, 8805, 1, 0, 0, 0, 8404, 8405, 5, 140, 0, 0, 8405, 8406, 5, 275, 0, 0, 8406, 8407, 5, 210, 0, 0, 8407, 8408, 3, 566, 283, 0, 8408, 8409, 5, 101, 0, 0, 8409, 8410, 3, 1892, 946, 0, 8410, 8411, 5, 307, 0, 0, 8411, 8412, 5, 95, 0, 0, 8412, 8413, 3, 1892, 946, 0, 8413, 8805, 1, 0, 0, 0, 8414, 8415, 5, 140, 0, 0, 8415, 8416, 5, 643, 0, 0, 8416, 8417, 3, 1892, 946, 0, 8417, 8418, 5, 80, 0, 0, 8418, 8419, 3, 1888, 944, 0, 8419, 8420, 5, 307, 0, 0, 8420, 8421, 5, 95, 0, 0, 8421, 8422, 3, 1892, 946, 0, 8422, 8805, 1, 0, 0, 0, 8423, 8424, 5, 140, 0, 0, 8424, 8425, 5, 643, 0, 0, 8425, 8426, 5, 224, 0, 0, 8426, 8427, 5, 558, 0, 0, 8427, 8428, 3, 1892, 946, 0, 8428, 8429, 5, 80, 0, 0, 8429, 8430, 3, 1888, 944, 0, 8430, 8431, 5, 307, 0, 0, 8431, 8432, 5, 95, 0, 0, 8432, 8433, 3, 1892, 946, 0, 8433, 8805, 1, 0, 0, 0, 8434, 8435, 5, 140, 0, 0, 8435, 8436, 5, 294, 0, 0, 8436, 8437, 3, 844, 422, 0, 8437, 8438, 5, 307, 0, 0, 8438, 8439, 5, 95, 0, 0, 8439, 8440, 3, 1892, 946, 0, 8440, 8805, 1, 0, 0, 0, 8441, 8442, 5, 140, 0, 0, 8442, 8443, 5, 651, 0, 0, 8443, 8444, 3, 1892, 946, 0, 8444, 8445, 5, 307, 0, 0, 8445, 8446, 5, 95, 0, 0, 8446, 8447, 3, 1892, 946, 0, 8447, 8805, 1, 0, 0, 0, 8448, 8449, 5, 140, 0, 0, 8449, 8450, 5, 640, 0, 0, 8450, 8451, 3, 844, 422, 0, 8451, 8452, 5, 307, 0, 0, 8452, 8453, 5, 95, 0, 0, 8453, 8454, 3, 1892, 946, 0, 8454, 8805, 1, 0, 0, 0, 8455, 8456, 5, 140, 0, 0, 8456, 8457, 5, 321, 0, 0, 8457, 8458, 3, 1892, 946, 0, 8458, 8459, 5, 307, 0, 0, 8459, 8460, 5, 95, 0, 0, 8460, 8461, 3, 1892, 946, 0, 8461, 8805, 1, 0, 0, 0, 8462, 8463, 5, 140, 0, 0, 8463, 8464, 5, 329, 0, 0, 8464, 8465, 3, 1892, 946, 0, 8465, 8466, 5, 307, 0, 0, 8466, 8467, 5, 95, 0, 0, 8467, 8468, 3, 1892, 946, 0, 8468, 8805, 1, 0, 0, 0, 8469, 8470, 5, 140, 0, 0, 8470, 8471, 5, 650, 0, 0, 8471, 8472, 3, 1892, 946, 0, 8472, 8473, 5, 307, 0, 0, 8473, 8474, 5, 95, 0, 0, 8474, 8475, 3, 1892, 946, 0, 8475, 8805, 1, 0, 0, 0, 8476, 8477, 5, 140, 0, 0, 8477, 8478, 5, 93, 0, 0, 8478, 8479, 3, 1618, 809, 0, 8479, 8480, 5, 307, 0, 0, 8480, 8481, 5, 95, 0, 0, 8481, 8482, 3, 1892, 946, 0, 8482, 8805, 1, 0, 0, 0, 8483, 8484, 5, 140, 0, 0, 8484, 8485, 5, 93, 0, 0, 8485, 8486, 5, 224, 0, 0, 8486, 8487, 5, 558, 0, 0, 8487, 8488, 3, 1618, 809, 0, 8488, 8489, 5, 307, 0, 0, 8489, 8490, 5, 95, 0, 0, 8490, 8491, 3, 1892, 946, 0, 8491, 8805, 1, 0, 0, 0, 8492, 8493, 5, 140, 0, 0, 8493, 8494, 5, 326, 0, 0, 8494, 8495, 3, 1888, 944, 0, 8495, 8496, 5, 307, 0, 0, 8496, 8497, 5, 95, 0, 0, 8497, 8498, 3, 1892, 946, 0, 8498, 8805, 1, 0, 0, 0, 8499, 8500, 5, 140, 0, 0, 8500, 8501, 5, 326, 0, 0, 8501, 8502, 5, 224, 0, 0, 8502, 8503, 5, 558, 0, 0, 8503, 8504, 3, 1888, 944, 0, 8504, 8505, 5, 307, 0, 0, 8505, 8506, 5, 95, 0, 0, 8506, 8507, 3, 1892, 946, 0, 8507, 8805, 1, 0, 0, 0, 8508, 8509, 5, 140, 0, 0, 8509, 8510, 5, 374, 0, 0, 8510, 8511, 3, 1888, 944, 0, 8511, 8512, 5, 307, 0, 0, 8512, 8513, 5, 95, 0, 0, 8513, 8514, 3, 1892, 946, 0, 8514, 8805, 1, 0, 0, 0, 8515, 8516, 5, 140, 0, 0, 8516, 8517, 5, 374, 0, 0, 8517, 8518, 5, 224, 0, 0, 8518, 8519, 5, 558, 0, 0, 8519, 8520, 3, 1888, 944, 0, 8520, 8521, 5, 307, 0, 0, 8521, 8522, 5, 95, 0, 0, 8522, 8523, 3, 1892, 946, 0, 8523, 8805, 1, 0, 0, 0, 8524, 8525, 5, 140, 0, 0, 8525, 8526, 5, 255, 0, 0, 8526, 8527, 5, 374, 0, 0, 8527, 8528, 3, 1888, 944, 0, 8528, 8529, 5, 307, 0, 0, 8529, 8530, 5, 95, 0, 0, 8530, 8531, 3, 1892, 946, 0, 8531, 8805, 1, 0, 0, 0, 8532, 8533, 5, 140, 0, 0, 8533, 8534, 5, 255, 0, 0, 8534, 8535, 5, 374, 0, 0, 8535, 8536, 5, 224, 0, 0, 8536, 8537, 5, 558, 0, 0, 8537, 8538, 3, 1888, 944, 0, 8538, 8539, 5, 307, 0, 0, 8539, 8540, 5, 95, 0, 0, 8540, 8541, 3, 1892, 946, 0, 8541, 8805, 1, 0, 0, 0, 8542, 8543, 5, 140, 0, 0, 8543, 8544, 5, 230, 0, 0, 8544, 8545, 3, 1888, 944, 0, 8545, 8546, 5, 307, 0, 0, 8546, 8547, 5, 95, 0, 0, 8547, 8548, 3, 1892, 946, 0, 8548, 8805, 1, 0, 0, 0, 8549, 8550, 5, 140, 0, 0, 8550, 8551, 5, 230, 0, 0, 8551, 8552, 5, 224, 0, 0, 8552, 8553, 5, 558, 0, 0, 8553, 8554, 3, 1888, 944, 0, 8554, 8555, 5, 307, 0, 0, 8555, 8556, 5, 95, 0, 0, 8556, 8557, 3, 1892, 946, 0, 8557, 8805, 1, 0, 0, 0, 8558, 8559, 5, 140, 0, 0, 8559, 8560, 5, 63, 0, 0, 8560, 8561, 5, 93, 0, 0, 8561, 8562, 3, 1618, 809, 0, 8562, 8563, 5, 307, 0, 0, 8563, 8564, 5, 95, 0, 0, 8564, 8565, 3, 1892, 946, 0, 8565, 8805, 1, 0, 0, 0, 8566, 8567, 5, 140, 0, 0, 8567, 8568, 5, 63, 0, 0, 8568, 8569, 5, 93, 0, 0, 8569, 8570, 5, 224, 0, 0, 8570, 8571, 5, 558, 0, 0, 8571, 8572, 3, 1618, 809, 0, 8572, 8573, 5, 307, 0, 0, 8573, 8574, 5, 95, 0, 0, 8574, 8575, 3, 1892, 946, 0, 8575, 8805, 1, 0, 0, 0, 8576, 8577, 5, 140, 0, 0, 8577, 8578, 5, 93, 0, 0, 8578, 8579, 3, 1618, 809, 0, 8579, 8581, 5, 307, 0, 0, 8580, 8582, 3, 944, 472, 0, 8581, 8580, 1, 0, 0, 0, 8581, 8582, 1, 0, 0, 0, 8582, 8583, 1, 0, 0, 0, 8583, 8584, 3, 1892, 946, 0, 8584, 8585, 5, 95, 0, 0, 8585, 8586, 3, 1892, 946, 0, 8586, 8805, 1, 0, 0, 0, 8587, 8588, 5, 140, 0, 0, 8588, 8589, 5, 93, 0, 0, 8589, 8590, 5, 224, 0, 0, 8590, 8591, 5, 558, 0, 0, 8591, 8592, 3, 1618, 809, 0, 8592, 8594, 5, 307, 0, 0, 8593, 8595, 3, 944, 472, 0, 8594, 8593, 1, 0, 0, 0, 8594, 8595, 1, 0, 0, 0, 8595, 8596, 1, 0, 0, 0, 8596, 8597, 3, 1892, 946, 0, 8597, 8598, 5, 95, 0, 0, 8598, 8599, 3, 1892, 946, 0, 8599, 8805, 1, 0, 0, 0, 8600, 8601, 5, 140, 0, 0, 8601, 8602, 5, 374, 0, 0, 8602, 8603, 3, 1888, 944, 0, 8603, 8605, 5, 307, 0, 0, 8604, 8606, 3, 944, 472, 0, 8605, 8604, 1, 0, 0, 0, 8605, 8606, 1, 0, 0, 0, 8606, 8607, 1, 0, 0, 0, 8607, 8608, 3, 1892, 946, 0, 8608, 8609, 5, 95, 0, 0, 8609, 8610, 3, 1892, 946, 0, 8610, 8805, 1, 0, 0, 0, 8611, 8612, 5, 140, 0, 0, 8612, 8613, 5, 374, 0, 0, 8613, 8614, 5, 224, 0, 0, 8614, 8615, 5, 558, 0, 0, 8615, 8616, 3, 1888, 944, 0, 8616, 8618, 5, 307, 0, 0, 8617, 8619, 3, 944, 472, 0, 8618, 8617, 1, 0, 0, 0, 8618, 8619, 1, 0, 0, 0, 8619, 8620, 1, 0, 0, 0, 8620, 8621, 3, 1892, 946, 0, 8621, 8622, 5, 95, 0, 0, 8622, 8623, 3, 1892, 946, 0, 8623, 8805, 1, 0, 0, 0, 8624, 8625, 5, 140, 0, 0, 8625, 8626, 5, 255, 0, 0, 8626, 8627, 5, 374, 0, 0, 8627, 8628, 3, 1888, 944, 0, 8628, 8630, 5, 307, 0, 0, 8629, 8631, 3, 944, 472, 0, 8630, 8629, 1, 0, 0, 0, 8630, 8631, 1, 0, 0, 0, 8631, 8632, 1, 0, 0, 0, 8632, 8633, 3, 1892, 946, 0, 8633, 8634, 5, 95, 0, 0, 8634, 8635, 3, 1892, 946, 0, 8635, 8805, 1, 0, 0, 0, 8636, 8637, 5, 140, 0, 0, 8637, 8638, 5, 255, 0, 0, 8638, 8639, 5, 374, 0, 0, 8639, 8640, 5, 224, 0, 0, 8640, 8641, 5, 558, 0, 0, 8641, 8642, 3, 1888, 944, 0, 8642, 8644, 5, 307, 0, 0, 8643, 8645, 3, 944, 472, 0, 8644, 8643, 1, 0, 0, 0, 8644, 8645, 1, 0, 0, 0, 8645, 8646, 1, 0, 0, 0, 8646, 8647, 3, 1892, 946, 0, 8647, 8648, 5, 95, 0, 0, 8648, 8649, 3, 1892, 946, 0, 8649, 8805, 1, 0, 0, 0, 8650, 8651, 5, 140, 0, 0, 8651, 8652, 5, 93, 0, 0, 8652, 8653, 3, 1618, 809, 0, 8653, 8654, 5, 307, 0, 0, 8654, 8655, 5, 45, 0, 0, 8655, 8656, 3, 1892, 946, 0, 8656, 8657, 5, 95, 0, 0, 8657, 8658, 3, 1892, 946, 0, 8658, 8805, 1, 0, 0, 0, 8659, 8660, 5, 140, 0, 0, 8660, 8661, 5, 93, 0, 0, 8661, 8662, 5, 224, 0, 0, 8662, 8663, 5, 558, 0, 0, 8663, 8664, 3, 1618, 809, 0, 8664, 8665, 5, 307, 0, 0, 8665, 8666, 5, 45, 0, 0, 8666, 8667, 3, 1892, 946, 0, 8667, 8668, 5, 95, 0, 0, 8668, 8669, 3, 1892, 946, 0, 8669, 8805, 1, 0, 0, 0, 8670, 8671, 5, 140, 0, 0, 8671, 8672, 5, 63, 0, 0, 8672, 8673, 5, 93, 0, 0, 8673, 8674, 3, 1618, 809, 0, 8674, 8676, 5, 307, 0, 0, 8675, 8677, 3, 944, 472, 0, 8676, 8675, 1, 0, 0, 0, 8676, 8677, 1, 0, 0, 0, 8677, 8678, 1, 0, 0, 0, 8678, 8679, 3, 1892, 946, 0, 8679, 8680, 5, 95, 0, 0, 8680, 8681, 3, 1892, 946, 0, 8681, 8805, 1, 0, 0, 0, 8682, 8683, 5, 140, 0, 0, 8683, 8684, 5, 63, 0, 0, 8684, 8685, 5, 93, 0, 0, 8685, 8686, 5, 224, 0, 0, 8686, 8687, 5, 558, 0, 0, 8687, 8688, 3, 1618, 809, 0, 8688, 8690, 5, 307, 0, 0, 8689, 8691, 3, 944, 472, 0, 8690, 8689, 1, 0, 0, 0, 8690, 8691, 1, 0, 0, 0, 8691, 8692, 1, 0, 0, 0, 8692, 8693, 3, 1892, 946, 0, 8693, 8694, 5, 95, 0, 0, 8694, 8695, 3, 1892, 946, 0, 8695, 8805, 1, 0, 0, 0, 8696, 8697, 5, 140, 0, 0, 8697, 8698, 5, 319, 0, 0, 8698, 8699, 3, 1892, 946, 0, 8699, 8700, 5, 80, 0, 0, 8700, 8701, 3, 1888, 944, 0, 8701, 8702, 5, 307, 0, 0, 8702, 8703, 5, 95, 0, 0, 8703, 8704, 3, 1892, 946, 0, 8704, 8805, 1, 0, 0, 0, 8705, 8706, 5, 140, 0, 0, 8706, 8707, 5, 355, 0, 0, 8707, 8708, 3, 1892, 946, 0, 8708, 8709, 5, 80, 0, 0, 8709, 8710, 3, 1888, 944, 0, 8710, 8711, 5, 307, 0, 0, 8711, 8712, 5, 95, 0, 0, 8712, 8713, 3, 1892, 946, 0, 8713, 8805, 1, 0, 0, 0, 8714, 8715, 5, 140, 0, 0, 8715, 8716, 5, 202, 0, 0, 8716, 8717, 5, 355, 0, 0, 8717, 8718, 3, 1892, 946, 0, 8718, 8719, 5, 307, 0, 0, 8719, 8720, 5, 95, 0, 0, 8720, 8721, 3, 1892, 946, 0, 8721, 8805, 1, 0, 0, 0, 8722, 8723, 5, 140, 0, 0, 8723, 8724, 5, 316, 0, 0, 8724, 8725, 3, 1918, 959, 0, 8725, 8726, 5, 307, 0, 0, 8726, 8727, 5, 95, 0, 0, 8727, 8728, 3, 1918, 959, 0, 8728, 8805, 1, 0, 0, 0, 8729, 8730, 5, 140, 0, 0, 8730, 8731, 5, 100, 0, 0, 8731, 8732, 3, 1918, 959, 0, 8732, 8733, 5, 307, 0, 0, 8733, 8734, 5, 95, 0, 0, 8734, 8735, 3, 1918, 959, 0, 8735, 8805, 1, 0, 0, 0, 8736, 8737, 5, 140, 0, 0, 8737, 8738, 5, 349, 0, 0, 8738, 8739, 3, 1892, 946, 0, 8739, 8740, 5, 307, 0, 0, 8740, 8741, 5, 95, 0, 0, 8741, 8742, 3, 1892, 946, 0, 8742, 8805, 1, 0, 0, 0, 8743, 8744, 5, 140, 0, 0, 8744, 8745, 5, 340, 0, 0, 8745, 8746, 3, 566, 283, 0, 8746, 8747, 5, 307, 0, 0, 8747, 8748, 5, 95, 0, 0, 8748, 8749, 3, 1892, 946, 0, 8749, 8805, 1, 0, 0, 0, 8750, 8751, 5, 140, 0, 0, 8751, 8752, 5, 353, 0, 0, 8752, 8753, 5, 323, 0, 0, 8753, 8754, 5, 280, 0, 0, 8754, 8755, 3, 566, 283, 0, 8755, 8756, 5, 307, 0, 0, 8756, 8757, 5, 95, 0, 0, 8757, 8758, 3, 1892, 946, 0, 8758, 8805, 1, 0, 0, 0, 8759, 8760, 5, 140, 0, 0, 8760, 8761, 5, 353, 0, 0, 8761, 8762, 5, 323, 0, 0, 8762, 8763, 5, 189, 0, 0, 8763, 8764, 3, 566, 283, 0, 8764, 8765, 5, 307, 0, 0, 8765, 8766, 5, 95, 0, 0, 8766, 8767, 3, 1892, 946, 0, 8767, 8805, 1, 0, 0, 0, 8768, 8769, 5, 140, 0, 0, 8769, 8770, 5, 353, 0, 0, 8770, 8771, 5, 323, 0, 0, 8771, 8772, 5, 351, 0, 0, 8772, 8773, 3, 566, 283, 0, 8773, 8774, 5, 307, 0, 0, 8774, 8775, 5, 95, 0, 0, 8775, 8776, 3, 1892, 946, 0, 8776, 8805, 1, 0, 0, 0, 8777, 8778, 5, 140, 0, 0, 8778, 8779, 5, 353, 0, 0, 8779, 8780, 5, 323, 0, 0, 8780, 8781, 5, 165, 0, 0, 8781, 8782, 3, 566, 283, 0, 8782, 8783, 5, 307, 0, 0, 8783, 8784, 5, 95, 0, 0, 8784, 8785, 3, 1892, 946, 0, 8785, 8805, 1, 0, 0, 0, 8786, 8787, 5, 140, 0, 0, 8787, 8788, 5, 358, 0, 0, 8788, 8789, 3, 566, 283, 0, 8789, 8790, 5, 307, 0, 0, 8790, 8791, 5, 95, 0, 0, 8791, 8792, 3, 1892, 946, 0, 8792, 8805, 1, 0, 0, 0, 8793, 8794, 5, 140, 0, 0, 8794, 8795, 5, 358, 0, 0, 8795, 8796, 3, 566, 283, 0, 8796, 8797, 5, 307, 0, 0, 8797, 8798, 5, 145, 0, 0, 8798, 8799, 3, 1892, 946, 0, 8799, 8800, 5, 95, 0, 0, 8800, 8802, 3, 1892, 946, 0, 8801, 8803, 3, 120, 60, 0, 8802, 8801, 1, 0, 0, 0, 8802, 8803, 1, 0, 0, 0, 8803, 8805, 1, 0, 0, 0, 8804, 8317, 1, 0, 0, 0, 8804, 8324, 1, 0, 0, 0, 8804, 8331, 1, 0, 0, 0, 8804, 8338, 1, 0, 0, 0, 8804, 8345, 1, 0, 0, 0, 8804, 8352, 1, 0, 0, 0, 8804, 8361, 1, 0, 0, 0, 8804, 8370, 1, 0, 0, 0, 8804, 8377, 1, 0, 0, 0, 8804, 8384, 1, 0, 0, 0, 8804, 8394, 1, 0, 0, 0, 8804, 8404, 1, 0, 0, 0, 8804, 8414, 1, 0, 0, 0, 8804, 8423, 1, 0, 0, 0, 8804, 8434, 1, 0, 0, 0, 8804, 8441, 1, 0, 0, 0, 8804, 8448, 1, 0, 0, 0, 8804, 8455, 1, 0, 0, 0, 8804, 8462, 1, 0, 0, 0, 8804, 8469, 1, 0, 0, 0, 8804, 8476, 1, 0, 0, 0, 8804, 8483, 1, 0, 0, 0, 8804, 8492, 1, 0, 0, 0, 8804, 8499, 1, 0, 0, 0, 8804, 8508, 1, 0, 0, 0, 8804, 8515, 1, 0, 0, 0, 8804, 8524, 1, 0, 0, 0, 8804, 8532, 1, 0, 0, 0, 8804, 8542, 1, 0, 0, 0, 8804, 8549, 1, 0, 0, 0, 8804, 8558, 1, 0, 0, 0, 8804, 8566, 1, 0, 0, 0, 8804, 8576, 1, 0, 0, 0, 8804, 8587, 1, 0, 0, 0, 8804, 8600, 1, 0, 0, 0, 8804, 8611, 1, 0, 0, 0, 8804, 8624, 1, 0, 0, 0, 8804, 8636, 1, 0, 0, 0, 8804, 8650, 1, 0, 0, 0, 8804, 8659, 1, 0, 0, 0, 8804, 8670, 1, 0, 0, 0, 8804, 8682, 1, 0, 0, 0, 8804, 8696, 1, 0, 0, 0, 8804, 8705, 1, 0, 0, 0, 8804, 8714, 1, 0, 0, 0, 8804, 8722, 1, 0, 0, 0, 8804, 8729, 1, 0, 0, 0, 8804, 8736, 1, 0, 0, 0, 8804, 8743, 1, 0, 0, 0, 8804, 8750, 1, 0, 0, 0, 8804, 8759, 1, 0, 0, 0, 8804, 8768, 1, 0, 0, 0, 8804, 8777, 1, 0, 0, 0, 8804, 8786, 1, 0, 0, 0, 8804, 8793, 1, 0, 0, 0, 8805, 943, 1, 0, 0, 0, 8806, 8807, 5, 44, 0, 0, 8807, 945, 1, 0, 0, 0, 8808, 8809, 5, 331, 0, 0, 8809, 8810, 5, 177, 0, 0, 8810, 947, 1, 0, 0, 0, 8811, 8812, 5, 140, 0, 0, 8812, 8813, 5, 215, 0, 0, 8813, 8815, 3, 844, 422, 0, 8814, 8816, 3, 950, 475, 0, 8815, 8814, 1, 0, 0, 0, 8815, 8816, 1, 0, 0, 0, 8816, 8817, 1, 0, 0, 0, 8817, 8818, 5, 661, 0, 0, 8818, 8819, 5, 80, 0, 0, 8819, 8820, 5, 208, 0, 0, 8820, 8821, 3, 1892, 946, 0, 8821, 8881, 1, 0, 0, 0, 8822, 8823, 5, 140, 0, 0, 8823, 8824, 5, 294, 0, 0, 8824, 8826, 3, 844, 422, 0, 8825, 8827, 3, 950, 475, 0, 8826, 8825, 1, 0, 0, 0, 8826, 8827, 1, 0, 0, 0, 8827, 8828, 1, 0, 0, 0, 8828, 8829, 5, 661, 0, 0, 8829, 8830, 5, 80, 0, 0, 8830, 8831, 5, 208, 0, 0, 8831, 8832, 3, 1892, 946, 0, 8832, 8881, 1, 0, 0, 0, 8833, 8834, 5, 140, 0, 0, 8834, 8835, 5, 640, 0, 0, 8835, 8837, 3, 844, 422, 0, 8836, 8838, 3, 950, 475, 0, 8837, 8836, 1, 0, 0, 0, 8837, 8838, 1, 0, 0, 0, 8838, 8839, 1, 0, 0, 0, 8839, 8840, 5, 661, 0, 0, 8840, 8841, 5, 80, 0, 0, 8841, 8842, 5, 208, 0, 0, 8842, 8843, 3, 1892, 946, 0, 8843, 8881, 1, 0, 0, 0, 8844, 8845, 5, 140, 0, 0, 8845, 8846, 5, 355, 0, 0, 8846, 8847, 3, 1892, 946, 0, 8847, 8848, 5, 80, 0, 0, 8848, 8850, 3, 1888, 944, 0, 8849, 8851, 3, 950, 475, 0, 8850, 8849, 1, 0, 0, 0, 8850, 8851, 1, 0, 0, 0, 8851, 8852, 1, 0, 0, 0, 8852, 8853, 5, 661, 0, 0, 8853, 8854, 5, 80, 0, 0, 8854, 8855, 5, 208, 0, 0, 8855, 8856, 3, 1892, 946, 0, 8856, 8881, 1, 0, 0, 0, 8857, 8858, 5, 140, 0, 0, 8858, 8859, 5, 255, 0, 0, 8859, 8860, 5, 374, 0, 0, 8860, 8862, 3, 1888, 944, 0, 8861, 8863, 3, 950, 475, 0, 8862, 8861, 1, 0, 0, 0, 8862, 8863, 1, 0, 0, 0, 8863, 8864, 1, 0, 0, 0, 8864, 8865, 5, 661, 0, 0, 8865, 8866, 5, 80, 0, 0, 8866, 8867, 5, 208, 0, 0, 8867, 8868, 3, 1892, 946, 0, 8868, 8881, 1, 0, 0, 0, 8869, 8870, 5, 140, 0, 0, 8870, 8871, 5, 230, 0, 0, 8871, 8873, 3, 1888, 944, 0, 8872, 8874, 3, 950, 475, 0, 8873, 8872, 1, 0, 0, 0, 8873, 8874, 1, 0, 0, 0, 8874, 8875, 1, 0, 0, 0, 8875, 8876, 5, 661, 0, 0, 8876, 8877, 5, 80, 0, 0, 8877, 8878, 5, 208, 0, 0, 8878, 8879, 3, 1892, 946, 0, 8879, 8881, 1, 0, 0, 0, 8880, 8811, 1, 0, 0, 0, 8880, 8822, 1, 0, 0, 0, 8880, 8833, 1, 0, 0, 0, 8880, 8844, 1, 0, 0, 0, 8880, 8857, 1, 0, 0, 0, 8880, 8869, 1, 0, 0, 0, 8881, 949, 1, 0, 0, 0, 8882, 8883, 5, 266, 0, 0, 8883, 951, 1, 0, 0, 0, 8884, 8885, 5, 140, 0, 0, 8885, 8886, 5, 138, 0, 0, 8886, 8887, 3, 868, 434, 0, 8887, 8888, 5, 331, 0, 0, 8888, 8889, 5, 321, 0, 0, 8889, 8890, 3, 1892, 946, 0, 8890, 9102, 1, 0, 0, 0, 8891, 8892, 5, 140, 0, 0, 8892, 8893, 5, 110, 0, 0, 8893, 8894, 3, 566, 283, 0, 8894, 8895, 5, 331, 0, 0, 8895, 8896, 5, 321, 0, 0, 8896, 8897, 3, 1892, 946, 0, 8897, 9102, 1, 0, 0, 0, 8898, 8899, 5, 140, 0, 0, 8899, 8900, 5, 170, 0, 0, 8900, 8901, 3, 566, 283, 0, 8901, 8902, 5, 331, 0, 0, 8902, 8903, 5, 321, 0, 0, 8903, 8904, 3, 1892, 946, 0, 8904, 9102, 1, 0, 0, 0, 8905, 8906, 5, 140, 0, 0, 8906, 8907, 5, 193, 0, 0, 8907, 8908, 3, 566, 283, 0, 8908, 8909, 5, 331, 0, 0, 8909, 8910, 5, 321, 0, 0, 8910, 8911, 3, 1892, 946, 0, 8911, 9102, 1, 0, 0, 0, 8912, 8913, 5, 140, 0, 0, 8913, 8914, 5, 208, 0, 0, 8914, 8915, 3, 1892, 946, 0, 8915, 8916, 5, 331, 0, 0, 8916, 8917, 5, 321, 0, 0, 8917, 8918, 3, 1892, 946, 0, 8918, 9102, 1, 0, 0, 0, 8919, 8920, 5, 140, 0, 0, 8920, 8921, 5, 215, 0, 0, 8921, 8922, 3, 844, 422, 0, 8922, 8923, 5, 331, 0, 0, 8923, 8924, 5, 321, 0, 0, 8924, 8925, 3, 1892, 946, 0, 8925, 9102, 1, 0, 0, 0, 8926, 8927, 5, 140, 0, 0, 8927, 8928, 5, 275, 0, 0, 8928, 8929, 3, 908, 454, 0, 8929, 8930, 5, 331, 0, 0, 8930, 8931, 5, 321, 0, 0, 8931, 8932, 3, 1892, 946, 0, 8932, 9102, 1, 0, 0, 0, 8933, 8934, 5, 140, 0, 0, 8934, 8935, 5, 275, 0, 0, 8935, 8936, 5, 158, 0, 0, 8936, 8937, 3, 566, 283, 0, 8937, 8938, 5, 101, 0, 0, 8938, 8939, 3, 1892, 946, 0, 8939, 8940, 5, 331, 0, 0, 8940, 8941, 5, 321, 0, 0, 8941, 8942, 3, 1892, 946, 0, 8942, 9102, 1, 0, 0, 0, 8943, 8944, 5, 140, 0, 0, 8944, 8945, 5, 275, 0, 0, 8945, 8946, 5, 210, 0, 0, 8946, 8947, 3, 566, 283, 0, 8947, 8948, 5, 101, 0, 0, 8948, 8949, 3, 1892, 946, 0, 8949, 8950, 5, 331, 0, 0, 8950, 8951, 5, 321, 0, 0, 8951, 8952, 3, 1892, 946, 0, 8952, 9102, 1, 0, 0, 0, 8953, 8954, 5, 140, 0, 0, 8954, 8955, 5, 294, 0, 0, 8955, 8956, 3, 844, 422, 0, 8956, 8957, 5, 331, 0, 0, 8957, 8958, 5, 321, 0, 0, 8958, 8959, 3, 1892, 946, 0, 8959, 9102, 1, 0, 0, 0, 8960, 8961, 5, 140, 0, 0, 8961, 8962, 5, 640, 0, 0, 8962, 8963, 3, 844, 422, 0, 8963, 8964, 5, 331, 0, 0, 8964, 8965, 5, 321, 0, 0, 8965, 8966, 3, 1892, 946, 0, 8966, 9102, 1, 0, 0, 0, 8967, 8968, 5, 140, 0, 0, 8968, 8969, 5, 93, 0, 0, 8969, 8970, 3, 1618, 809, 0, 8970, 8971, 5, 331, 0, 0, 8971, 8972, 5, 321, 0, 0, 8972, 8973, 3, 1892, 946, 0, 8973, 9102, 1, 0, 0, 0, 8974, 8975, 5, 140, 0, 0, 8975, 8976, 5, 93, 0, 0, 8976, 8977, 5, 224, 0, 0, 8977, 8978, 5, 558, 0, 0, 8978, 8979, 3, 1618, 809, 0, 8979, 8980, 5, 331, 0, 0, 8980, 8981, 5, 321, 0, 0, 8981, 8982, 3, 1892, 946, 0, 8982, 9102, 1, 0, 0, 0, 8983, 8984, 5, 140, 0, 0, 8984, 8985, 5, 340, 0, 0, 8985, 8986, 3, 566, 283, 0, 8986, 8987, 5, 331, 0, 0, 8987, 8988, 5, 321, 0, 0, 8988, 8989, 3, 1892, 946, 0, 8989, 9102, 1, 0, 0, 0, 8990, 8991, 5, 140, 0, 0, 8991, 8992, 5, 353, 0, 0, 8992, 8993, 5, 323, 0, 0, 8993, 8994, 5, 280, 0, 0, 8994, 8995, 3, 566, 283, 0, 8995, 8996, 5, 331, 0, 0, 8996, 8997, 5, 321, 0, 0, 8997, 8998, 3, 1892, 946, 0, 8998, 9102, 1, 0, 0, 0, 8999, 9000, 5, 140, 0, 0, 9000, 9001, 5, 353, 0, 0, 9001, 9002, 5, 323, 0, 0, 9002, 9003, 5, 189, 0, 0, 9003, 9004, 3, 566, 283, 0, 9004, 9005, 5, 331, 0, 0, 9005, 9006, 5, 321, 0, 0, 9006, 9007, 3, 1892, 946, 0, 9007, 9102, 1, 0, 0, 0, 9008, 9009, 5, 140, 0, 0, 9009, 9010, 5, 353, 0, 0, 9010, 9011, 5, 323, 0, 0, 9011, 9012, 5, 351, 0, 0, 9012, 9013, 3, 566, 283, 0, 9013, 9014, 5, 331, 0, 0, 9014, 9015, 5, 321, 0, 0, 9015, 9016, 3, 1892, 946, 0, 9016, 9102, 1, 0, 0, 0, 9017, 9018, 5, 140, 0, 0, 9018, 9019, 5, 353, 0, 0, 9019, 9020, 5, 323, 0, 0, 9020, 9021, 5, 165, 0, 0, 9021, 9022, 3, 566, 283, 0, 9022, 9023, 5, 331, 0, 0, 9023, 9024, 5, 321, 0, 0, 9024, 9025, 3, 1892, 946, 0, 9025, 9102, 1, 0, 0, 0, 9026, 9027, 5, 140, 0, 0, 9027, 9028, 5, 326, 0, 0, 9028, 9029, 3, 1888, 944, 0, 9029, 9030, 5, 331, 0, 0, 9030, 9031, 5, 321, 0, 0, 9031, 9032, 3, 1892, 946, 0, 9032, 9102, 1, 0, 0, 0, 9033, 9034, 5, 140, 0, 0, 9034, 9035, 5, 326, 0, 0, 9035, 9036, 5, 224, 0, 0, 9036, 9037, 5, 558, 0, 0, 9037, 9038, 3, 1888, 944, 0, 9038, 9039, 5, 331, 0, 0, 9039, 9040, 5, 321, 0, 0, 9040, 9041, 3, 1892, 946, 0, 9041, 9102, 1, 0, 0, 0, 9042, 9043, 5, 140, 0, 0, 9043, 9044, 5, 374, 0, 0, 9044, 9045, 3, 1888, 944, 0, 9045, 9046, 5, 331, 0, 0, 9046, 9047, 5, 321, 0, 0, 9047, 9048, 3, 1892, 946, 0, 9048, 9102, 1, 0, 0, 0, 9049, 9050, 5, 140, 0, 0, 9050, 9051, 5, 374, 0, 0, 9051, 9052, 5, 224, 0, 0, 9052, 9053, 5, 558, 0, 0, 9053, 9054, 3, 1888, 944, 0, 9054, 9055, 5, 331, 0, 0, 9055, 9056, 5, 321, 0, 0, 9056, 9057, 3, 1892, 946, 0, 9057, 9102, 1, 0, 0, 0, 9058, 9059, 5, 140, 0, 0, 9059, 9060, 5, 255, 0, 0, 9060, 9061, 5, 374, 0, 0, 9061, 9062, 3, 1888, 944, 0, 9062, 9063, 5, 331, 0, 0, 9063, 9064, 5, 321, 0, 0, 9064, 9065, 3, 1892, 946, 0, 9065, 9102, 1, 0, 0, 0, 9066, 9067, 5, 140, 0, 0, 9067, 9068, 5, 255, 0, 0, 9068, 9069, 5, 374, 0, 0, 9069, 9070, 5, 224, 0, 0, 9070, 9071, 5, 558, 0, 0, 9071, 9072, 3, 1888, 944, 0, 9072, 9073, 5, 331, 0, 0, 9073, 9074, 5, 321, 0, 0, 9074, 9075, 3, 1892, 946, 0, 9075, 9102, 1, 0, 0, 0, 9076, 9077, 5, 140, 0, 0, 9077, 9078, 5, 63, 0, 0, 9078, 9079, 5, 93, 0, 0, 9079, 9080, 3, 1618, 809, 0, 9080, 9081, 5, 331, 0, 0, 9081, 9082, 5, 321, 0, 0, 9082, 9083, 3, 1892, 946, 0, 9083, 9102, 1, 0, 0, 0, 9084, 9085, 5, 140, 0, 0, 9085, 9086, 5, 63, 0, 0, 9086, 9087, 5, 93, 0, 0, 9087, 9088, 5, 224, 0, 0, 9088, 9089, 5, 558, 0, 0, 9089, 9090, 3, 1618, 809, 0, 9090, 9091, 5, 331, 0, 0, 9091, 9092, 5, 321, 0, 0, 9092, 9093, 3, 1892, 946, 0, 9093, 9102, 1, 0, 0, 0, 9094, 9095, 5, 140, 0, 0, 9095, 9096, 5, 358, 0, 0, 9096, 9097, 3, 566, 283, 0, 9097, 9098, 5, 331, 0, 0, 9098, 9099, 5, 321, 0, 0, 9099, 9100, 3, 1892, 946, 0, 9100, 9102, 1, 0, 0, 0, 9101, 8884, 1, 0, 0, 0, 9101, 8891, 1, 0, 0, 0, 9101, 8898, 1, 0, 0, 0, 9101, 8905, 1, 0, 0, 0, 9101, 8912, 1, 0, 0, 0, 9101, 8919, 1, 0, 0, 0, 9101, 8926, 1, 0, 0, 0, 9101, 8933, 1, 0, 0, 0, 9101, 8943, 1, 0, 0, 0, 9101, 8953, 1, 0, 0, 0, 9101, 8960, 1, 0, 0, 0, 9101, 8967, 1, 0, 0, 0, 9101, 8974, 1, 0, 0, 0, 9101, 8983, 1, 0, 0, 0, 9101, 8990, 1, 0, 0, 0, 9101, 8999, 1, 0, 0, 0, 9101, 9008, 1, 0, 0, 0, 9101, 9017, 1, 0, 0, 0, 9101, 9026, 1, 0, 0, 0, 9101, 9033, 1, 0, 0, 0, 9101, 9042, 1, 0, 0, 0, 9101, 9049, 1, 0, 0, 0, 9101, 9058, 1, 0, 0, 0, 9101, 9066, 1, 0, 0, 0, 9101, 9076, 1, 0, 0, 0, 9101, 9084, 1, 0, 0, 0, 9101, 9094, 1, 0, 0, 0, 9102, 953, 1, 0, 0, 0, 9103, 9104, 5, 140, 0, 0, 9104, 9105, 5, 275, 0, 0, 9105, 9106, 3, 908, 454, 0, 9106, 9107, 5, 331, 0, 0, 9107, 9108, 5, 2, 0, 0, 9108, 9109, 3, 956, 478, 0, 9109, 9110, 5, 3, 0, 0, 9110, 955, 1, 0, 0, 0, 9111, 9116, 3, 958, 479, 0, 9112, 9113, 5, 6, 0, 0, 9113, 9115, 3, 958, 479, 0, 9114, 9112, 1, 0, 0, 0, 9115, 9118, 1, 0, 0, 0, 9116, 9114, 1, 0, 0, 0, 9116, 9117, 1, 0, 0, 0, 9117, 957, 1, 0, 0, 0, 9118, 9116, 1, 0, 0, 0, 9119, 9120, 3, 1932, 966, 0, 9120, 9121, 5, 10, 0, 0, 9121, 9122, 5, 569, 0, 0, 9122, 9128, 1, 0, 0, 0, 9123, 9124, 3, 1932, 966, 0, 9124, 9125, 5, 10, 0, 0, 9125, 9126, 3, 960, 480, 0, 9126, 9128, 1, 0, 0, 0, 9127, 9119, 1, 0, 0, 0, 9127, 9123, 1, 0, 0, 0, 9128, 959, 1, 0, 0, 0, 9129, 9135, 3, 858, 429, 0, 9130, 9135, 3, 1944, 972, 0, 9131, 9135, 3, 1826, 913, 0, 9132, 9135, 3, 334, 167, 0, 9133, 9135, 3, 1910, 955, 0, 9134, 9129, 1, 0, 0, 0, 9134, 9130, 1, 0, 0, 0, 9134, 9131, 1, 0, 0, 0, 9134, 9132, 1, 0, 0, 0, 9134, 9133, 1, 0, 0, 0, 9135, 961, 1, 0, 0, 0, 9136, 9137, 5, 140, 0, 0, 9137, 9138, 5, 358, 0, 0, 9138, 9139, 3, 566, 283, 0, 9139, 9140, 5, 331, 0, 0, 9140, 9141, 5, 2, 0, 0, 9141, 9142, 3, 956, 478, 0, 9142, 9143, 5, 3, 0, 0, 9143, 963, 1, 0, 0, 0, 9144, 9145, 5, 140, 0, 0, 9145, 9146, 5, 138, 0, 0, 9146, 9147, 3, 868, 434, 0, 9147, 9148, 5, 279, 0, 0, 9148, 9149, 5, 95, 0, 0, 9149, 9150, 3, 1920, 960, 0, 9150, 9330, 1, 0, 0, 0, 9151, 9152, 5, 140, 0, 0, 9152, 9153, 5, 110, 0, 0, 9153, 9154, 3, 566, 283, 0, 9154, 9155, 5, 279, 0, 0, 9155, 9156, 5, 95, 0, 0, 9156, 9157, 3, 1920, 960, 0, 9157, 9330, 1, 0, 0, 0, 9158, 9159, 5, 140, 0, 0, 9159, 9160, 5, 170, 0, 0, 9160, 9161, 3, 566, 283, 0, 9161, 9162, 5, 279, 0, 0, 9162, 9163, 5, 95, 0, 0, 9163, 9164, 3, 1920, 960, 0, 9164, 9330, 1, 0, 0, 0, 9165, 9166, 5, 140, 0, 0, 9166, 9167, 5, 179, 0, 0, 9167, 9168, 3, 1892, 946, 0, 9168, 9169, 5, 279, 0, 0, 9169, 9170, 5, 95, 0, 0, 9170, 9171, 3, 1920, 960, 0, 9171, 9330, 1, 0, 0, 0, 9172, 9173, 5, 140, 0, 0, 9173, 9174, 5, 193, 0, 0, 9174, 9175, 3, 566, 283, 0, 9175, 9176, 5, 279, 0, 0, 9176, 9177, 5, 95, 0, 0, 9177, 9178, 3, 1920, 960, 0, 9178, 9330, 1, 0, 0, 0, 9179, 9180, 5, 140, 0, 0, 9180, 9181, 5, 215, 0, 0, 9181, 9182, 3, 844, 422, 0, 9182, 9183, 5, 279, 0, 0, 9183, 9184, 5, 95, 0, 0, 9184, 9185, 3, 1920, 960, 0, 9185, 9330, 1, 0, 0, 0, 9186, 9188, 5, 140, 0, 0, 9187, 9189, 3, 350, 175, 0, 9188, 9187, 1, 0, 0, 0, 9188, 9189, 1, 0, 0, 0, 9189, 9190, 1, 0, 0, 0, 9190, 9191, 5, 242, 0, 0, 9191, 9192, 3, 1892, 946, 0, 9192, 9193, 5, 279, 0, 0, 9193, 9194, 5, 95, 0, 0, 9194, 9195, 3, 1920, 960, 0, 9195, 9330, 1, 0, 0, 0, 9196, 9197, 5, 140, 0, 0, 9197, 9198, 5, 243, 0, 0, 9198, 9199, 5, 271, 0, 0, 9199, 9200, 3, 334, 167, 0, 9200, 9201, 5, 279, 0, 0, 9201, 9202, 5, 95, 0, 0, 9202, 9203, 3, 1920, 960, 0, 9203, 9330, 1, 0, 0, 0, 9204, 9205, 5, 140, 0, 0, 9205, 9206, 5, 275, 0, 0, 9206, 9207, 3, 908, 454, 0, 9207, 9208, 5, 279, 0, 0, 9208, 9209, 5, 95, 0, 0, 9209, 9210, 3, 1920, 960, 0, 9210, 9330, 1, 0, 0, 0, 9211, 9212, 5, 140, 0, 0, 9212, 9213, 5, 275, 0, 0, 9213, 9214, 5, 158, 0, 0, 9214, 9215, 3, 566, 283, 0, 9215, 9216, 5, 101, 0, 0, 9216, 9217, 3, 1892, 946, 0, 9217, 9218, 5, 279, 0, 0, 9218, 9219, 5, 95, 0, 0, 9219, 9220, 3, 1920, 960, 0, 9220, 9330, 1, 0, 0, 0, 9221, 9222, 5, 140, 0, 0, 9222, 9223, 5, 275, 0, 0, 9223, 9224, 5, 210, 0, 0, 9224, 9225, 3, 566, 283, 0, 9225, 9226, 5, 101, 0, 0, 9226, 9227, 3, 1892, 946, 0, 9227, 9228, 5, 279, 0, 0, 9228, 9229, 5, 95, 0, 0, 9229, 9230, 3, 1920, 960, 0, 9230, 9330, 1, 0, 0, 0, 9231, 9232, 5, 140, 0, 0, 9232, 9233, 5, 294, 0, 0, 9233, 9234, 3, 844, 422, 0, 9234, 9235, 5, 279, 0, 0, 9235, 9236, 5, 95, 0, 0, 9236, 9237, 3, 1920, 960, 0, 9237, 9330, 1, 0, 0, 0, 9238, 9239, 5, 140, 0, 0, 9239, 9240, 5, 640, 0, 0, 9240, 9241, 3, 844, 422, 0, 9241, 9242, 5, 279, 0, 0, 9242, 9243, 5, 95, 0, 0, 9243, 9244, 3, 1920, 960, 0, 9244, 9330, 1, 0, 0, 0, 9245, 9246, 5, 140, 0, 0, 9246, 9247, 5, 321, 0, 0, 9247, 9248, 3, 1892, 946, 0, 9248, 9249, 5, 279, 0, 0, 9249, 9250, 5, 95, 0, 0, 9250, 9251, 3, 1920, 960, 0, 9251, 9330, 1, 0, 0, 0, 9252, 9253, 5, 140, 0, 0, 9253, 9254, 5, 358, 0, 0, 9254, 9255, 3, 566, 283, 0, 9255, 9256, 5, 279, 0, 0, 9256, 9257, 5, 95, 0, 0, 9257, 9258, 3, 1920, 960, 0, 9258, 9330, 1, 0, 0, 0, 9259, 9260, 5, 140, 0, 0, 9260, 9261, 5, 349, 0, 0, 9261, 9262, 3, 1892, 946, 0, 9262, 9263, 5, 279, 0, 0, 9263, 9264, 5, 95, 0, 0, 9264, 9265, 3, 1920, 960, 0, 9265, 9330, 1, 0, 0, 0, 9266, 9267, 5, 140, 0, 0, 9267, 9268, 5, 340, 0, 0, 9268, 9269, 3, 566, 283, 0, 9269, 9270, 5, 279, 0, 0, 9270, 9271, 5, 95, 0, 0, 9271, 9272, 3, 1920, 960, 0, 9272, 9330, 1, 0, 0, 0, 9273, 9274, 5, 140, 0, 0, 9274, 9275, 5, 353, 0, 0, 9275, 9276, 5, 323, 0, 0, 9276, 9277, 5, 189, 0, 0, 9277, 9278, 3, 566, 283, 0, 9278, 9279, 5, 279, 0, 0, 9279, 9280, 5, 95, 0, 0, 9280, 9281, 3, 1920, 960, 0, 9281, 9330, 1, 0, 0, 0, 9282, 9283, 5, 140, 0, 0, 9283, 9284, 5, 353, 0, 0, 9284, 9285, 5, 323, 0, 0, 9285, 9286, 5, 165, 0, 0, 9286, 9287, 3, 566, 283, 0, 9287, 9288, 5, 279, 0, 0, 9288, 9289, 5, 95, 0, 0, 9289, 9290, 3, 1920, 960, 0, 9290, 9330, 1, 0, 0, 0, 9291, 9292, 5, 140, 0, 0, 9292, 9293, 5, 63, 0, 0, 9293, 9294, 5, 177, 0, 0, 9294, 9295, 5, 379, 0, 0, 9295, 9296, 3, 1892, 946, 0, 9296, 9297, 5, 279, 0, 0, 9297, 9298, 5, 95, 0, 0, 9298, 9299, 3, 1920, 960, 0, 9299, 9330, 1, 0, 0, 0, 9300, 9301, 5, 140, 0, 0, 9301, 9302, 5, 329, 0, 0, 9302, 9303, 3, 1892, 946, 0, 9303, 9304, 5, 279, 0, 0, 9304, 9305, 5, 95, 0, 0, 9305, 9306, 3, 1920, 960, 0, 9306, 9330, 1, 0, 0, 0, 9307, 9308, 5, 140, 0, 0, 9308, 9309, 5, 202, 0, 0, 9309, 9310, 5, 355, 0, 0, 9310, 9311, 3, 1892, 946, 0, 9311, 9312, 5, 279, 0, 0, 9312, 9313, 5, 95, 0, 0, 9313, 9314, 3, 1920, 960, 0, 9314, 9330, 1, 0, 0, 0, 9315, 9316, 5, 140, 0, 0, 9316, 9317, 5, 651, 0, 0, 9317, 9318, 3, 1892, 946, 0, 9318, 9319, 5, 279, 0, 0, 9319, 9320, 5, 95, 0, 0, 9320, 9321, 3, 1920, 960, 0, 9321, 9330, 1, 0, 0, 0, 9322, 9323, 5, 140, 0, 0, 9323, 9324, 5, 650, 0, 0, 9324, 9325, 3, 1892, 946, 0, 9325, 9326, 5, 279, 0, 0, 9326, 9327, 5, 95, 0, 0, 9327, 9328, 3, 1920, 960, 0, 9328, 9330, 1, 0, 0, 0, 9329, 9144, 1, 0, 0, 0, 9329, 9151, 1, 0, 0, 0, 9329, 9158, 1, 0, 0, 0, 9329, 9165, 1, 0, 0, 0, 9329, 9172, 1, 0, 0, 0, 9329, 9179, 1, 0, 0, 0, 9329, 9186, 1, 0, 0, 0, 9329, 9196, 1, 0, 0, 0, 9329, 9204, 1, 0, 0, 0, 9329, 9211, 1, 0, 0, 0, 9329, 9221, 1, 0, 0, 0, 9329, 9231, 1, 0, 0, 0, 9329, 9238, 1, 0, 0, 0, 9329, 9245, 1, 0, 0, 0, 9329, 9252, 1, 0, 0, 0, 9329, 9259, 1, 0, 0, 0, 9329, 9266, 1, 0, 0, 0, 9329, 9273, 1, 0, 0, 0, 9329, 9282, 1, 0, 0, 0, 9329, 9291, 1, 0, 0, 0, 9329, 9300, 1, 0, 0, 0, 9329, 9307, 1, 0, 0, 0, 9329, 9315, 1, 0, 0, 0, 9329, 9322, 1, 0, 0, 0, 9330, 965, 1, 0, 0, 0, 9331, 9332, 5, 46, 0, 0, 9332, 9333, 5, 651, 0, 0, 9333, 9335, 3, 1892, 946, 0, 9334, 9336, 3, 882, 441, 0, 9335, 9334, 1, 0, 0, 0, 9335, 9336, 1, 0, 0, 0, 9336, 9355, 1, 0, 0, 0, 9337, 9338, 5, 46, 0, 0, 9338, 9339, 5, 651, 0, 0, 9339, 9340, 3, 1892, 946, 0, 9340, 9341, 5, 62, 0, 0, 9341, 9342, 5, 30, 0, 0, 9342, 9344, 5, 348, 0, 0, 9343, 9345, 3, 882, 441, 0, 9344, 9343, 1, 0, 0, 0, 9344, 9345, 1, 0, 0, 0, 9345, 9355, 1, 0, 0, 0, 9346, 9347, 5, 46, 0, 0, 9347, 9348, 5, 651, 0, 0, 9348, 9349, 3, 1892, 946, 0, 9349, 9350, 5, 62, 0, 0, 9350, 9352, 3, 968, 484, 0, 9351, 9353, 3, 882, 441, 0, 9352, 9351, 1, 0, 0, 0, 9352, 9353, 1, 0, 0, 0, 9353, 9355, 1, 0, 0, 0, 9354, 9331, 1, 0, 0, 0, 9354, 9337, 1, 0, 0, 0, 9354, 9346, 1, 0, 0, 0, 9355, 967, 1, 0, 0, 0, 9356, 9361, 3, 970, 485, 0, 9357, 9358, 5, 6, 0, 0, 9358, 9360, 3, 970, 485, 0, 9359, 9357, 1, 0, 0, 0, 9360, 9363, 1, 0, 0, 0, 9361, 9359, 1, 0, 0, 0, 9361, 9362, 1, 0, 0, 0, 9362, 969, 1, 0, 0, 0, 9363, 9361, 1, 0, 0, 0, 9364, 9365, 5, 93, 0, 0, 9365, 9367, 3, 1618, 809, 0, 9366, 9368, 3, 244, 122, 0, 9367, 9366, 1, 0, 0, 0, 9367, 9368, 1, 0, 0, 0, 9368, 9370, 1, 0, 0, 0, 9369, 9371, 3, 972, 486, 0, 9370, 9369, 1, 0, 0, 0, 9370, 9371, 1, 0, 0, 0, 9371, 9403, 1, 0, 0, 0, 9372, 9373, 5, 93, 0, 0, 9373, 9374, 5, 68, 0, 0, 9374, 9377, 5, 321, 0, 0, 9375, 9378, 3, 1924, 962, 0, 9376, 9378, 5, 113, 0, 0, 9377, 9375, 1, 0, 0, 0, 9377, 9376, 1, 0, 0, 0, 9378, 9403, 1, 0, 0, 0, 9379, 9381, 3, 1924, 962, 0, 9380, 9382, 3, 244, 122, 0, 9381, 9380, 1, 0, 0, 0, 9381, 9382, 1, 0, 0, 0, 9382, 9384, 1, 0, 0, 0, 9383, 9385, 3, 972, 486, 0, 9384, 9383, 1, 0, 0, 0, 9384, 9385, 1, 0, 0, 0, 9385, 9403, 1, 0, 0, 0, 9386, 9387, 3, 1924, 962, 0, 9387, 9389, 3, 1874, 937, 0, 9388, 9390, 3, 244, 122, 0, 9389, 9388, 1, 0, 0, 0, 9389, 9390, 1, 0, 0, 0, 9390, 9392, 1, 0, 0, 0, 9391, 9393, 3, 972, 486, 0, 9392, 9391, 1, 0, 0, 0, 9392, 9393, 1, 0, 0, 0, 9393, 9403, 1, 0, 0, 0, 9394, 9396, 3, 1618, 809, 0, 9395, 9397, 3, 244, 122, 0, 9396, 9395, 1, 0, 0, 0, 9396, 9397, 1, 0, 0, 0, 9397, 9399, 1, 0, 0, 0, 9398, 9400, 3, 972, 486, 0, 9399, 9398, 1, 0, 0, 0, 9399, 9400, 1, 0, 0, 0, 9400, 9403, 1, 0, 0, 0, 9401, 9403, 5, 113, 0, 0, 9402, 9364, 1, 0, 0, 0, 9402, 9372, 1, 0, 0, 0, 9402, 9379, 1, 0, 0, 0, 9402, 9386, 1, 0, 0, 0, 9402, 9394, 1, 0, 0, 0, 9402, 9401, 1, 0, 0, 0, 9403, 971, 1, 0, 0, 0, 9404, 9405, 5, 104, 0, 0, 9405, 9406, 5, 2, 0, 0, 9406, 9407, 3, 1710, 855, 0, 9407, 9408, 5, 3, 0, 0, 9408, 973, 1, 0, 0, 0, 9409, 9410, 5, 140, 0, 0, 9410, 9411, 5, 651, 0, 0, 9411, 9412, 3, 1892, 946, 0, 9412, 9413, 5, 331, 0, 0, 9413, 9414, 3, 502, 251, 0, 9414, 9434, 1, 0, 0, 0, 9415, 9416, 5, 140, 0, 0, 9416, 9417, 5, 651, 0, 0, 9417, 9418, 3, 1892, 946, 0, 9418, 9419, 5, 135, 0, 0, 9419, 9420, 3, 968, 484, 0, 9420, 9434, 1, 0, 0, 0, 9421, 9422, 5, 140, 0, 0, 9422, 9423, 5, 651, 0, 0, 9423, 9424, 3, 1892, 946, 0, 9424, 9425, 5, 331, 0, 0, 9425, 9426, 3, 968, 484, 0, 9426, 9434, 1, 0, 0, 0, 9427, 9428, 5, 140, 0, 0, 9428, 9429, 5, 651, 0, 0, 9429, 9430, 3, 1892, 946, 0, 9430, 9431, 5, 195, 0, 0, 9431, 9432, 3, 968, 484, 0, 9432, 9434, 1, 0, 0, 0, 9433, 9409, 1, 0, 0, 0, 9433, 9415, 1, 0, 0, 0, 9433, 9421, 1, 0, 0, 0, 9433, 9427, 1, 0, 0, 0, 9434, 975, 1, 0, 0, 0, 9435, 9436, 5, 46, 0, 0, 9436, 9437, 5, 650, 0, 0, 9437, 9438, 3, 1892, 946, 0, 9438, 9439, 5, 166, 0, 0, 9439, 9440, 3, 1910, 955, 0, 9440, 9441, 5, 651, 0, 0, 9441, 9443, 3, 978, 489, 0, 9442, 9444, 3, 882, 441, 0, 9443, 9442, 1, 0, 0, 0, 9443, 9444, 1, 0, 0, 0, 9444, 977, 1, 0, 0, 0, 9445, 9450, 3, 980, 490, 0, 9446, 9447, 5, 6, 0, 0, 9447, 9449, 3, 980, 490, 0, 9448, 9446, 1, 0, 0, 0, 9449, 9452, 1, 0, 0, 0, 9450, 9448, 1, 0, 0, 0, 9450, 9451, 1, 0, 0, 0, 9451, 979, 1, 0, 0, 0, 9452, 9450, 1, 0, 0, 0, 9453, 9454, 3, 1932, 966, 0, 9454, 981, 1, 0, 0, 0, 9455, 9456, 5, 140, 0, 0, 9456, 9457, 5, 650, 0, 0, 9457, 9458, 3, 1892, 946, 0, 9458, 9459, 5, 331, 0, 0, 9459, 9460, 3, 502, 251, 0, 9460, 9501, 1, 0, 0, 0, 9461, 9462, 5, 140, 0, 0, 9462, 9463, 5, 650, 0, 0, 9463, 9464, 3, 1892, 946, 0, 9464, 9465, 5, 166, 0, 0, 9465, 9466, 3, 1910, 955, 0, 9466, 9501, 1, 0, 0, 0, 9467, 9468, 5, 140, 0, 0, 9468, 9469, 5, 650, 0, 0, 9469, 9470, 3, 1892, 946, 0, 9470, 9471, 5, 303, 0, 0, 9471, 9473, 5, 651, 0, 0, 9472, 9474, 3, 882, 441, 0, 9473, 9472, 1, 0, 0, 0, 9473, 9474, 1, 0, 0, 0, 9474, 9501, 1, 0, 0, 0, 9475, 9476, 5, 140, 0, 0, 9476, 9477, 5, 650, 0, 0, 9477, 9478, 3, 1892, 946, 0, 9478, 9479, 5, 331, 0, 0, 9479, 9480, 5, 651, 0, 0, 9480, 9482, 3, 978, 489, 0, 9481, 9483, 3, 882, 441, 0, 9482, 9481, 1, 0, 0, 0, 9482, 9483, 1, 0, 0, 0, 9483, 9501, 1, 0, 0, 0, 9484, 9485, 5, 140, 0, 0, 9485, 9486, 5, 650, 0, 0, 9486, 9487, 3, 1892, 946, 0, 9487, 9488, 5, 197, 0, 0, 9488, 9501, 1, 0, 0, 0, 9489, 9490, 5, 140, 0, 0, 9490, 9491, 5, 650, 0, 0, 9491, 9492, 3, 1892, 946, 0, 9492, 9493, 5, 190, 0, 0, 9493, 9501, 1, 0, 0, 0, 9494, 9495, 5, 140, 0, 0, 9495, 9496, 5, 650, 0, 0, 9496, 9497, 3, 1892, 946, 0, 9497, 9498, 5, 664, 0, 0, 9498, 9499, 3, 502, 251, 0, 9499, 9501, 1, 0, 0, 0, 9500, 9455, 1, 0, 0, 0, 9500, 9461, 1, 0, 0, 0, 9500, 9467, 1, 0, 0, 0, 9500, 9475, 1, 0, 0, 0, 9500, 9484, 1, 0, 0, 0, 9500, 9489, 1, 0, 0, 0, 9500, 9494, 1, 0, 0, 0, 9501, 983, 1, 0, 0, 0, 9502, 9503, 5, 195, 0, 0, 9503, 9504, 5, 650, 0, 0, 9504, 9506, 3, 1892, 946, 0, 9505, 9507, 3, 120, 60, 0, 9506, 9505, 1, 0, 0, 0, 9506, 9507, 1, 0, 0, 0, 9507, 9517, 1, 0, 0, 0, 9508, 9509, 5, 195, 0, 0, 9509, 9510, 5, 650, 0, 0, 9510, 9511, 5, 224, 0, 0, 9511, 9512, 5, 558, 0, 0, 9512, 9514, 3, 1892, 946, 0, 9513, 9515, 3, 120, 60, 0, 9514, 9513, 1, 0, 0, 0, 9514, 9515, 1, 0, 0, 0, 9515, 9517, 1, 0, 0, 0, 9516, 9502, 1, 0, 0, 0, 9516, 9508, 1, 0, 0, 0, 9517, 985, 1, 0, 0, 0, 9518, 9520, 5, 46, 0, 0, 9519, 9521, 3, 832, 416, 0, 9520, 9519, 1, 0, 0, 0, 9520, 9521, 1, 0, 0, 0, 9521, 9522, 1, 0, 0, 0, 9522, 9523, 5, 319, 0, 0, 9523, 9524, 3, 1892, 946, 0, 9524, 9525, 5, 36, 0, 0, 9525, 9526, 5, 80, 0, 0, 9526, 9527, 3, 996, 498, 0, 9527, 9528, 5, 95, 0, 0, 9528, 9530, 3, 1888, 944, 0, 9529, 9531, 3, 1638, 819, 0, 9530, 9529, 1, 0, 0, 0, 9530, 9531, 1, 0, 0, 0, 9531, 9532, 1, 0, 0, 0, 9532, 9534, 5, 57, 0, 0, 9533, 9535, 3, 998, 499, 0, 9534, 9533, 1, 0, 0, 0, 9534, 9535, 1, 0, 0, 0, 9535, 9536, 1, 0, 0, 0, 9536, 9537, 3, 988, 494, 0, 9537, 987, 1, 0, 0, 0, 9538, 9545, 5, 267, 0, 0, 9539, 9545, 3, 992, 496, 0, 9540, 9541, 5, 2, 0, 0, 9541, 9542, 3, 990, 495, 0, 9542, 9543, 5, 3, 0, 0, 9543, 9545, 1, 0, 0, 0, 9544, 9538, 1, 0, 0, 0, 9544, 9539, 1, 0, 0, 0, 9544, 9540, 1, 0, 0, 0, 9545, 989, 1, 0, 0, 0, 9546, 9548, 3, 994, 497, 0, 9547, 9546, 1, 0, 0, 0, 9547, 9548, 1, 0, 0, 0, 9548, 9555, 1, 0, 0, 0, 9549, 9551, 5, 7, 0, 0, 9550, 9552, 3, 994, 497, 0, 9551, 9550, 1, 0, 0, 0, 9551, 9552, 1, 0, 0, 0, 9552, 9554, 1, 0, 0, 0, 9553, 9549, 1, 0, 0, 0, 9554, 9557, 1, 0, 0, 0, 9555, 9553, 1, 0, 0, 0, 9555, 9556, 1, 0, 0, 0, 9556, 991, 1, 0, 0, 0, 9557, 9555, 1, 0, 0, 0, 9558, 9564, 3, 1496, 748, 0, 9559, 9564, 3, 1436, 718, 0, 9560, 9564, 3, 1478, 739, 0, 9561, 9564, 3, 1464, 732, 0, 9562, 9564, 3, 1000, 500, 0, 9563, 9558, 1, 0, 0, 0, 9563, 9559, 1, 0, 0, 0, 9563, 9560, 1, 0, 0, 0, 9563, 9561, 1, 0, 0, 0, 9563, 9562, 1, 0, 0, 0, 9564, 993, 1, 0, 0, 0, 9565, 9566, 3, 992, 496, 0, 9566, 995, 1, 0, 0, 0, 9567, 9568, 7, 53, 0, 0, 9568, 997, 1, 0, 0, 0, 9569, 9570, 7, 54, 0, 0, 9570, 999, 1, 0, 0, 0, 9571, 9572, 5, 268, 0, 0, 9572, 9574, 3, 1924, 962, 0, 9573, 9575, 3, 1002, 501, 0, 9574, 9573, 1, 0, 0, 0, 9574, 9575, 1, 0, 0, 0, 9575, 1001, 1, 0, 0, 0, 9576, 9577, 5, 6, 0, 0, 9577, 9578, 3, 1910, 955, 0, 9578, 1003, 1, 0, 0, 0, 9579, 9580, 5, 247, 0, 0, 9580, 9581, 3, 1924, 962, 0, 9581, 1005, 1, 0, 0, 0, 9582, 9583, 5, 364, 0, 0, 9583, 9587, 3, 1924, 962, 0, 9584, 9585, 5, 364, 0, 0, 9585, 9587, 5, 9, 0, 0, 9586, 9582, 1, 0, 0, 0, 9586, 9584, 1, 0, 0, 0, 9587, 1007, 1, 0, 0, 0, 9588, 9590, 5, 131, 0, 0, 9589, 9591, 3, 1010, 505, 0, 9590, 9589, 1, 0, 0, 0, 9590, 9591, 1, 0, 0, 0, 9591, 9593, 1, 0, 0, 0, 9592, 9594, 3, 1018, 509, 0, 9593, 9592, 1, 0, 0, 0, 9593, 9594, 1, 0, 0, 0, 9594, 9658, 1, 0, 0, 0, 9595, 9597, 5, 148, 0, 0, 9596, 9598, 3, 1010, 505, 0, 9597, 9596, 1, 0, 0, 0, 9597, 9598, 1, 0, 0, 0, 9598, 9600, 1, 0, 0, 0, 9599, 9601, 3, 1016, 508, 0, 9600, 9599, 1, 0, 0, 0, 9600, 9601, 1, 0, 0, 0, 9601, 9658, 1, 0, 0, 0, 9602, 9603, 5, 338, 0, 0, 9603, 9605, 5, 354, 0, 0, 9604, 9606, 3, 1016, 508, 0, 9605, 9604, 1, 0, 0, 0, 9605, 9606, 1, 0, 0, 0, 9606, 9658, 1, 0, 0, 0, 9607, 9609, 5, 163, 0, 0, 9608, 9610, 3, 1010, 505, 0, 9609, 9608, 1, 0, 0, 0, 9609, 9610, 1, 0, 0, 0, 9610, 9612, 1, 0, 0, 0, 9611, 9613, 3, 1018, 509, 0, 9612, 9611, 1, 0, 0, 0, 9612, 9613, 1, 0, 0, 0, 9613, 9658, 1, 0, 0, 0, 9614, 9616, 5, 653, 0, 0, 9615, 9617, 3, 1010, 505, 0, 9616, 9615, 1, 0, 0, 0, 9616, 9617, 1, 0, 0, 0, 9617, 9619, 1, 0, 0, 0, 9618, 9620, 3, 1018, 509, 0, 9619, 9618, 1, 0, 0, 0, 9619, 9620, 1, 0, 0, 0, 9620, 9658, 1, 0, 0, 0, 9621, 9623, 5, 317, 0, 0, 9622, 9624, 3, 1010, 505, 0, 9623, 9622, 1, 0, 0, 0, 9623, 9624, 1, 0, 0, 0, 9624, 9626, 1, 0, 0, 0, 9625, 9627, 3, 1018, 509, 0, 9626, 9625, 1, 0, 0, 0, 9626, 9627, 1, 0, 0, 0, 9627, 9658, 1, 0, 0, 0, 9628, 9629, 5, 320, 0, 0, 9629, 9658, 3, 1924, 962, 0, 9630, 9631, 5, 306, 0, 0, 9631, 9632, 5, 320, 0, 0, 9632, 9658, 3, 1924, 962, 0, 9633, 9634, 5, 306, 0, 0, 9634, 9658, 3, 1924, 962, 0, 9635, 9637, 5, 317, 0, 0, 9636, 9638, 3, 1010, 505, 0, 9637, 9636, 1, 0, 0, 0, 9637, 9638, 1, 0, 0, 0, 9638, 9639, 1, 0, 0, 0, 9639, 9640, 5, 95, 0, 0, 9640, 9641, 5, 320, 0, 0, 9641, 9658, 3, 1924, 962, 0, 9642, 9644, 5, 317, 0, 0, 9643, 9645, 3, 1010, 505, 0, 9644, 9643, 1, 0, 0, 0, 9644, 9645, 1, 0, 0, 0, 9645, 9646, 1, 0, 0, 0, 9646, 9647, 5, 95, 0, 0, 9647, 9658, 3, 1924, 962, 0, 9648, 9649, 5, 288, 0, 0, 9649, 9650, 5, 354, 0, 0, 9650, 9658, 3, 1910, 955, 0, 9651, 9652, 5, 163, 0, 0, 9652, 9653, 5, 289, 0, 0, 9653, 9658, 3, 1910, 955, 0, 9654, 9655, 5, 317, 0, 0, 9655, 9656, 5, 289, 0, 0, 9656, 9658, 3, 1910, 955, 0, 9657, 9588, 1, 0, 0, 0, 9657, 9595, 1, 0, 0, 0, 9657, 9602, 1, 0, 0, 0, 9657, 9607, 1, 0, 0, 0, 9657, 9614, 1, 0, 0, 0, 9657, 9621, 1, 0, 0, 0, 9657, 9628, 1, 0, 0, 0, 9657, 9630, 1, 0, 0, 0, 9657, 9633, 1, 0, 0, 0, 9657, 9635, 1, 0, 0, 0, 9657, 9642, 1, 0, 0, 0, 9657, 9648, 1, 0, 0, 0, 9657, 9651, 1, 0, 0, 0, 9657, 9654, 1, 0, 0, 0, 9658, 1009, 1, 0, 0, 0, 9659, 9660, 7, 55, 0, 0, 9660, 1011, 1, 0, 0, 0, 9661, 9662, 5, 239, 0, 0, 9662, 9663, 5, 246, 0, 0, 9663, 9672, 3, 74, 37, 0, 9664, 9665, 5, 298, 0, 0, 9665, 9672, 5, 81, 0, 0, 9666, 9667, 5, 298, 0, 0, 9667, 9672, 5, 380, 0, 0, 9668, 9672, 5, 54, 0, 0, 9669, 9670, 5, 77, 0, 0, 9670, 9672, 5, 54, 0, 0, 9671, 9661, 1, 0, 0, 0, 9671, 9664, 1, 0, 0, 0, 9671, 9666, 1, 0, 0, 0, 9671, 9668, 1, 0, 0, 0, 9671, 9669, 1, 0, 0, 0, 9672, 1013, 1, 0, 0, 0, 9673, 9680, 3, 1012, 506, 0, 9674, 9676, 5, 6, 0, 0, 9675, 9674, 1, 0, 0, 0, 9675, 9676, 1, 0, 0, 0, 9676, 9677, 1, 0, 0, 0, 9677, 9679, 3, 1012, 506, 0, 9678, 9675, 1, 0, 0, 0, 9679, 9682, 1, 0, 0, 0, 9680, 9678, 1, 0, 0, 0, 9680, 9681, 1, 0, 0, 0, 9681, 1015, 1, 0, 0, 0, 9682, 9680, 1, 0, 0, 0, 9683, 9684, 3, 1014, 507, 0, 9684, 1017, 1, 0, 0, 0, 9685, 9687, 5, 33, 0, 0, 9686, 9688, 5, 266, 0, 0, 9687, 9686, 1, 0, 0, 0, 9687, 9688, 1, 0, 0, 0, 9688, 9689, 1, 0, 0, 0, 9689, 9690, 5, 155, 0, 0, 9690, 1019, 1, 0, 0, 0, 9691, 9694, 5, 46, 0, 0, 9692, 9693, 5, 82, 0, 0, 9693, 9695, 5, 309, 0, 0, 9694, 9692, 1, 0, 0, 0, 9694, 9695, 1, 0, 0, 0, 9695, 9697, 1, 0, 0, 0, 9696, 9698, 3, 198, 99, 0, 9697, 9696, 1, 0, 0, 0, 9697, 9698, 1, 0, 0, 0, 9698, 9716, 1, 0, 0, 0, 9699, 9700, 5, 374, 0, 0, 9700, 9702, 3, 1888, 944, 0, 9701, 9703, 3, 244, 122, 0, 9702, 9701, 1, 0, 0, 0, 9702, 9703, 1, 0, 0, 0, 9703, 9705, 1, 0, 0, 0, 9704, 9706, 3, 130, 65, 0, 9705, 9704, 1, 0, 0, 0, 9705, 9706, 1, 0, 0, 0, 9706, 9717, 1, 0, 0, 0, 9707, 9708, 5, 301, 0, 0, 9708, 9709, 5, 374, 0, 0, 9709, 9710, 3, 1888, 944, 0, 9710, 9711, 5, 2, 0, 0, 9711, 9712, 3, 246, 123, 0, 9712, 9714, 5, 3, 0, 0, 9713, 9715, 3, 130, 65, 0, 9714, 9713, 1, 0, 0, 0, 9714, 9715, 1, 0, 0, 0, 9715, 9717, 1, 0, 0, 0, 9716, 9699, 1, 0, 0, 0, 9716, 9707, 1, 0, 0, 0, 9717, 9718, 1, 0, 0, 0, 9718, 9719, 5, 36, 0, 0, 9719, 9721, 3, 1496, 748, 0, 9720, 9722, 3, 1024, 512, 0, 9721, 9720, 1, 0, 0, 0, 9721, 9722, 1, 0, 0, 0, 9722, 9724, 1, 0, 0, 0, 9723, 9725, 3, 1022, 511, 0, 9724, 9723, 1, 0, 0, 0, 9724, 9725, 1, 0, 0, 0, 9725, 1021, 1, 0, 0, 0, 9726, 9727, 5, 106, 0, 0, 9727, 9728, 5, 266, 0, 0, 9728, 9729, 5, 321, 0, 0, 9729, 9730, 5, 109, 0, 0, 9730, 1023, 1, 0, 0, 0, 9731, 9733, 5, 106, 0, 0, 9732, 9734, 7, 56, 0, 0, 9733, 9732, 1, 0, 0, 0, 9733, 9734, 1, 0, 0, 0, 9734, 9735, 1, 0, 0, 0, 9735, 9736, 5, 42, 0, 0, 9736, 9737, 5, 276, 0, 0, 9737, 1025, 1, 0, 0, 0, 9738, 9739, 5, 248, 0, 0, 9739, 9740, 3, 1896, 948, 0, 9740, 1027, 1, 0, 0, 0, 9741, 9742, 5, 140, 0, 0, 9742, 9743, 5, 392, 0, 0, 9743, 9744, 3, 1924, 962, 0, 9744, 9745, 3, 1030, 515, 0, 9745, 1029, 1, 0, 0, 0, 9746, 9747, 3, 1032, 516, 0, 9747, 9748, 3, 1034, 517, 0, 9748, 9766, 1, 0, 0, 0, 9749, 9750, 5, 331, 0, 0, 9750, 9752, 5, 394, 0, 0, 9751, 9753, 3, 1346, 673, 0, 9752, 9751, 1, 0, 0, 0, 9752, 9753, 1, 0, 0, 0, 9753, 9754, 1, 0, 0, 0, 9754, 9766, 3, 76, 38, 0, 9755, 9756, 5, 331, 0, 0, 9756, 9758, 5, 395, 0, 0, 9757, 9759, 3, 1346, 673, 0, 9758, 9757, 1, 0, 0, 0, 9758, 9759, 1, 0, 0, 0, 9759, 9760, 1, 0, 0, 0, 9760, 9761, 3, 76, 38, 0, 9761, 9762, 5, 62, 0, 0, 9762, 9763, 5, 321, 0, 0, 9763, 9764, 3, 1924, 962, 0, 9764, 9766, 1, 0, 0, 0, 9765, 9746, 1, 0, 0, 0, 9765, 9749, 1, 0, 0, 0, 9765, 9755, 1, 0, 0, 0, 9766, 1031, 1, 0, 0, 0, 9767, 9768, 7, 57, 0, 0, 9768, 1033, 1, 0, 0, 0, 9769, 9770, 5, 93, 0, 0, 9770, 9786, 3, 1036, 518, 0, 9771, 9772, 5, 321, 0, 0, 9772, 9786, 3, 1890, 945, 0, 9773, 9774, 5, 215, 0, 0, 9774, 9786, 3, 1044, 522, 0, 9775, 9776, 5, 30, 0, 0, 9776, 9777, 5, 348, 0, 0, 9777, 9778, 5, 68, 0, 0, 9778, 9779, 5, 321, 0, 0, 9779, 9786, 3, 1890, 945, 0, 9780, 9781, 5, 30, 0, 0, 9781, 9782, 5, 216, 0, 0, 9782, 9783, 5, 68, 0, 0, 9783, 9784, 5, 321, 0, 0, 9784, 9786, 3, 1890, 945, 0, 9785, 9769, 1, 0, 0, 0, 9785, 9771, 1, 0, 0, 0, 9785, 9773, 1, 0, 0, 0, 9785, 9775, 1, 0, 0, 0, 9785, 9780, 1, 0, 0, 0, 9786, 1035, 1, 0, 0, 0, 9787, 9792, 3, 1038, 519, 0, 9788, 9789, 5, 6, 0, 0, 9789, 9791, 3, 1038, 519, 0, 9790, 9788, 1, 0, 0, 0, 9791, 9794, 1, 0, 0, 0, 9792, 9790, 1, 0, 0, 0, 9792, 9793, 1, 0, 0, 0, 9793, 1037, 1, 0, 0, 0, 9794, 9792, 1, 0, 0, 0, 9795, 9798, 3, 1924, 962, 0, 9796, 9797, 5, 11, 0, 0, 9797, 9799, 3, 1924, 962, 0, 9798, 9796, 1, 0, 0, 0, 9798, 9799, 1, 0, 0, 0, 9799, 1039, 1, 0, 0, 0, 9800, 9803, 3, 1888, 944, 0, 9801, 9803, 3, 1042, 521, 0, 9802, 9800, 1, 0, 0, 0, 9802, 9801, 1, 0, 0, 0, 9803, 1041, 1, 0, 0, 0, 9804, 9805, 5, 852, 0, 0, 9805, 1043, 1, 0, 0, 0, 9806, 9811, 3, 1046, 523, 0, 9807, 9808, 5, 6, 0, 0, 9808, 9810, 3, 1046, 523, 0, 9809, 9807, 1, 0, 0, 0, 9810, 9813, 1, 0, 0, 0, 9811, 9809, 1, 0, 0, 0, 9811, 9812, 1, 0, 0, 0, 9812, 1045, 1, 0, 0, 0, 9813, 9811, 1, 0, 0, 0, 9814, 9815, 3, 1048, 524, 0, 9815, 9816, 3, 838, 419, 0, 9816, 1047, 1, 0, 0, 0, 9817, 9820, 3, 1924, 962, 0, 9818, 9819, 5, 11, 0, 0, 9819, 9821, 3, 1924, 962, 0, 9820, 9818, 1, 0, 0, 0, 9820, 9821, 1, 0, 0, 0, 9821, 1049, 1, 0, 0, 0, 9822, 9823, 5, 46, 0, 0, 9823, 9824, 5, 392, 0, 0, 9824, 9826, 3, 1888, 944, 0, 9825, 9827, 3, 1052, 526, 0, 9826, 9825, 1, 0, 0, 0, 9826, 9827, 1, 0, 0, 0, 9827, 1051, 1, 0, 0, 0, 9828, 9833, 3, 1054, 527, 0, 9829, 9830, 5, 6, 0, 0, 9830, 9832, 3, 1054, 527, 0, 9831, 9829, 1, 0, 0, 0, 9832, 9835, 1, 0, 0, 0, 9833, 9831, 1, 0, 0, 0, 9833, 9834, 1, 0, 0, 0, 9834, 1053, 1, 0, 0, 0, 9835, 9833, 1, 0, 0, 0, 9836, 9839, 3, 1056, 528, 0, 9837, 9839, 3, 1058, 529, 0, 9838, 9836, 1, 0, 0, 0, 9838, 9837, 1, 0, 0, 0, 9839, 1055, 1, 0, 0, 0, 9840, 9842, 5, 331, 0, 0, 9841, 9840, 1, 0, 0, 0, 9841, 9842, 1, 0, 0, 0, 9842, 9843, 1, 0, 0, 0, 9843, 9848, 5, 394, 0, 0, 9844, 9846, 5, 10, 0, 0, 9845, 9844, 1, 0, 0, 0, 9845, 9846, 1, 0, 0, 0, 9846, 9847, 1, 0, 0, 0, 9847, 9849, 7, 58, 0, 0, 9848, 9845, 1, 0, 0, 0, 9848, 9849, 1, 0, 0, 0, 9849, 1057, 1, 0, 0, 0, 9850, 9851, 5, 470, 0, 0, 9851, 9852, 5, 471, 0, 0, 9852, 1059, 1, 0, 0, 0, 9853, 9854, 7, 59, 0, 0, 9854, 9855, 5, 392, 0, 0, 9855, 9863, 3, 1924, 962, 0, 9856, 9859, 5, 272, 0, 0, 9857, 9858, 5, 466, 0, 0, 9858, 9860, 3, 1910, 955, 0, 9859, 9857, 1, 0, 0, 0, 9859, 9860, 1, 0, 0, 0, 9860, 9861, 1, 0, 0, 0, 9861, 9862, 5, 467, 0, 0, 9862, 9864, 3, 1910, 955, 0, 9863, 9856, 1, 0, 0, 0, 9863, 9864, 1, 0, 0, 0, 9864, 1061, 1, 0, 0, 0, 9865, 9866, 5, 195, 0, 0, 9866, 9868, 5, 392, 0, 0, 9867, 9869, 3, 922, 461, 0, 9868, 9867, 1, 0, 0, 0, 9868, 9869, 1, 0, 0, 0, 9869, 9870, 1, 0, 0, 0, 9870, 9871, 3, 1924, 962, 0, 9871, 1063, 1, 0, 0, 0, 9872, 9873, 5, 140, 0, 0, 9873, 9874, 5, 209, 0, 0, 9874, 9875, 5, 321, 0, 0, 9875, 9877, 3, 1924, 962, 0, 9876, 9878, 3, 1066, 533, 0, 9877, 9876, 1, 0, 0, 0, 9878, 9879, 1, 0, 0, 0, 9879, 9877, 1, 0, 0, 0, 9879, 9880, 1, 0, 0, 0, 9880, 1065, 1, 0, 0, 0, 9881, 9882, 5, 307, 0, 0, 9882, 9883, 5, 95, 0, 0, 9883, 9902, 3, 1924, 962, 0, 9884, 9885, 5, 279, 0, 0, 9885, 9886, 5, 95, 0, 0, 9886, 9902, 3, 1924, 962, 0, 9887, 9891, 5, 396, 0, 0, 9888, 9892, 5, 53, 0, 0, 9889, 9892, 5, 330, 0, 0, 9890, 9892, 3, 1910, 955, 0, 9891, 9888, 1, 0, 0, 0, 9891, 9889, 1, 0, 0, 0, 9891, 9890, 1, 0, 0, 0, 9892, 9902, 1, 0, 0, 0, 9893, 9894, 5, 408, 0, 0, 9894, 9902, 7, 60, 0, 0, 9895, 9896, 5, 409, 0, 0, 9896, 9902, 3, 1910, 955, 0, 9897, 9898, 5, 404, 0, 0, 9898, 9902, 3, 1910, 955, 0, 9899, 9900, 5, 401, 0, 0, 9900, 9902, 3, 1910, 955, 0, 9901, 9881, 1, 0, 0, 0, 9901, 9884, 1, 0, 0, 0, 9901, 9887, 1, 0, 0, 0, 9901, 9893, 1, 0, 0, 0, 9901, 9895, 1, 0, 0, 0, 9901, 9897, 1, 0, 0, 0, 9901, 9899, 1, 0, 0, 0, 9902, 1067, 1, 0, 0, 0, 9903, 9904, 5, 140, 0, 0, 9904, 9905, 5, 209, 0, 0, 9905, 9906, 5, 374, 0, 0, 9906, 9908, 3, 1888, 944, 0, 9907, 9909, 5, 213, 0, 0, 9908, 9907, 1, 0, 0, 0, 9908, 9909, 1, 0, 0, 0, 9909, 9914, 1, 0, 0, 0, 9910, 9911, 5, 36, 0, 0, 9911, 9915, 3, 1496, 748, 0, 9912, 9913, 5, 472, 0, 0, 9913, 9915, 5, 391, 0, 0, 9914, 9910, 1, 0, 0, 0, 9914, 9912, 1, 0, 0, 0, 9914, 9915, 1, 0, 0, 0, 9915, 1069, 1, 0, 0, 0, 9916, 9917, 5, 46, 0, 0, 9917, 9918, 5, 209, 0, 0, 9918, 9920, 5, 321, 0, 0, 9919, 9921, 3, 522, 261, 0, 9920, 9919, 1, 0, 0, 0, 9920, 9921, 1, 0, 0, 0, 9921, 9922, 1, 0, 0, 0, 9922, 9932, 3, 1924, 962, 0, 9923, 9933, 3, 1072, 536, 0, 9924, 9933, 3, 1078, 539, 0, 9925, 9933, 3, 1080, 540, 0, 9926, 9933, 3, 1082, 541, 0, 9927, 9933, 3, 1084, 542, 0, 9928, 9933, 3, 1086, 543, 0, 9929, 9933, 3, 1088, 544, 0, 9930, 9933, 3, 1090, 545, 0, 9931, 9933, 3, 1076, 538, 0, 9932, 9923, 1, 0, 0, 0, 9932, 9924, 1, 0, 0, 0, 9932, 9925, 1, 0, 0, 0, 9932, 9926, 1, 0, 0, 0, 9932, 9927, 1, 0, 0, 0, 9932, 9928, 1, 0, 0, 0, 9932, 9929, 1, 0, 0, 0, 9932, 9930, 1, 0, 0, 0, 9932, 9931, 1, 0, 0, 0, 9933, 1071, 1, 0, 0, 0, 9934, 9938, 5, 64, 0, 0, 9935, 9936, 5, 177, 0, 0, 9936, 9939, 5, 154, 0, 0, 9937, 9939, 5, 178, 0, 0, 9938, 9935, 1, 0, 0, 0, 9938, 9937, 1, 0, 0, 0, 9939, 9940, 1, 0, 0, 0, 9940, 9941, 5, 179, 0, 0, 9941, 9942, 3, 1910, 955, 0, 9942, 9943, 3, 1924, 962, 0, 9943, 9944, 3, 1910, 955, 0, 9944, 9945, 5, 396, 0, 0, 9945, 9948, 3, 1092, 546, 0, 9946, 9947, 5, 397, 0, 0, 9947, 9949, 3, 1094, 547, 0, 9948, 9946, 1, 0, 0, 0, 9948, 9949, 1, 0, 0, 0, 9949, 9954, 1, 0, 0, 0, 9950, 9951, 5, 46, 0, 0, 9951, 9952, 5, 209, 0, 0, 9952, 9953, 5, 179, 0, 0, 9953, 9955, 3, 522, 261, 0, 9954, 9950, 1, 0, 0, 0, 9954, 9955, 1, 0, 0, 0, 9955, 9958, 1, 0, 0, 0, 9956, 9957, 5, 398, 0, 0, 9957, 9959, 3, 1910, 955, 0, 9958, 9956, 1, 0, 0, 0, 9958, 9959, 1, 0, 0, 0, 9959, 1073, 1, 0, 0, 0, 9960, 9961, 5, 195, 0, 0, 9961, 9963, 5, 321, 0, 0, 9962, 9964, 3, 922, 461, 0, 9963, 9962, 1, 0, 0, 0, 9963, 9964, 1, 0, 0, 0, 9964, 9965, 1, 0, 0, 0, 9965, 9970, 3, 1888, 944, 0, 9966, 9967, 5, 6, 0, 0, 9967, 9969, 3, 1888, 944, 0, 9968, 9966, 1, 0, 0, 0, 9969, 9972, 1, 0, 0, 0, 9970, 9968, 1, 0, 0, 0, 9970, 9971, 1, 0, 0, 0, 9971, 9976, 1, 0, 0, 0, 9972, 9970, 1, 0, 0, 0, 9973, 9974, 5, 195, 0, 0, 9974, 9975, 5, 209, 0, 0, 9975, 9977, 5, 179, 0, 0, 9976, 9973, 1, 0, 0, 0, 9976, 9977, 1, 0, 0, 0, 9977, 9979, 1, 0, 0, 0, 9978, 9980, 7, 12, 0, 0, 9979, 9978, 1, 0, 0, 0, 9979, 9980, 1, 0, 0, 0, 9980, 1075, 1, 0, 0, 0, 9981, 9982, 5, 64, 0, 0, 9982, 9983, 5, 179, 0, 0, 9983, 9984, 3, 1910, 955, 0, 9984, 9985, 3, 1924, 962, 0, 9985, 9986, 3, 1910, 955, 0, 9986, 9987, 5, 396, 0, 0, 9987, 9990, 3, 1092, 546, 0, 9988, 9989, 5, 397, 0, 0, 9989, 9991, 3, 1094, 547, 0, 9990, 9988, 1, 0, 0, 0, 9990, 9991, 1, 0, 0, 0, 9991, 9996, 1, 0, 0, 0, 9992, 9993, 5, 46, 0, 0, 9993, 9994, 5, 209, 0, 0, 9994, 9995, 5, 179, 0, 0, 9995, 9997, 3, 522, 261, 0, 9996, 9992, 1, 0, 0, 0, 9996, 9997, 1, 0, 0, 0, 9997, 10000, 1, 0, 0, 0, 9998, 9999, 5, 398, 0, 0, 9999, 10001, 3, 1910, 955, 0, 10000, 9998, 1, 0, 0, 0, 10000, 10001, 1, 0, 0, 0, 10001, 1077, 1, 0, 0, 0, 10002, 10003, 5, 64, 0, 0, 10003, 10004, 5, 399, 0, 0, 10004, 10005, 5, 400, 0, 0, 10005, 10006, 5, 179, 0, 0, 10006, 10007, 3, 1910, 955, 0, 10007, 10008, 5, 401, 0, 0, 10008, 10011, 3, 1910, 955, 0, 10009, 10010, 5, 491, 0, 0, 10010, 10012, 3, 1908, 954, 0, 10011, 10009, 1, 0, 0, 0, 10011, 10012, 1, 0, 0, 0, 10012, 10013, 1, 0, 0, 0, 10013, 10014, 5, 396, 0, 0, 10014, 10015, 3, 1910, 955, 0, 10015, 1079, 1, 0, 0, 0, 10016, 10017, 5, 64, 0, 0, 10017, 10018, 5, 402, 0, 0, 10018, 10019, 5, 179, 0, 0, 10019, 10022, 3, 1910, 955, 0, 10020, 10021, 5, 321, 0, 0, 10021, 10023, 3, 1910, 955, 0, 10022, 10020, 1, 0, 0, 0, 10022, 10023, 1, 0, 0, 0, 10023, 10024, 1, 0, 0, 0, 10024, 10025, 5, 401, 0, 0, 10025, 10028, 3, 1910, 955, 0, 10026, 10027, 5, 491, 0, 0, 10027, 10029, 3, 1908, 954, 0, 10028, 10026, 1, 0, 0, 0, 10028, 10029, 1, 0, 0, 0, 10029, 10030, 1, 0, 0, 0, 10030, 10031, 5, 396, 0, 0, 10031, 10032, 3, 1092, 546, 0, 10032, 10033, 5, 404, 0, 0, 10033, 10034, 3, 1910, 955, 0, 10034, 1081, 1, 0, 0, 0, 10035, 10036, 5, 64, 0, 0, 10036, 10037, 5, 403, 0, 0, 10037, 10038, 5, 179, 0, 0, 10038, 10039, 3, 1910, 955, 0, 10039, 10040, 5, 401, 0, 0, 10040, 10043, 3, 1910, 955, 0, 10041, 10042, 5, 491, 0, 0, 10042, 10044, 3, 1908, 954, 0, 10043, 10041, 1, 0, 0, 0, 10043, 10044, 1, 0, 0, 0, 10044, 10045, 1, 0, 0, 0, 10045, 10046, 5, 396, 0, 0, 10046, 10047, 3, 1092, 546, 0, 10047, 10048, 5, 404, 0, 0, 10048, 10049, 3, 1910, 955, 0, 10049, 1083, 1, 0, 0, 0, 10050, 10051, 5, 64, 0, 0, 10051, 10052, 5, 405, 0, 0, 10052, 10053, 5, 396, 0, 0, 10053, 10054, 3, 1092, 546, 0, 10054, 1085, 1, 0, 0, 0, 10055, 10056, 5, 64, 0, 0, 10056, 10057, 5, 406, 0, 0, 10057, 10058, 5, 396, 0, 0, 10058, 10061, 3, 1092, 546, 0, 10059, 10060, 5, 401, 0, 0, 10060, 10062, 3, 1910, 955, 0, 10061, 10059, 1, 0, 0, 0, 10061, 10062, 1, 0, 0, 0, 10062, 10065, 1, 0, 0, 0, 10063, 10064, 5, 408, 0, 0, 10064, 10066, 3, 1096, 548, 0, 10065, 10063, 1, 0, 0, 0, 10065, 10066, 1, 0, 0, 0, 10066, 10069, 1, 0, 0, 0, 10067, 10068, 5, 409, 0, 0, 10068, 10070, 3, 1910, 955, 0, 10069, 10067, 1, 0, 0, 0, 10069, 10070, 1, 0, 0, 0, 10070, 1087, 1, 0, 0, 0, 10071, 10072, 5, 64, 0, 0, 10072, 10073, 5, 407, 0, 0, 10073, 10074, 5, 396, 0, 0, 10074, 10077, 3, 1092, 546, 0, 10075, 10076, 5, 401, 0, 0, 10076, 10078, 3, 1910, 955, 0, 10077, 10075, 1, 0, 0, 0, 10077, 10078, 1, 0, 0, 0, 10078, 10081, 1, 0, 0, 0, 10079, 10080, 5, 408, 0, 0, 10080, 10082, 3, 1096, 548, 0, 10081, 10079, 1, 0, 0, 0, 10081, 10082, 1, 0, 0, 0, 10082, 10085, 1, 0, 0, 0, 10083, 10084, 5, 409, 0, 0, 10084, 10086, 3, 1910, 955, 0, 10085, 10083, 1, 0, 0, 0, 10085, 10086, 1, 0, 0, 0, 10086, 1089, 1, 0, 0, 0, 10087, 10088, 5, 64, 0, 0, 10088, 10089, 5, 492, 0, 0, 10089, 10090, 5, 179, 0, 0, 10090, 10093, 3, 1910, 955, 0, 10091, 10092, 5, 321, 0, 0, 10092, 10094, 3, 1910, 955, 0, 10093, 10091, 1, 0, 0, 0, 10093, 10094, 1, 0, 0, 0, 10094, 10098, 1, 0, 0, 0, 10095, 10096, 3, 1924, 962, 0, 10096, 10097, 3, 1910, 955, 0, 10097, 10099, 1, 0, 0, 0, 10098, 10095, 1, 0, 0, 0, 10098, 10099, 1, 0, 0, 0, 10099, 10102, 1, 0, 0, 0, 10100, 10101, 5, 396, 0, 0, 10101, 10103, 3, 1092, 546, 0, 10102, 10100, 1, 0, 0, 0, 10102, 10103, 1, 0, 0, 0, 10103, 1091, 1, 0, 0, 0, 10104, 10108, 5, 53, 0, 0, 10105, 10108, 5, 410, 0, 0, 10106, 10108, 3, 1910, 955, 0, 10107, 10104, 1, 0, 0, 0, 10107, 10105, 1, 0, 0, 0, 10107, 10106, 1, 0, 0, 0, 10108, 1093, 1, 0, 0, 0, 10109, 10112, 5, 410, 0, 0, 10110, 10112, 3, 1910, 955, 0, 10111, 10109, 1, 0, 0, 0, 10111, 10110, 1, 0, 0, 0, 10112, 1095, 1, 0, 0, 0, 10113, 10114, 7, 60, 0, 0, 10114, 1097, 1, 0, 0, 0, 10115, 10118, 5, 46, 0, 0, 10116, 10117, 5, 82, 0, 0, 10117, 10119, 5, 309, 0, 0, 10118, 10116, 1, 0, 0, 0, 10118, 10119, 1, 0, 0, 0, 10119, 10120, 1, 0, 0, 0, 10120, 10121, 5, 209, 0, 0, 10121, 10122, 5, 215, 0, 0, 10122, 10123, 3, 1888, 944, 0, 10123, 10125, 5, 2, 0, 0, 10124, 10126, 3, 1100, 550, 0, 10125, 10124, 1, 0, 0, 0, 10125, 10126, 1, 0, 0, 0, 10126, 10127, 1, 0, 0, 0, 10127, 10128, 5, 3, 0, 0, 10128, 10129, 5, 314, 0, 0, 10129, 10130, 3, 1662, 831, 0, 10130, 10131, 7, 47, 0, 0, 10131, 10132, 5, 519, 0, 0, 10132, 10133, 3, 1910, 955, 0, 10133, 10134, 5, 396, 0, 0, 10134, 10137, 3, 1092, 546, 0, 10135, 10136, 5, 635, 0, 0, 10136, 10138, 3, 1908, 954, 0, 10137, 10135, 1, 0, 0, 0, 10137, 10138, 1, 0, 0, 0, 10138, 10141, 1, 0, 0, 0, 10139, 10140, 5, 443, 0, 0, 10140, 10142, 3, 1908, 954, 0, 10141, 10139, 1, 0, 0, 0, 10141, 10142, 1, 0, 0, 0, 10142, 10148, 1, 0, 0, 0, 10143, 10144, 5, 636, 0, 0, 10144, 10146, 3, 1908, 954, 0, 10145, 10147, 7, 61, 0, 0, 10146, 10145, 1, 0, 0, 0, 10146, 10147, 1, 0, 0, 0, 10147, 10149, 1, 0, 0, 0, 10148, 10143, 1, 0, 0, 0, 10148, 10149, 1, 0, 0, 0, 10149, 1099, 1, 0, 0, 0, 10150, 10155, 3, 1662, 831, 0, 10151, 10152, 5, 6, 0, 0, 10152, 10154, 3, 1662, 831, 0, 10153, 10151, 1, 0, 0, 0, 10154, 10157, 1, 0, 0, 0, 10155, 10153, 1, 0, 0, 0, 10155, 10156, 1, 0, 0, 0, 10156, 1101, 1, 0, 0, 0, 10157, 10155, 1, 0, 0, 0, 10158, 10163, 3, 1104, 552, 0, 10159, 10160, 5, 6, 0, 0, 10160, 10162, 3, 1104, 552, 0, 10161, 10159, 1, 0, 0, 0, 10162, 10165, 1, 0, 0, 0, 10163, 10161, 1, 0, 0, 0, 10163, 10164, 1, 0, 0, 0, 10164, 10168, 1, 0, 0, 0, 10165, 10163, 1, 0, 0, 0, 10166, 10168, 1, 0, 0, 0, 10167, 10158, 1, 0, 0, 0, 10167, 10166, 1, 0, 0, 0, 10168, 1103, 1, 0, 0, 0, 10169, 10170, 3, 1924, 962, 0, 10170, 10171, 3, 1662, 831, 0, 10171, 1105, 1, 0, 0, 0, 10172, 10173, 5, 46, 0, 0, 10173, 10174, 5, 209, 0, 0, 10174, 10175, 5, 417, 0, 0, 10175, 10176, 3, 1888, 944, 0, 10176, 10177, 5, 64, 0, 0, 10177, 10180, 3, 1910, 955, 0, 10178, 10179, 5, 547, 0, 0, 10179, 10181, 3, 1888, 944, 0, 10180, 10178, 1, 0, 0, 0, 10180, 10181, 1, 0, 0, 0, 10181, 10182, 1, 0, 0, 0, 10182, 10183, 5, 396, 0, 0, 10183, 10189, 3, 1092, 546, 0, 10184, 10185, 5, 546, 0, 0, 10185, 10186, 5, 2, 0, 0, 10186, 10187, 3, 1204, 602, 0, 10187, 10188, 5, 3, 0, 0, 10188, 10190, 1, 0, 0, 0, 10189, 10184, 1, 0, 0, 0, 10189, 10190, 1, 0, 0, 0, 10190, 10207, 1, 0, 0, 0, 10191, 10192, 5, 46, 0, 0, 10192, 10193, 5, 209, 0, 0, 10193, 10194, 5, 417, 0, 0, 10194, 10195, 3, 1888, 944, 0, 10195, 10196, 5, 215, 0, 0, 10196, 10197, 3, 1888, 944, 0, 10197, 10198, 5, 396, 0, 0, 10198, 10199, 3, 1092, 546, 0, 10199, 10200, 5, 421, 0, 0, 10200, 10201, 5, 474, 0, 0, 10201, 10202, 5, 546, 0, 0, 10202, 10203, 5, 2, 0, 0, 10203, 10204, 3, 1204, 602, 0, 10204, 10205, 5, 3, 0, 0, 10205, 10207, 1, 0, 0, 0, 10206, 10172, 1, 0, 0, 0, 10206, 10191, 1, 0, 0, 0, 10207, 1107, 1, 0, 0, 0, 10208, 10209, 5, 46, 0, 0, 10209, 10210, 5, 209, 0, 0, 10210, 10212, 5, 93, 0, 0, 10211, 10213, 3, 522, 261, 0, 10212, 10211, 1, 0, 0, 0, 10212, 10213, 1, 0, 0, 0, 10213, 10214, 1, 0, 0, 0, 10214, 10215, 3, 1888, 944, 0, 10215, 10216, 5, 2, 0, 0, 10216, 10217, 3, 1110, 555, 0, 10217, 10224, 5, 3, 0, 0, 10218, 10219, 5, 623, 0, 0, 10219, 10220, 5, 149, 0, 0, 10220, 10221, 5, 2, 0, 0, 10221, 10222, 3, 1110, 555, 0, 10222, 10223, 5, 3, 0, 0, 10223, 10225, 1, 0, 0, 0, 10224, 10218, 1, 0, 0, 0, 10224, 10225, 1, 0, 0, 0, 10225, 10226, 1, 0, 0, 0, 10226, 10227, 3, 1116, 558, 0, 10227, 10228, 5, 250, 0, 0, 10228, 10235, 3, 1910, 955, 0, 10229, 10230, 5, 93, 0, 0, 10230, 10231, 5, 512, 0, 0, 10231, 10232, 5, 2, 0, 0, 10232, 10233, 3, 1126, 563, 0, 10233, 10234, 5, 3, 0, 0, 10234, 10236, 1, 0, 0, 0, 10235, 10229, 1, 0, 0, 0, 10235, 10236, 1, 0, 0, 0, 10236, 1109, 1, 0, 0, 0, 10237, 10242, 3, 1112, 556, 0, 10238, 10239, 5, 6, 0, 0, 10239, 10241, 3, 1112, 556, 0, 10240, 10238, 1, 0, 0, 0, 10241, 10244, 1, 0, 0, 0, 10242, 10240, 1, 0, 0, 0, 10242, 10243, 1, 0, 0, 0, 10243, 1111, 1, 0, 0, 0, 10244, 10242, 1, 0, 0, 0, 10245, 10246, 3, 1924, 962, 0, 10246, 10247, 3, 1114, 557, 0, 10247, 1113, 1, 0, 0, 0, 10248, 10251, 3, 1662, 831, 0, 10249, 10251, 5, 626, 0, 0, 10250, 10248, 1, 0, 0, 0, 10250, 10249, 1, 0, 0, 0, 10251, 1115, 1, 0, 0, 0, 10252, 10253, 5, 610, 0, 0, 10253, 10254, 5, 36, 0, 0, 10254, 10268, 3, 1124, 562, 0, 10255, 10256, 3, 1118, 559, 0, 10256, 10257, 5, 610, 0, 0, 10257, 10258, 5, 36, 0, 0, 10258, 10259, 3, 1124, 562, 0, 10259, 10268, 1, 0, 0, 0, 10260, 10261, 5, 610, 0, 0, 10261, 10262, 5, 36, 0, 0, 10262, 10263, 5, 613, 0, 0, 10263, 10264, 3, 1910, 955, 0, 10264, 10265, 5, 614, 0, 0, 10265, 10266, 3, 1910, 955, 0, 10266, 10268, 1, 0, 0, 0, 10267, 10252, 1, 0, 0, 0, 10267, 10255, 1, 0, 0, 0, 10267, 10260, 1, 0, 0, 0, 10268, 1117, 1, 0, 0, 0, 10269, 10270, 5, 577, 0, 0, 10270, 10271, 5, 780, 0, 0, 10271, 10281, 5, 627, 0, 0, 10272, 10273, 5, 615, 0, 0, 10273, 10274, 5, 618, 0, 0, 10274, 10275, 5, 149, 0, 0, 10275, 10279, 3, 1910, 955, 0, 10276, 10277, 5, 619, 0, 0, 10277, 10278, 5, 149, 0, 0, 10278, 10280, 3, 1910, 955, 0, 10279, 10276, 1, 0, 0, 0, 10279, 10280, 1, 0, 0, 0, 10280, 10282, 1, 0, 0, 0, 10281, 10272, 1, 0, 0, 0, 10281, 10282, 1, 0, 0, 0, 10282, 10288, 1, 0, 0, 0, 10283, 10284, 5, 616, 0, 0, 10284, 10285, 5, 617, 0, 0, 10285, 10286, 5, 618, 0, 0, 10286, 10287, 5, 149, 0, 0, 10287, 10289, 3, 1910, 955, 0, 10288, 10283, 1, 0, 0, 0, 10288, 10289, 1, 0, 0, 0, 10289, 10295, 1, 0, 0, 0, 10290, 10291, 5, 625, 0, 0, 10291, 10292, 5, 622, 0, 0, 10292, 10293, 5, 618, 0, 0, 10293, 10294, 5, 149, 0, 0, 10294, 10296, 3, 1910, 955, 0, 10295, 10290, 1, 0, 0, 0, 10295, 10296, 1, 0, 0, 0, 10296, 10301, 1, 0, 0, 0, 10297, 10298, 5, 621, 0, 0, 10298, 10299, 5, 618, 0, 0, 10299, 10300, 5, 149, 0, 0, 10300, 10302, 3, 1910, 955, 0, 10301, 10297, 1, 0, 0, 0, 10301, 10302, 1, 0, 0, 0, 10302, 10307, 1, 0, 0, 0, 10303, 10304, 5, 78, 0, 0, 10304, 10305, 5, 620, 0, 0, 10305, 10306, 5, 36, 0, 0, 10306, 10308, 3, 1910, 955, 0, 10307, 10303, 1, 0, 0, 0, 10307, 10308, 1, 0, 0, 0, 10308, 10322, 1, 0, 0, 0, 10309, 10310, 5, 577, 0, 0, 10310, 10311, 5, 780, 0, 0, 10311, 10312, 5, 611, 0, 0, 10312, 10319, 3, 1910, 955, 0, 10313, 10314, 5, 106, 0, 0, 10314, 10315, 5, 612, 0, 0, 10315, 10316, 5, 2, 0, 0, 10316, 10317, 3, 1120, 560, 0, 10317, 10318, 5, 3, 0, 0, 10318, 10320, 1, 0, 0, 0, 10319, 10313, 1, 0, 0, 0, 10319, 10320, 1, 0, 0, 0, 10320, 10322, 1, 0, 0, 0, 10321, 10269, 1, 0, 0, 0, 10321, 10309, 1, 0, 0, 0, 10322, 1119, 1, 0, 0, 0, 10323, 10328, 3, 1122, 561, 0, 10324, 10325, 5, 6, 0, 0, 10325, 10327, 3, 1122, 561, 0, 10326, 10324, 1, 0, 0, 0, 10327, 10330, 1, 0, 0, 0, 10328, 10326, 1, 0, 0, 0, 10328, 10329, 1, 0, 0, 0, 10329, 1121, 1, 0, 0, 0, 10330, 10328, 1, 0, 0, 0, 10331, 10332, 3, 1910, 955, 0, 10332, 10333, 5, 10, 0, 0, 10333, 10334, 3, 1910, 955, 0, 10334, 1123, 1, 0, 0, 0, 10335, 10336, 7, 62, 0, 0, 10336, 1125, 1, 0, 0, 0, 10337, 10342, 3, 1128, 564, 0, 10338, 10339, 5, 6, 0, 0, 10339, 10341, 3, 1128, 564, 0, 10340, 10338, 1, 0, 0, 0, 10341, 10344, 1, 0, 0, 0, 10342, 10340, 1, 0, 0, 0, 10342, 10343, 1, 0, 0, 0, 10343, 1127, 1, 0, 0, 0, 10344, 10342, 1, 0, 0, 0, 10345, 10346, 3, 1910, 955, 0, 10346, 10347, 5, 10, 0, 0, 10347, 10348, 3, 1910, 955, 0, 10348, 1129, 1, 0, 0, 0, 10349, 10352, 5, 46, 0, 0, 10350, 10351, 5, 82, 0, 0, 10351, 10353, 5, 309, 0, 0, 10352, 10350, 1, 0, 0, 0, 10352, 10353, 1, 0, 0, 0, 10353, 10354, 1, 0, 0, 0, 10354, 10356, 5, 209, 0, 0, 10355, 10357, 5, 416, 0, 0, 10356, 10355, 1, 0, 0, 0, 10356, 10357, 1, 0, 0, 0, 10357, 10358, 1, 0, 0, 0, 10358, 10359, 5, 374, 0, 0, 10359, 10363, 3, 1888, 944, 0, 10360, 10361, 5, 224, 0, 0, 10361, 10362, 5, 77, 0, 0, 10362, 10364, 5, 558, 0, 0, 10363, 10360, 1, 0, 0, 0, 10363, 10364, 1, 0, 0, 0, 10364, 10369, 1, 0, 0, 0, 10365, 10366, 5, 2, 0, 0, 10366, 10367, 3, 1890, 945, 0, 10367, 10368, 5, 3, 0, 0, 10368, 10370, 1, 0, 0, 0, 10369, 10365, 1, 0, 0, 0, 10369, 10370, 1, 0, 0, 0, 10370, 10371, 1, 0, 0, 0, 10371, 10372, 5, 36, 0, 0, 10372, 10373, 3, 1496, 748, 0, 10373, 1131, 1, 0, 0, 0, 10374, 10375, 5, 195, 0, 0, 10375, 10376, 5, 209, 0, 0, 10376, 10378, 5, 374, 0, 0, 10377, 10379, 3, 922, 461, 0, 10378, 10377, 1, 0, 0, 0, 10378, 10379, 1, 0, 0, 0, 10379, 10380, 1, 0, 0, 0, 10380, 10382, 3, 1888, 944, 0, 10381, 10383, 3, 120, 60, 0, 10382, 10381, 1, 0, 0, 0, 10382, 10383, 1, 0, 0, 0, 10383, 1133, 1, 0, 0, 0, 10384, 10385, 5, 140, 0, 0, 10385, 10386, 5, 223, 0, 0, 10386, 10387, 5, 415, 0, 0, 10387, 10389, 3, 1924, 962, 0, 10388, 10390, 3, 1136, 568, 0, 10389, 10388, 1, 0, 0, 0, 10390, 10391, 1, 0, 0, 0, 10391, 10389, 1, 0, 0, 0, 10391, 10392, 1, 0, 0, 0, 10392, 1135, 1, 0, 0, 0, 10393, 10394, 5, 503, 0, 0, 10394, 10413, 3, 1910, 955, 0, 10395, 10396, 5, 467, 0, 0, 10396, 10413, 3, 1910, 955, 0, 10397, 10398, 5, 396, 0, 0, 10398, 10413, 3, 1910, 955, 0, 10399, 10408, 5, 505, 0, 0, 10400, 10405, 5, 97, 0, 0, 10401, 10402, 7, 63, 0, 0, 10402, 10403, 5, 680, 0, 0, 10403, 10404, 5, 122, 0, 0, 10404, 10406, 3, 1910, 955, 0, 10405, 10401, 1, 0, 0, 0, 10405, 10406, 1, 0, 0, 0, 10406, 10409, 1, 0, 0, 0, 10407, 10409, 5, 60, 0, 0, 10408, 10400, 1, 0, 0, 0, 10408, 10407, 1, 0, 0, 0, 10408, 10409, 1, 0, 0, 0, 10409, 10413, 1, 0, 0, 0, 10410, 10413, 5, 190, 0, 0, 10411, 10413, 5, 197, 0, 0, 10412, 10393, 1, 0, 0, 0, 10412, 10395, 1, 0, 0, 0, 10412, 10397, 1, 0, 0, 0, 10412, 10399, 1, 0, 0, 0, 10412, 10410, 1, 0, 0, 0, 10412, 10411, 1, 0, 0, 0, 10413, 1137, 1, 0, 0, 0, 10414, 10415, 5, 140, 0, 0, 10415, 10416, 5, 412, 0, 0, 10416, 10417, 5, 643, 0, 0, 10417, 10418, 3, 1924, 962, 0, 10418, 10419, 3, 1142, 571, 0, 10419, 1139, 1, 0, 0, 0, 10420, 10421, 5, 140, 0, 0, 10421, 10422, 5, 255, 0, 0, 10422, 10423, 5, 374, 0, 0, 10423, 10472, 3, 1888, 944, 0, 10424, 10425, 5, 420, 0, 0, 10425, 10426, 5, 303, 0, 0, 10426, 10473, 7, 27, 0, 0, 10427, 10428, 5, 140, 0, 0, 10428, 10429, 5, 836, 0, 0, 10429, 10473, 3, 1924, 962, 0, 10430, 10431, 5, 140, 0, 0, 10431, 10438, 5, 838, 0, 0, 10432, 10439, 5, 30, 0, 0, 10433, 10439, 5, 842, 0, 0, 10434, 10435, 5, 240, 0, 0, 10435, 10436, 5, 836, 0, 0, 10436, 10439, 3, 1924, 962, 0, 10437, 10439, 5, 420, 0, 0, 10438, 10432, 1, 0, 0, 0, 10438, 10433, 1, 0, 0, 0, 10438, 10434, 1, 0, 0, 0, 10438, 10437, 1, 0, 0, 0, 10439, 10473, 1, 0, 0, 0, 10440, 10442, 5, 140, 0, 0, 10441, 10443, 5, 840, 0, 0, 10442, 10441, 1, 0, 0, 0, 10442, 10443, 1, 0, 0, 0, 10443, 10444, 1, 0, 0, 0, 10444, 10445, 5, 837, 0, 0, 10445, 10446, 5, 2, 0, 0, 10446, 10451, 3, 1924, 962, 0, 10447, 10448, 5, 6, 0, 0, 10448, 10450, 3, 1924, 962, 0, 10449, 10447, 1, 0, 0, 0, 10450, 10453, 1, 0, 0, 0, 10451, 10449, 1, 0, 0, 0, 10451, 10452, 1, 0, 0, 0, 10452, 10454, 1, 0, 0, 0, 10453, 10451, 1, 0, 0, 0, 10454, 10455, 5, 3, 0, 0, 10455, 10473, 1, 0, 0, 0, 10456, 10457, 5, 140, 0, 0, 10457, 10458, 5, 837, 0, 0, 10458, 10473, 7, 64, 0, 0, 10459, 10460, 5, 577, 0, 0, 10460, 10461, 5, 246, 0, 0, 10461, 10462, 5, 325, 0, 0, 10462, 10466, 7, 14, 0, 0, 10463, 10464, 5, 390, 0, 0, 10464, 10465, 5, 358, 0, 0, 10465, 10467, 7, 15, 0, 0, 10466, 10463, 1, 0, 0, 0, 10466, 10467, 1, 0, 0, 0, 10467, 10470, 1, 0, 0, 0, 10468, 10469, 5, 62, 0, 0, 10469, 10471, 5, 455, 0, 0, 10470, 10468, 1, 0, 0, 0, 10470, 10471, 1, 0, 0, 0, 10471, 10473, 1, 0, 0, 0, 10472, 10424, 1, 0, 0, 0, 10472, 10427, 1, 0, 0, 0, 10472, 10430, 1, 0, 0, 0, 10472, 10440, 1, 0, 0, 0, 10472, 10456, 1, 0, 0, 0, 10472, 10459, 1, 0, 0, 0, 10473, 1141, 1, 0, 0, 0, 10474, 10475, 5, 307, 0, 0, 10475, 10476, 5, 95, 0, 0, 10476, 10491, 3, 1924, 962, 0, 10477, 10478, 5, 279, 0, 0, 10478, 10479, 5, 95, 0, 0, 10479, 10491, 3, 1924, 962, 0, 10480, 10481, 5, 331, 0, 0, 10481, 10482, 5, 2, 0, 0, 10482, 10483, 3, 1144, 572, 0, 10483, 10484, 5, 3, 0, 0, 10484, 10491, 1, 0, 0, 0, 10485, 10486, 5, 101, 0, 0, 10486, 10487, 5, 2, 0, 0, 10487, 10488, 3, 1180, 590, 0, 10488, 10489, 5, 3, 0, 0, 10489, 10491, 1, 0, 0, 0, 10490, 10474, 1, 0, 0, 0, 10490, 10477, 1, 0, 0, 0, 10490, 10480, 1, 0, 0, 0, 10490, 10485, 1, 0, 0, 0, 10491, 1143, 1, 0, 0, 0, 10492, 10497, 3, 1146, 573, 0, 10493, 10494, 5, 6, 0, 0, 10494, 10496, 3, 1146, 573, 0, 10495, 10493, 1, 0, 0, 0, 10496, 10499, 1, 0, 0, 0, 10497, 10495, 1, 0, 0, 0, 10497, 10498, 1, 0, 0, 0, 10498, 1145, 1, 0, 0, 0, 10499, 10497, 1, 0, 0, 0, 10500, 10501, 3, 1924, 962, 0, 10501, 10502, 3, 1662, 831, 0, 10502, 1147, 1, 0, 0, 0, 10503, 10504, 5, 140, 0, 0, 10504, 10505, 5, 413, 0, 0, 10505, 10506, 5, 643, 0, 0, 10506, 10507, 3, 1924, 962, 0, 10507, 10508, 5, 101, 0, 0, 10508, 10509, 5, 2, 0, 0, 10509, 10510, 3, 1710, 855, 0, 10510, 10511, 5, 3, 0, 0, 10511, 1149, 1, 0, 0, 0, 10512, 10513, 5, 605, 0, 0, 10513, 10514, 5, 412, 0, 0, 10514, 10515, 5, 643, 0, 0, 10515, 10516, 3, 1924, 962, 0, 10516, 10517, 5, 80, 0, 0, 10517, 10518, 3, 1888, 944, 0, 10518, 10519, 5, 2, 0, 0, 10519, 10520, 3, 1152, 576, 0, 10520, 10526, 5, 3, 0, 0, 10521, 10522, 5, 101, 0, 0, 10522, 10523, 5, 2, 0, 0, 10523, 10524, 3, 1152, 576, 0, 10524, 10525, 5, 3, 0, 0, 10525, 10527, 1, 0, 0, 0, 10526, 10521, 1, 0, 0, 0, 10526, 10527, 1, 0, 0, 0, 10527, 10528, 1, 0, 0, 0, 10528, 10529, 5, 95, 0, 0, 10529, 10532, 3, 1156, 578, 0, 10530, 10531, 5, 644, 0, 0, 10531, 10533, 3, 1908, 954, 0, 10532, 10530, 1, 0, 0, 0, 10532, 10533, 1, 0, 0, 0, 10533, 1151, 1, 0, 0, 0, 10534, 10539, 3, 1154, 577, 0, 10535, 10536, 5, 6, 0, 0, 10536, 10538, 3, 1154, 577, 0, 10537, 10535, 1, 0, 0, 0, 10538, 10541, 1, 0, 0, 0, 10539, 10537, 1, 0, 0, 0, 10539, 10540, 1, 0, 0, 0, 10540, 1153, 1, 0, 0, 0, 10541, 10539, 1, 0, 0, 0, 10542, 10543, 3, 1888, 944, 0, 10543, 1155, 1, 0, 0, 0, 10544, 10549, 3, 1158, 579, 0, 10545, 10546, 5, 6, 0, 0, 10546, 10548, 3, 1158, 579, 0, 10547, 10545, 1, 0, 0, 0, 10548, 10551, 1, 0, 0, 0, 10549, 10547, 1, 0, 0, 0, 10549, 10550, 1, 0, 0, 0, 10550, 1157, 1, 0, 0, 0, 10551, 10549, 1, 0, 0, 0, 10552, 10553, 5, 316, 0, 0, 10553, 10556, 3, 1888, 944, 0, 10554, 10556, 3, 1924, 962, 0, 10555, 10552, 1, 0, 0, 0, 10555, 10554, 1, 0, 0, 0, 10556, 1159, 1, 0, 0, 0, 10557, 10558, 5, 605, 0, 0, 10558, 10559, 5, 413, 0, 0, 10559, 10560, 5, 643, 0, 0, 10560, 10561, 3, 1924, 962, 0, 10561, 10563, 5, 80, 0, 0, 10562, 10564, 5, 93, 0, 0, 10563, 10562, 1, 0, 0, 0, 10563, 10564, 1, 0, 0, 0, 10564, 10565, 1, 0, 0, 0, 10565, 10566, 3, 1162, 581, 0, 10566, 10567, 5, 95, 0, 0, 10567, 10568, 3, 1156, 578, 0, 10568, 1161, 1, 0, 0, 0, 10569, 10574, 3, 1888, 944, 0, 10570, 10571, 5, 6, 0, 0, 10571, 10573, 3, 1888, 944, 0, 10572, 10570, 1, 0, 0, 0, 10573, 10576, 1, 0, 0, 0, 10574, 10572, 1, 0, 0, 0, 10574, 10575, 1, 0, 0, 0, 10575, 1163, 1, 0, 0, 0, 10576, 10574, 1, 0, 0, 0, 10577, 10578, 5, 46, 0, 0, 10578, 10579, 5, 223, 0, 0, 10579, 10580, 5, 415, 0, 0, 10580, 10581, 3, 1924, 962, 0, 10581, 10584, 5, 358, 0, 0, 10582, 10585, 3, 1910, 955, 0, 10583, 10585, 3, 1924, 962, 0, 10584, 10582, 1, 0, 0, 0, 10584, 10583, 1, 0, 0, 0, 10585, 10589, 1, 0, 0, 0, 10586, 10588, 3, 1166, 583, 0, 10587, 10586, 1, 0, 0, 0, 10588, 10591, 1, 0, 0, 0, 10589, 10587, 1, 0, 0, 0, 10589, 10590, 1, 0, 0, 0, 10590, 1165, 1, 0, 0, 0, 10591, 10589, 1, 0, 0, 0, 10592, 10593, 5, 507, 0, 0, 10593, 10619, 3, 1910, 955, 0, 10594, 10595, 5, 508, 0, 0, 10595, 10619, 3, 1908, 954, 0, 10596, 10597, 5, 509, 0, 0, 10597, 10619, 3, 1910, 955, 0, 10598, 10599, 5, 510, 0, 0, 10599, 10619, 3, 1910, 955, 0, 10600, 10601, 5, 511, 0, 0, 10601, 10619, 3, 1910, 955, 0, 10602, 10603, 5, 467, 0, 0, 10603, 10619, 3, 1910, 955, 0, 10604, 10605, 5, 503, 0, 0, 10605, 10619, 3, 1910, 955, 0, 10606, 10607, 5, 504, 0, 0, 10607, 10619, 3, 1910, 955, 0, 10608, 10611, 5, 396, 0, 0, 10609, 10612, 5, 53, 0, 0, 10610, 10612, 3, 1910, 955, 0, 10611, 10609, 1, 0, 0, 0, 10611, 10610, 1, 0, 0, 0, 10612, 10619, 1, 0, 0, 0, 10613, 10614, 5, 505, 0, 0, 10614, 10616, 7, 58, 0, 0, 10615, 10617, 3, 1168, 584, 0, 10616, 10615, 1, 0, 0, 0, 10616, 10617, 1, 0, 0, 0, 10617, 10619, 1, 0, 0, 0, 10618, 10592, 1, 0, 0, 0, 10618, 10594, 1, 0, 0, 0, 10618, 10596, 1, 0, 0, 0, 10618, 10598, 1, 0, 0, 0, 10618, 10600, 1, 0, 0, 0, 10618, 10602, 1, 0, 0, 0, 10618, 10604, 1, 0, 0, 0, 10618, 10606, 1, 0, 0, 0, 10618, 10608, 1, 0, 0, 0, 10618, 10613, 1, 0, 0, 0, 10619, 1167, 1, 0, 0, 0, 10620, 10621, 5, 639, 0, 0, 10621, 10622, 5, 680, 0, 0, 10622, 10623, 5, 122, 0, 0, 10623, 10629, 3, 1910, 955, 0, 10624, 10625, 5, 203, 0, 0, 10625, 10626, 5, 680, 0, 0, 10626, 10627, 5, 122, 0, 0, 10627, 10629, 3, 1910, 955, 0, 10628, 10620, 1, 0, 0, 0, 10628, 10624, 1, 0, 0, 0, 10629, 1169, 1, 0, 0, 0, 10630, 10633, 5, 46, 0, 0, 10631, 10632, 5, 82, 0, 0, 10632, 10634, 5, 309, 0, 0, 10633, 10631, 1, 0, 0, 0, 10633, 10634, 1, 0, 0, 0, 10634, 10635, 1, 0, 0, 0, 10635, 10636, 5, 462, 0, 0, 10636, 10637, 3, 1924, 962, 0, 10637, 10638, 5, 242, 0, 0, 10638, 10639, 5, 485, 0, 0, 10639, 10640, 5, 64, 0, 0, 10640, 10644, 3, 1910, 955, 0, 10641, 10643, 3, 1172, 586, 0, 10642, 10641, 1, 0, 0, 0, 10643, 10646, 1, 0, 0, 0, 10644, 10642, 1, 0, 0, 0, 10644, 10645, 1, 0, 0, 0, 10645, 1171, 1, 0, 0, 0, 10646, 10644, 1, 0, 0, 0, 10647, 10648, 5, 501, 0, 0, 10648, 10661, 3, 1910, 955, 0, 10649, 10651, 3, 1924, 962, 0, 10650, 10652, 5, 36, 0, 0, 10651, 10650, 1, 0, 0, 0, 10651, 10652, 1, 0, 0, 0, 10652, 10653, 1, 0, 0, 0, 10653, 10654, 3, 1910, 955, 0, 10654, 10661, 1, 0, 0, 0, 10655, 10658, 5, 396, 0, 0, 10656, 10659, 5, 53, 0, 0, 10657, 10659, 3, 1910, 955, 0, 10658, 10656, 1, 0, 0, 0, 10658, 10657, 1, 0, 0, 0, 10659, 10661, 1, 0, 0, 0, 10660, 10647, 1, 0, 0, 0, 10660, 10649, 1, 0, 0, 0, 10660, 10655, 1, 0, 0, 0, 10661, 1173, 1, 0, 0, 0, 10662, 10663, 5, 46, 0, 0, 10663, 10664, 5, 412, 0, 0, 10664, 10666, 5, 643, 0, 0, 10665, 10667, 3, 522, 261, 0, 10666, 10665, 1, 0, 0, 0, 10666, 10667, 1, 0, 0, 0, 10667, 10668, 1, 0, 0, 0, 10668, 10669, 3, 1924, 962, 0, 10669, 10670, 5, 106, 0, 0, 10670, 10671, 5, 2, 0, 0, 10671, 10672, 3, 1176, 588, 0, 10672, 10673, 5, 3, 0, 0, 10673, 10674, 5, 101, 0, 0, 10674, 10675, 5, 2, 0, 0, 10675, 10676, 3, 1180, 590, 0, 10676, 10677, 5, 3, 0, 0, 10677, 1175, 1, 0, 0, 0, 10678, 10683, 3, 1178, 589, 0, 10679, 10680, 5, 6, 0, 0, 10680, 10682, 3, 1178, 589, 0, 10681, 10679, 1, 0, 0, 0, 10682, 10685, 1, 0, 0, 0, 10683, 10681, 1, 0, 0, 0, 10683, 10684, 1, 0, 0, 0, 10684, 1177, 1, 0, 0, 0, 10685, 10683, 1, 0, 0, 0, 10686, 10687, 3, 1924, 962, 0, 10687, 10688, 3, 1662, 831, 0, 10688, 1179, 1, 0, 0, 0, 10689, 10690, 3, 1710, 855, 0, 10690, 1181, 1, 0, 0, 0, 10691, 10692, 5, 46, 0, 0, 10692, 10693, 5, 417, 0, 0, 10693, 10694, 3, 1888, 944, 0, 10694, 10695, 5, 64, 0, 0, 10695, 10698, 3, 1184, 592, 0, 10696, 10697, 5, 418, 0, 0, 10697, 10699, 3, 1888, 944, 0, 10698, 10696, 1, 0, 0, 0, 10698, 10699, 1, 0, 0, 0, 10699, 10700, 1, 0, 0, 0, 10700, 10701, 5, 215, 0, 0, 10701, 10706, 3, 1888, 944, 0, 10702, 10703, 5, 2, 0, 0, 10703, 10704, 3, 1208, 604, 0, 10704, 10705, 5, 3, 0, 0, 10705, 10707, 1, 0, 0, 0, 10706, 10702, 1, 0, 0, 0, 10706, 10707, 1, 0, 0, 0, 10707, 10710, 1, 0, 0, 0, 10708, 10709, 5, 314, 0, 0, 10709, 10711, 3, 1662, 831, 0, 10710, 10708, 1, 0, 0, 0, 10710, 10711, 1, 0, 0, 0, 10711, 10714, 1, 0, 0, 0, 10712, 10713, 5, 419, 0, 0, 10713, 10715, 3, 1188, 594, 0, 10714, 10712, 1, 0, 0, 0, 10714, 10715, 1, 0, 0, 0, 10715, 10716, 1, 0, 0, 0, 10716, 10717, 5, 396, 0, 0, 10717, 10720, 3, 1186, 593, 0, 10718, 10719, 5, 420, 0, 0, 10719, 10721, 7, 14, 0, 0, 10720, 10718, 1, 0, 0, 0, 10720, 10721, 1, 0, 0, 0, 10721, 10724, 1, 0, 0, 0, 10722, 10723, 5, 421, 0, 0, 10723, 10725, 3, 1190, 595, 0, 10724, 10722, 1, 0, 0, 0, 10724, 10725, 1, 0, 0, 0, 10725, 10728, 1, 0, 0, 0, 10726, 10727, 5, 422, 0, 0, 10727, 10729, 3, 1192, 596, 0, 10728, 10726, 1, 0, 0, 0, 10728, 10729, 1, 0, 0, 0, 10729, 10732, 1, 0, 0, 0, 10730, 10731, 5, 423, 0, 0, 10731, 10733, 3, 1196, 598, 0, 10732, 10730, 1, 0, 0, 0, 10732, 10733, 1, 0, 0, 0, 10733, 10736, 1, 0, 0, 0, 10734, 10735, 5, 424, 0, 0, 10735, 10737, 3, 1910, 955, 0, 10736, 10734, 1, 0, 0, 0, 10736, 10737, 1, 0, 0, 0, 10737, 10740, 1, 0, 0, 0, 10738, 10739, 5, 425, 0, 0, 10739, 10741, 3, 1198, 599, 0, 10740, 10738, 1, 0, 0, 0, 10740, 10741, 1, 0, 0, 0, 10741, 10747, 1, 0, 0, 0, 10742, 10743, 5, 546, 0, 0, 10743, 10744, 5, 2, 0, 0, 10744, 10745, 3, 1204, 602, 0, 10745, 10746, 5, 3, 0, 0, 10746, 10748, 1, 0, 0, 0, 10747, 10742, 1, 0, 0, 0, 10747, 10748, 1, 0, 0, 0, 10748, 1183, 1, 0, 0, 0, 10749, 10756, 3, 1888, 944, 0, 10750, 10751, 5, 2, 0, 0, 10751, 10752, 3, 1496, 748, 0, 10752, 10753, 5, 3, 0, 0, 10753, 10756, 1, 0, 0, 0, 10754, 10756, 3, 1910, 955, 0, 10755, 10749, 1, 0, 0, 0, 10755, 10750, 1, 0, 0, 0, 10755, 10754, 1, 0, 0, 0, 10756, 1185, 1, 0, 0, 0, 10757, 10760, 5, 53, 0, 0, 10758, 10760, 3, 1910, 955, 0, 10759, 10757, 1, 0, 0, 0, 10759, 10758, 1, 0, 0, 0, 10760, 1187, 1, 0, 0, 0, 10761, 10764, 3, 1910, 955, 0, 10762, 10763, 5, 8, 0, 0, 10763, 10765, 3, 1910, 955, 0, 10764, 10762, 1, 0, 0, 0, 10764, 10765, 1, 0, 0, 0, 10765, 1189, 1, 0, 0, 0, 10766, 10767, 7, 65, 0, 0, 10767, 1191, 1, 0, 0, 0, 10768, 10769, 5, 2, 0, 0, 10769, 10770, 3, 1194, 597, 0, 10770, 10771, 5, 3, 0, 0, 10771, 1193, 1, 0, 0, 0, 10772, 10773, 7, 66, 0, 0, 10773, 1195, 1, 0, 0, 0, 10774, 10775, 5, 2, 0, 0, 10775, 10776, 3, 1910, 955, 0, 10776, 10777, 5, 3, 0, 0, 10777, 1197, 1, 0, 0, 0, 10778, 10786, 5, 53, 0, 0, 10779, 10780, 5, 53, 0, 0, 10780, 10781, 5, 59, 0, 0, 10781, 10782, 5, 2, 0, 0, 10782, 10783, 3, 1200, 600, 0, 10783, 10784, 5, 3, 0, 0, 10784, 10786, 1, 0, 0, 0, 10785, 10778, 1, 0, 0, 0, 10785, 10779, 1, 0, 0, 0, 10786, 1199, 1, 0, 0, 0, 10787, 10792, 3, 1202, 601, 0, 10788, 10789, 5, 6, 0, 0, 10789, 10791, 3, 1202, 601, 0, 10790, 10788, 1, 0, 0, 0, 10791, 10794, 1, 0, 0, 0, 10792, 10790, 1, 0, 0, 0, 10792, 10793, 1, 0, 0, 0, 10793, 1201, 1, 0, 0, 0, 10794, 10792, 1, 0, 0, 0, 10795, 10796, 3, 1924, 962, 0, 10796, 10797, 3, 1910, 955, 0, 10797, 1203, 1, 0, 0, 0, 10798, 10803, 3, 1206, 603, 0, 10799, 10800, 5, 6, 0, 0, 10800, 10802, 3, 1206, 603, 0, 10801, 10799, 1, 0, 0, 0, 10802, 10805, 1, 0, 0, 0, 10803, 10801, 1, 0, 0, 0, 10803, 10804, 1, 0, 0, 0, 10804, 1205, 1, 0, 0, 0, 10805, 10803, 1, 0, 0, 0, 10806, 10807, 5, 434, 0, 0, 10807, 10841, 3, 1910, 955, 0, 10808, 10809, 5, 435, 0, 0, 10809, 10841, 3, 1910, 955, 0, 10810, 10811, 5, 436, 0, 0, 10811, 10841, 3, 1910, 955, 0, 10812, 10813, 5, 437, 0, 0, 10813, 10841, 7, 14, 0, 0, 10814, 10815, 5, 438, 0, 0, 10815, 10841, 3, 1908, 954, 0, 10816, 10817, 5, 439, 0, 0, 10817, 10841, 3, 1908, 954, 0, 10818, 10819, 5, 636, 0, 0, 10819, 10841, 3, 1910, 955, 0, 10820, 10821, 5, 637, 0, 0, 10821, 10841, 3, 1910, 955, 0, 10822, 10823, 5, 440, 0, 0, 10823, 10841, 3, 1908, 954, 0, 10824, 10825, 5, 441, 0, 0, 10825, 10841, 3, 1908, 954, 0, 10826, 10827, 5, 442, 0, 0, 10827, 10841, 3, 1910, 955, 0, 10828, 10829, 5, 443, 0, 0, 10829, 10841, 3, 1908, 954, 0, 10830, 10831, 5, 475, 0, 0, 10831, 10841, 3, 1910, 955, 0, 10832, 10833, 5, 476, 0, 0, 10833, 10841, 3, 1910, 955, 0, 10834, 10835, 5, 477, 0, 0, 10835, 10841, 3, 1910, 955, 0, 10836, 10837, 5, 478, 0, 0, 10837, 10841, 7, 67, 0, 0, 10838, 10839, 5, 479, 0, 0, 10839, 10841, 7, 68, 0, 0, 10840, 10806, 1, 0, 0, 0, 10840, 10808, 1, 0, 0, 0, 10840, 10810, 1, 0, 0, 0, 10840, 10812, 1, 0, 0, 0, 10840, 10814, 1, 0, 0, 0, 10840, 10816, 1, 0, 0, 0, 10840, 10818, 1, 0, 0, 0, 10840, 10820, 1, 0, 0, 0, 10840, 10822, 1, 0, 0, 0, 10840, 10824, 1, 0, 0, 0, 10840, 10826, 1, 0, 0, 0, 10840, 10828, 1, 0, 0, 0, 10840, 10830, 1, 0, 0, 0, 10840, 10832, 1, 0, 0, 0, 10840, 10834, 1, 0, 0, 0, 10840, 10836, 1, 0, 0, 0, 10840, 10838, 1, 0, 0, 0, 10841, 1207, 1, 0, 0, 0, 10842, 10847, 3, 1210, 605, 0, 10843, 10844, 5, 6, 0, 0, 10844, 10846, 3, 1210, 605, 0, 10845, 10843, 1, 0, 0, 0, 10846, 10849, 1, 0, 0, 0, 10847, 10845, 1, 0, 0, 0, 10847, 10848, 1, 0, 0, 0, 10848, 1209, 1, 0, 0, 0, 10849, 10847, 1, 0, 0, 0, 10850, 10858, 3, 1662, 831, 0, 10851, 10852, 3, 1924, 962, 0, 10852, 10853, 3, 1662, 831, 0, 10853, 10858, 1, 0, 0, 0, 10854, 10855, 3, 1924, 962, 0, 10855, 10856, 3, 1924, 962, 0, 10856, 10858, 1, 0, 0, 0, 10857, 10850, 1, 0, 0, 0, 10857, 10851, 1, 0, 0, 0, 10857, 10854, 1, 0, 0, 0, 10858, 1211, 1, 0, 0, 0, 10859, 10860, 5, 46, 0, 0, 10860, 10861, 5, 413, 0, 0, 10861, 10862, 5, 643, 0, 0, 10862, 10871, 3, 1924, 962, 0, 10863, 10864, 5, 106, 0, 0, 10864, 10865, 5, 2, 0, 0, 10865, 10866, 3, 1176, 588, 0, 10866, 10869, 5, 3, 0, 0, 10867, 10868, 5, 36, 0, 0, 10868, 10870, 3, 1924, 962, 0, 10869, 10867, 1, 0, 0, 0, 10869, 10870, 1, 0, 0, 0, 10870, 10872, 1, 0, 0, 0, 10871, 10863, 1, 0, 0, 0, 10871, 10872, 1, 0, 0, 0, 10872, 10873, 1, 0, 0, 0, 10873, 10874, 5, 101, 0, 0, 10874, 10875, 5, 2, 0, 0, 10875, 10876, 3, 1710, 855, 0, 10876, 10877, 5, 3, 0, 0, 10877, 1213, 1, 0, 0, 0, 10878, 10879, 7, 59, 0, 0, 10879, 10880, 5, 223, 0, 0, 10880, 10881, 5, 415, 0, 0, 10881, 10882, 3, 1924, 962, 0, 10882, 1215, 1, 0, 0, 0, 10883, 10884, 5, 606, 0, 0, 10884, 10885, 5, 412, 0, 0, 10885, 10886, 5, 643, 0, 0, 10886, 10887, 3, 1924, 962, 0, 10887, 10888, 5, 80, 0, 0, 10888, 10889, 3, 1888, 944, 0, 10889, 10890, 5, 2, 0, 0, 10890, 10891, 3, 1152, 576, 0, 10891, 10892, 5, 3, 0, 0, 10892, 10893, 5, 64, 0, 0, 10893, 10894, 3, 1156, 578, 0, 10894, 1217, 1, 0, 0, 0, 10895, 10896, 5, 606, 0, 0, 10896, 10897, 5, 413, 0, 0, 10897, 10898, 5, 643, 0, 0, 10898, 10899, 3, 1224, 612, 0, 10899, 10901, 5, 80, 0, 0, 10900, 10902, 5, 93, 0, 0, 10901, 10900, 1, 0, 0, 0, 10901, 10902, 1, 0, 0, 0, 10902, 10903, 1, 0, 0, 0, 10903, 10904, 3, 1162, 581, 0, 10904, 10905, 5, 64, 0, 0, 10905, 10906, 3, 1220, 610, 0, 10906, 1219, 1, 0, 0, 0, 10907, 10912, 3, 1222, 611, 0, 10908, 10909, 5, 6, 0, 0, 10909, 10911, 3, 1222, 611, 0, 10910, 10908, 1, 0, 0, 0, 10911, 10914, 1, 0, 0, 0, 10912, 10910, 1, 0, 0, 0, 10912, 10913, 1, 0, 0, 0, 10913, 1221, 1, 0, 0, 0, 10914, 10912, 1, 0, 0, 0, 10915, 10920, 3, 1920, 960, 0, 10916, 10917, 5, 316, 0, 0, 10917, 10920, 3, 1920, 960, 0, 10918, 10920, 5, 86, 0, 0, 10919, 10915, 1, 0, 0, 0, 10919, 10916, 1, 0, 0, 0, 10919, 10918, 1, 0, 0, 0, 10920, 1223, 1, 0, 0, 0, 10921, 10922, 3, 1924, 962, 0, 10922, 1225, 1, 0, 0, 0, 10923, 10924, 5, 195, 0, 0, 10924, 10925, 5, 223, 0, 0, 10925, 10927, 5, 415, 0, 0, 10926, 10928, 3, 922, 461, 0, 10927, 10926, 1, 0, 0, 0, 10927, 10928, 1, 0, 0, 0, 10928, 10929, 1, 0, 0, 0, 10929, 10931, 3, 1924, 962, 0, 10930, 10932, 5, 152, 0, 0, 10931, 10930, 1, 0, 0, 0, 10931, 10932, 1, 0, 0, 0, 10932, 1227, 1, 0, 0, 0, 10933, 10934, 5, 195, 0, 0, 10934, 10936, 5, 462, 0, 0, 10935, 10937, 3, 922, 461, 0, 10936, 10935, 1, 0, 0, 0, 10936, 10937, 1, 0, 0, 0, 10937, 10938, 1, 0, 0, 0, 10938, 10939, 3, 1924, 962, 0, 10939, 1229, 1, 0, 0, 0, 10940, 10941, 5, 195, 0, 0, 10941, 10942, 5, 412, 0, 0, 10942, 10944, 5, 643, 0, 0, 10943, 10945, 3, 922, 461, 0, 10944, 10943, 1, 0, 0, 0, 10944, 10945, 1, 0, 0, 0, 10945, 10946, 1, 0, 0, 0, 10946, 10947, 3, 1924, 962, 0, 10947, 1231, 1, 0, 0, 0, 10948, 10949, 5, 195, 0, 0, 10949, 10951, 5, 417, 0, 0, 10950, 10952, 3, 922, 461, 0, 10951, 10950, 1, 0, 0, 0, 10951, 10952, 1, 0, 0, 0, 10952, 10953, 1, 0, 0, 0, 10953, 10954, 3, 1888, 944, 0, 10954, 1233, 1, 0, 0, 0, 10955, 10956, 5, 195, 0, 0, 10956, 10957, 5, 413, 0, 0, 10957, 10959, 5, 643, 0, 0, 10958, 10960, 3, 922, 461, 0, 10959, 10958, 1, 0, 0, 0, 10959, 10960, 1, 0, 0, 0, 10960, 10961, 1, 0, 0, 0, 10961, 10963, 3, 1924, 962, 0, 10962, 10964, 7, 12, 0, 0, 10963, 10962, 1, 0, 0, 0, 10963, 10964, 1, 0, 0, 0, 10964, 1235, 1, 0, 0, 0, 10965, 10966, 5, 140, 0, 0, 10966, 10967, 5, 93, 0, 0, 10967, 10968, 3, 1888, 944, 0, 10968, 10969, 5, 463, 0, 0, 10969, 10970, 5, 64, 0, 0, 10970, 10974, 3, 1888, 944, 0, 10971, 10973, 3, 1238, 619, 0, 10972, 10971, 1, 0, 0, 0, 10973, 10976, 1, 0, 0, 0, 10974, 10972, 1, 0, 0, 0, 10974, 10975, 1, 0, 0, 0, 10975, 1237, 1, 0, 0, 0, 10976, 10974, 1, 0, 0, 0, 10977, 10978, 7, 16, 0, 0, 10978, 1239, 1, 0, 0, 0, 10979, 10980, 5, 140, 0, 0, 10980, 10981, 5, 100, 0, 0, 10981, 10983, 3, 1920, 960, 0, 10982, 10984, 5, 106, 0, 0, 10983, 10982, 1, 0, 0, 0, 10983, 10984, 1, 0, 0, 0, 10984, 10986, 1, 0, 0, 0, 10985, 10987, 3, 1242, 621, 0, 10986, 10985, 1, 0, 0, 0, 10987, 10988, 1, 0, 0, 0, 10988, 10986, 1, 0, 0, 0, 10988, 10989, 1, 0, 0, 0, 10989, 1241, 1, 0, 0, 0, 10990, 11030, 5, 494, 0, 0, 10991, 11030, 5, 495, 0, 0, 10992, 11030, 5, 488, 0, 0, 10993, 11030, 5, 489, 0, 0, 10994, 10995, 5, 500, 0, 0, 10995, 10996, 5, 133, 0, 0, 10996, 11030, 7, 1, 0, 0, 10997, 11000, 5, 284, 0, 0, 10998, 11001, 3, 1910, 955, 0, 10999, 11001, 5, 190, 0, 0, 11000, 10998, 1, 0, 0, 0, 11000, 10999, 1, 0, 0, 0, 11001, 11030, 1, 0, 0, 0, 11002, 11003, 5, 369, 0, 0, 11003, 11004, 5, 366, 0, 0, 11004, 11030, 3, 1910, 955, 0, 11005, 11006, 5, 307, 0, 0, 11006, 11007, 5, 95, 0, 0, 11007, 11030, 3, 1924, 962, 0, 11008, 11009, 5, 166, 0, 0, 11009, 11012, 5, 74, 0, 0, 11010, 11013, 3, 1908, 954, 0, 11011, 11013, 5, 497, 0, 0, 11012, 11010, 1, 0, 0, 0, 11012, 11011, 1, 0, 0, 0, 11013, 11030, 1, 0, 0, 0, 11014, 11015, 5, 330, 0, 0, 11015, 11016, 5, 499, 0, 0, 11016, 11030, 3, 1908, 954, 0, 11017, 11018, 5, 311, 0, 0, 11018, 11019, 5, 330, 0, 0, 11019, 11030, 5, 499, 0, 0, 11020, 11021, 5, 331, 0, 0, 11021, 11022, 3, 1924, 962, 0, 11022, 11023, 5, 95, 0, 0, 11023, 11024, 3, 1710, 855, 0, 11024, 11030, 1, 0, 0, 0, 11025, 11026, 5, 311, 0, 0, 11026, 11030, 3, 1924, 962, 0, 11027, 11028, 5, 498, 0, 0, 11028, 11030, 3, 1924, 962, 0, 11029, 10990, 1, 0, 0, 0, 11029, 10991, 1, 0, 0, 0, 11029, 10992, 1, 0, 0, 0, 11029, 10993, 1, 0, 0, 0, 11029, 10994, 1, 0, 0, 0, 11029, 10997, 1, 0, 0, 0, 11029, 11002, 1, 0, 0, 0, 11029, 11005, 1, 0, 0, 0, 11029, 11008, 1, 0, 0, 0, 11029, 11014, 1, 0, 0, 0, 11029, 11017, 1, 0, 0, 0, 11029, 11020, 1, 0, 0, 0, 11029, 11025, 1, 0, 0, 0, 11029, 11027, 1, 0, 0, 0, 11030, 1243, 1, 0, 0, 0, 11031, 11032, 7, 69, 0, 0, 11032, 11040, 5, 461, 0, 0, 11033, 11038, 3, 1888, 944, 0, 11034, 11035, 5, 2, 0, 0, 11035, 11036, 3, 1890, 945, 0, 11036, 11037, 5, 3, 0, 0, 11037, 11039, 1, 0, 0, 0, 11038, 11034, 1, 0, 0, 0, 11038, 11039, 1, 0, 0, 0, 11039, 11041, 1, 0, 0, 0, 11040, 11033, 1, 0, 0, 0, 11040, 11041, 1, 0, 0, 0, 11041, 11044, 1, 0, 0, 0, 11042, 11043, 5, 506, 0, 0, 11043, 11045, 3, 1908, 954, 0, 11044, 11042, 1, 0, 0, 0, 11044, 11045, 1, 0, 0, 0, 11045, 1245, 1, 0, 0, 0, 11046, 11049, 5, 458, 0, 0, 11047, 11050, 3, 1910, 955, 0, 11048, 11050, 3, 1908, 954, 0, 11049, 11047, 1, 0, 0, 0, 11049, 11048, 1, 0, 0, 0, 11050, 11052, 1, 0, 0, 0, 11051, 11053, 3, 1910, 955, 0, 11052, 11051, 1, 0, 0, 0, 11052, 11053, 1, 0, 0, 0, 11053, 1247, 1, 0, 0, 0, 11054, 11055, 5, 159, 0, 0, 11055, 11056, 3, 1924, 962, 0, 11056, 1249, 1, 0, 0, 0, 11057, 11058, 5, 236, 0, 0, 11058, 11059, 5, 71, 0, 0, 11059, 11060, 3, 1888, 944, 0, 11060, 11061, 3, 1252, 626, 0, 11061, 1251, 1, 0, 0, 0, 11062, 11065, 3, 1496, 748, 0, 11063, 11065, 3, 1596, 798, 0, 11064, 11062, 1, 0, 0, 0, 11064, 11063, 1, 0, 0, 0, 11065, 1253, 1, 0, 0, 0, 11066, 11068, 5, 89, 0, 0, 11067, 11069, 3, 1538, 769, 0, 11068, 11067, 1, 0, 0, 0, 11068, 11069, 1, 0, 0, 0, 11069, 11070, 1, 0, 0, 0, 11070, 11071, 3, 1878, 939, 0, 11071, 11072, 5, 71, 0, 0, 11072, 11074, 3, 1888, 944, 0, 11073, 11075, 3, 1598, 799, 0, 11074, 11073, 1, 0, 0, 0, 11074, 11075, 1, 0, 0, 0, 11075, 1255, 1, 0, 0, 0, 11076, 11077, 5, 331, 0, 0, 11077, 11078, 5, 330, 0, 0, 11078, 11079, 5, 107, 0, 0, 11079, 11088, 3, 1924, 962, 0, 11080, 11081, 5, 331, 0, 0, 11081, 11082, 5, 330, 0, 0, 11082, 11083, 5, 107, 0, 0, 11083, 11088, 5, 53, 0, 0, 11084, 11085, 5, 311, 0, 0, 11085, 11086, 5, 330, 0, 0, 11086, 11088, 5, 107, 0, 0, 11087, 11076, 1, 0, 0, 0, 11087, 11080, 1, 0, 0, 0, 11087, 11084, 1, 0, 0, 0, 11088, 1257, 1, 0, 0, 0, 11089, 11090, 5, 331, 0, 0, 11090, 11091, 5, 330, 0, 0, 11091, 11092, 5, 156, 0, 0, 11092, 11093, 5, 36, 0, 0, 11093, 11094, 5, 354, 0, 0, 11094, 11095, 3, 1014, 507, 0, 11095, 1259, 1, 0, 0, 0, 11096, 11097, 5, 333, 0, 0, 11097, 11098, 5, 674, 0, 0, 11098, 11100, 5, 64, 0, 0, 11099, 11101, 5, 93, 0, 0, 11100, 11099, 1, 0, 0, 0, 11100, 11101, 1, 0, 0, 0, 11101, 11102, 1, 0, 0, 0, 11102, 11105, 3, 1888, 944, 0, 11103, 11104, 5, 122, 0, 0, 11104, 11106, 3, 1910, 955, 0, 11105, 11103, 1, 0, 0, 0, 11105, 11106, 1, 0, 0, 0, 11106, 11109, 1, 0, 0, 0, 11107, 11108, 5, 74, 0, 0, 11108, 11110, 3, 1908, 954, 0, 11109, 11107, 1, 0, 0, 0, 11109, 11110, 1, 0, 0, 0, 11110, 1261, 1, 0, 0, 0, 11111, 11112, 5, 333, 0, 0, 11112, 11116, 5, 454, 0, 0, 11113, 11114, 5, 64, 0, 0, 11114, 11115, 5, 177, 0, 0, 11115, 11117, 5, 154, 0, 0, 11116, 11113, 1, 0, 0, 0, 11116, 11117, 1, 0, 0, 0, 11117, 11121, 1, 0, 0, 0, 11118, 11120, 3, 1264, 632, 0, 11119, 11118, 1, 0, 0, 0, 11120, 11123, 1, 0, 0, 0, 11121, 11119, 1, 0, 0, 0, 11121, 11122, 1, 0, 0, 0, 11122, 1263, 1, 0, 0, 0, 11123, 11121, 1, 0, 0, 0, 11124, 11125, 5, 122, 0, 0, 11125, 11147, 3, 1910, 955, 0, 11126, 11127, 5, 106, 0, 0, 11127, 11128, 5, 392, 0, 0, 11128, 11147, 3, 1910, 955, 0, 11129, 11130, 5, 74, 0, 0, 11130, 11147, 3, 1908, 954, 0, 11131, 11132, 5, 466, 0, 0, 11132, 11137, 3, 1910, 955, 0, 11133, 11134, 5, 6, 0, 0, 11134, 11136, 3, 1910, 955, 0, 11135, 11133, 1, 0, 0, 0, 11136, 11139, 1, 0, 0, 0, 11137, 11135, 1, 0, 0, 0, 11137, 11138, 1, 0, 0, 0, 11138, 11147, 1, 0, 0, 0, 11139, 11137, 1, 0, 0, 0, 11140, 11144, 5, 396, 0, 0, 11141, 11145, 5, 53, 0, 0, 11142, 11145, 5, 330, 0, 0, 11143, 11145, 3, 1910, 955, 0, 11144, 11141, 1, 0, 0, 0, 11144, 11142, 1, 0, 0, 0, 11144, 11143, 1, 0, 0, 0, 11145, 11147, 1, 0, 0, 0, 11146, 11124, 1, 0, 0, 0, 11146, 11126, 1, 0, 0, 0, 11146, 11129, 1, 0, 0, 0, 11146, 11131, 1, 0, 0, 0, 11146, 11140, 1, 0, 0, 0, 11147, 1265, 1, 0, 0, 0, 11148, 11149, 5, 333, 0, 0, 11149, 11152, 5, 455, 0, 0, 11150, 11151, 5, 122, 0, 0, 11151, 11153, 3, 1910, 955, 0, 11152, 11150, 1, 0, 0, 0, 11152, 11153, 1, 0, 0, 0, 11153, 1267, 1, 0, 0, 0, 11154, 11155, 5, 333, 0, 0, 11155, 11156, 5, 209, 0, 0, 11156, 11157, 5, 93, 0, 0, 11157, 11159, 3, 1888, 944, 0, 11158, 11160, 5, 282, 0, 0, 11159, 11158, 1, 0, 0, 0, 11159, 11160, 1, 0, 0, 0, 11160, 1269, 1, 0, 0, 0, 11161, 11162, 5, 333, 0, 0, 11162, 11165, 5, 456, 0, 0, 11163, 11164, 5, 80, 0, 0, 11164, 11166, 3, 1272, 636, 0, 11165, 11163, 1, 0, 0, 0, 11165, 11166, 1, 0, 0, 0, 11166, 11169, 1, 0, 0, 0, 11167, 11168, 5, 62, 0, 0, 11168, 11170, 3, 1274, 637, 0, 11169, 11167, 1, 0, 0, 0, 11169, 11170, 1, 0, 0, 0, 11170, 11173, 1, 0, 0, 0, 11171, 11172, 5, 74, 0, 0, 11172, 11174, 3, 1908, 954, 0, 11173, 11171, 1, 0, 0, 0, 11173, 11174, 1, 0, 0, 0, 11174, 11185, 1, 0, 0, 0, 11175, 11176, 5, 333, 0, 0, 11176, 11177, 5, 456, 0, 0, 11177, 11178, 5, 62, 0, 0, 11178, 11179, 3, 1274, 637, 0, 11179, 11182, 1, 0, 0, 0, 11180, 11181, 5, 74, 0, 0, 11181, 11183, 3, 1908, 954, 0, 11182, 11180, 1, 0, 0, 0, 11182, 11183, 1, 0, 0, 0, 11183, 11185, 1, 0, 0, 0, 11184, 11161, 1, 0, 0, 0, 11184, 11175, 1, 0, 0, 0, 11185, 1271, 1, 0, 0, 0, 11186, 11187, 5, 179, 0, 0, 11187, 11204, 3, 1924, 962, 0, 11188, 11189, 5, 321, 0, 0, 11189, 11204, 3, 1888, 944, 0, 11190, 11192, 5, 93, 0, 0, 11191, 11190, 1, 0, 0, 0, 11191, 11192, 1, 0, 0, 0, 11192, 11193, 1, 0, 0, 0, 11193, 11204, 3, 1888, 944, 0, 11194, 11195, 5, 215, 0, 0, 11195, 11201, 3, 1888, 944, 0, 11196, 11198, 5, 2, 0, 0, 11197, 11199, 3, 1208, 604, 0, 11198, 11197, 1, 0, 0, 0, 11198, 11199, 1, 0, 0, 0, 11199, 11200, 1, 0, 0, 0, 11200, 11202, 5, 3, 0, 0, 11201, 11196, 1, 0, 0, 0, 11201, 11202, 1, 0, 0, 0, 11202, 11204, 1, 0, 0, 0, 11203, 11186, 1, 0, 0, 0, 11203, 11188, 1, 0, 0, 0, 11203, 11191, 1, 0, 0, 0, 11203, 11194, 1, 0, 0, 0, 11204, 1273, 1, 0, 0, 0, 11205, 11209, 3, 1924, 962, 0, 11206, 11207, 5, 316, 0, 0, 11207, 11209, 3, 1924, 962, 0, 11208, 11205, 1, 0, 0, 0, 11208, 11206, 1, 0, 0, 0, 11209, 1275, 1, 0, 0, 0, 11210, 11211, 5, 333, 0, 0, 11211, 11214, 5, 417, 0, 0, 11212, 11215, 3, 1888, 944, 0, 11213, 11215, 5, 30, 0, 0, 11214, 11212, 1, 0, 0, 0, 11214, 11213, 1, 0, 0, 0, 11215, 1277, 1, 0, 0, 0, 11216, 11217, 5, 333, 0, 0, 11217, 11218, 5, 294, 0, 0, 11218, 11220, 3, 1888, 944, 0, 11219, 11221, 3, 838, 419, 0, 11220, 11219, 1, 0, 0, 0, 11220, 11221, 1, 0, 0, 0, 11221, 1279, 1, 0, 0, 0, 11222, 11223, 5, 333, 0, 0, 11223, 11227, 5, 655, 0, 0, 11224, 11225, 5, 64, 0, 0, 11225, 11226, 5, 179, 0, 0, 11226, 11228, 3, 1924, 962, 0, 11227, 11224, 1, 0, 0, 0, 11227, 11228, 1, 0, 0, 0, 11228, 11231, 1, 0, 0, 0, 11229, 11230, 5, 122, 0, 0, 11230, 11232, 3, 1910, 955, 0, 11231, 11229, 1, 0, 0, 0, 11231, 11232, 1, 0, 0, 0, 11232, 11235, 1, 0, 0, 0, 11233, 11234, 5, 74, 0, 0, 11234, 11236, 3, 1908, 954, 0, 11235, 11233, 1, 0, 0, 0, 11235, 11236, 1, 0, 0, 0, 11236, 1281, 1, 0, 0, 0, 11237, 11238, 5, 333, 0, 0, 11238, 11239, 5, 93, 0, 0, 11239, 11240, 3, 1888, 944, 0, 11240, 1283, 1, 0, 0, 0, 11241, 11242, 5, 333, 0, 0, 11242, 11243, 5, 348, 0, 0, 11243, 11244, 5, 64, 0, 0, 11244, 11245, 5, 321, 0, 0, 11245, 11246, 3, 1924, 962, 0, 11246, 11247, 5, 11, 0, 0, 11247, 11250, 3, 1924, 962, 0, 11248, 11249, 5, 122, 0, 0, 11249, 11251, 3, 1910, 955, 0, 11250, 11248, 1, 0, 0, 0, 11250, 11251, 1, 0, 0, 0, 11251, 11254, 1, 0, 0, 0, 11252, 11253, 5, 74, 0, 0, 11253, 11255, 3, 1908, 954, 0, 11254, 11252, 1, 0, 0, 0, 11254, 11255, 1, 0, 0, 0, 11255, 1285, 1, 0, 0, 0, 11256, 11257, 5, 333, 0, 0, 11257, 11258, 5, 374, 0, 0, 11258, 11259, 3, 1888, 944, 0, 11259, 1287, 1, 0, 0, 0, 11260, 11261, 5, 444, 0, 0, 11261, 11262, 5, 2, 0, 0, 11262, 11263, 3, 1910, 955, 0, 11263, 11264, 5, 3, 0, 0, 11264, 11265, 5, 95, 0, 0, 11265, 11266, 3, 1910, 955, 0, 11266, 11270, 3, 1290, 645, 0, 11267, 11269, 3, 1292, 646, 0, 11268, 11267, 1, 0, 0, 0, 11269, 11272, 1, 0, 0, 0, 11270, 11268, 1, 0, 0, 0, 11270, 11271, 1, 0, 0, 0, 11271, 1289, 1, 0, 0, 0, 11272, 11270, 1, 0, 0, 0, 11273, 11276, 5, 396, 0, 0, 11274, 11277, 5, 53, 0, 0, 11275, 11277, 3, 1910, 955, 0, 11276, 11274, 1, 0, 0, 0, 11276, 11275, 1, 0, 0, 0, 11277, 1291, 1, 0, 0, 0, 11278, 11298, 3, 1294, 647, 0, 11279, 11298, 3, 1296, 648, 0, 11280, 11298, 3, 1298, 649, 0, 11281, 11298, 3, 1300, 650, 0, 11282, 11298, 3, 1302, 651, 0, 11283, 11298, 3, 1304, 652, 0, 11284, 11298, 3, 1306, 653, 0, 11285, 11298, 3, 1308, 654, 0, 11286, 11298, 3, 1310, 655, 0, 11287, 11298, 3, 1312, 656, 0, 11288, 11298, 3, 1314, 657, 0, 11289, 11298, 3, 1316, 658, 0, 11290, 11298, 3, 1318, 659, 0, 11291, 11298, 3, 1320, 660, 0, 11292, 11298, 3, 1322, 661, 0, 11293, 11298, 3, 1324, 662, 0, 11294, 11298, 3, 1326, 663, 0, 11295, 11298, 3, 1330, 665, 0, 11296, 11298, 3, 1332, 666, 0, 11297, 11278, 1, 0, 0, 0, 11297, 11279, 1, 0, 0, 0, 11297, 11280, 1, 0, 0, 0, 11297, 11281, 1, 0, 0, 0, 11297, 11282, 1, 0, 0, 0, 11297, 11283, 1, 0, 0, 0, 11297, 11284, 1, 0, 0, 0, 11297, 11285, 1, 0, 0, 0, 11297, 11286, 1, 0, 0, 0, 11297, 11287, 1, 0, 0, 0, 11297, 11288, 1, 0, 0, 0, 11297, 11289, 1, 0, 0, 0, 11297, 11290, 1, 0, 0, 0, 11297, 11291, 1, 0, 0, 0, 11297, 11292, 1, 0, 0, 0, 11297, 11293, 1, 0, 0, 0, 11297, 11294, 1, 0, 0, 0, 11297, 11295, 1, 0, 0, 0, 11297, 11296, 1, 0, 0, 0, 11298, 1293, 1, 0, 0, 0, 11299, 11300, 5, 780, 0, 0, 11300, 11301, 7, 70, 0, 0, 11301, 1295, 1, 0, 0, 0, 11302, 11303, 5, 282, 0, 0, 11303, 11304, 5, 149, 0, 0, 11304, 11305, 5, 2, 0, 0, 11305, 11306, 3, 246, 123, 0, 11306, 11308, 5, 3, 0, 0, 11307, 11309, 5, 639, 0, 0, 11308, 11307, 1, 0, 0, 0, 11308, 11309, 1, 0, 0, 0, 11309, 1297, 1, 0, 0, 0, 11310, 11312, 5, 445, 0, 0, 11311, 11313, 5, 130, 0, 0, 11312, 11311, 1, 0, 0, 0, 11312, 11313, 1, 0, 0, 0, 11313, 1299, 1, 0, 0, 0, 11314, 11315, 5, 220, 0, 0, 11315, 1301, 1, 0, 0, 0, 11316, 11318, 5, 187, 0, 0, 11317, 11319, 5, 36, 0, 0, 11318, 11317, 1, 0, 0, 0, 11318, 11319, 1, 0, 0, 0, 11319, 11320, 1, 0, 0, 0, 11320, 11321, 3, 1910, 955, 0, 11321, 1303, 1, 0, 0, 0, 11322, 11323, 5, 520, 0, 0, 11323, 11324, 3, 1910, 955, 0, 11324, 1305, 1, 0, 0, 0, 11325, 11327, 5, 199, 0, 0, 11326, 11328, 5, 420, 0, 0, 11327, 11326, 1, 0, 0, 0, 11327, 11328, 1, 0, 0, 0, 11328, 1307, 1, 0, 0, 0, 11329, 11330, 5, 436, 0, 0, 11330, 11331, 3, 1910, 955, 0, 11331, 1309, 1, 0, 0, 0, 11332, 11333, 7, 71, 0, 0, 11333, 1311, 1, 0, 0, 0, 11334, 11335, 5, 446, 0, 0, 11335, 1313, 1, 0, 0, 0, 11336, 11337, 5, 78, 0, 0, 11337, 11338, 5, 36, 0, 0, 11338, 11339, 3, 1910, 955, 0, 11339, 1315, 1, 0, 0, 0, 11340, 11341, 5, 201, 0, 0, 11341, 1317, 1, 0, 0, 0, 11342, 11343, 5, 447, 0, 0, 11343, 1319, 1, 0, 0, 0, 11344, 11345, 5, 448, 0, 0, 11345, 1321, 1, 0, 0, 0, 11346, 11347, 5, 659, 0, 0, 11347, 11348, 7, 14, 0, 0, 11348, 1323, 1, 0, 0, 0, 11349, 11351, 5, 449, 0, 0, 11350, 11352, 5, 36, 0, 0, 11351, 11350, 1, 0, 0, 0, 11351, 11352, 1, 0, 0, 0, 11352, 11353, 1, 0, 0, 0, 11353, 11355, 3, 1908, 954, 0, 11354, 11356, 3, 1328, 664, 0, 11355, 11354, 1, 0, 0, 0, 11355, 11356, 1, 0, 0, 0, 11356, 1325, 1, 0, 0, 0, 11357, 11359, 5, 450, 0, 0, 11358, 11360, 5, 36, 0, 0, 11359, 11358, 1, 0, 0, 0, 11359, 11360, 1, 0, 0, 0, 11360, 11361, 1, 0, 0, 0, 11361, 11363, 3, 1908, 954, 0, 11362, 11364, 3, 1328, 664, 0, 11363, 11362, 1, 0, 0, 0, 11363, 11364, 1, 0, 0, 0, 11364, 1327, 1, 0, 0, 0, 11365, 11366, 7, 72, 0, 0, 11366, 1329, 1, 0, 0, 0, 11367, 11369, 3, 1924, 962, 0, 11368, 11370, 5, 36, 0, 0, 11369, 11368, 1, 0, 0, 0, 11369, 11370, 1, 0, 0, 0, 11370, 11371, 1, 0, 0, 0, 11371, 11372, 3, 1910, 955, 0, 11372, 1331, 1, 0, 0, 0, 11373, 11374, 5, 208, 0, 0, 11374, 11375, 3, 1910, 955, 0, 11375, 1333, 1, 0, 0, 0, 11376, 11377, 5, 457, 0, 0, 11377, 11378, 3, 1924, 962, 0, 11378, 1335, 1, 0, 0, 0, 11379, 11380, 5, 46, 0, 0, 11380, 11381, 5, 179, 0, 0, 11381, 11383, 3, 1892, 946, 0, 11382, 11384, 3, 16, 8, 0, 11383, 11382, 1, 0, 0, 0, 11383, 11384, 1, 0, 0, 0, 11384, 11386, 1, 0, 0, 0, 11385, 11387, 3, 1338, 669, 0, 11386, 11385, 1, 0, 0, 0, 11386, 11387, 1, 0, 0, 0, 11387, 1337, 1, 0, 0, 0, 11388, 11389, 3, 1340, 670, 0, 11389, 1339, 1, 0, 0, 0, 11390, 11392, 3, 1342, 671, 0, 11391, 11390, 1, 0, 0, 0, 11392, 11393, 1, 0, 0, 0, 11393, 11391, 1, 0, 0, 0, 11393, 11394, 1, 0, 0, 0, 11394, 1341, 1, 0, 0, 0, 11395, 11397, 3, 1344, 672, 0, 11396, 11398, 3, 1346, 673, 0, 11397, 11396, 1, 0, 0, 0, 11397, 11398, 1, 0, 0, 0, 11398, 11403, 1, 0, 0, 0, 11399, 11404, 3, 1916, 958, 0, 11400, 11404, 3, 76, 38, 0, 11401, 11404, 5, 53, 0, 0, 11402, 11404, 5, 497, 0, 0, 11403, 11399, 1, 0, 0, 0, 11403, 11400, 1, 0, 0, 0, 11403, 11401, 1, 0, 0, 0, 11403, 11402, 1, 0, 0, 0, 11404, 11411, 1, 0, 0, 0, 11405, 11406, 5, 239, 0, 0, 11406, 11407, 5, 246, 0, 0, 11407, 11411, 7, 73, 0, 0, 11408, 11409, 5, 43, 0, 0, 11409, 11411, 7, 13, 0, 0, 11410, 11395, 1, 0, 0, 0, 11410, 11405, 1, 0, 0, 0, 11410, 11408, 1, 0, 0, 0, 11411, 1343, 1, 0, 0, 0, 11412, 11421, 3, 1934, 967, 0, 11413, 11414, 5, 166, 0, 0, 11414, 11421, 5, 74, 0, 0, 11415, 11421, 5, 198, 0, 0, 11416, 11421, 5, 250, 0, 0, 11417, 11421, 5, 279, 0, 0, 11418, 11421, 5, 349, 0, 0, 11419, 11421, 5, 351, 0, 0, 11420, 11412, 1, 0, 0, 0, 11420, 11413, 1, 0, 0, 0, 11420, 11415, 1, 0, 0, 0, 11420, 11416, 1, 0, 0, 0, 11420, 11417, 1, 0, 0, 0, 11420, 11418, 1, 0, 0, 0, 11420, 11419, 1, 0, 0, 0, 11421, 1345, 1, 0, 0, 0, 11422, 11423, 5, 10, 0, 0, 11423, 1347, 1, 0, 0, 0, 11424, 11425, 5, 140, 0, 0, 11425, 11426, 5, 179, 0, 0, 11426, 11448, 3, 1892, 946, 0, 11427, 11429, 5, 106, 0, 0, 11428, 11430, 3, 1338, 669, 0, 11429, 11428, 1, 0, 0, 0, 11429, 11430, 1, 0, 0, 0, 11430, 11449, 1, 0, 0, 0, 11431, 11433, 3, 1338, 669, 0, 11432, 11431, 1, 0, 0, 0, 11432, 11433, 1, 0, 0, 0, 11433, 11449, 1, 0, 0, 0, 11434, 11435, 5, 331, 0, 0, 11435, 11436, 5, 349, 0, 0, 11436, 11449, 3, 1892, 946, 0, 11437, 11438, 5, 303, 0, 0, 11438, 11439, 5, 110, 0, 0, 11439, 11449, 5, 373, 0, 0, 11440, 11441, 5, 43, 0, 0, 11441, 11449, 7, 22, 0, 0, 11442, 11443, 5, 166, 0, 0, 11443, 11446, 5, 74, 0, 0, 11444, 11447, 3, 1908, 954, 0, 11445, 11447, 5, 497, 0, 0, 11446, 11444, 1, 0, 0, 0, 11446, 11445, 1, 0, 0, 0, 11447, 11449, 1, 0, 0, 0, 11448, 11427, 1, 0, 0, 0, 11448, 11432, 1, 0, 0, 0, 11448, 11434, 1, 0, 0, 0, 11448, 11437, 1, 0, 0, 0, 11448, 11440, 1, 0, 0, 0, 11448, 11442, 1, 0, 0, 0, 11449, 1349, 1, 0, 0, 0, 11450, 11451, 5, 140, 0, 0, 11451, 11452, 5, 179, 0, 0, 11452, 11453, 3, 1892, 946, 0, 11453, 11454, 3, 90, 45, 0, 11454, 1351, 1, 0, 0, 0, 11455, 11456, 5, 195, 0, 0, 11456, 11457, 5, 179, 0, 0, 11457, 11458, 3, 1892, 946, 0, 11458, 1353, 1, 0, 0, 0, 11459, 11464, 3, 1356, 678, 0, 11460, 11461, 5, 6, 0, 0, 11461, 11463, 3, 1356, 678, 0, 11462, 11460, 1, 0, 0, 0, 11463, 11466, 1, 0, 0, 0, 11464, 11462, 1, 0, 0, 0, 11464, 11465, 1, 0, 0, 0, 11465, 1355, 1, 0, 0, 0, 11466, 11464, 1, 0, 0, 0, 11467, 11468, 5, 213, 0, 0, 11468, 1357, 1, 0, 0, 0, 11469, 11470, 5, 140, 0, 0, 11470, 11471, 5, 110, 0, 0, 11471, 11472, 3, 566, 283, 0, 11472, 11473, 5, 303, 0, 0, 11473, 11474, 5, 373, 0, 0, 11474, 1359, 1, 0, 0, 0, 11475, 11476, 5, 140, 0, 0, 11476, 11477, 5, 347, 0, 0, 11477, 11478, 7, 74, 0, 0, 11478, 11479, 3, 64, 32, 0, 11479, 1361, 1, 0, 0, 0, 11480, 11481, 5, 46, 0, 0, 11481, 11482, 5, 193, 0, 0, 11482, 11484, 3, 566, 283, 0, 11483, 11485, 3, 1366, 683, 0, 11484, 11483, 1, 0, 0, 0, 11484, 11485, 1, 0, 0, 0, 11485, 11486, 1, 0, 0, 0, 11486, 11487, 3, 1662, 831, 0, 11487, 11488, 3, 220, 110, 0, 11488, 1363, 1, 0, 0, 0, 11489, 11490, 5, 140, 0, 0, 11490, 11491, 5, 193, 0, 0, 11491, 11514, 3, 566, 283, 0, 11492, 11515, 3, 118, 59, 0, 11493, 11494, 5, 195, 0, 0, 11494, 11495, 5, 77, 0, 0, 11495, 11515, 5, 78, 0, 0, 11496, 11497, 5, 331, 0, 0, 11497, 11498, 5, 77, 0, 0, 11498, 11515, 5, 78, 0, 0, 11499, 11500, 5, 135, 0, 0, 11500, 11515, 3, 238, 119, 0, 11501, 11502, 5, 195, 0, 0, 11502, 11505, 5, 45, 0, 0, 11503, 11504, 5, 224, 0, 0, 11504, 11506, 5, 558, 0, 0, 11505, 11503, 1, 0, 0, 0, 11505, 11506, 1, 0, 0, 0, 11506, 11507, 1, 0, 0, 0, 11507, 11509, 3, 1892, 946, 0, 11508, 11510, 3, 120, 60, 0, 11509, 11508, 1, 0, 0, 0, 11509, 11510, 1, 0, 0, 0, 11510, 11515, 1, 0, 0, 0, 11511, 11512, 5, 370, 0, 0, 11512, 11513, 5, 45, 0, 0, 11513, 11515, 3, 1892, 946, 0, 11514, 11492, 1, 0, 0, 0, 11514, 11493, 1, 0, 0, 0, 11514, 11496, 1, 0, 0, 0, 11514, 11499, 1, 0, 0, 0, 11514, 11501, 1, 0, 0, 0, 11514, 11511, 1, 0, 0, 0, 11515, 1365, 1, 0, 0, 0, 11516, 11517, 5, 36, 0, 0, 11517, 1367, 1, 0, 0, 0, 11518, 11519, 5, 140, 0, 0, 11519, 11520, 5, 353, 0, 0, 11520, 11521, 5, 323, 0, 0, 11521, 11522, 5, 189, 0, 0, 11522, 11523, 3, 566, 283, 0, 11523, 11524, 3, 502, 251, 0, 11524, 1369, 1, 0, 0, 0, 11525, 11526, 5, 140, 0, 0, 11526, 11527, 5, 353, 0, 0, 11527, 11528, 5, 323, 0, 0, 11528, 11529, 5, 165, 0, 0, 11529, 11530, 3, 566, 283, 0, 11530, 11531, 5, 135, 0, 0, 11531, 11532, 5, 252, 0, 0, 11532, 11533, 5, 62, 0, 0, 11533, 11534, 3, 1890, 945, 0, 11534, 11535, 3, 1372, 686, 0, 11535, 11536, 3, 564, 282, 0, 11536, 11598, 1, 0, 0, 0, 11537, 11538, 5, 140, 0, 0, 11538, 11539, 5, 353, 0, 0, 11539, 11540, 5, 323, 0, 0, 11540, 11541, 5, 165, 0, 0, 11541, 11542, 3, 566, 283, 0, 11542, 11543, 5, 140, 0, 0, 11543, 11544, 5, 252, 0, 0, 11544, 11545, 5, 62, 0, 0, 11545, 11546, 3, 1890, 945, 0, 11546, 11547, 3, 1372, 686, 0, 11547, 11548, 3, 564, 282, 0, 11548, 11598, 1, 0, 0, 0, 11549, 11550, 5, 140, 0, 0, 11550, 11551, 5, 353, 0, 0, 11551, 11552, 5, 323, 0, 0, 11552, 11553, 5, 165, 0, 0, 11553, 11554, 3, 566, 283, 0, 11554, 11555, 5, 140, 0, 0, 11555, 11556, 5, 252, 0, 0, 11556, 11557, 5, 309, 0, 0, 11557, 11558, 3, 566, 283, 0, 11558, 11559, 3, 1372, 686, 0, 11559, 11560, 3, 566, 283, 0, 11560, 11598, 1, 0, 0, 0, 11561, 11562, 5, 140, 0, 0, 11562, 11563, 5, 353, 0, 0, 11563, 11564, 5, 323, 0, 0, 11564, 11565, 5, 165, 0, 0, 11565, 11566, 3, 566, 283, 0, 11566, 11567, 5, 140, 0, 0, 11567, 11568, 5, 252, 0, 0, 11568, 11569, 5, 62, 0, 0, 11569, 11570, 3, 1890, 945, 0, 11570, 11571, 5, 309, 0, 0, 11571, 11572, 3, 566, 283, 0, 11572, 11573, 3, 1372, 686, 0, 11573, 11574, 3, 566, 283, 0, 11574, 11598, 1, 0, 0, 0, 11575, 11576, 5, 140, 0, 0, 11576, 11577, 5, 353, 0, 0, 11577, 11578, 5, 323, 0, 0, 11578, 11579, 5, 165, 0, 0, 11579, 11580, 3, 566, 283, 0, 11580, 11581, 5, 195, 0, 0, 11581, 11582, 5, 252, 0, 0, 11582, 11583, 5, 62, 0, 0, 11583, 11584, 3, 1890, 945, 0, 11584, 11598, 1, 0, 0, 0, 11585, 11586, 5, 140, 0, 0, 11586, 11587, 5, 353, 0, 0, 11587, 11588, 5, 323, 0, 0, 11588, 11589, 5, 165, 0, 0, 11589, 11590, 3, 566, 283, 0, 11590, 11591, 5, 195, 0, 0, 11591, 11592, 5, 252, 0, 0, 11592, 11593, 5, 224, 0, 0, 11593, 11594, 5, 558, 0, 0, 11594, 11595, 5, 62, 0, 0, 11595, 11596, 3, 1890, 945, 0, 11596, 11598, 1, 0, 0, 0, 11597, 11525, 1, 0, 0, 0, 11597, 11537, 1, 0, 0, 0, 11597, 11549, 1, 0, 0, 0, 11597, 11561, 1, 0, 0, 0, 11597, 11575, 1, 0, 0, 0, 11597, 11585, 1, 0, 0, 0, 11598, 1371, 1, 0, 0, 0, 11599, 11600, 5, 106, 0, 0, 11600, 1373, 1, 0, 0, 0, 11601, 11603, 5, 46, 0, 0, 11602, 11604, 3, 530, 265, 0, 11603, 11602, 1, 0, 0, 0, 11603, 11604, 1, 0, 0, 0, 11604, 11605, 1, 0, 0, 0, 11605, 11606, 5, 170, 0, 0, 11606, 11607, 3, 566, 283, 0, 11607, 11608, 5, 62, 0, 0, 11608, 11609, 3, 1910, 955, 0, 11609, 11610, 5, 95, 0, 0, 11610, 11611, 3, 1910, 955, 0, 11611, 11612, 5, 64, 0, 0, 11612, 11613, 3, 566, 283, 0, 11613, 1375, 1, 0, 0, 0, 11614, 11616, 5, 160, 0, 0, 11615, 11617, 3, 1398, 699, 0, 11616, 11615, 1, 0, 0, 0, 11616, 11617, 1, 0, 0, 0, 11617, 11618, 1, 0, 0, 0, 11618, 11620, 3, 1888, 944, 0, 11619, 11621, 3, 1378, 689, 0, 11620, 11619, 1, 0, 0, 0, 11620, 11621, 1, 0, 0, 0, 11621, 11635, 1, 0, 0, 0, 11622, 11624, 5, 160, 0, 0, 11623, 11625, 3, 1398, 699, 0, 11624, 11623, 1, 0, 0, 0, 11624, 11625, 1, 0, 0, 0, 11625, 11635, 1, 0, 0, 0, 11626, 11628, 5, 160, 0, 0, 11627, 11629, 3, 1398, 699, 0, 11628, 11627, 1, 0, 0, 0, 11628, 11629, 1, 0, 0, 0, 11629, 11630, 1, 0, 0, 0, 11630, 11631, 3, 1892, 946, 0, 11631, 11632, 5, 80, 0, 0, 11632, 11633, 3, 1888, 944, 0, 11633, 11635, 1, 0, 0, 0, 11634, 11614, 1, 0, 0, 0, 11634, 11622, 1, 0, 0, 0, 11634, 11626, 1, 0, 0, 0, 11635, 1377, 1, 0, 0, 0, 11636, 11637, 5, 101, 0, 0, 11637, 11638, 3, 1892, 946, 0, 11638, 1379, 1, 0, 0, 0, 11639, 11641, 5, 368, 0, 0, 11640, 11642, 3, 1400, 700, 0, 11641, 11640, 1, 0, 0, 0, 11641, 11642, 1, 0, 0, 0, 11642, 11644, 1, 0, 0, 0, 11643, 11645, 3, 1402, 701, 0, 11644, 11643, 1, 0, 0, 0, 11644, 11645, 1, 0, 0, 0, 11645, 11647, 1, 0, 0, 0, 11646, 11648, 3, 1398, 699, 0, 11647, 11646, 1, 0, 0, 0, 11647, 11648, 1, 0, 0, 0, 11648, 11650, 1, 0, 0, 0, 11649, 11651, 3, 1396, 698, 0, 11650, 11649, 1, 0, 0, 0, 11650, 11651, 1, 0, 0, 0, 11651, 11653, 1, 0, 0, 0, 11652, 11654, 3, 1410, 705, 0, 11653, 11652, 1, 0, 0, 0, 11653, 11654, 1, 0, 0, 0, 11654, 11679, 1, 0, 0, 0, 11655, 11656, 5, 368, 0, 0, 11656, 11657, 5, 2, 0, 0, 11657, 11658, 3, 1386, 693, 0, 11658, 11660, 5, 3, 0, 0, 11659, 11661, 3, 1410, 705, 0, 11660, 11659, 1, 0, 0, 0, 11660, 11661, 1, 0, 0, 0, 11661, 11679, 1, 0, 0, 0, 11662, 11664, 5, 368, 0, 0, 11663, 11665, 3, 1382, 691, 0, 11664, 11663, 1, 0, 0, 0, 11664, 11665, 1, 0, 0, 0, 11665, 11667, 1, 0, 0, 0, 11666, 11668, 3, 1888, 944, 0, 11667, 11666, 1, 0, 0, 0, 11667, 11668, 1, 0, 0, 0, 11668, 11673, 1, 0, 0, 0, 11669, 11670, 5, 95, 0, 0, 11670, 11671, 3, 1908, 954, 0, 11671, 11672, 5, 849, 0, 0, 11672, 11674, 1, 0, 0, 0, 11673, 11669, 1, 0, 0, 0, 11673, 11674, 1, 0, 0, 0, 11674, 11676, 1, 0, 0, 0, 11675, 11677, 5, 846, 0, 0, 11676, 11675, 1, 0, 0, 0, 11676, 11677, 1, 0, 0, 0, 11677, 11679, 1, 0, 0, 0, 11678, 11639, 1, 0, 0, 0, 11678, 11655, 1, 0, 0, 0, 11678, 11662, 1, 0, 0, 0, 11679, 1381, 1, 0, 0, 0, 11680, 11688, 5, 115, 0, 0, 11681, 11682, 5, 848, 0, 0, 11682, 11688, 5, 81, 0, 0, 11683, 11684, 5, 186, 0, 0, 11684, 11688, 5, 81, 0, 0, 11685, 11688, 5, 304, 0, 0, 11686, 11688, 5, 847, 0, 0, 11687, 11680, 1, 0, 0, 0, 11687, 11681, 1, 0, 0, 0, 11687, 11683, 1, 0, 0, 0, 11687, 11685, 1, 0, 0, 0, 11687, 11686, 1, 0, 0, 0, 11688, 1383, 1, 0, 0, 0, 11689, 11691, 3, 1388, 694, 0, 11690, 11692, 3, 1398, 699, 0, 11691, 11690, 1, 0, 0, 0, 11691, 11692, 1, 0, 0, 0, 11692, 11700, 1, 0, 0, 0, 11693, 11698, 3, 1888, 944, 0, 11694, 11695, 5, 2, 0, 0, 11695, 11696, 3, 246, 123, 0, 11696, 11697, 5, 3, 0, 0, 11697, 11699, 1, 0, 0, 0, 11698, 11694, 1, 0, 0, 0, 11698, 11699, 1, 0, 0, 0, 11699, 11701, 1, 0, 0, 0, 11700, 11693, 1, 0, 0, 0, 11700, 11701, 1, 0, 0, 0, 11701, 11706, 1, 0, 0, 0, 11702, 11703, 5, 287, 0, 0, 11703, 11707, 5, 674, 0, 0, 11704, 11705, 5, 30, 0, 0, 11705, 11707, 5, 674, 0, 0, 11706, 11702, 1, 0, 0, 0, 11706, 11704, 1, 0, 0, 0, 11706, 11707, 1, 0, 0, 0, 11707, 1385, 1, 0, 0, 0, 11708, 11713, 3, 1390, 695, 0, 11709, 11710, 5, 6, 0, 0, 11710, 11712, 3, 1390, 695, 0, 11711, 11709, 1, 0, 0, 0, 11712, 11715, 1, 0, 0, 0, 11713, 11711, 1, 0, 0, 0, 11713, 11714, 1, 0, 0, 0, 11714, 1387, 1, 0, 0, 0, 11715, 11713, 1, 0, 0, 0, 11716, 11717, 7, 69, 0, 0, 11717, 1389, 1, 0, 0, 0, 11718, 11720, 3, 1392, 696, 0, 11719, 11721, 3, 1394, 697, 0, 11720, 11719, 1, 0, 0, 0, 11720, 11721, 1, 0, 0, 0, 11721, 1391, 1, 0, 0, 0, 11722, 11725, 3, 1930, 965, 0, 11723, 11725, 3, 1388, 694, 0, 11724, 11722, 1, 0, 0, 0, 11724, 11723, 1, 0, 0, 0, 11725, 1393, 1, 0, 0, 0, 11726, 11729, 3, 76, 38, 0, 11727, 11729, 3, 334, 167, 0, 11728, 11726, 1, 0, 0, 0, 11728, 11727, 1, 0, 0, 0, 11729, 1395, 1, 0, 0, 0, 11730, 11731, 3, 1388, 694, 0, 11731, 1397, 1, 0, 0, 0, 11732, 11733, 5, 130, 0, 0, 11733, 1399, 1, 0, 0, 0, 11734, 11735, 5, 115, 0, 0, 11735, 1401, 1, 0, 0, 0, 11736, 11737, 5, 114, 0, 0, 11737, 1403, 1, 0, 0, 0, 11738, 11739, 5, 2, 0, 0, 11739, 11740, 3, 1890, 945, 0, 11740, 11741, 5, 3, 0, 0, 11741, 1405, 1, 0, 0, 0, 11742, 11744, 3, 1888, 944, 0, 11743, 11745, 3, 1404, 702, 0, 11744, 11743, 1, 0, 0, 0, 11744, 11745, 1, 0, 0, 0, 11745, 1407, 1, 0, 0, 0, 11746, 11751, 3, 1406, 703, 0, 11747, 11748, 5, 6, 0, 0, 11748, 11750, 3, 1406, 703, 0, 11749, 11747, 1, 0, 0, 0, 11750, 11753, 1, 0, 0, 0, 11751, 11749, 1, 0, 0, 0, 11751, 11752, 1, 0, 0, 0, 11752, 1409, 1, 0, 0, 0, 11753, 11751, 1, 0, 0, 0, 11754, 11755, 3, 1408, 704, 0, 11755, 1411, 1, 0, 0, 0, 11756, 11757, 5, 207, 0, 0, 11757, 11775, 3, 1414, 707, 0, 11758, 11759, 5, 207, 0, 0, 11759, 11761, 3, 1388, 694, 0, 11760, 11762, 3, 1398, 699, 0, 11761, 11760, 1, 0, 0, 0, 11761, 11762, 1, 0, 0, 0, 11762, 11763, 1, 0, 0, 0, 11763, 11764, 3, 1414, 707, 0, 11764, 11775, 1, 0, 0, 0, 11765, 11766, 5, 207, 0, 0, 11766, 11767, 5, 130, 0, 0, 11767, 11775, 3, 1414, 707, 0, 11768, 11769, 5, 207, 0, 0, 11769, 11770, 5, 2, 0, 0, 11770, 11771, 3, 1416, 708, 0, 11771, 11772, 5, 3, 0, 0, 11772, 11773, 3, 1414, 707, 0, 11773, 11775, 1, 0, 0, 0, 11774, 11756, 1, 0, 0, 0, 11774, 11758, 1, 0, 0, 0, 11774, 11765, 1, 0, 0, 0, 11774, 11768, 1, 0, 0, 0, 11775, 1413, 1, 0, 0, 0, 11776, 11786, 3, 1496, 748, 0, 11777, 11786, 3, 1436, 718, 0, 11778, 11786, 3, 1478, 739, 0, 11779, 11786, 3, 1464, 732, 0, 11780, 11786, 3, 1488, 744, 0, 11781, 11786, 3, 302, 151, 0, 11782, 11786, 3, 314, 157, 0, 11783, 11786, 3, 318, 159, 0, 11784, 11786, 3, 1430, 715, 0, 11785, 11776, 1, 0, 0, 0, 11785, 11777, 1, 0, 0, 0, 11785, 11778, 1, 0, 0, 0, 11785, 11779, 1, 0, 0, 0, 11785, 11780, 1, 0, 0, 0, 11785, 11781, 1, 0, 0, 0, 11785, 11782, 1, 0, 0, 0, 11785, 11783, 1, 0, 0, 0, 11785, 11784, 1, 0, 0, 0, 11786, 1415, 1, 0, 0, 0, 11787, 11792, 3, 1418, 709, 0, 11788, 11789, 5, 6, 0, 0, 11789, 11791, 3, 1418, 709, 0, 11790, 11788, 1, 0, 0, 0, 11791, 11794, 1, 0, 0, 0, 11792, 11790, 1, 0, 0, 0, 11792, 11793, 1, 0, 0, 0, 11793, 1417, 1, 0, 0, 0, 11794, 11792, 1, 0, 0, 0, 11795, 11797, 3, 1420, 710, 0, 11796, 11798, 3, 1422, 711, 0, 11797, 11796, 1, 0, 0, 0, 11797, 11798, 1, 0, 0, 0, 11798, 1419, 1, 0, 0, 0, 11799, 11802, 3, 1930, 965, 0, 11800, 11802, 3, 1388, 694, 0, 11801, 11799, 1, 0, 0, 0, 11801, 11800, 1, 0, 0, 0, 11802, 1421, 1, 0, 0, 0, 11803, 11806, 3, 76, 38, 0, 11804, 11806, 3, 334, 167, 0, 11805, 11803, 1, 0, 0, 0, 11805, 11804, 1, 0, 0, 0, 11806, 1423, 1, 0, 0, 0, 11807, 11808, 5, 288, 0, 0, 11808, 11810, 3, 1892, 946, 0, 11809, 11811, 3, 1426, 713, 0, 11810, 11809, 1, 0, 0, 0, 11810, 11811, 1, 0, 0, 0, 11811, 11812, 1, 0, 0, 0, 11812, 11813, 5, 36, 0, 0, 11813, 11814, 3, 1428, 714, 0, 11814, 1425, 1, 0, 0, 0, 11815, 11816, 5, 2, 0, 0, 11816, 11817, 3, 1836, 918, 0, 11817, 11818, 5, 3, 0, 0, 11818, 1427, 1, 0, 0, 0, 11819, 11825, 3, 1496, 748, 0, 11820, 11825, 3, 1436, 718, 0, 11821, 11825, 3, 1478, 739, 0, 11822, 11825, 3, 1464, 732, 0, 11823, 11825, 3, 1454, 727, 0, 11824, 11819, 1, 0, 0, 0, 11824, 11820, 1, 0, 0, 0, 11824, 11821, 1, 0, 0, 0, 11824, 11822, 1, 0, 0, 0, 11824, 11823, 1, 0, 0, 0, 11825, 1429, 1, 0, 0, 0, 11826, 11827, 5, 206, 0, 0, 11827, 11829, 3, 1892, 946, 0, 11828, 11830, 3, 1432, 716, 0, 11829, 11828, 1, 0, 0, 0, 11829, 11830, 1, 0, 0, 0, 11830, 11865, 1, 0, 0, 0, 11831, 11833, 5, 46, 0, 0, 11832, 11834, 3, 198, 99, 0, 11833, 11832, 1, 0, 0, 0, 11833, 11834, 1, 0, 0, 0, 11834, 11835, 1, 0, 0, 0, 11835, 11836, 5, 93, 0, 0, 11836, 11837, 3, 304, 152, 0, 11837, 11838, 5, 36, 0, 0, 11838, 11839, 5, 206, 0, 0, 11839, 11841, 3, 1892, 946, 0, 11840, 11842, 3, 1432, 716, 0, 11841, 11840, 1, 0, 0, 0, 11841, 11842, 1, 0, 0, 0, 11842, 11844, 1, 0, 0, 0, 11843, 11845, 3, 312, 156, 0, 11844, 11843, 1, 0, 0, 0, 11844, 11845, 1, 0, 0, 0, 11845, 11865, 1, 0, 0, 0, 11846, 11848, 5, 46, 0, 0, 11847, 11849, 3, 198, 99, 0, 11848, 11847, 1, 0, 0, 0, 11848, 11849, 1, 0, 0, 0, 11849, 11850, 1, 0, 0, 0, 11850, 11851, 5, 93, 0, 0, 11851, 11852, 5, 224, 0, 0, 11852, 11853, 5, 77, 0, 0, 11853, 11854, 5, 558, 0, 0, 11854, 11855, 3, 304, 152, 0, 11855, 11856, 5, 36, 0, 0, 11856, 11857, 5, 206, 0, 0, 11857, 11859, 3, 1892, 946, 0, 11858, 11860, 3, 1432, 716, 0, 11859, 11858, 1, 0, 0, 0, 11859, 11860, 1, 0, 0, 0, 11860, 11862, 1, 0, 0, 0, 11861, 11863, 3, 312, 156, 0, 11862, 11861, 1, 0, 0, 0, 11862, 11863, 1, 0, 0, 0, 11863, 11865, 1, 0, 0, 0, 11864, 11826, 1, 0, 0, 0, 11864, 11831, 1, 0, 0, 0, 11864, 11846, 1, 0, 0, 0, 11865, 1431, 1, 0, 0, 0, 11866, 11867, 5, 2, 0, 0, 11867, 11868, 3, 1830, 915, 0, 11868, 11869, 5, 3, 0, 0, 11869, 1433, 1, 0, 0, 0, 11870, 11871, 5, 181, 0, 0, 11871, 11881, 3, 1892, 946, 0, 11872, 11873, 5, 181, 0, 0, 11873, 11874, 5, 288, 0, 0, 11874, 11881, 3, 1892, 946, 0, 11875, 11876, 5, 181, 0, 0, 11876, 11881, 5, 30, 0, 0, 11877, 11878, 5, 181, 0, 0, 11878, 11879, 5, 288, 0, 0, 11879, 11881, 5, 30, 0, 0, 11880, 11870, 1, 0, 0, 0, 11880, 11872, 1, 0, 0, 0, 11880, 11875, 1, 0, 0, 0, 11880, 11877, 1, 0, 0, 0, 11881, 1435, 1, 0, 0, 0, 11882, 11884, 3, 1522, 761, 0, 11883, 11882, 1, 0, 0, 0, 11883, 11884, 1, 0, 0, 0, 11884, 11885, 1, 0, 0, 0, 11885, 11886, 5, 236, 0, 0, 11886, 11887, 5, 71, 0, 0, 11887, 11888, 3, 1438, 719, 0, 11888, 11890, 3, 1440, 720, 0, 11889, 11891, 3, 1448, 724, 0, 11890, 11889, 1, 0, 0, 0, 11890, 11891, 1, 0, 0, 0, 11891, 11893, 1, 0, 0, 0, 11892, 11894, 3, 1452, 726, 0, 11893, 11892, 1, 0, 0, 0, 11893, 11894, 1, 0, 0, 0, 11894, 1437, 1, 0, 0, 0, 11895, 11898, 3, 1888, 944, 0, 11896, 11897, 5, 36, 0, 0, 11897, 11899, 3, 1924, 962, 0, 11898, 11896, 1, 0, 0, 0, 11898, 11899, 1, 0, 0, 0, 11899, 1439, 1, 0, 0, 0, 11900, 11920, 3, 1496, 748, 0, 11901, 11902, 5, 662, 0, 0, 11902, 11903, 3, 1442, 721, 0, 11903, 11904, 5, 649, 0, 0, 11904, 11905, 3, 1496, 748, 0, 11905, 11920, 1, 0, 0, 0, 11906, 11907, 5, 2, 0, 0, 11907, 11908, 3, 1444, 722, 0, 11908, 11913, 5, 3, 0, 0, 11909, 11910, 5, 662, 0, 0, 11910, 11911, 3, 1442, 721, 0, 11911, 11912, 5, 649, 0, 0, 11912, 11914, 1, 0, 0, 0, 11913, 11909, 1, 0, 0, 0, 11913, 11914, 1, 0, 0, 0, 11914, 11915, 1, 0, 0, 0, 11915, 11916, 3, 1496, 748, 0, 11916, 11920, 1, 0, 0, 0, 11917, 11918, 5, 53, 0, 0, 11918, 11920, 5, 585, 0, 0, 11919, 11900, 1, 0, 0, 0, 11919, 11901, 1, 0, 0, 0, 11919, 11906, 1, 0, 0, 0, 11919, 11917, 1, 0, 0, 0, 11920, 1441, 1, 0, 0, 0, 11921, 11922, 7, 75, 0, 0, 11922, 1443, 1, 0, 0, 0, 11923, 11928, 3, 1446, 723, 0, 11924, 11925, 5, 6, 0, 0, 11925, 11927, 3, 1446, 723, 0, 11926, 11924, 1, 0, 0, 0, 11927, 11930, 1, 0, 0, 0, 11928, 11926, 1, 0, 0, 0, 11928, 11929, 1, 0, 0, 0, 11929, 1445, 1, 0, 0, 0, 11930, 11928, 1, 0, 0, 0, 11931, 11932, 3, 1924, 962, 0, 11932, 11933, 3, 1876, 938, 0, 11933, 1447, 1, 0, 0, 0, 11934, 11935, 5, 80, 0, 0, 11935, 11937, 5, 663, 0, 0, 11936, 11938, 3, 1450, 725, 0, 11937, 11936, 1, 0, 0, 0, 11937, 11938, 1, 0, 0, 0, 11938, 11939, 1, 0, 0, 0, 11939, 11947, 5, 57, 0, 0, 11940, 11941, 5, 367, 0, 0, 11941, 11942, 5, 331, 0, 0, 11942, 11944, 3, 1480, 740, 0, 11943, 11945, 3, 1638, 819, 0, 11944, 11943, 1, 0, 0, 0, 11944, 11945, 1, 0, 0, 0, 11945, 11948, 1, 0, 0, 0, 11946, 11948, 5, 267, 0, 0, 11947, 11940, 1, 0, 0, 0, 11947, 11946, 1, 0, 0, 0, 11948, 1449, 1, 0, 0, 0, 11949, 11950, 5, 2, 0, 0, 11950, 11951, 3, 808, 404, 0, 11951, 11953, 5, 3, 0, 0, 11952, 11954, 3, 1638, 819, 0, 11953, 11952, 1, 0, 0, 0, 11953, 11954, 1, 0, 0, 0, 11954, 11959, 1, 0, 0, 0, 11955, 11956, 5, 80, 0, 0, 11956, 11957, 5, 45, 0, 0, 11957, 11959, 3, 1892, 946, 0, 11958, 11949, 1, 0, 0, 0, 11958, 11955, 1, 0, 0, 0, 11959, 1451, 1, 0, 0, 0, 11960, 11961, 5, 88, 0, 0, 11961, 11962, 3, 1880, 940, 0, 11962, 1453, 1, 0, 0, 0, 11963, 11965, 3, 1514, 757, 0, 11964, 11963, 1, 0, 0, 0, 11964, 11965, 1, 0, 0, 0, 11965, 11966, 1, 0, 0, 0, 11966, 11967, 5, 257, 0, 0, 11967, 11969, 5, 71, 0, 0, 11968, 11970, 5, 81, 0, 0, 11969, 11968, 1, 0, 0, 0, 11969, 11970, 1, 0, 0, 0, 11970, 11971, 1, 0, 0, 0, 11971, 11973, 3, 1888, 944, 0, 11972, 11974, 3, 1606, 803, 0, 11973, 11972, 1, 0, 0, 0, 11973, 11974, 1, 0, 0, 0, 11974, 11975, 1, 0, 0, 0, 11975, 11978, 5, 101, 0, 0, 11976, 11979, 3, 1498, 749, 0, 11977, 11979, 3, 1888, 944, 0, 11978, 11976, 1, 0, 0, 0, 11978, 11977, 1, 0, 0, 0, 11979, 11981, 1, 0, 0, 0, 11980, 11982, 3, 1606, 803, 0, 11981, 11980, 1, 0, 0, 0, 11981, 11982, 1, 0, 0, 0, 11982, 11983, 1, 0, 0, 0, 11983, 11984, 5, 80, 0, 0, 11984, 11992, 3, 1710, 855, 0, 11985, 11987, 3, 1456, 728, 0, 11986, 11985, 1, 0, 0, 0, 11987, 11988, 1, 0, 0, 0, 11988, 11986, 1, 0, 0, 0, 11988, 11989, 1, 0, 0, 0, 11989, 11993, 1, 0, 0, 0, 11990, 11991, 5, 472, 0, 0, 11991, 11993, 5, 473, 0, 0, 11992, 11986, 1, 0, 0, 0, 11992, 11990, 1, 0, 0, 0, 11993, 1455, 1, 0, 0, 0, 11994, 11998, 3, 1458, 729, 0, 11995, 11998, 3, 1460, 730, 0, 11996, 11998, 3, 1462, 731, 0, 11997, 11994, 1, 0, 0, 0, 11997, 11995, 1, 0, 0, 0, 11997, 11996, 1, 0, 0, 0, 11998, 1457, 1, 0, 0, 0, 11999, 12000, 5, 103, 0, 0, 12000, 12001, 5, 77, 0, 0, 12001, 12004, 5, 254, 0, 0, 12002, 12003, 5, 33, 0, 0, 12003, 12005, 3, 1710, 855, 0, 12004, 12002, 1, 0, 0, 0, 12004, 12005, 1, 0, 0, 0, 12005, 12007, 1, 0, 0, 0, 12006, 12008, 5, 94, 0, 0, 12007, 12006, 1, 0, 0, 0, 12007, 12008, 1, 0, 0, 0, 12008, 12009, 1, 0, 0, 0, 12009, 12014, 5, 236, 0, 0, 12010, 12011, 5, 2, 0, 0, 12011, 12012, 3, 1444, 722, 0, 12012, 12013, 5, 3, 0, 0, 12013, 12015, 1, 0, 0, 0, 12014, 12010, 1, 0, 0, 0, 12014, 12015, 1, 0, 0, 0, 12015, 12016, 1, 0, 0, 0, 12016, 12017, 3, 1596, 798, 0, 12017, 1459, 1, 0, 0, 0, 12018, 12019, 5, 103, 0, 0, 12019, 12022, 5, 254, 0, 0, 12020, 12021, 5, 33, 0, 0, 12021, 12023, 3, 1710, 855, 0, 12022, 12020, 1, 0, 0, 0, 12022, 12023, 1, 0, 0, 0, 12023, 12025, 1, 0, 0, 0, 12024, 12026, 5, 94, 0, 0, 12025, 12024, 1, 0, 0, 0, 12025, 12026, 1, 0, 0, 0, 12026, 12027, 1, 0, 0, 0, 12027, 12028, 5, 367, 0, 0, 12028, 12029, 5, 331, 0, 0, 12029, 12030, 3, 1480, 740, 0, 12030, 1461, 1, 0, 0, 0, 12031, 12032, 5, 103, 0, 0, 12032, 12035, 5, 254, 0, 0, 12033, 12034, 5, 33, 0, 0, 12034, 12036, 3, 1710, 855, 0, 12035, 12033, 1, 0, 0, 0, 12035, 12036, 1, 0, 0, 0, 12036, 12038, 1, 0, 0, 0, 12037, 12039, 5, 94, 0, 0, 12038, 12037, 1, 0, 0, 0, 12038, 12039, 1, 0, 0, 0, 12039, 12040, 1, 0, 0, 0, 12040, 12041, 5, 186, 0, 0, 12041, 1463, 1, 0, 0, 0, 12042, 12044, 3, 1522, 761, 0, 12043, 12042, 1, 0, 0, 0, 12043, 12044, 1, 0, 0, 0, 12044, 12045, 1, 0, 0, 0, 12045, 12047, 5, 186, 0, 0, 12046, 12048, 5, 64, 0, 0, 12047, 12046, 1, 0, 0, 0, 12047, 12048, 1, 0, 0, 0, 12048, 12049, 1, 0, 0, 0, 12049, 12051, 3, 1622, 811, 0, 12050, 12052, 3, 1466, 733, 0, 12051, 12050, 1, 0, 0, 0, 12051, 12052, 1, 0, 0, 0, 12052, 12054, 1, 0, 0, 0, 12053, 12055, 3, 1640, 820, 0, 12054, 12053, 1, 0, 0, 0, 12054, 12055, 1, 0, 0, 0, 12055, 12057, 1, 0, 0, 0, 12056, 12058, 3, 1452, 726, 0, 12057, 12056, 1, 0, 0, 0, 12057, 12058, 1, 0, 0, 0, 12058, 1465, 1, 0, 0, 0, 12059, 12060, 5, 101, 0, 0, 12060, 12061, 3, 1600, 800, 0, 12061, 1467, 1, 0, 0, 0, 12062, 12064, 5, 251, 0, 0, 12063, 12065, 3, 1532, 766, 0, 12064, 12063, 1, 0, 0, 0, 12064, 12065, 1, 0, 0, 0, 12065, 12066, 1, 0, 0, 0, 12066, 12068, 3, 1620, 810, 0, 12067, 12069, 3, 1470, 735, 0, 12068, 12067, 1, 0, 0, 0, 12068, 12069, 1, 0, 0, 0, 12069, 12071, 1, 0, 0, 0, 12070, 12072, 3, 1474, 737, 0, 12071, 12070, 1, 0, 0, 0, 12071, 12072, 1, 0, 0, 0, 12072, 1469, 1, 0, 0, 0, 12073, 12074, 5, 68, 0, 0, 12074, 12075, 3, 1472, 736, 0, 12075, 12076, 5, 260, 0, 0, 12076, 1471, 1, 0, 0, 0, 12077, 12078, 5, 133, 0, 0, 12078, 12090, 7, 76, 0, 0, 12079, 12080, 5, 577, 0, 0, 12080, 12090, 7, 76, 0, 0, 12081, 12086, 5, 332, 0, 0, 12082, 12083, 5, 367, 0, 0, 12083, 12087, 5, 205, 0, 0, 12084, 12085, 5, 577, 0, 0, 12085, 12087, 5, 205, 0, 0, 12086, 12082, 1, 0, 0, 0, 12086, 12084, 1, 0, 0, 0, 12086, 12087, 1, 0, 0, 0, 12087, 12090, 1, 0, 0, 0, 12088, 12090, 5, 205, 0, 0, 12089, 12077, 1, 0, 0, 0, 12089, 12079, 1, 0, 0, 0, 12089, 12081, 1, 0, 0, 0, 12089, 12088, 1, 0, 0, 0, 12090, 1473, 1, 0, 0, 0, 12091, 12092, 5, 269, 0, 0, 12092, 1475, 1, 0, 0, 0, 12093, 12097, 5, 269, 0, 0, 12094, 12095, 5, 664, 0, 0, 12095, 12097, 5, 665, 0, 0, 12096, 12093, 1, 0, 0, 0, 12096, 12094, 1, 0, 0, 0, 12097, 1477, 1, 0, 0, 0, 12098, 12100, 3, 1522, 761, 0, 12099, 12098, 1, 0, 0, 0, 12099, 12100, 1, 0, 0, 0, 12100, 12101, 1, 0, 0, 0, 12101, 12102, 5, 367, 0, 0, 12102, 12103, 3, 1622, 811, 0, 12103, 12104, 5, 331, 0, 0, 12104, 12106, 3, 1480, 740, 0, 12105, 12107, 3, 1598, 799, 0, 12106, 12105, 1, 0, 0, 0, 12106, 12107, 1, 0, 0, 0, 12107, 12109, 1, 0, 0, 0, 12108, 12110, 3, 1640, 820, 0, 12109, 12108, 1, 0, 0, 0, 12109, 12110, 1, 0, 0, 0, 12110, 12112, 1, 0, 0, 0, 12111, 12113, 3, 1452, 726, 0, 12112, 12111, 1, 0, 0, 0, 12112, 12113, 1, 0, 0, 0, 12113, 1479, 1, 0, 0, 0, 12114, 12119, 3, 1482, 741, 0, 12115, 12116, 5, 6, 0, 0, 12116, 12118, 3, 1482, 741, 0, 12117, 12115, 1, 0, 0, 0, 12118, 12121, 1, 0, 0, 0, 12119, 12117, 1, 0, 0, 0, 12119, 12120, 1, 0, 0, 0, 12120, 1481, 1, 0, 0, 0, 12121, 12119, 1, 0, 0, 0, 12122, 12123, 3, 1484, 742, 0, 12123, 12124, 5, 10, 0, 0, 12124, 12125, 3, 1710, 855, 0, 12125, 12133, 1, 0, 0, 0, 12126, 12127, 5, 2, 0, 0, 12127, 12128, 3, 1486, 743, 0, 12128, 12129, 5, 3, 0, 0, 12129, 12130, 5, 10, 0, 0, 12130, 12131, 3, 1710, 855, 0, 12131, 12133, 1, 0, 0, 0, 12132, 12122, 1, 0, 0, 0, 12132, 12126, 1, 0, 0, 0, 12133, 1483, 1, 0, 0, 0, 12134, 12135, 3, 1924, 962, 0, 12135, 12136, 3, 1876, 938, 0, 12136, 1485, 1, 0, 0, 0, 12137, 12142, 3, 1484, 742, 0, 12138, 12139, 5, 6, 0, 0, 12139, 12141, 3, 1484, 742, 0, 12140, 12138, 1, 0, 0, 0, 12141, 12144, 1, 0, 0, 0, 12142, 12140, 1, 0, 0, 0, 12142, 12143, 1, 0, 0, 0, 12143, 1487, 1, 0, 0, 0, 12144, 12142, 1, 0, 0, 0, 12145, 12146, 5, 182, 0, 0, 12146, 12147, 3, 1490, 745, 0, 12147, 12148, 3, 1492, 746, 0, 12148, 12150, 5, 175, 0, 0, 12149, 12151, 3, 1494, 747, 0, 12150, 12149, 1, 0, 0, 0, 12150, 12151, 1, 0, 0, 0, 12151, 12152, 1, 0, 0, 0, 12152, 12153, 5, 62, 0, 0, 12153, 12154, 3, 1496, 748, 0, 12154, 1489, 1, 0, 0, 0, 12155, 12156, 3, 1892, 946, 0, 12156, 1491, 1, 0, 0, 0, 12157, 12158, 5, 266, 0, 0, 12158, 12163, 5, 322, 0, 0, 12159, 12163, 5, 322, 0, 0, 12160, 12163, 5, 108, 0, 0, 12161, 12163, 5, 235, 0, 0, 12162, 12157, 1, 0, 0, 0, 12162, 12159, 1, 0, 0, 0, 12162, 12160, 1, 0, 0, 0, 12162, 12161, 1, 0, 0, 0, 12163, 12166, 1, 0, 0, 0, 12164, 12162, 1, 0, 0, 0, 12164, 12165, 1, 0, 0, 0, 12165, 1493, 1, 0, 0, 0, 12166, 12164, 1, 0, 0, 0, 12167, 12168, 5, 106, 0, 0, 12168, 12172, 5, 221, 0, 0, 12169, 12170, 5, 377, 0, 0, 12170, 12172, 5, 221, 0, 0, 12171, 12167, 1, 0, 0, 0, 12171, 12169, 1, 0, 0, 0, 12172, 1495, 1, 0, 0, 0, 12173, 12176, 3, 1500, 750, 0, 12174, 12176, 3, 1498, 749, 0, 12175, 12173, 1, 0, 0, 0, 12175, 12174, 1, 0, 0, 0, 12176, 1497, 1, 0, 0, 0, 12177, 12178, 5, 2, 0, 0, 12178, 12179, 3, 1500, 750, 0, 12179, 12180, 5, 3, 0, 0, 12180, 12186, 1, 0, 0, 0, 12181, 12182, 5, 2, 0, 0, 12182, 12183, 3, 1498, 749, 0, 12183, 12184, 5, 3, 0, 0, 12184, 12186, 1, 0, 0, 0, 12185, 12177, 1, 0, 0, 0, 12185, 12181, 1, 0, 0, 0, 12186, 1499, 1, 0, 0, 0, 12187, 12189, 3, 1502, 751, 0, 12188, 12190, 3, 1540, 770, 0, 12189, 12188, 1, 0, 0, 0, 12189, 12190, 1, 0, 0, 0, 12190, 12199, 1, 0, 0, 0, 12191, 12193, 3, 1584, 792, 0, 12192, 12194, 3, 1550, 775, 0, 12193, 12192, 1, 0, 0, 0, 12193, 12194, 1, 0, 0, 0, 12194, 12200, 1, 0, 0, 0, 12195, 12197, 3, 1548, 774, 0, 12196, 12198, 3, 1586, 793, 0, 12197, 12196, 1, 0, 0, 0, 12197, 12198, 1, 0, 0, 0, 12198, 12200, 1, 0, 0, 0, 12199, 12191, 1, 0, 0, 0, 12199, 12195, 1, 0, 0, 0, 12199, 12200, 1, 0, 0, 0, 12200, 12217, 1, 0, 0, 0, 12201, 12202, 3, 1514, 757, 0, 12202, 12204, 3, 1502, 751, 0, 12203, 12205, 3, 1540, 770, 0, 12204, 12203, 1, 0, 0, 0, 12204, 12205, 1, 0, 0, 0, 12205, 12214, 1, 0, 0, 0, 12206, 12208, 3, 1584, 792, 0, 12207, 12209, 3, 1550, 775, 0, 12208, 12207, 1, 0, 0, 0, 12208, 12209, 1, 0, 0, 0, 12209, 12215, 1, 0, 0, 0, 12210, 12212, 3, 1548, 774, 0, 12211, 12213, 3, 1586, 793, 0, 12212, 12211, 1, 0, 0, 0, 12212, 12213, 1, 0, 0, 0, 12213, 12215, 1, 0, 0, 0, 12214, 12206, 1, 0, 0, 0, 12214, 12210, 1, 0, 0, 0, 12214, 12215, 1, 0, 0, 0, 12215, 12217, 1, 0, 0, 0, 12216, 12187, 1, 0, 0, 0, 12216, 12201, 1, 0, 0, 0, 12217, 1501, 1, 0, 0, 0, 12218, 12226, 3, 1504, 752, 0, 12219, 12221, 7, 77, 0, 0, 12220, 12222, 3, 1534, 767, 0, 12221, 12220, 1, 0, 0, 0, 12221, 12222, 1, 0, 0, 0, 12222, 12223, 1, 0, 0, 0, 12223, 12225, 3, 1504, 752, 0, 12224, 12219, 1, 0, 0, 0, 12225, 12228, 1, 0, 0, 0, 12226, 12224, 1, 0, 0, 0, 12226, 12227, 1, 0, 0, 0, 12227, 1503, 1, 0, 0, 0, 12228, 12226, 1, 0, 0, 0, 12229, 12237, 3, 1506, 753, 0, 12230, 12232, 5, 70, 0, 0, 12231, 12233, 3, 1534, 767, 0, 12232, 12231, 1, 0, 0, 0, 12232, 12233, 1, 0, 0, 0, 12233, 12234, 1, 0, 0, 0, 12234, 12236, 3, 1506, 753, 0, 12235, 12230, 1, 0, 0, 0, 12236, 12239, 1, 0, 0, 0, 12237, 12235, 1, 0, 0, 0, 12237, 12238, 1, 0, 0, 0, 12238, 1505, 1, 0, 0, 0, 12239, 12237, 1, 0, 0, 0, 12240, 12260, 5, 89, 0, 0, 12241, 12243, 3, 1538, 769, 0, 12242, 12241, 1, 0, 0, 0, 12242, 12243, 1, 0, 0, 0, 12243, 12245, 1, 0, 0, 0, 12244, 12246, 3, 1524, 762, 0, 12245, 12244, 1, 0, 0, 0, 12245, 12246, 1, 0, 0, 0, 12246, 12248, 1, 0, 0, 0, 12247, 12249, 3, 1878, 939, 0, 12248, 12247, 1, 0, 0, 0, 12248, 12249, 1, 0, 0, 0, 12249, 12261, 1, 0, 0, 0, 12250, 12252, 3, 1526, 763, 0, 12251, 12250, 1, 0, 0, 0, 12251, 12252, 1, 0, 0, 0, 12252, 12254, 1, 0, 0, 0, 12253, 12255, 3, 1524, 762, 0, 12254, 12253, 1, 0, 0, 0, 12254, 12255, 1, 0, 0, 0, 12255, 12256, 1, 0, 0, 0, 12256, 12261, 3, 1880, 940, 0, 12257, 12258, 3, 1536, 768, 0, 12258, 12259, 3, 1880, 940, 0, 12259, 12261, 1, 0, 0, 0, 12260, 12242, 1, 0, 0, 0, 12260, 12251, 1, 0, 0, 0, 12260, 12257, 1, 0, 0, 0, 12261, 12263, 1, 0, 0, 0, 12262, 12264, 3, 1508, 754, 0, 12263, 12262, 1, 0, 0, 0, 12263, 12264, 1, 0, 0, 0, 12264, 12266, 1, 0, 0, 0, 12265, 12267, 3, 1524, 762, 0, 12266, 12265, 1, 0, 0, 0, 12266, 12267, 1, 0, 0, 0, 12267, 12269, 1, 0, 0, 0, 12268, 12270, 3, 1598, 799, 0, 12269, 12268, 1, 0, 0, 0, 12269, 12270, 1, 0, 0, 0, 12270, 12272, 1, 0, 0, 0, 12271, 12273, 3, 1638, 819, 0, 12272, 12271, 1, 0, 0, 0, 12272, 12273, 1, 0, 0, 0, 12273, 12275, 1, 0, 0, 0, 12274, 12276, 3, 1512, 756, 0, 12275, 12274, 1, 0, 0, 0, 12275, 12276, 1, 0, 0, 0, 12276, 12278, 1, 0, 0, 0, 12277, 12279, 3, 1568, 784, 0, 12278, 12277, 1, 0, 0, 0, 12278, 12279, 1, 0, 0, 0, 12279, 12281, 1, 0, 0, 0, 12280, 12282, 3, 1582, 791, 0, 12281, 12280, 1, 0, 0, 0, 12281, 12282, 1, 0, 0, 0, 12282, 12284, 1, 0, 0, 0, 12283, 12285, 3, 1510, 755, 0, 12284, 12283, 1, 0, 0, 0, 12284, 12285, 1, 0, 0, 0, 12285, 12287, 1, 0, 0, 0, 12286, 12288, 3, 1790, 895, 0, 12287, 12286, 1, 0, 0, 0, 12287, 12288, 1, 0, 0, 0, 12288, 12294, 1, 0, 0, 0, 12289, 12294, 3, 1596, 798, 0, 12290, 12291, 5, 93, 0, 0, 12291, 12294, 3, 1618, 809, 0, 12292, 12294, 3, 1498, 749, 0, 12293, 12240, 1, 0, 0, 0, 12293, 12289, 1, 0, 0, 0, 12293, 12290, 1, 0, 0, 0, 12293, 12292, 1, 0, 0, 0, 12294, 1507, 1, 0, 0, 0, 12295, 12296, 5, 203, 0, 0, 12296, 12297, 5, 2, 0, 0, 12297, 12298, 3, 246, 123, 0, 12298, 12299, 5, 3, 0, 0, 12299, 1509, 1, 0, 0, 0, 12300, 12301, 5, 385, 0, 0, 12301, 12302, 3, 1710, 855, 0, 12302, 1511, 1, 0, 0, 0, 12303, 12304, 5, 338, 0, 0, 12304, 12305, 5, 106, 0, 0, 12305, 12307, 3, 1710, 855, 0, 12306, 12303, 1, 0, 0, 0, 12306, 12307, 1, 0, 0, 0, 12307, 12308, 1, 0, 0, 0, 12308, 12309, 5, 386, 0, 0, 12309, 12310, 5, 149, 0, 0, 12310, 12311, 3, 1710, 855, 0, 12311, 1513, 1, 0, 0, 0, 12312, 12314, 5, 106, 0, 0, 12313, 12315, 5, 301, 0, 0, 12314, 12313, 1, 0, 0, 0, 12314, 12315, 1, 0, 0, 0, 12315, 12316, 1, 0, 0, 0, 12316, 12317, 3, 1516, 758, 0, 12317, 1515, 1, 0, 0, 0, 12318, 12323, 3, 1518, 759, 0, 12319, 12320, 5, 6, 0, 0, 12320, 12322, 3, 1518, 759, 0, 12321, 12319, 1, 0, 0, 0, 12322, 12325, 1, 0, 0, 0, 12323, 12321, 1, 0, 0, 0, 12323, 12324, 1, 0, 0, 0, 12324, 1517, 1, 0, 0, 0, 12325, 12323, 1, 0, 0, 0, 12326, 12328, 3, 1892, 946, 0, 12327, 12329, 3, 1404, 702, 0, 12328, 12327, 1, 0, 0, 0, 12328, 12329, 1, 0, 0, 0, 12329, 12330, 1, 0, 0, 0, 12330, 12332, 5, 36, 0, 0, 12331, 12333, 3, 1520, 760, 0, 12332, 12331, 1, 0, 0, 0, 12332, 12333, 1, 0, 0, 0, 12333, 12334, 1, 0, 0, 0, 12334, 12335, 5, 2, 0, 0, 12335, 12336, 3, 1428, 714, 0, 12336, 12337, 5, 3, 0, 0, 12337, 1519, 1, 0, 0, 0, 12338, 12342, 5, 255, 0, 0, 12339, 12340, 5, 77, 0, 0, 12340, 12342, 5, 255, 0, 0, 12341, 12338, 1, 0, 0, 0, 12341, 12339, 1, 0, 0, 0, 12342, 1521, 1, 0, 0, 0, 12343, 12344, 3, 1514, 757, 0, 12344, 1523, 1, 0, 0, 0, 12345, 12351, 5, 71, 0, 0, 12346, 12348, 3, 1528, 764, 0, 12347, 12346, 1, 0, 0, 0, 12347, 12348, 1, 0, 0, 0, 12348, 12349, 1, 0, 0, 0, 12349, 12352, 3, 1530, 765, 0, 12350, 12352, 3, 2118, 1059, 0, 12351, 12347, 1, 0, 0, 0, 12351, 12350, 1, 0, 0, 0, 12352, 1525, 1, 0, 0, 0, 12353, 12354, 5, 387, 0, 0, 12354, 12355, 3, 1908, 954, 0, 12355, 1527, 1, 0, 0, 0, 12356, 12357, 5, 344, 0, 0, 12357, 1529, 1, 0, 0, 0, 12358, 12360, 7, 78, 0, 0, 12359, 12358, 1, 0, 0, 0, 12359, 12360, 1, 0, 0, 0, 12360, 12361, 1, 0, 0, 0, 12361, 12363, 7, 21, 0, 0, 12362, 12364, 3, 1532, 766, 0, 12363, 12362, 1, 0, 0, 0, 12363, 12364, 1, 0, 0, 0, 12364, 12365, 1, 0, 0, 0, 12365, 12375, 3, 1888, 944, 0, 12366, 12368, 5, 365, 0, 0, 12367, 12369, 3, 1532, 766, 0, 12368, 12367, 1, 0, 0, 0, 12368, 12369, 1, 0, 0, 0, 12369, 12370, 1, 0, 0, 0, 12370, 12375, 3, 1888, 944, 0, 12371, 12372, 5, 93, 0, 0, 12372, 12375, 3, 1888, 944, 0, 12373, 12375, 3, 1888, 944, 0, 12374, 12359, 1, 0, 0, 0, 12374, 12366, 1, 0, 0, 0, 12374, 12371, 1, 0, 0, 0, 12374, 12373, 1, 0, 0, 0, 12375, 1531, 1, 0, 0, 0, 12376, 12377, 5, 93, 0, 0, 12377, 1533, 1, 0, 0, 0, 12378, 12379, 7, 79, 0, 0, 12379, 1535, 1, 0, 0, 0, 12380, 12386, 5, 56, 0, 0, 12381, 12382, 5, 80, 0, 0, 12382, 12383, 5, 2, 0, 0, 12383, 12384, 3, 1830, 915, 0, 12384, 12385, 5, 3, 0, 0, 12385, 12387, 1, 0, 0, 0, 12386, 12381, 1, 0, 0, 0, 12386, 12387, 1, 0, 0, 0, 12387, 1537, 1, 0, 0, 0, 12388, 12389, 5, 30, 0, 0, 12389, 1539, 1, 0, 0, 0, 12390, 12391, 3, 1542, 771, 0, 12391, 1541, 1, 0, 0, 0, 12392, 12393, 5, 83, 0, 0, 12393, 12394, 5, 149, 0, 0, 12394, 12395, 3, 1544, 772, 0, 12395, 1543, 1, 0, 0, 0, 12396, 12401, 3, 1546, 773, 0, 12397, 12398, 5, 6, 0, 0, 12398, 12400, 3, 1546, 773, 0, 12399, 12397, 1, 0, 0, 0, 12400, 12403, 1, 0, 0, 0, 12401, 12399, 1, 0, 0, 0, 12401, 12402, 1, 0, 0, 0, 12402, 1545, 1, 0, 0, 0, 12403, 12401, 1, 0, 0, 0, 12404, 12410, 3, 1710, 855, 0, 12405, 12406, 5, 101, 0, 0, 12406, 12411, 3, 1826, 913, 0, 12407, 12409, 3, 822, 411, 0, 12408, 12407, 1, 0, 0, 0, 12408, 12409, 1, 0, 0, 0, 12409, 12411, 1, 0, 0, 0, 12410, 12405, 1, 0, 0, 0, 12410, 12408, 1, 0, 0, 0, 12411, 12413, 1, 0, 0, 0, 12412, 12414, 3, 824, 412, 0, 12413, 12412, 1, 0, 0, 0, 12413, 12414, 1, 0, 0, 0, 12414, 1547, 1, 0, 0, 0, 12415, 12417, 3, 1552, 776, 0, 12416, 12418, 3, 1554, 777, 0, 12417, 12416, 1, 0, 0, 0, 12417, 12418, 1, 0, 0, 0, 12418, 12424, 1, 0, 0, 0, 12419, 12421, 3, 1554, 777, 0, 12420, 12422, 3, 1552, 776, 0, 12421, 12420, 1, 0, 0, 0, 12421, 12422, 1, 0, 0, 0, 12422, 12424, 1, 0, 0, 0, 12423, 12415, 1, 0, 0, 0, 12423, 12419, 1, 0, 0, 0, 12424, 1549, 1, 0, 0, 0, 12425, 12426, 3, 1548, 774, 0, 12426, 1551, 1, 0, 0, 0, 12427, 12428, 5, 74, 0, 0, 12428, 12431, 3, 1556, 778, 0, 12429, 12430, 5, 6, 0, 0, 12430, 12432, 3, 1558, 779, 0, 12431, 12429, 1, 0, 0, 0, 12431, 12432, 1, 0, 0, 0, 12432, 12451, 1, 0, 0, 0, 12433, 12434, 5, 61, 0, 0, 12434, 12448, 3, 1566, 783, 0, 12435, 12436, 3, 1560, 780, 0, 12436, 12440, 3, 1564, 782, 0, 12437, 12441, 5, 81, 0, 0, 12438, 12439, 5, 106, 0, 0, 12439, 12441, 5, 666, 0, 0, 12440, 12437, 1, 0, 0, 0, 12440, 12438, 1, 0, 0, 0, 12441, 12449, 1, 0, 0, 0, 12442, 12446, 3, 1564, 782, 0, 12443, 12447, 5, 81, 0, 0, 12444, 12445, 5, 106, 0, 0, 12445, 12447, 5, 666, 0, 0, 12446, 12443, 1, 0, 0, 0, 12446, 12444, 1, 0, 0, 0, 12447, 12449, 1, 0, 0, 0, 12448, 12435, 1, 0, 0, 0, 12448, 12442, 1, 0, 0, 0, 12449, 12451, 1, 0, 0, 0, 12450, 12427, 1, 0, 0, 0, 12450, 12433, 1, 0, 0, 0, 12451, 1553, 1, 0, 0, 0, 12452, 12457, 5, 79, 0, 0, 12453, 12458, 3, 1558, 779, 0, 12454, 12455, 3, 1560, 780, 0, 12455, 12456, 3, 1564, 782, 0, 12456, 12458, 1, 0, 0, 0, 12457, 12453, 1, 0, 0, 0, 12457, 12454, 1, 0, 0, 0, 12458, 1555, 1, 0, 0, 0, 12459, 12462, 3, 1710, 855, 0, 12460, 12462, 5, 30, 0, 0, 12461, 12459, 1, 0, 0, 0, 12461, 12460, 1, 0, 0, 0, 12462, 1557, 1, 0, 0, 0, 12463, 12464, 3, 1710, 855, 0, 12464, 1559, 1, 0, 0, 0, 12465, 12471, 3, 1756, 878, 0, 12466, 12467, 5, 12, 0, 0, 12467, 12471, 3, 1562, 781, 0, 12468, 12469, 5, 13, 0, 0, 12469, 12471, 3, 1562, 781, 0, 12470, 12465, 1, 0, 0, 0, 12470, 12466, 1, 0, 0, 0, 12470, 12468, 1, 0, 0, 0, 12471, 1561, 1, 0, 0, 0, 12472, 12475, 3, 1908, 954, 0, 12473, 12475, 3, 1906, 953, 0, 12474, 12472, 1, 0, 0, 0, 12474, 12473, 1, 0, 0, 0, 12475, 1563, 1, 0, 0, 0, 12476, 12477, 7, 80, 0, 0, 12477, 1565, 1, 0, 0, 0, 12478, 12479, 7, 81, 0, 0, 12479, 1567, 1, 0, 0, 0, 12480, 12481, 5, 66, 0, 0, 12481, 12482, 5, 149, 0, 0, 12482, 12483, 3, 1570, 785, 0, 12483, 1569, 1, 0, 0, 0, 12484, 12489, 3, 1572, 786, 0, 12485, 12486, 5, 6, 0, 0, 12486, 12488, 3, 1572, 786, 0, 12487, 12485, 1, 0, 0, 0, 12488, 12491, 1, 0, 0, 0, 12489, 12487, 1, 0, 0, 0, 12489, 12490, 1, 0, 0, 0, 12490, 12494, 1, 0, 0, 0, 12491, 12489, 1, 0, 0, 0, 12492, 12494, 5, 30, 0, 0, 12493, 12484, 1, 0, 0, 0, 12493, 12492, 1, 0, 0, 0, 12494, 1571, 1, 0, 0, 0, 12495, 12501, 3, 1710, 855, 0, 12496, 12501, 3, 1574, 787, 0, 12497, 12501, 3, 1578, 789, 0, 12498, 12501, 3, 1576, 788, 0, 12499, 12501, 3, 1580, 790, 0, 12500, 12495, 1, 0, 0, 0, 12500, 12496, 1, 0, 0, 0, 12500, 12497, 1, 0, 0, 0, 12500, 12498, 1, 0, 0, 0, 12500, 12499, 1, 0, 0, 0, 12501, 1573, 1, 0, 0, 0, 12502, 12503, 5, 2, 0, 0, 12503, 12504, 5, 3, 0, 0, 12504, 1575, 1, 0, 0, 0, 12505, 12506, 5, 667, 0, 0, 12506, 12507, 5, 2, 0, 0, 12507, 12508, 3, 1830, 915, 0, 12508, 12509, 5, 3, 0, 0, 12509, 1577, 1, 0, 0, 0, 12510, 12511, 5, 668, 0, 0, 12511, 12512, 5, 2, 0, 0, 12512, 12513, 3, 1830, 915, 0, 12513, 12514, 5, 3, 0, 0, 12514, 1579, 1, 0, 0, 0, 12515, 12516, 5, 669, 0, 0, 12516, 12517, 5, 670, 0, 0, 12517, 12518, 5, 2, 0, 0, 12518, 12519, 3, 1570, 785, 0, 12519, 12520, 5, 3, 0, 0, 12520, 1581, 1, 0, 0, 0, 12521, 12522, 5, 67, 0, 0, 12522, 12523, 3, 1710, 855, 0, 12523, 1583, 1, 0, 0, 0, 12524, 12529, 3, 1588, 794, 0, 12525, 12526, 5, 62, 0, 0, 12526, 12527, 5, 298, 0, 0, 12527, 12529, 5, 81, 0, 0, 12528, 12524, 1, 0, 0, 0, 12528, 12525, 1, 0, 0, 0, 12529, 1585, 1, 0, 0, 0, 12530, 12531, 3, 1584, 792, 0, 12531, 1587, 1, 0, 0, 0, 12532, 12534, 3, 1590, 795, 0, 12533, 12532, 1, 0, 0, 0, 12534, 12535, 1, 0, 0, 0, 12535, 12533, 1, 0, 0, 0, 12535, 12536, 1, 0, 0, 0, 12536, 1589, 1, 0, 0, 0, 12537, 12539, 3, 1592, 796, 0, 12538, 12540, 3, 1594, 797, 0, 12539, 12538, 1, 0, 0, 0, 12539, 12540, 1, 0, 0, 0, 12540, 12542, 1, 0, 0, 0, 12541, 12543, 3, 1476, 738, 0, 12542, 12541, 1, 0, 0, 0, 12542, 12543, 1, 0, 0, 0, 12543, 1591, 1, 0, 0, 0, 12544, 12554, 5, 62, 0, 0, 12545, 12546, 5, 266, 0, 0, 12546, 12548, 5, 240, 0, 0, 12547, 12545, 1, 0, 0, 0, 12547, 12548, 1, 0, 0, 0, 12548, 12549, 1, 0, 0, 0, 12549, 12555, 5, 367, 0, 0, 12550, 12552, 5, 240, 0, 0, 12551, 12550, 1, 0, 0, 0, 12551, 12552, 1, 0, 0, 0, 12552, 12553, 1, 0, 0, 0, 12553, 12555, 5, 332, 0, 0, 12554, 12547, 1, 0, 0, 0, 12554, 12551, 1, 0, 0, 0, 12555, 1593, 1, 0, 0, 0, 12556, 12557, 5, 272, 0, 0, 12557, 12558, 3, 1886, 943, 0, 12558, 1595, 1, 0, 0, 0, 12559, 12560, 5, 585, 0, 0, 12560, 12561, 5, 2, 0, 0, 12561, 12562, 3, 1830, 915, 0, 12562, 12570, 5, 3, 0, 0, 12563, 12564, 5, 6, 0, 0, 12564, 12565, 5, 2, 0, 0, 12565, 12566, 3, 1830, 915, 0, 12566, 12567, 5, 3, 0, 0, 12567, 12569, 1, 0, 0, 0, 12568, 12563, 1, 0, 0, 0, 12569, 12572, 1, 0, 0, 0, 12570, 12568, 1, 0, 0, 0, 12570, 12571, 1, 0, 0, 0, 12571, 1597, 1, 0, 0, 0, 12572, 12570, 1, 0, 0, 0, 12573, 12574, 5, 64, 0, 0, 12574, 12575, 3, 1600, 800, 0, 12575, 1599, 1, 0, 0, 0, 12576, 12581, 3, 1602, 801, 0, 12577, 12578, 5, 6, 0, 0, 12578, 12580, 3, 1602, 801, 0, 12579, 12577, 1, 0, 0, 0, 12580, 12583, 1, 0, 0, 0, 12581, 12579, 1, 0, 0, 0, 12581, 12582, 1, 0, 0, 0, 12582, 1601, 1, 0, 0, 0, 12583, 12581, 1, 0, 0, 0, 12584, 12586, 3, 1618, 809, 0, 12585, 12587, 3, 1608, 804, 0, 12586, 12585, 1, 0, 0, 0, 12586, 12587, 1, 0, 0, 0, 12587, 12589, 1, 0, 0, 0, 12588, 12590, 3, 1624, 812, 0, 12589, 12588, 1, 0, 0, 0, 12589, 12590, 1, 0, 0, 0, 12590, 12643, 1, 0, 0, 0, 12591, 12593, 3, 1628, 814, 0, 12592, 12594, 3, 1612, 806, 0, 12593, 12592, 1, 0, 0, 0, 12593, 12594, 1, 0, 0, 0, 12594, 12643, 1, 0, 0, 0, 12595, 12597, 3, 1648, 824, 0, 12596, 12598, 3, 1608, 804, 0, 12597, 12596, 1, 0, 0, 0, 12597, 12598, 1, 0, 0, 0, 12598, 12643, 1, 0, 0, 0, 12599, 12601, 3, 1498, 749, 0, 12600, 12602, 3, 1608, 804, 0, 12601, 12600, 1, 0, 0, 0, 12601, 12602, 1, 0, 0, 0, 12602, 12643, 1, 0, 0, 0, 12603, 12616, 5, 72, 0, 0, 12604, 12606, 3, 1648, 824, 0, 12605, 12607, 3, 1608, 804, 0, 12606, 12605, 1, 0, 0, 0, 12606, 12607, 1, 0, 0, 0, 12607, 12617, 1, 0, 0, 0, 12608, 12610, 3, 1628, 814, 0, 12609, 12611, 3, 1612, 806, 0, 12610, 12609, 1, 0, 0, 0, 12610, 12611, 1, 0, 0, 0, 12611, 12617, 1, 0, 0, 0, 12612, 12614, 3, 1498, 749, 0, 12613, 12615, 3, 1608, 804, 0, 12614, 12613, 1, 0, 0, 0, 12614, 12615, 1, 0, 0, 0, 12615, 12617, 1, 0, 0, 0, 12616, 12604, 1, 0, 0, 0, 12616, 12608, 1, 0, 0, 0, 12616, 12612, 1, 0, 0, 0, 12617, 12643, 1, 0, 0, 0, 12618, 12619, 5, 2, 0, 0, 12619, 12636, 3, 1602, 801, 0, 12620, 12621, 5, 112, 0, 0, 12621, 12622, 5, 120, 0, 0, 12622, 12637, 3, 1602, 801, 0, 12623, 12625, 5, 123, 0, 0, 12624, 12626, 3, 1614, 807, 0, 12625, 12624, 1, 0, 0, 0, 12625, 12626, 1, 0, 0, 0, 12626, 12627, 1, 0, 0, 0, 12627, 12628, 5, 120, 0, 0, 12628, 12637, 3, 1602, 801, 0, 12629, 12631, 3, 1614, 807, 0, 12630, 12629, 1, 0, 0, 0, 12630, 12631, 1, 0, 0, 0, 12631, 12632, 1, 0, 0, 0, 12632, 12633, 5, 120, 0, 0, 12633, 12634, 3, 1602, 801, 0, 12634, 12635, 3, 1616, 808, 0, 12635, 12637, 1, 0, 0, 0, 12636, 12620, 1, 0, 0, 0, 12636, 12623, 1, 0, 0, 0, 12636, 12630, 1, 0, 0, 0, 12636, 12637, 1, 0, 0, 0, 12637, 12638, 1, 0, 0, 0, 12638, 12640, 5, 3, 0, 0, 12639, 12641, 3, 1608, 804, 0, 12640, 12639, 1, 0, 0, 0, 12640, 12641, 1, 0, 0, 0, 12641, 12643, 1, 0, 0, 0, 12642, 12584, 1, 0, 0, 0, 12642, 12591, 1, 0, 0, 0, 12642, 12595, 1, 0, 0, 0, 12642, 12599, 1, 0, 0, 0, 12642, 12603, 1, 0, 0, 0, 12642, 12618, 1, 0, 0, 0, 12643, 12647, 1, 0, 0, 0, 12644, 12646, 3, 1604, 802, 0, 12645, 12644, 1, 0, 0, 0, 12646, 12649, 1, 0, 0, 0, 12647, 12645, 1, 0, 0, 0, 12647, 12648, 1, 0, 0, 0, 12648, 1603, 1, 0, 0, 0, 12649, 12647, 1, 0, 0, 0, 12650, 12652, 3, 1614, 807, 0, 12651, 12650, 1, 0, 0, 0, 12651, 12652, 1, 0, 0, 0, 12652, 12653, 1, 0, 0, 0, 12653, 12654, 5, 120, 0, 0, 12654, 12655, 3, 1602, 801, 0, 12655, 12656, 3, 1616, 808, 0, 12656, 12667, 1, 0, 0, 0, 12657, 12658, 5, 112, 0, 0, 12658, 12659, 5, 120, 0, 0, 12659, 12667, 3, 1602, 801, 0, 12660, 12662, 5, 123, 0, 0, 12661, 12663, 3, 1614, 807, 0, 12662, 12661, 1, 0, 0, 0, 12662, 12663, 1, 0, 0, 0, 12663, 12664, 1, 0, 0, 0, 12664, 12665, 5, 120, 0, 0, 12665, 12667, 3, 1602, 801, 0, 12666, 12651, 1, 0, 0, 0, 12666, 12657, 1, 0, 0, 0, 12666, 12660, 1, 0, 0, 0, 12667, 1605, 1, 0, 0, 0, 12668, 12670, 5, 36, 0, 0, 12669, 12668, 1, 0, 0, 0, 12669, 12670, 1, 0, 0, 0, 12670, 12671, 1, 0, 0, 0, 12671, 12676, 3, 1924, 962, 0, 12672, 12673, 5, 2, 0, 0, 12673, 12674, 3, 1890, 945, 0, 12674, 12675, 5, 3, 0, 0, 12675, 12677, 1, 0, 0, 0, 12676, 12672, 1, 0, 0, 0, 12676, 12677, 1, 0, 0, 0, 12677, 1607, 1, 0, 0, 0, 12678, 12679, 3, 1610, 805, 0, 12679, 1609, 1, 0, 0, 0, 12680, 12682, 5, 36, 0, 0, 12681, 12680, 1, 0, 0, 0, 12681, 12682, 1, 0, 0, 0, 12682, 12683, 1, 0, 0, 0, 12683, 12688, 3, 1926, 963, 0, 12684, 12685, 5, 2, 0, 0, 12685, 12686, 3, 1890, 945, 0, 12686, 12687, 5, 3, 0, 0, 12687, 12689, 1, 0, 0, 0, 12688, 12684, 1, 0, 0, 0, 12688, 12689, 1, 0, 0, 0, 12689, 1611, 1, 0, 0, 0, 12690, 12703, 3, 1606, 803, 0, 12691, 12693, 5, 36, 0, 0, 12692, 12694, 3, 1924, 962, 0, 12693, 12692, 1, 0, 0, 0, 12693, 12694, 1, 0, 0, 0, 12694, 12697, 1, 0, 0, 0, 12695, 12697, 3, 1924, 962, 0, 12696, 12691, 1, 0, 0, 0, 12696, 12695, 1, 0, 0, 0, 12697, 12698, 1, 0, 0, 0, 12698, 12699, 5, 2, 0, 0, 12699, 12700, 3, 1644, 822, 0, 12700, 12701, 5, 3, 0, 0, 12701, 12703, 1, 0, 0, 0, 12702, 12690, 1, 0, 0, 0, 12702, 12696, 1, 0, 0, 0, 12703, 1613, 1, 0, 0, 0, 12704, 12706, 7, 82, 0, 0, 12705, 12707, 5, 125, 0, 0, 12706, 12705, 1, 0, 0, 0, 12706, 12707, 1, 0, 0, 0, 12707, 1615, 1, 0, 0, 0, 12708, 12709, 5, 101, 0, 0, 12709, 12710, 5, 2, 0, 0, 12710, 12711, 3, 1890, 945, 0, 12711, 12712, 5, 3, 0, 0, 12712, 12716, 1, 0, 0, 0, 12713, 12714, 5, 80, 0, 0, 12714, 12716, 3, 1710, 855, 0, 12715, 12708, 1, 0, 0, 0, 12715, 12713, 1, 0, 0, 0, 12716, 1617, 1, 0, 0, 0, 12717, 12719, 3, 1888, 944, 0, 12718, 12720, 5, 9, 0, 0, 12719, 12718, 1, 0, 0, 0, 12719, 12720, 1, 0, 0, 0, 12720, 12730, 1, 0, 0, 0, 12721, 12727, 5, 81, 0, 0, 12722, 12728, 3, 1888, 944, 0, 12723, 12724, 5, 2, 0, 0, 12724, 12725, 3, 1888, 944, 0, 12725, 12726, 5, 3, 0, 0, 12726, 12728, 1, 0, 0, 0, 12727, 12722, 1, 0, 0, 0, 12727, 12723, 1, 0, 0, 0, 12728, 12730, 1, 0, 0, 0, 12729, 12717, 1, 0, 0, 0, 12729, 12721, 1, 0, 0, 0, 12730, 1619, 1, 0, 0, 0, 12731, 12736, 3, 1618, 809, 0, 12732, 12733, 5, 6, 0, 0, 12733, 12735, 3, 1618, 809, 0, 12734, 12732, 1, 0, 0, 0, 12735, 12738, 1, 0, 0, 0, 12736, 12734, 1, 0, 0, 0, 12736, 12737, 1, 0, 0, 0, 12737, 1621, 1, 0, 0, 0, 12738, 12736, 1, 0, 0, 0, 12739, 12744, 3, 1618, 809, 0, 12740, 12742, 5, 36, 0, 0, 12741, 12740, 1, 0, 0, 0, 12741, 12742, 1, 0, 0, 0, 12742, 12743, 1, 0, 0, 0, 12743, 12745, 3, 1924, 962, 0, 12744, 12741, 1, 0, 0, 0, 12744, 12745, 1, 0, 0, 0, 12745, 1623, 1, 0, 0, 0, 12746, 12747, 5, 671, 0, 0, 12747, 12748, 3, 1898, 949, 0, 12748, 12749, 5, 2, 0, 0, 12749, 12750, 3, 1830, 915, 0, 12750, 12752, 5, 3, 0, 0, 12751, 12753, 3, 1626, 813, 0, 12752, 12751, 1, 0, 0, 0, 12752, 12753, 1, 0, 0, 0, 12753, 1625, 1, 0, 0, 0, 12754, 12755, 5, 308, 0, 0, 12755, 12756, 5, 2, 0, 0, 12756, 12757, 3, 1710, 855, 0, 12757, 12758, 5, 3, 0, 0, 12758, 1627, 1, 0, 0, 0, 12759, 12761, 3, 1764, 882, 0, 12760, 12762, 3, 1636, 818, 0, 12761, 12760, 1, 0, 0, 0, 12761, 12762, 1, 0, 0, 0, 12762, 12772, 1, 0, 0, 0, 12763, 12764, 5, 318, 0, 0, 12764, 12765, 5, 64, 0, 0, 12765, 12766, 5, 2, 0, 0, 12766, 12767, 3, 1632, 816, 0, 12767, 12769, 5, 3, 0, 0, 12768, 12770, 3, 1636, 818, 0, 12769, 12768, 1, 0, 0, 0, 12769, 12770, 1, 0, 0, 0, 12770, 12772, 1, 0, 0, 0, 12771, 12759, 1, 0, 0, 0, 12771, 12763, 1, 0, 0, 0, 12772, 1629, 1, 0, 0, 0, 12773, 12775, 3, 1764, 882, 0, 12774, 12776, 3, 1634, 817, 0, 12775, 12774, 1, 0, 0, 0, 12775, 12776, 1, 0, 0, 0, 12776, 1631, 1, 0, 0, 0, 12777, 12782, 3, 1630, 815, 0, 12778, 12779, 5, 6, 0, 0, 12779, 12781, 3, 1630, 815, 0, 12780, 12778, 1, 0, 0, 0, 12781, 12784, 1, 0, 0, 0, 12782, 12780, 1, 0, 0, 0, 12782, 12783, 1, 0, 0, 0, 12783, 1633, 1, 0, 0, 0, 12784, 12782, 1, 0, 0, 0, 12785, 12786, 5, 36, 0, 0, 12786, 12787, 5, 2, 0, 0, 12787, 12788, 3, 1644, 822, 0, 12788, 12789, 5, 3, 0, 0, 12789, 1635, 1, 0, 0, 0, 12790, 12791, 5, 106, 0, 0, 12791, 12792, 5, 672, 0, 0, 12792, 1637, 1, 0, 0, 0, 12793, 12794, 5, 104, 0, 0, 12794, 12795, 3, 1710, 855, 0, 12795, 1639, 1, 0, 0, 0, 12796, 12801, 5, 104, 0, 0, 12797, 12798, 5, 604, 0, 0, 12798, 12799, 5, 272, 0, 0, 12799, 12802, 3, 1490, 745, 0, 12800, 12802, 3, 1710, 855, 0, 12801, 12797, 1, 0, 0, 0, 12801, 12800, 1, 0, 0, 0, 12802, 1641, 1, 0, 0, 0, 12803, 12804, 3, 1644, 822, 0, 12804, 1643, 1, 0, 0, 0, 12805, 12810, 3, 1646, 823, 0, 12806, 12807, 5, 6, 0, 0, 12807, 12809, 3, 1646, 823, 0, 12808, 12806, 1, 0, 0, 0, 12809, 12812, 1, 0, 0, 0, 12810, 12808, 1, 0, 0, 0, 12810, 12811, 1, 0, 0, 0, 12811, 1645, 1, 0, 0, 0, 12812, 12810, 1, 0, 0, 0, 12813, 12814, 3, 1924, 962, 0, 12814, 12816, 3, 1662, 831, 0, 12815, 12817, 3, 122, 61, 0, 12816, 12815, 1, 0, 0, 0, 12816, 12817, 1, 0, 0, 0, 12817, 1647, 1, 0, 0, 0, 12818, 12819, 5, 673, 0, 0, 12819, 12835, 5, 2, 0, 0, 12820, 12821, 3, 1756, 878, 0, 12821, 12822, 3, 1782, 891, 0, 12822, 12823, 5, 674, 0, 0, 12823, 12824, 3, 1650, 825, 0, 12824, 12836, 1, 0, 0, 0, 12825, 12826, 5, 675, 0, 0, 12826, 12827, 5, 2, 0, 0, 12827, 12828, 3, 1658, 829, 0, 12828, 12829, 5, 3, 0, 0, 12829, 12830, 5, 6, 0, 0, 12830, 12831, 3, 1756, 878, 0, 12831, 12832, 3, 1782, 891, 0, 12832, 12833, 5, 674, 0, 0, 12833, 12834, 3, 1650, 825, 0, 12834, 12836, 1, 0, 0, 0, 12835, 12820, 1, 0, 0, 0, 12835, 12825, 1, 0, 0, 0, 12836, 12837, 1, 0, 0, 0, 12837, 12838, 5, 3, 0, 0, 12838, 1649, 1, 0, 0, 0, 12839, 12844, 3, 1652, 826, 0, 12840, 12841, 5, 6, 0, 0, 12841, 12843, 3, 1652, 826, 0, 12842, 12840, 1, 0, 0, 0, 12843, 12846, 1, 0, 0, 0, 12844, 12842, 1, 0, 0, 0, 12844, 12845, 1, 0, 0, 0, 12845, 1651, 1, 0, 0, 0, 12846, 12844, 1, 0, 0, 0, 12847, 12854, 3, 1924, 962, 0, 12848, 12850, 3, 1662, 831, 0, 12849, 12851, 3, 1654, 827, 0, 12850, 12849, 1, 0, 0, 0, 12850, 12851, 1, 0, 0, 0, 12851, 12855, 1, 0, 0, 0, 12852, 12853, 5, 62, 0, 0, 12853, 12855, 5, 672, 0, 0, 12854, 12848, 1, 0, 0, 0, 12854, 12852, 1, 0, 0, 0, 12855, 1653, 1, 0, 0, 0, 12856, 12858, 3, 1656, 828, 0, 12857, 12856, 1, 0, 0, 0, 12858, 12859, 1, 0, 0, 0, 12859, 12857, 1, 0, 0, 0, 12859, 12860, 1, 0, 0, 0, 12860, 1655, 1, 0, 0, 0, 12861, 12862, 5, 53, 0, 0, 12862, 12870, 3, 1710, 855, 0, 12863, 12864, 3, 1934, 967, 0, 12864, 12865, 3, 1710, 855, 0, 12865, 12870, 1, 0, 0, 0, 12866, 12867, 5, 77, 0, 0, 12867, 12870, 5, 78, 0, 0, 12868, 12870, 5, 78, 0, 0, 12869, 12861, 1, 0, 0, 0, 12869, 12863, 1, 0, 0, 0, 12869, 12866, 1, 0, 0, 0, 12869, 12868, 1, 0, 0, 0, 12870, 1657, 1, 0, 0, 0, 12871, 12876, 3, 1660, 830, 0, 12872, 12873, 5, 6, 0, 0, 12873, 12875, 3, 1660, 830, 0, 12874, 12872, 1, 0, 0, 0, 12875, 12878, 1, 0, 0, 0, 12876, 12874, 1, 0, 0, 0, 12876, 12877, 1, 0, 0, 0, 12877, 1659, 1, 0, 0, 0, 12878, 12876, 1, 0, 0, 0, 12879, 12880, 3, 1754, 877, 0, 12880, 12881, 5, 36, 0, 0, 12881, 12882, 3, 1932, 966, 0, 12882, 12886, 1, 0, 0, 0, 12883, 12884, 5, 53, 0, 0, 12884, 12886, 3, 1754, 877, 0, 12885, 12879, 1, 0, 0, 0, 12885, 12883, 1, 0, 0, 0, 12886, 1661, 1, 0, 0, 0, 12887, 12889, 5, 578, 0, 0, 12888, 12887, 1, 0, 0, 0, 12888, 12889, 1, 0, 0, 0, 12889, 12890, 1, 0, 0, 0, 12890, 12901, 3, 1666, 833, 0, 12891, 12893, 3, 1664, 832, 0, 12892, 12891, 1, 0, 0, 0, 12892, 12893, 1, 0, 0, 0, 12893, 12902, 1, 0, 0, 0, 12894, 12899, 5, 35, 0, 0, 12895, 12896, 5, 4, 0, 0, 12896, 12897, 3, 1908, 954, 0, 12897, 12898, 5, 5, 0, 0, 12898, 12900, 1, 0, 0, 0, 12899, 12895, 1, 0, 0, 0, 12899, 12900, 1, 0, 0, 0, 12900, 12902, 1, 0, 0, 0, 12901, 12892, 1, 0, 0, 0, 12901, 12894, 1, 0, 0, 0, 12902, 12909, 1, 0, 0, 0, 12903, 12904, 3, 1888, 944, 0, 12904, 12905, 5, 27, 0, 0, 12905, 12906, 7, 83, 0, 0, 12906, 12909, 1, 0, 0, 0, 12907, 12909, 5, 482, 0, 0, 12908, 12888, 1, 0, 0, 0, 12908, 12903, 1, 0, 0, 0, 12908, 12907, 1, 0, 0, 0, 12909, 1663, 1, 0, 0, 0, 12910, 12912, 5, 4, 0, 0, 12911, 12913, 3, 1908, 954, 0, 12912, 12911, 1, 0, 0, 0, 12912, 12913, 1, 0, 0, 0, 12913, 12914, 1, 0, 0, 0, 12914, 12916, 5, 5, 0, 0, 12915, 12910, 1, 0, 0, 0, 12916, 12917, 1, 0, 0, 0, 12917, 12915, 1, 0, 0, 0, 12917, 12918, 1, 0, 0, 0, 12918, 1665, 1, 0, 0, 0, 12919, 12937, 3, 1674, 837, 0, 12920, 12937, 3, 1678, 839, 0, 12921, 12937, 3, 1682, 841, 0, 12922, 12937, 3, 1690, 845, 0, 12923, 12937, 3, 1668, 834, 0, 12924, 12937, 3, 1698, 849, 0, 12925, 12933, 3, 1700, 850, 0, 12926, 12928, 3, 1704, 852, 0, 12927, 12926, 1, 0, 0, 0, 12927, 12928, 1, 0, 0, 0, 12928, 12934, 1, 0, 0, 0, 12929, 12930, 5, 2, 0, 0, 12930, 12931, 3, 1908, 954, 0, 12931, 12932, 5, 3, 0, 0, 12932, 12934, 1, 0, 0, 0, 12933, 12927, 1, 0, 0, 0, 12933, 12929, 1, 0, 0, 0, 12934, 12937, 1, 0, 0, 0, 12935, 12937, 3, 1670, 835, 0, 12936, 12919, 1, 0, 0, 0, 12936, 12920, 1, 0, 0, 0, 12936, 12921, 1, 0, 0, 0, 12936, 12922, 1, 0, 0, 0, 12936, 12923, 1, 0, 0, 0, 12936, 12924, 1, 0, 0, 0, 12936, 12925, 1, 0, 0, 0, 12936, 12935, 1, 0, 0, 0, 12937, 1667, 1, 0, 0, 0, 12938, 12943, 5, 388, 0, 0, 12939, 12943, 5, 389, 0, 0, 12940, 12941, 5, 108, 0, 0, 12941, 12943, 5, 372, 0, 0, 12942, 12938, 1, 0, 0, 0, 12942, 12939, 1, 0, 0, 0, 12942, 12940, 1, 0, 0, 0, 12943, 12944, 1, 0, 0, 0, 12944, 12945, 5, 2, 0, 0, 12945, 12946, 3, 1908, 954, 0, 12946, 12947, 5, 3, 0, 0, 12947, 1669, 1, 0, 0, 0, 12948, 12949, 5, 174, 0, 0, 12949, 1671, 1, 0, 0, 0, 12950, 12955, 3, 1678, 839, 0, 12951, 12955, 3, 1684, 842, 0, 12952, 12955, 3, 1692, 846, 0, 12953, 12955, 3, 1698, 849, 0, 12954, 12950, 1, 0, 0, 0, 12954, 12951, 1, 0, 0, 0, 12954, 12952, 1, 0, 0, 0, 12954, 12953, 1, 0, 0, 0, 12955, 1673, 1, 0, 0, 0, 12956, 12961, 3, 1946, 973, 0, 12957, 12961, 3, 1928, 964, 0, 12958, 12961, 5, 121, 0, 0, 12959, 12961, 5, 128, 0, 0, 12960, 12956, 1, 0, 0, 0, 12960, 12957, 1, 0, 0, 0, 12960, 12958, 1, 0, 0, 0, 12960, 12959, 1, 0, 0, 0, 12961, 12963, 1, 0, 0, 0, 12962, 12964, 3, 568, 284, 0, 12963, 12962, 1, 0, 0, 0, 12963, 12964, 1, 0, 0, 0, 12964, 12966, 1, 0, 0, 0, 12965, 12967, 3, 1676, 838, 0, 12966, 12965, 1, 0, 0, 0, 12966, 12967, 1, 0, 0, 0, 12967, 1675, 1, 0, 0, 0, 12968, 12969, 5, 2, 0, 0, 12969, 12970, 3, 1830, 915, 0, 12970, 12971, 5, 3, 0, 0, 12971, 1677, 1, 0, 0, 0, 12972, 12997, 5, 563, 0, 0, 12973, 12997, 5, 564, 0, 0, 12974, 12997, 5, 579, 0, 0, 12975, 12997, 5, 550, 0, 0, 12976, 12997, 5, 576, 0, 0, 12977, 12979, 5, 560, 0, 0, 12978, 12980, 3, 1680, 840, 0, 12979, 12978, 1, 0, 0, 0, 12979, 12980, 1, 0, 0, 0, 12980, 12997, 1, 0, 0, 0, 12981, 12982, 5, 194, 0, 0, 12982, 12997, 5, 575, 0, 0, 12983, 12985, 5, 557, 0, 0, 12984, 12986, 3, 1676, 838, 0, 12985, 12984, 1, 0, 0, 0, 12985, 12986, 1, 0, 0, 0, 12986, 12997, 1, 0, 0, 0, 12987, 12989, 5, 556, 0, 0, 12988, 12990, 3, 1676, 838, 0, 12989, 12988, 1, 0, 0, 0, 12989, 12990, 1, 0, 0, 0, 12990, 12997, 1, 0, 0, 0, 12991, 12993, 5, 571, 0, 0, 12992, 12994, 3, 1676, 838, 0, 12993, 12992, 1, 0, 0, 0, 12993, 12994, 1, 0, 0, 0, 12994, 12997, 1, 0, 0, 0, 12995, 12997, 5, 552, 0, 0, 12996, 12972, 1, 0, 0, 0, 12996, 12973, 1, 0, 0, 0, 12996, 12974, 1, 0, 0, 0, 12996, 12975, 1, 0, 0, 0, 12996, 12976, 1, 0, 0, 0, 12996, 12977, 1, 0, 0, 0, 12996, 12981, 1, 0, 0, 0, 12996, 12983, 1, 0, 0, 0, 12996, 12987, 1, 0, 0, 0, 12996, 12991, 1, 0, 0, 0, 12996, 12995, 1, 0, 0, 0, 12997, 1679, 1, 0, 0, 0, 12998, 12999, 5, 2, 0, 0, 12999, 13000, 3, 1908, 954, 0, 13000, 13001, 5, 3, 0, 0, 13001, 1681, 1, 0, 0, 0, 13002, 13005, 3, 1686, 843, 0, 13003, 13005, 3, 1688, 844, 0, 13004, 13002, 1, 0, 0, 0, 13004, 13003, 1, 0, 0, 0, 13005, 1683, 1, 0, 0, 0, 13006, 13009, 3, 1686, 843, 0, 13007, 13009, 3, 1688, 844, 0, 13008, 13006, 1, 0, 0, 0, 13008, 13007, 1, 0, 0, 0, 13009, 1685, 1, 0, 0, 0, 13010, 13012, 5, 551, 0, 0, 13011, 13013, 3, 1696, 848, 0, 13012, 13011, 1, 0, 0, 0, 13012, 13013, 1, 0, 0, 0, 13013, 13014, 1, 0, 0, 0, 13014, 13015, 5, 2, 0, 0, 13015, 13016, 3, 1830, 915, 0, 13016, 13017, 5, 3, 0, 0, 13017, 1687, 1, 0, 0, 0, 13018, 13020, 5, 551, 0, 0, 13019, 13021, 3, 1696, 848, 0, 13020, 13019, 1, 0, 0, 0, 13020, 13021, 1, 0, 0, 0, 13021, 1689, 1, 0, 0, 0, 13022, 13030, 3, 1694, 847, 0, 13023, 13026, 5, 2, 0, 0, 13024, 13027, 3, 1908, 954, 0, 13025, 13027, 3, 1924, 962, 0, 13026, 13024, 1, 0, 0, 0, 13026, 13025, 1, 0, 0, 0, 13027, 13028, 1, 0, 0, 0, 13028, 13029, 5, 3, 0, 0, 13029, 13031, 1, 0, 0, 0, 13030, 13023, 1, 0, 0, 0, 13030, 13031, 1, 0, 0, 0, 13031, 1691, 1, 0, 0, 0, 13032, 13040, 3, 1694, 847, 0, 13033, 13036, 5, 2, 0, 0, 13034, 13037, 3, 1908, 954, 0, 13035, 13037, 3, 1924, 962, 0, 13036, 13034, 1, 0, 0, 0, 13036, 13035, 1, 0, 0, 0, 13037, 13038, 1, 0, 0, 0, 13038, 13039, 5, 3, 0, 0, 13039, 13041, 1, 0, 0, 0, 13040, 13033, 1, 0, 0, 0, 13040, 13041, 1, 0, 0, 0, 13041, 1693, 1, 0, 0, 0, 13042, 13044, 7, 84, 0, 0, 13043, 13045, 3, 1696, 848, 0, 13044, 13043, 1, 0, 0, 0, 13044, 13045, 1, 0, 0, 0, 13045, 13053, 1, 0, 0, 0, 13046, 13053, 5, 586, 0, 0, 13047, 13048, 5, 567, 0, 0, 13048, 13050, 7, 85, 0, 0, 13049, 13051, 3, 1696, 848, 0, 13050, 13049, 1, 0, 0, 0, 13050, 13051, 1, 0, 0, 0, 13051, 13053, 1, 0, 0, 0, 13052, 13042, 1, 0, 0, 0, 13052, 13046, 1, 0, 0, 0, 13052, 13047, 1, 0, 0, 0, 13053, 1695, 1, 0, 0, 0, 13054, 13055, 5, 372, 0, 0, 13055, 1697, 1, 0, 0, 0, 13056, 13061, 7, 86, 0, 0, 13057, 13058, 5, 2, 0, 0, 13058, 13059, 3, 1908, 954, 0, 13059, 13060, 5, 3, 0, 0, 13060, 13062, 1, 0, 0, 0, 13061, 13057, 1, 0, 0, 0, 13061, 13062, 1, 0, 0, 0, 13062, 13064, 1, 0, 0, 0, 13063, 13065, 3, 1702, 851, 0, 13064, 13063, 1, 0, 0, 0, 13064, 13065, 1, 0, 0, 0, 13065, 1699, 1, 0, 0, 0, 13066, 13067, 5, 565, 0, 0, 13067, 1701, 1, 0, 0, 0, 13068, 13069, 5, 106, 0, 0, 13069, 13070, 5, 581, 0, 0, 13070, 13075, 5, 384, 0, 0, 13071, 13072, 5, 377, 0, 0, 13072, 13073, 5, 581, 0, 0, 13073, 13075, 5, 384, 0, 0, 13074, 13068, 1, 0, 0, 0, 13074, 13071, 1, 0, 0, 0, 13075, 1703, 1, 0, 0, 0, 13076, 13102, 5, 382, 0, 0, 13077, 13102, 5, 261, 0, 0, 13078, 13102, 5, 180, 0, 0, 13079, 13102, 5, 222, 0, 0, 13080, 13102, 5, 258, 0, 0, 13081, 13102, 3, 1706, 853, 0, 13082, 13083, 5, 382, 0, 0, 13083, 13084, 5, 95, 0, 0, 13084, 13102, 5, 261, 0, 0, 13085, 13086, 5, 180, 0, 0, 13086, 13090, 5, 95, 0, 0, 13087, 13091, 5, 222, 0, 0, 13088, 13091, 5, 258, 0, 0, 13089, 13091, 3, 1706, 853, 0, 13090, 13087, 1, 0, 0, 0, 13090, 13088, 1, 0, 0, 0, 13090, 13089, 1, 0, 0, 0, 13091, 13102, 1, 0, 0, 0, 13092, 13093, 5, 222, 0, 0, 13093, 13096, 5, 95, 0, 0, 13094, 13097, 5, 258, 0, 0, 13095, 13097, 3, 1706, 853, 0, 13096, 13094, 1, 0, 0, 0, 13096, 13095, 1, 0, 0, 0, 13097, 13102, 1, 0, 0, 0, 13098, 13099, 5, 258, 0, 0, 13099, 13100, 5, 95, 0, 0, 13100, 13102, 3, 1706, 853, 0, 13101, 13076, 1, 0, 0, 0, 13101, 13077, 1, 0, 0, 0, 13101, 13078, 1, 0, 0, 0, 13101, 13079, 1, 0, 0, 0, 13101, 13080, 1, 0, 0, 0, 13101, 13081, 1, 0, 0, 0, 13101, 13082, 1, 0, 0, 0, 13101, 13085, 1, 0, 0, 0, 13101, 13092, 1, 0, 0, 0, 13101, 13098, 1, 0, 0, 0, 13102, 1705, 1, 0, 0, 0, 13103, 13108, 5, 324, 0, 0, 13104, 13105, 5, 2, 0, 0, 13105, 13106, 3, 1908, 954, 0, 13106, 13107, 5, 3, 0, 0, 13107, 13109, 1, 0, 0, 0, 13108, 13104, 1, 0, 0, 0, 13108, 13109, 1, 0, 0, 0, 13109, 1707, 1, 0, 0, 0, 13110, 13111, 5, 201, 0, 0, 13111, 13112, 3, 1710, 855, 0, 13112, 1709, 1, 0, 0, 0, 13113, 13114, 3, 1712, 856, 0, 13114, 1711, 1, 0, 0, 0, 13115, 13117, 3, 1714, 857, 0, 13116, 13118, 3, 1824, 912, 0, 13117, 13116, 1, 0, 0, 0, 13117, 13118, 1, 0, 0, 0, 13118, 1713, 1, 0, 0, 0, 13119, 13124, 3, 1716, 858, 0, 13120, 13121, 7, 87, 0, 0, 13121, 13123, 3, 1716, 858, 0, 13122, 13120, 1, 0, 0, 0, 13123, 13126, 1, 0, 0, 0, 13124, 13122, 1, 0, 0, 0, 13124, 13125, 1, 0, 0, 0, 13125, 1715, 1, 0, 0, 0, 13126, 13124, 1, 0, 0, 0, 13127, 13132, 3, 1718, 859, 0, 13128, 13129, 5, 82, 0, 0, 13129, 13131, 3, 1718, 859, 0, 13130, 13128, 1, 0, 0, 0, 13131, 13134, 1, 0, 0, 0, 13132, 13130, 1, 0, 0, 0, 13132, 13133, 1, 0, 0, 0, 13133, 1717, 1, 0, 0, 0, 13134, 13132, 1, 0, 0, 0, 13135, 13140, 3, 1720, 860, 0, 13136, 13137, 5, 33, 0, 0, 13137, 13139, 3, 1720, 860, 0, 13138, 13136, 1, 0, 0, 0, 13139, 13142, 1, 0, 0, 0, 13140, 13138, 1, 0, 0, 0, 13140, 13141, 1, 0, 0, 0, 13141, 1719, 1, 0, 0, 0, 13142, 13140, 1, 0, 0, 0, 13143, 13155, 3, 1722, 861, 0, 13144, 13146, 5, 77, 0, 0, 13145, 13144, 1, 0, 0, 0, 13145, 13146, 1, 0, 0, 0, 13146, 13147, 1, 0, 0, 0, 13147, 13149, 5, 549, 0, 0, 13148, 13150, 5, 92, 0, 0, 13149, 13148, 1, 0, 0, 0, 13149, 13150, 1, 0, 0, 0, 13150, 13151, 1, 0, 0, 0, 13151, 13152, 3, 1722, 861, 0, 13152, 13153, 5, 33, 0, 0, 13153, 13154, 3, 1722, 861, 0, 13154, 13156, 1, 0, 0, 0, 13155, 13145, 1, 0, 0, 0, 13155, 13156, 1, 0, 0, 0, 13156, 1721, 1, 0, 0, 0, 13157, 13163, 3, 1724, 862, 0, 13158, 13160, 5, 77, 0, 0, 13159, 13158, 1, 0, 0, 0, 13159, 13160, 1, 0, 0, 0, 13160, 13161, 1, 0, 0, 0, 13161, 13162, 5, 68, 0, 0, 13162, 13164, 3, 1856, 928, 0, 13163, 13159, 1, 0, 0, 0, 13163, 13164, 1, 0, 0, 0, 13164, 1723, 1, 0, 0, 0, 13165, 13167, 5, 77, 0, 0, 13166, 13165, 1, 0, 0, 0, 13166, 13167, 1, 0, 0, 0, 13167, 13168, 1, 0, 0, 0, 13168, 13169, 3, 1726, 863, 0, 13169, 1725, 1, 0, 0, 0, 13170, 13172, 3, 1728, 864, 0, 13171, 13173, 7, 88, 0, 0, 13172, 13171, 1, 0, 0, 0, 13172, 13173, 1, 0, 0, 0, 13173, 1727, 1, 0, 0, 0, 13174, 13198, 3, 1730, 865, 0, 13175, 13177, 5, 118, 0, 0, 13176, 13178, 5, 77, 0, 0, 13177, 13176, 1, 0, 0, 0, 13177, 13178, 1, 0, 0, 0, 13178, 13196, 1, 0, 0, 0, 13179, 13197, 5, 78, 0, 0, 13180, 13197, 5, 97, 0, 0, 13181, 13197, 5, 60, 0, 0, 13182, 13197, 5, 363, 0, 0, 13183, 13184, 5, 56, 0, 0, 13184, 13185, 5, 64, 0, 0, 13185, 13197, 3, 1710, 855, 0, 13186, 13187, 5, 272, 0, 0, 13187, 13188, 5, 2, 0, 0, 13188, 13189, 3, 1836, 918, 0, 13189, 13190, 5, 3, 0, 0, 13190, 13197, 1, 0, 0, 0, 13191, 13197, 5, 192, 0, 0, 13192, 13194, 3, 1846, 923, 0, 13193, 13192, 1, 0, 0, 0, 13193, 13194, 1, 0, 0, 0, 13194, 13195, 1, 0, 0, 0, 13195, 13197, 5, 677, 0, 0, 13196, 13179, 1, 0, 0, 0, 13196, 13180, 1, 0, 0, 0, 13196, 13181, 1, 0, 0, 0, 13196, 13182, 1, 0, 0, 0, 13196, 13183, 1, 0, 0, 0, 13196, 13186, 1, 0, 0, 0, 13196, 13191, 1, 0, 0, 0, 13196, 13193, 1, 0, 0, 0, 13197, 13199, 1, 0, 0, 0, 13198, 13175, 1, 0, 0, 0, 13198, 13199, 1, 0, 0, 0, 13199, 1729, 1, 0, 0, 0, 13200, 13212, 3, 1732, 866, 0, 13201, 13202, 7, 89, 0, 0, 13202, 13213, 3, 1732, 866, 0, 13203, 13204, 3, 1828, 914, 0, 13204, 13210, 3, 1818, 909, 0, 13205, 13211, 3, 1498, 749, 0, 13206, 13207, 5, 2, 0, 0, 13207, 13208, 3, 1710, 855, 0, 13208, 13209, 5, 3, 0, 0, 13209, 13211, 1, 0, 0, 0, 13210, 13205, 1, 0, 0, 0, 13210, 13206, 1, 0, 0, 0, 13211, 13213, 1, 0, 0, 0, 13212, 13201, 1, 0, 0, 0, 13212, 13203, 1, 0, 0, 0, 13212, 13213, 1, 0, 0, 0, 13213, 1731, 1, 0, 0, 0, 13214, 13216, 7, 90, 0, 0, 13215, 13214, 1, 0, 0, 0, 13215, 13216, 1, 0, 0, 0, 13216, 13217, 1, 0, 0, 0, 13217, 13218, 3, 1734, 867, 0, 13218, 1733, 1, 0, 0, 0, 13219, 13233, 3, 1736, 868, 0, 13220, 13222, 5, 77, 0, 0, 13221, 13220, 1, 0, 0, 0, 13221, 13222, 1, 0, 0, 0, 13222, 13227, 1, 0, 0, 0, 13223, 13228, 5, 122, 0, 0, 13224, 13228, 5, 116, 0, 0, 13225, 13226, 5, 129, 0, 0, 13226, 13228, 5, 95, 0, 0, 13227, 13223, 1, 0, 0, 0, 13227, 13224, 1, 0, 0, 0, 13227, 13225, 1, 0, 0, 0, 13228, 13229, 1, 0, 0, 0, 13229, 13231, 3, 1736, 868, 0, 13230, 13232, 3, 1708, 854, 0, 13231, 13230, 1, 0, 0, 0, 13231, 13232, 1, 0, 0, 0, 13232, 13234, 1, 0, 0, 0, 13233, 13221, 1, 0, 0, 0, 13233, 13234, 1, 0, 0, 0, 13234, 1735, 1, 0, 0, 0, 13235, 13241, 3, 1738, 869, 0, 13236, 13237, 3, 1824, 912, 0, 13237, 13238, 3, 1738, 869, 0, 13238, 13240, 1, 0, 0, 0, 13239, 13236, 1, 0, 0, 0, 13240, 13243, 1, 0, 0, 0, 13241, 13239, 1, 0, 0, 0, 13241, 13242, 1, 0, 0, 0, 13242, 1737, 1, 0, 0, 0, 13243, 13241, 1, 0, 0, 0, 13244, 13246, 3, 1824, 912, 0, 13245, 13244, 1, 0, 0, 0, 13245, 13246, 1, 0, 0, 0, 13246, 13247, 1, 0, 0, 0, 13247, 13248, 3, 1740, 870, 0, 13248, 1739, 1, 0, 0, 0, 13249, 13254, 3, 1742, 871, 0, 13250, 13251, 7, 91, 0, 0, 13251, 13253, 3, 1742, 871, 0, 13252, 13250, 1, 0, 0, 0, 13253, 13256, 1, 0, 0, 0, 13254, 13252, 1, 0, 0, 0, 13254, 13255, 1, 0, 0, 0, 13255, 1741, 1, 0, 0, 0, 13256, 13254, 1, 0, 0, 0, 13257, 13262, 3, 1744, 872, 0, 13258, 13259, 7, 92, 0, 0, 13259, 13261, 3, 1744, 872, 0, 13260, 13258, 1, 0, 0, 0, 13261, 13264, 1, 0, 0, 0, 13262, 13260, 1, 0, 0, 0, 13262, 13263, 1, 0, 0, 0, 13263, 1743, 1, 0, 0, 0, 13264, 13262, 1, 0, 0, 0, 13265, 13268, 3, 1746, 873, 0, 13266, 13267, 5, 15, 0, 0, 13267, 13269, 3, 1710, 855, 0, 13268, 13266, 1, 0, 0, 0, 13268, 13269, 1, 0, 0, 0, 13269, 1745, 1, 0, 0, 0, 13270, 13272, 7, 91, 0, 0, 13271, 13270, 1, 0, 0, 0, 13271, 13272, 1, 0, 0, 0, 13272, 13273, 1, 0, 0, 0, 13273, 13274, 3, 1748, 874, 0, 13274, 1747, 1, 0, 0, 0, 13275, 13280, 3, 1750, 875, 0, 13276, 13277, 5, 144, 0, 0, 13277, 13278, 5, 581, 0, 0, 13278, 13279, 5, 384, 0, 0, 13279, 13281, 3, 1710, 855, 0, 13280, 13276, 1, 0, 0, 0, 13280, 13281, 1, 0, 0, 0, 13281, 1749, 1, 0, 0, 0, 13282, 13285, 3, 1752, 876, 0, 13283, 13284, 5, 43, 0, 0, 13284, 13286, 3, 566, 283, 0, 13285, 13283, 1, 0, 0, 0, 13285, 13286, 1, 0, 0, 0, 13286, 1751, 1, 0, 0, 0, 13287, 13292, 3, 1756, 878, 0, 13288, 13289, 5, 26, 0, 0, 13289, 13291, 3, 1662, 831, 0, 13290, 13288, 1, 0, 0, 0, 13291, 13294, 1, 0, 0, 0, 13292, 13290, 1, 0, 0, 0, 13292, 13293, 1, 0, 0, 0, 13293, 1753, 1, 0, 0, 0, 13294, 13292, 1, 0, 0, 0, 13295, 13296, 6, 877, -1, 0, 13296, 13303, 3, 1756, 878, 0, 13297, 13298, 7, 91, 0, 0, 13298, 13303, 3, 1754, 877, 9, 13299, 13300, 3, 1824, 912, 0, 13300, 13301, 3, 1754, 877, 3, 13301, 13303, 1, 0, 0, 0, 13302, 13295, 1, 0, 0, 0, 13302, 13297, 1, 0, 0, 0, 13302, 13299, 1, 0, 0, 0, 13303, 13343, 1, 0, 0, 0, 13304, 13305, 10, 8, 0, 0, 13305, 13306, 5, 15, 0, 0, 13306, 13342, 3, 1754, 877, 9, 13307, 13308, 10, 7, 0, 0, 13308, 13309, 7, 92, 0, 0, 13309, 13342, 3, 1754, 877, 8, 13310, 13311, 10, 6, 0, 0, 13311, 13312, 7, 91, 0, 0, 13312, 13342, 3, 1754, 877, 7, 13313, 13314, 10, 5, 0, 0, 13314, 13315, 3, 1824, 912, 0, 13315, 13316, 3, 1754, 877, 6, 13316, 13342, 1, 0, 0, 0, 13317, 13318, 10, 4, 0, 0, 13318, 13319, 7, 89, 0, 0, 13319, 13342, 3, 1754, 877, 5, 13320, 13321, 10, 10, 0, 0, 13321, 13322, 5, 26, 0, 0, 13322, 13342, 3, 1662, 831, 0, 13323, 13324, 10, 2, 0, 0, 13324, 13342, 3, 1824, 912, 0, 13325, 13326, 10, 1, 0, 0, 13326, 13328, 5, 118, 0, 0, 13327, 13329, 5, 77, 0, 0, 13328, 13327, 1, 0, 0, 0, 13328, 13329, 1, 0, 0, 0, 13329, 13339, 1, 0, 0, 0, 13330, 13331, 5, 56, 0, 0, 13331, 13332, 5, 64, 0, 0, 13332, 13340, 3, 1754, 877, 0, 13333, 13334, 5, 272, 0, 0, 13334, 13335, 5, 2, 0, 0, 13335, 13336, 3, 1836, 918, 0, 13336, 13337, 5, 3, 0, 0, 13337, 13340, 1, 0, 0, 0, 13338, 13340, 5, 192, 0, 0, 13339, 13330, 1, 0, 0, 0, 13339, 13333, 1, 0, 0, 0, 13339, 13338, 1, 0, 0, 0, 13340, 13342, 1, 0, 0, 0, 13341, 13304, 1, 0, 0, 0, 13341, 13307, 1, 0, 0, 0, 13341, 13310, 1, 0, 0, 0, 13341, 13313, 1, 0, 0, 0, 13341, 13317, 1, 0, 0, 0, 13341, 13320, 1, 0, 0, 0, 13341, 13323, 1, 0, 0, 0, 13341, 13325, 1, 0, 0, 0, 13342, 13345, 1, 0, 0, 0, 13343, 13341, 1, 0, 0, 0, 13343, 13344, 1, 0, 0, 0, 13344, 1755, 1, 0, 0, 0, 13345, 13343, 1, 0, 0, 0, 13346, 13347, 5, 558, 0, 0, 13347, 13383, 3, 1498, 749, 0, 13348, 13351, 5, 35, 0, 0, 13349, 13352, 3, 1498, 749, 0, 13350, 13352, 3, 1838, 919, 0, 13351, 13349, 1, 0, 0, 0, 13351, 13350, 1, 0, 0, 0, 13352, 13383, 1, 0, 0, 0, 13353, 13354, 5, 28, 0, 0, 13354, 13383, 3, 1876, 938, 0, 13355, 13356, 5, 669, 0, 0, 13356, 13357, 5, 2, 0, 0, 13357, 13358, 3, 1830, 915, 0, 13358, 13359, 5, 3, 0, 0, 13359, 13383, 1, 0, 0, 0, 13360, 13361, 5, 99, 0, 0, 13361, 13383, 3, 1498, 749, 0, 13362, 13383, 3, 1868, 934, 0, 13363, 13383, 3, 1900, 950, 0, 13364, 13383, 3, 1758, 879, 0, 13365, 13366, 5, 2, 0, 0, 13366, 13367, 3, 1710, 855, 0, 13367, 13368, 5, 3, 0, 0, 13368, 13369, 3, 1876, 938, 0, 13369, 13383, 1, 0, 0, 0, 13370, 13383, 3, 1858, 929, 0, 13371, 13383, 3, 1762, 881, 0, 13372, 13374, 3, 1498, 749, 0, 13373, 13375, 3, 1874, 937, 0, 13374, 13373, 1, 0, 0, 0, 13374, 13375, 1, 0, 0, 0, 13375, 13383, 1, 0, 0, 0, 13376, 13383, 3, 1814, 907, 0, 13377, 13383, 3, 1816, 908, 0, 13378, 13379, 3, 1812, 906, 0, 13379, 13380, 5, 127, 0, 0, 13380, 13381, 3, 1812, 906, 0, 13381, 13383, 1, 0, 0, 0, 13382, 13346, 1, 0, 0, 0, 13382, 13348, 1, 0, 0, 0, 13382, 13353, 1, 0, 0, 0, 13382, 13355, 1, 0, 0, 0, 13382, 13360, 1, 0, 0, 0, 13382, 13362, 1, 0, 0, 0, 13382, 13363, 1, 0, 0, 0, 13382, 13364, 1, 0, 0, 0, 13382, 13365, 1, 0, 0, 0, 13382, 13370, 1, 0, 0, 0, 13382, 13371, 1, 0, 0, 0, 13382, 13372, 1, 0, 0, 0, 13382, 13376, 1, 0, 0, 0, 13382, 13377, 1, 0, 0, 0, 13382, 13378, 1, 0, 0, 0, 13383, 1757, 1, 0, 0, 0, 13384, 13385, 5, 878, 0, 0, 13385, 1759, 1, 0, 0, 0, 13386, 13387, 3, 1898, 949, 0, 13387, 13409, 5, 2, 0, 0, 13388, 13392, 3, 1832, 916, 0, 13389, 13390, 5, 6, 0, 0, 13390, 13391, 5, 102, 0, 0, 13391, 13393, 3, 1834, 917, 0, 13392, 13389, 1, 0, 0, 0, 13392, 13393, 1, 0, 0, 0, 13393, 13395, 1, 0, 0, 0, 13394, 13396, 3, 1540, 770, 0, 13395, 13394, 1, 0, 0, 0, 13395, 13396, 1, 0, 0, 0, 13396, 13410, 1, 0, 0, 0, 13397, 13398, 5, 102, 0, 0, 13398, 13400, 3, 1834, 917, 0, 13399, 13401, 3, 1540, 770, 0, 13400, 13399, 1, 0, 0, 0, 13400, 13401, 1, 0, 0, 0, 13401, 13410, 1, 0, 0, 0, 13402, 13403, 7, 79, 0, 0, 13403, 13405, 3, 1832, 916, 0, 13404, 13406, 3, 1540, 770, 0, 13405, 13404, 1, 0, 0, 0, 13405, 13406, 1, 0, 0, 0, 13406, 13410, 1, 0, 0, 0, 13407, 13410, 5, 9, 0, 0, 13408, 13410, 1, 0, 0, 0, 13409, 13388, 1, 0, 0, 0, 13409, 13397, 1, 0, 0, 0, 13409, 13402, 1, 0, 0, 0, 13409, 13407, 1, 0, 0, 0, 13409, 13408, 1, 0, 0, 0, 13410, 13411, 1, 0, 0, 0, 13411, 13412, 5, 3, 0, 0, 13412, 1761, 1, 0, 0, 0, 13413, 13415, 3, 1760, 880, 0, 13414, 13416, 3, 1786, 893, 0, 13415, 13414, 1, 0, 0, 0, 13415, 13416, 1, 0, 0, 0, 13416, 13418, 1, 0, 0, 0, 13417, 13419, 3, 1788, 894, 0, 13418, 13417, 1, 0, 0, 0, 13418, 13419, 1, 0, 0, 0, 13419, 13421, 1, 0, 0, 0, 13420, 13422, 3, 1796, 898, 0, 13421, 13420, 1, 0, 0, 0, 13421, 13422, 1, 0, 0, 0, 13422, 13425, 1, 0, 0, 0, 13423, 13425, 3, 1766, 883, 0, 13424, 13413, 1, 0, 0, 0, 13424, 13423, 1, 0, 0, 0, 13425, 1763, 1, 0, 0, 0, 13426, 13429, 3, 1760, 880, 0, 13427, 13429, 3, 1766, 883, 0, 13428, 13426, 1, 0, 0, 0, 13428, 13427, 1, 0, 0, 0, 13429, 1765, 1, 0, 0, 0, 13430, 13431, 5, 110, 0, 0, 13431, 13432, 5, 62, 0, 0, 13432, 13433, 5, 2, 0, 0, 13433, 13434, 3, 1710, 855, 0, 13434, 13435, 5, 3, 0, 0, 13435, 13614, 1, 0, 0, 0, 13436, 13614, 5, 48, 0, 0, 13437, 13442, 5, 50, 0, 0, 13438, 13439, 5, 2, 0, 0, 13439, 13440, 3, 1908, 954, 0, 13440, 13441, 5, 3, 0, 0, 13441, 13443, 1, 0, 0, 0, 13442, 13438, 1, 0, 0, 0, 13442, 13443, 1, 0, 0, 0, 13443, 13614, 1, 0, 0, 0, 13444, 13449, 5, 51, 0, 0, 13445, 13446, 5, 2, 0, 0, 13446, 13447, 3, 1908, 954, 0, 13447, 13448, 5, 3, 0, 0, 13448, 13450, 1, 0, 0, 0, 13449, 13445, 1, 0, 0, 0, 13449, 13450, 1, 0, 0, 0, 13450, 13614, 1, 0, 0, 0, 13451, 13456, 5, 75, 0, 0, 13452, 13453, 5, 2, 0, 0, 13453, 13454, 3, 1908, 954, 0, 13454, 13455, 5, 3, 0, 0, 13455, 13457, 1, 0, 0, 0, 13456, 13452, 1, 0, 0, 0, 13456, 13457, 1, 0, 0, 0, 13457, 13614, 1, 0, 0, 0, 13458, 13463, 5, 76, 0, 0, 13459, 13460, 5, 2, 0, 0, 13460, 13461, 3, 1908, 954, 0, 13461, 13462, 5, 3, 0, 0, 13462, 13464, 1, 0, 0, 0, 13463, 13459, 1, 0, 0, 0, 13463, 13464, 1, 0, 0, 0, 13464, 13614, 1, 0, 0, 0, 13465, 13614, 5, 49, 0, 0, 13466, 13614, 5, 52, 0, 0, 13467, 13614, 5, 90, 0, 0, 13468, 13614, 5, 100, 0, 0, 13469, 13614, 5, 47, 0, 0, 13470, 13614, 5, 113, 0, 0, 13471, 13472, 5, 41, 0, 0, 13472, 13473, 5, 2, 0, 0, 13473, 13474, 3, 1710, 855, 0, 13474, 13475, 5, 36, 0, 0, 13475, 13476, 3, 1662, 831, 0, 13476, 13477, 5, 3, 0, 0, 13477, 13614, 1, 0, 0, 0, 13478, 13479, 5, 559, 0, 0, 13479, 13481, 5, 2, 0, 0, 13480, 13482, 3, 1842, 921, 0, 13481, 13480, 1, 0, 0, 0, 13481, 13482, 1, 0, 0, 0, 13482, 13483, 1, 0, 0, 0, 13483, 13614, 5, 3, 0, 0, 13484, 13485, 5, 688, 0, 0, 13485, 13486, 5, 2, 0, 0, 13486, 13489, 3, 1710, 855, 0, 13487, 13488, 5, 6, 0, 0, 13488, 13490, 3, 1846, 923, 0, 13489, 13487, 1, 0, 0, 0, 13489, 13490, 1, 0, 0, 0, 13490, 13491, 1, 0, 0, 0, 13491, 13492, 5, 3, 0, 0, 13492, 13614, 1, 0, 0, 0, 13493, 13494, 5, 572, 0, 0, 13494, 13495, 5, 2, 0, 0, 13495, 13496, 3, 1848, 924, 0, 13496, 13497, 5, 3, 0, 0, 13497, 13614, 1, 0, 0, 0, 13498, 13499, 5, 574, 0, 0, 13499, 13501, 5, 2, 0, 0, 13500, 13502, 3, 1850, 925, 0, 13501, 13500, 1, 0, 0, 0, 13501, 13502, 1, 0, 0, 0, 13502, 13503, 1, 0, 0, 0, 13503, 13614, 5, 3, 0, 0, 13504, 13505, 5, 580, 0, 0, 13505, 13506, 5, 2, 0, 0, 13506, 13507, 3, 1852, 926, 0, 13507, 13508, 5, 3, 0, 0, 13508, 13614, 1, 0, 0, 0, 13509, 13510, 5, 583, 0, 0, 13510, 13511, 5, 2, 0, 0, 13511, 13512, 3, 1710, 855, 0, 13512, 13513, 5, 36, 0, 0, 13513, 13514, 3, 1662, 831, 0, 13514, 13515, 5, 3, 0, 0, 13515, 13614, 1, 0, 0, 0, 13516, 13517, 5, 584, 0, 0, 13517, 13519, 5, 2, 0, 0, 13518, 13520, 7, 93, 0, 0, 13519, 13518, 1, 0, 0, 0, 13519, 13520, 1, 0, 0, 0, 13520, 13521, 1, 0, 0, 0, 13521, 13522, 3, 1854, 927, 0, 13522, 13523, 5, 3, 0, 0, 13523, 13614, 1, 0, 0, 0, 13524, 13525, 5, 570, 0, 0, 13525, 13526, 5, 2, 0, 0, 13526, 13527, 3, 1710, 855, 0, 13527, 13528, 5, 6, 0, 0, 13528, 13529, 3, 1710, 855, 0, 13529, 13530, 5, 3, 0, 0, 13530, 13614, 1, 0, 0, 0, 13531, 13532, 5, 555, 0, 0, 13532, 13533, 5, 2, 0, 0, 13533, 13534, 3, 1830, 915, 0, 13534, 13535, 5, 3, 0, 0, 13535, 13614, 1, 0, 0, 0, 13536, 13537, 5, 561, 0, 0, 13537, 13538, 5, 2, 0, 0, 13538, 13539, 3, 1830, 915, 0, 13539, 13540, 5, 3, 0, 0, 13540, 13614, 1, 0, 0, 0, 13541, 13542, 5, 566, 0, 0, 13542, 13543, 5, 2, 0, 0, 13543, 13544, 3, 1830, 915, 0, 13544, 13545, 5, 3, 0, 0, 13545, 13614, 1, 0, 0, 0, 13546, 13547, 5, 595, 0, 0, 13547, 13548, 5, 2, 0, 0, 13548, 13549, 3, 1830, 915, 0, 13549, 13550, 5, 3, 0, 0, 13550, 13614, 1, 0, 0, 0, 13551, 13552, 5, 596, 0, 0, 13552, 13553, 5, 2, 0, 0, 13553, 13554, 5, 263, 0, 0, 13554, 13560, 3, 1932, 966, 0, 13555, 13558, 5, 6, 0, 0, 13556, 13559, 3, 1772, 886, 0, 13557, 13559, 3, 1830, 915, 0, 13558, 13556, 1, 0, 0, 0, 13558, 13557, 1, 0, 0, 0, 13559, 13561, 1, 0, 0, 0, 13560, 13555, 1, 0, 0, 0, 13560, 13561, 1, 0, 0, 0, 13561, 13562, 1, 0, 0, 0, 13562, 13563, 5, 3, 0, 0, 13563, 13614, 1, 0, 0, 0, 13564, 13565, 5, 597, 0, 0, 13565, 13566, 5, 2, 0, 0, 13566, 13567, 3, 1756, 878, 0, 13567, 13568, 3, 1782, 891, 0, 13568, 13569, 5, 3, 0, 0, 13569, 13614, 1, 0, 0, 0, 13570, 13571, 5, 598, 0, 0, 13571, 13572, 5, 2, 0, 0, 13572, 13573, 3, 1774, 887, 0, 13573, 13574, 5, 3, 0, 0, 13574, 13614, 1, 0, 0, 0, 13575, 13576, 5, 599, 0, 0, 13576, 13577, 5, 2, 0, 0, 13577, 13578, 3, 1778, 889, 0, 13578, 13580, 3, 1710, 855, 0, 13579, 13581, 3, 1780, 890, 0, 13580, 13579, 1, 0, 0, 0, 13580, 13581, 1, 0, 0, 0, 13581, 13582, 1, 0, 0, 0, 13582, 13583, 5, 3, 0, 0, 13583, 13614, 1, 0, 0, 0, 13584, 13585, 5, 600, 0, 0, 13585, 13586, 5, 2, 0, 0, 13586, 13587, 5, 263, 0, 0, 13587, 13590, 3, 1932, 966, 0, 13588, 13589, 5, 6, 0, 0, 13589, 13591, 3, 1710, 855, 0, 13590, 13588, 1, 0, 0, 0, 13590, 13591, 1, 0, 0, 0, 13591, 13592, 1, 0, 0, 0, 13592, 13593, 5, 3, 0, 0, 13593, 13614, 1, 0, 0, 0, 13594, 13595, 5, 601, 0, 0, 13595, 13596, 5, 2, 0, 0, 13596, 13597, 5, 381, 0, 0, 13597, 13598, 3, 1710, 855, 0, 13598, 13599, 5, 6, 0, 0, 13599, 13601, 3, 1768, 884, 0, 13600, 13602, 3, 1770, 885, 0, 13601, 13600, 1, 0, 0, 0, 13601, 13602, 1, 0, 0, 0, 13602, 13603, 1, 0, 0, 0, 13603, 13604, 5, 3, 0, 0, 13604, 13614, 1, 0, 0, 0, 13605, 13606, 5, 602, 0, 0, 13606, 13607, 5, 2, 0, 0, 13607, 13608, 3, 1778, 889, 0, 13608, 13609, 3, 1710, 855, 0, 13609, 13610, 5, 36, 0, 0, 13610, 13611, 3, 1666, 833, 0, 13611, 13612, 5, 3, 0, 0, 13612, 13614, 1, 0, 0, 0, 13613, 13430, 1, 0, 0, 0, 13613, 13436, 1, 0, 0, 0, 13613, 13437, 1, 0, 0, 0, 13613, 13444, 1, 0, 0, 0, 13613, 13451, 1, 0, 0, 0, 13613, 13458, 1, 0, 0, 0, 13613, 13465, 1, 0, 0, 0, 13613, 13466, 1, 0, 0, 0, 13613, 13467, 1, 0, 0, 0, 13613, 13468, 1, 0, 0, 0, 13613, 13469, 1, 0, 0, 0, 13613, 13470, 1, 0, 0, 0, 13613, 13471, 1, 0, 0, 0, 13613, 13478, 1, 0, 0, 0, 13613, 13484, 1, 0, 0, 0, 13613, 13493, 1, 0, 0, 0, 13613, 13498, 1, 0, 0, 0, 13613, 13504, 1, 0, 0, 0, 13613, 13509, 1, 0, 0, 0, 13613, 13516, 1, 0, 0, 0, 13613, 13524, 1, 0, 0, 0, 13613, 13531, 1, 0, 0, 0, 13613, 13536, 1, 0, 0, 0, 13613, 13541, 1, 0, 0, 0, 13613, 13546, 1, 0, 0, 0, 13613, 13551, 1, 0, 0, 0, 13613, 13564, 1, 0, 0, 0, 13613, 13570, 1, 0, 0, 0, 13613, 13575, 1, 0, 0, 0, 13613, 13584, 1, 0, 0, 0, 13613, 13594, 1, 0, 0, 0, 13613, 13605, 1, 0, 0, 0, 13614, 1767, 1, 0, 0, 0, 13615, 13616, 5, 373, 0, 0, 13616, 13621, 3, 1710, 855, 0, 13617, 13618, 5, 373, 0, 0, 13618, 13619, 5, 266, 0, 0, 13619, 13621, 5, 649, 0, 0, 13620, 13615, 1, 0, 0, 0, 13620, 13617, 1, 0, 0, 0, 13621, 1769, 1, 0, 0, 0, 13622, 13623, 5, 6, 0, 0, 13623, 13624, 5, 337, 0, 0, 13624, 13633, 5, 383, 0, 0, 13625, 13626, 5, 6, 0, 0, 13626, 13627, 5, 337, 0, 0, 13627, 13633, 5, 266, 0, 0, 13628, 13629, 5, 6, 0, 0, 13629, 13630, 5, 337, 0, 0, 13630, 13631, 5, 266, 0, 0, 13631, 13633, 5, 649, 0, 0, 13632, 13622, 1, 0, 0, 0, 13632, 13625, 1, 0, 0, 0, 13632, 13628, 1, 0, 0, 0, 13633, 1771, 1, 0, 0, 0, 13634, 13635, 5, 587, 0, 0, 13635, 13636, 5, 2, 0, 0, 13636, 13637, 3, 1774, 887, 0, 13637, 13638, 5, 3, 0, 0, 13638, 1773, 1, 0, 0, 0, 13639, 13644, 3, 1776, 888, 0, 13640, 13641, 5, 6, 0, 0, 13641, 13643, 3, 1776, 888, 0, 13642, 13640, 1, 0, 0, 0, 13643, 13646, 1, 0, 0, 0, 13644, 13642, 1, 0, 0, 0, 13644, 13645, 1, 0, 0, 0, 13645, 1775, 1, 0, 0, 0, 13646, 13644, 1, 0, 0, 0, 13647, 13650, 3, 1710, 855, 0, 13648, 13649, 5, 36, 0, 0, 13649, 13651, 3, 1932, 966, 0, 13650, 13648, 1, 0, 0, 0, 13650, 13651, 1, 0, 0, 0, 13651, 1777, 1, 0, 0, 0, 13652, 13653, 7, 94, 0, 0, 13653, 1779, 1, 0, 0, 0, 13654, 13655, 5, 290, 0, 0, 13655, 13659, 5, 376, 0, 0, 13656, 13657, 5, 345, 0, 0, 13657, 13659, 5, 376, 0, 0, 13658, 13654, 1, 0, 0, 0, 13658, 13656, 1, 0, 0, 0, 13659, 1781, 1, 0, 0, 0, 13660, 13661, 5, 283, 0, 0, 13661, 13676, 3, 1756, 878, 0, 13662, 13663, 5, 283, 0, 0, 13663, 13664, 3, 1756, 878, 0, 13664, 13665, 3, 1784, 892, 0, 13665, 13676, 1, 0, 0, 0, 13666, 13667, 5, 283, 0, 0, 13667, 13668, 3, 1784, 892, 0, 13668, 13669, 3, 1756, 878, 0, 13669, 13676, 1, 0, 0, 0, 13670, 13671, 5, 283, 0, 0, 13671, 13672, 3, 1784, 892, 0, 13672, 13673, 3, 1756, 878, 0, 13673, 13674, 3, 1784, 892, 0, 13674, 13676, 1, 0, 0, 0, 13675, 13660, 1, 0, 0, 0, 13675, 13662, 1, 0, 0, 0, 13675, 13666, 1, 0, 0, 0, 13675, 13670, 1, 0, 0, 0, 13676, 1783, 1, 0, 0, 0, 13677, 13678, 5, 149, 0, 0, 13678, 13679, 7, 95, 0, 0, 13679, 1785, 1, 0, 0, 0, 13680, 13681, 5, 678, 0, 0, 13681, 13682, 5, 66, 0, 0, 13682, 13683, 5, 2, 0, 0, 13683, 13684, 3, 1542, 771, 0, 13684, 13685, 5, 3, 0, 0, 13685, 1787, 1, 0, 0, 0, 13686, 13687, 5, 679, 0, 0, 13687, 13688, 5, 2, 0, 0, 13688, 13689, 5, 104, 0, 0, 13689, 13690, 3, 1710, 855, 0, 13690, 13691, 5, 3, 0, 0, 13691, 1789, 1, 0, 0, 0, 13692, 13693, 5, 105, 0, 0, 13693, 13694, 3, 1792, 896, 0, 13694, 1791, 1, 0, 0, 0, 13695, 13700, 3, 1794, 897, 0, 13696, 13697, 5, 6, 0, 0, 13697, 13699, 3, 1794, 897, 0, 13698, 13696, 1, 0, 0, 0, 13699, 13702, 1, 0, 0, 0, 13700, 13698, 1, 0, 0, 0, 13700, 13701, 1, 0, 0, 0, 13701, 1793, 1, 0, 0, 0, 13702, 13700, 1, 0, 0, 0, 13703, 13704, 3, 1924, 962, 0, 13704, 13705, 5, 36, 0, 0, 13705, 13706, 3, 1798, 899, 0, 13706, 1795, 1, 0, 0, 0, 13707, 13710, 5, 126, 0, 0, 13708, 13711, 3, 1798, 899, 0, 13709, 13711, 3, 1924, 962, 0, 13710, 13708, 1, 0, 0, 0, 13710, 13709, 1, 0, 0, 0, 13711, 1797, 1, 0, 0, 0, 13712, 13714, 5, 2, 0, 0, 13713, 13715, 3, 1800, 900, 0, 13714, 13713, 1, 0, 0, 0, 13714, 13715, 1, 0, 0, 0, 13715, 13717, 1, 0, 0, 0, 13716, 13718, 3, 1802, 901, 0, 13717, 13716, 1, 0, 0, 0, 13717, 13718, 1, 0, 0, 0, 13718, 13720, 1, 0, 0, 0, 13719, 13721, 3, 1540, 770, 0, 13720, 13719, 1, 0, 0, 0, 13720, 13721, 1, 0, 0, 0, 13721, 13723, 1, 0, 0, 0, 13722, 13724, 3, 1804, 902, 0, 13723, 13722, 1, 0, 0, 0, 13723, 13724, 1, 0, 0, 0, 13724, 13725, 1, 0, 0, 0, 13725, 13726, 5, 3, 0, 0, 13726, 1799, 1, 0, 0, 0, 13727, 13728, 3, 1924, 962, 0, 13728, 1801, 1, 0, 0, 0, 13729, 13730, 5, 282, 0, 0, 13730, 13731, 5, 149, 0, 0, 13731, 13732, 3, 1830, 915, 0, 13732, 1803, 1, 0, 0, 0, 13733, 13734, 5, 297, 0, 0, 13734, 13736, 3, 1806, 903, 0, 13735, 13737, 3, 1810, 905, 0, 13736, 13735, 1, 0, 0, 0, 13736, 13737, 1, 0, 0, 0, 13737, 13749, 1, 0, 0, 0, 13738, 13739, 5, 318, 0, 0, 13739, 13741, 3, 1806, 903, 0, 13740, 13742, 3, 1810, 905, 0, 13741, 13740, 1, 0, 0, 0, 13741, 13742, 1, 0, 0, 0, 13742, 13749, 1, 0, 0, 0, 13743, 13744, 5, 680, 0, 0, 13744, 13746, 3, 1806, 903, 0, 13745, 13747, 3, 1810, 905, 0, 13746, 13745, 1, 0, 0, 0, 13746, 13747, 1, 0, 0, 0, 13747, 13749, 1, 0, 0, 0, 13748, 13733, 1, 0, 0, 0, 13748, 13738, 1, 0, 0, 0, 13748, 13743, 1, 0, 0, 0, 13749, 1805, 1, 0, 0, 0, 13750, 13757, 3, 1808, 904, 0, 13751, 13752, 5, 549, 0, 0, 13752, 13753, 3, 1808, 904, 0, 13753, 13754, 5, 33, 0, 0, 13754, 13755, 3, 1808, 904, 0, 13755, 13757, 1, 0, 0, 0, 13756, 13750, 1, 0, 0, 0, 13756, 13751, 1, 0, 0, 0, 13757, 1807, 1, 0, 0, 0, 13758, 13759, 5, 360, 0, 0, 13759, 13766, 7, 96, 0, 0, 13760, 13761, 5, 604, 0, 0, 13761, 13766, 5, 577, 0, 0, 13762, 13763, 3, 1710, 855, 0, 13763, 13764, 7, 96, 0, 0, 13764, 13766, 1, 0, 0, 0, 13765, 13758, 1, 0, 0, 0, 13765, 13760, 1, 0, 0, 0, 13765, 13762, 1, 0, 0, 0, 13766, 1809, 1, 0, 0, 0, 13767, 13774, 5, 203, 0, 0, 13768, 13769, 5, 604, 0, 0, 13769, 13775, 5, 577, 0, 0, 13770, 13775, 5, 66, 0, 0, 13771, 13775, 5, 666, 0, 0, 13772, 13773, 5, 266, 0, 0, 13773, 13775, 5, 681, 0, 0, 13774, 13768, 1, 0, 0, 0, 13774, 13770, 1, 0, 0, 0, 13774, 13771, 1, 0, 0, 0, 13774, 13772, 1, 0, 0, 0, 13775, 1811, 1, 0, 0, 0, 13776, 13777, 5, 577, 0, 0, 13777, 13779, 5, 2, 0, 0, 13778, 13780, 3, 1830, 915, 0, 13779, 13778, 1, 0, 0, 0, 13779, 13780, 1, 0, 0, 0, 13780, 13781, 1, 0, 0, 0, 13781, 13789, 5, 3, 0, 0, 13782, 13783, 5, 2, 0, 0, 13783, 13784, 3, 1830, 915, 0, 13784, 13785, 5, 6, 0, 0, 13785, 13786, 3, 1710, 855, 0, 13786, 13787, 5, 3, 0, 0, 13787, 13789, 1, 0, 0, 0, 13788, 13776, 1, 0, 0, 0, 13788, 13782, 1, 0, 0, 0, 13789, 1813, 1, 0, 0, 0, 13790, 13791, 5, 577, 0, 0, 13791, 13793, 5, 2, 0, 0, 13792, 13794, 3, 1830, 915, 0, 13793, 13792, 1, 0, 0, 0, 13793, 13794, 1, 0, 0, 0, 13794, 13795, 1, 0, 0, 0, 13795, 13796, 5, 3, 0, 0, 13796, 1815, 1, 0, 0, 0, 13797, 13798, 5, 2, 0, 0, 13798, 13799, 3, 1830, 915, 0, 13799, 13800, 5, 6, 0, 0, 13800, 13801, 3, 1710, 855, 0, 13801, 13802, 5, 3, 0, 0, 13802, 1817, 1, 0, 0, 0, 13803, 13804, 7, 97, 0, 0, 13804, 1819, 1, 0, 0, 0, 13805, 13808, 5, 29, 0, 0, 13806, 13808, 3, 1822, 911, 0, 13807, 13805, 1, 0, 0, 0, 13807, 13806, 1, 0, 0, 0, 13808, 1821, 1, 0, 0, 0, 13809, 13810, 7, 98, 0, 0, 13810, 1823, 1, 0, 0, 0, 13811, 13818, 5, 29, 0, 0, 13812, 13813, 5, 275, 0, 0, 13813, 13814, 5, 2, 0, 0, 13814, 13815, 3, 904, 452, 0, 13815, 13816, 5, 3, 0, 0, 13816, 13818, 1, 0, 0, 0, 13817, 13811, 1, 0, 0, 0, 13817, 13812, 1, 0, 0, 0, 13818, 1825, 1, 0, 0, 0, 13819, 13826, 3, 1820, 910, 0, 13820, 13821, 5, 275, 0, 0, 13821, 13822, 5, 2, 0, 0, 13822, 13823, 3, 904, 452, 0, 13823, 13824, 5, 3, 0, 0, 13824, 13826, 1, 0, 0, 0, 13825, 13819, 1, 0, 0, 0, 13825, 13820, 1, 0, 0, 0, 13826, 1827, 1, 0, 0, 0, 13827, 13840, 3, 1820, 910, 0, 13828, 13829, 5, 275, 0, 0, 13829, 13830, 5, 2, 0, 0, 13830, 13831, 3, 904, 452, 0, 13831, 13832, 5, 3, 0, 0, 13832, 13840, 1, 0, 0, 0, 13833, 13840, 5, 122, 0, 0, 13834, 13835, 5, 77, 0, 0, 13835, 13840, 5, 122, 0, 0, 13836, 13840, 5, 116, 0, 0, 13837, 13838, 5, 77, 0, 0, 13838, 13840, 5, 116, 0, 0, 13839, 13827, 1, 0, 0, 0, 13839, 13828, 1, 0, 0, 0, 13839, 13833, 1, 0, 0, 0, 13839, 13834, 1, 0, 0, 0, 13839, 13836, 1, 0, 0, 0, 13839, 13837, 1, 0, 0, 0, 13840, 1829, 1, 0, 0, 0, 13841, 13846, 3, 1710, 855, 0, 13842, 13843, 5, 6, 0, 0, 13843, 13845, 3, 1710, 855, 0, 13844, 13842, 1, 0, 0, 0, 13845, 13848, 1, 0, 0, 0, 13846, 13844, 1, 0, 0, 0, 13846, 13847, 1, 0, 0, 0, 13847, 1831, 1, 0, 0, 0, 13848, 13846, 1, 0, 0, 0, 13849, 13854, 3, 1834, 917, 0, 13850, 13851, 5, 6, 0, 0, 13851, 13853, 3, 1834, 917, 0, 13852, 13850, 1, 0, 0, 0, 13853, 13856, 1, 0, 0, 0, 13854, 13852, 1, 0, 0, 0, 13854, 13855, 1, 0, 0, 0, 13855, 1833, 1, 0, 0, 0, 13856, 13854, 1, 0, 0, 0, 13857, 13863, 3, 1710, 855, 0, 13858, 13859, 3, 854, 427, 0, 13859, 13860, 7, 99, 0, 0, 13860, 13861, 3, 1710, 855, 0, 13861, 13863, 1, 0, 0, 0, 13862, 13857, 1, 0, 0, 0, 13862, 13858, 1, 0, 0, 0, 13863, 1835, 1, 0, 0, 0, 13864, 13869, 3, 1662, 831, 0, 13865, 13866, 5, 6, 0, 0, 13866, 13868, 3, 1662, 831, 0, 13867, 13865, 1, 0, 0, 0, 13868, 13871, 1, 0, 0, 0, 13869, 13867, 1, 0, 0, 0, 13869, 13870, 1, 0, 0, 0, 13870, 1837, 1, 0, 0, 0, 13871, 13869, 1, 0, 0, 0, 13872, 13875, 5, 4, 0, 0, 13873, 13876, 3, 1830, 915, 0, 13874, 13876, 3, 1840, 920, 0, 13875, 13873, 1, 0, 0, 0, 13875, 13874, 1, 0, 0, 0, 13875, 13876, 1, 0, 0, 0, 13876, 13877, 1, 0, 0, 0, 13877, 13878, 5, 5, 0, 0, 13878, 1839, 1, 0, 0, 0, 13879, 13884, 3, 1838, 919, 0, 13880, 13881, 5, 6, 0, 0, 13881, 13883, 3, 1838, 919, 0, 13882, 13880, 1, 0, 0, 0, 13883, 13886, 1, 0, 0, 0, 13884, 13882, 1, 0, 0, 0, 13884, 13885, 1, 0, 0, 0, 13885, 1841, 1, 0, 0, 0, 13886, 13884, 1, 0, 0, 0, 13887, 13888, 3, 1844, 922, 0, 13888, 13889, 5, 64, 0, 0, 13889, 13890, 3, 1710, 855, 0, 13890, 1843, 1, 0, 0, 0, 13891, 13900, 3, 1934, 967, 0, 13892, 13900, 5, 382, 0, 0, 13893, 13900, 5, 261, 0, 0, 13894, 13900, 5, 180, 0, 0, 13895, 13900, 5, 222, 0, 0, 13896, 13900, 5, 258, 0, 0, 13897, 13900, 5, 324, 0, 0, 13898, 13900, 3, 1910, 955, 0, 13899, 13891, 1, 0, 0, 0, 13899, 13892, 1, 0, 0, 0, 13899, 13893, 1, 0, 0, 0, 13899, 13894, 1, 0, 0, 0, 13899, 13895, 1, 0, 0, 0, 13899, 13896, 1, 0, 0, 0, 13899, 13897, 1, 0, 0, 0, 13899, 13898, 1, 0, 0, 0, 13900, 1845, 1, 0, 0, 0, 13901, 13902, 7, 100, 0, 0, 13902, 1847, 1, 0, 0, 0, 13903, 13904, 3, 1710, 855, 0, 13904, 13905, 5, 84, 0, 0, 13905, 13906, 3, 1710, 855, 0, 13906, 13907, 5, 64, 0, 0, 13907, 13910, 3, 1710, 855, 0, 13908, 13909, 5, 62, 0, 0, 13909, 13911, 3, 1710, 855, 0, 13910, 13908, 1, 0, 0, 0, 13910, 13911, 1, 0, 0, 0, 13911, 1849, 1, 0, 0, 0, 13912, 13913, 3, 1754, 877, 0, 13913, 13914, 5, 68, 0, 0, 13914, 13915, 3, 1754, 877, 0, 13915, 1851, 1, 0, 0, 0, 13916, 13917, 3, 1710, 855, 0, 13917, 13918, 5, 64, 0, 0, 13918, 13919, 3, 1710, 855, 0, 13919, 13920, 5, 62, 0, 0, 13920, 13921, 3, 1710, 855, 0, 13921, 13944, 1, 0, 0, 0, 13922, 13923, 3, 1710, 855, 0, 13923, 13924, 5, 62, 0, 0, 13924, 13925, 3, 1710, 855, 0, 13925, 13926, 5, 64, 0, 0, 13926, 13927, 3, 1710, 855, 0, 13927, 13944, 1, 0, 0, 0, 13928, 13929, 3, 1710, 855, 0, 13929, 13930, 5, 64, 0, 0, 13930, 13931, 3, 1710, 855, 0, 13931, 13944, 1, 0, 0, 0, 13932, 13933, 3, 1710, 855, 0, 13933, 13934, 5, 62, 0, 0, 13934, 13935, 3, 1710, 855, 0, 13935, 13944, 1, 0, 0, 0, 13936, 13937, 3, 1710, 855, 0, 13937, 13938, 5, 129, 0, 0, 13938, 13939, 3, 1710, 855, 0, 13939, 13940, 5, 201, 0, 0, 13940, 13941, 3, 1710, 855, 0, 13941, 13944, 1, 0, 0, 0, 13942, 13944, 3, 1830, 915, 0, 13943, 13916, 1, 0, 0, 0, 13943, 13922, 1, 0, 0, 0, 13943, 13928, 1, 0, 0, 0, 13943, 13932, 1, 0, 0, 0, 13943, 13936, 1, 0, 0, 0, 13943, 13942, 1, 0, 0, 0, 13944, 1853, 1, 0, 0, 0, 13945, 13946, 3, 1710, 855, 0, 13946, 13947, 5, 64, 0, 0, 13947, 13948, 3, 1830, 915, 0, 13948, 13953, 1, 0, 0, 0, 13949, 13950, 5, 64, 0, 0, 13950, 13953, 3, 1830, 915, 0, 13951, 13953, 3, 1830, 915, 0, 13952, 13945, 1, 0, 0, 0, 13952, 13949, 1, 0, 0, 0, 13952, 13951, 1, 0, 0, 0, 13953, 1855, 1, 0, 0, 0, 13954, 13960, 3, 1498, 749, 0, 13955, 13956, 5, 2, 0, 0, 13956, 13957, 3, 1830, 915, 0, 13957, 13958, 5, 3, 0, 0, 13958, 13960, 1, 0, 0, 0, 13959, 13954, 1, 0, 0, 0, 13959, 13955, 1, 0, 0, 0, 13960, 1857, 1, 0, 0, 0, 13961, 13963, 5, 40, 0, 0, 13962, 13964, 3, 1866, 933, 0, 13963, 13962, 1, 0, 0, 0, 13963, 13964, 1, 0, 0, 0, 13964, 13965, 1, 0, 0, 0, 13965, 13967, 3, 1860, 930, 0, 13966, 13968, 3, 1864, 932, 0, 13967, 13966, 1, 0, 0, 0, 13967, 13968, 1, 0, 0, 0, 13968, 13969, 1, 0, 0, 0, 13969, 13970, 5, 653, 0, 0, 13970, 1859, 1, 0, 0, 0, 13971, 13973, 3, 1862, 931, 0, 13972, 13971, 1, 0, 0, 0, 13973, 13974, 1, 0, 0, 0, 13974, 13972, 1, 0, 0, 0, 13974, 13975, 1, 0, 0, 0, 13975, 1861, 1, 0, 0, 0, 13976, 13977, 5, 103, 0, 0, 13977, 13978, 3, 1710, 855, 0, 13978, 13979, 5, 94, 0, 0, 13979, 13980, 3, 1710, 855, 0, 13980, 1863, 1, 0, 0, 0, 13981, 13982, 5, 58, 0, 0, 13982, 13983, 3, 1710, 855, 0, 13983, 1865, 1, 0, 0, 0, 13984, 13985, 3, 1710, 855, 0, 13985, 1867, 1, 0, 0, 0, 13986, 13988, 3, 1924, 962, 0, 13987, 13989, 3, 1874, 937, 0, 13988, 13987, 1, 0, 0, 0, 13988, 13989, 1, 0, 0, 0, 13989, 1869, 1, 0, 0, 0, 13990, 13993, 5, 11, 0, 0, 13991, 13994, 3, 1894, 947, 0, 13992, 13994, 5, 9, 0, 0, 13993, 13991, 1, 0, 0, 0, 13993, 13992, 1, 0, 0, 0, 13994, 14008, 1, 0, 0, 0, 13995, 14004, 5, 4, 0, 0, 13996, 14005, 3, 1710, 855, 0, 13997, 13999, 3, 1872, 936, 0, 13998, 13997, 1, 0, 0, 0, 13998, 13999, 1, 0, 0, 0, 13999, 14000, 1, 0, 0, 0, 14000, 14002, 5, 8, 0, 0, 14001, 14003, 3, 1872, 936, 0, 14002, 14001, 1, 0, 0, 0, 14002, 14003, 1, 0, 0, 0, 14003, 14005, 1, 0, 0, 0, 14004, 13996, 1, 0, 0, 0, 14004, 13998, 1, 0, 0, 0, 14005, 14006, 1, 0, 0, 0, 14006, 14008, 5, 5, 0, 0, 14007, 13990, 1, 0, 0, 0, 14007, 13995, 1, 0, 0, 0, 14008, 1871, 1, 0, 0, 0, 14009, 14010, 3, 1710, 855, 0, 14010, 1873, 1, 0, 0, 0, 14011, 14013, 3, 1870, 935, 0, 14012, 14011, 1, 0, 0, 0, 14013, 14014, 1, 0, 0, 0, 14014, 14012, 1, 0, 0, 0, 14014, 14015, 1, 0, 0, 0, 14015, 1875, 1, 0, 0, 0, 14016, 14018, 3, 1870, 935, 0, 14017, 14016, 1, 0, 0, 0, 14018, 14021, 1, 0, 0, 0, 14019, 14017, 1, 0, 0, 0, 14019, 14020, 1, 0, 0, 0, 14020, 1877, 1, 0, 0, 0, 14021, 14019, 1, 0, 0, 0, 14022, 14023, 3, 1880, 940, 0, 14023, 1879, 1, 0, 0, 0, 14024, 14029, 3, 1882, 941, 0, 14025, 14026, 5, 6, 0, 0, 14026, 14028, 3, 1882, 941, 0, 14027, 14025, 1, 0, 0, 0, 14028, 14031, 1, 0, 0, 0, 14029, 14027, 1, 0, 0, 0, 14029, 14030, 1, 0, 0, 0, 14030, 1881, 1, 0, 0, 0, 14031, 14029, 1, 0, 0, 0, 14032, 14034, 3, 1710, 855, 0, 14033, 14035, 3, 1884, 942, 0, 14034, 14033, 1, 0, 0, 0, 14034, 14035, 1, 0, 0, 0, 14035, 14038, 1, 0, 0, 0, 14036, 14038, 5, 9, 0, 0, 14037, 14032, 1, 0, 0, 0, 14037, 14036, 1, 0, 0, 0, 14038, 1883, 1, 0, 0, 0, 14039, 14040, 5, 36, 0, 0, 14040, 14043, 3, 1932, 966, 0, 14041, 14043, 3, 1934, 967, 0, 14042, 14039, 1, 0, 0, 0, 14042, 14041, 1, 0, 0, 0, 14043, 1885, 1, 0, 0, 0, 14044, 14049, 3, 1888, 944, 0, 14045, 14046, 5, 6, 0, 0, 14046, 14048, 3, 1888, 944, 0, 14047, 14045, 1, 0, 0, 0, 14048, 14051, 1, 0, 0, 0, 14049, 14047, 1, 0, 0, 0, 14049, 14050, 1, 0, 0, 0, 14050, 1887, 1, 0, 0, 0, 14051, 14049, 1, 0, 0, 0, 14052, 14054, 3, 1924, 962, 0, 14053, 14055, 3, 1874, 937, 0, 14054, 14053, 1, 0, 0, 0, 14054, 14055, 1, 0, 0, 0, 14055, 1889, 1, 0, 0, 0, 14056, 14061, 3, 1892, 946, 0, 14057, 14058, 5, 6, 0, 0, 14058, 14060, 3, 1892, 946, 0, 14059, 14057, 1, 0, 0, 0, 14060, 14063, 1, 0, 0, 0, 14061, 14059, 1, 0, 0, 0, 14061, 14062, 1, 0, 0, 0, 14062, 1891, 1, 0, 0, 0, 14063, 14061, 1, 0, 0, 0, 14064, 14065, 3, 1924, 962, 0, 14065, 1893, 1, 0, 0, 0, 14066, 14067, 3, 1932, 966, 0, 14067, 1895, 1, 0, 0, 0, 14068, 14069, 3, 1910, 955, 0, 14069, 1897, 1, 0, 0, 0, 14070, 14078, 3, 1946, 973, 0, 14071, 14078, 3, 1928, 964, 0, 14072, 14073, 3, 1924, 962, 0, 14073, 14074, 3, 1874, 937, 0, 14074, 14078, 1, 0, 0, 0, 14075, 14078, 5, 121, 0, 0, 14076, 14078, 5, 128, 0, 0, 14077, 14070, 1, 0, 0, 0, 14077, 14071, 1, 0, 0, 0, 14077, 14072, 1, 0, 0, 0, 14077, 14075, 1, 0, 0, 0, 14077, 14076, 1, 0, 0, 0, 14078, 1899, 1, 0, 0, 0, 14079, 14115, 3, 1908, 954, 0, 14080, 14115, 3, 1906, 953, 0, 14081, 14115, 3, 1910, 955, 0, 14082, 14115, 3, 1904, 952, 0, 14083, 14115, 3, 1902, 951, 0, 14084, 14094, 3, 1898, 949, 0, 14085, 14095, 3, 1910, 955, 0, 14086, 14087, 5, 2, 0, 0, 14087, 14089, 3, 1832, 916, 0, 14088, 14090, 3, 1540, 770, 0, 14089, 14088, 1, 0, 0, 0, 14089, 14090, 1, 0, 0, 0, 14090, 14091, 1, 0, 0, 0, 14091, 14092, 5, 3, 0, 0, 14092, 14093, 3, 1910, 955, 0, 14093, 14095, 1, 0, 0, 0, 14094, 14085, 1, 0, 0, 0, 14094, 14086, 1, 0, 0, 0, 14095, 14115, 1, 0, 0, 0, 14096, 14097, 3, 1672, 836, 0, 14097, 14098, 3, 1910, 955, 0, 14098, 14115, 1, 0, 0, 0, 14099, 14109, 3, 1700, 850, 0, 14100, 14102, 3, 1910, 955, 0, 14101, 14103, 3, 1704, 852, 0, 14102, 14101, 1, 0, 0, 0, 14102, 14103, 1, 0, 0, 0, 14103, 14110, 1, 0, 0, 0, 14104, 14105, 5, 2, 0, 0, 14105, 14106, 3, 1908, 954, 0, 14106, 14107, 5, 3, 0, 0, 14107, 14108, 3, 1910, 955, 0, 14108, 14110, 1, 0, 0, 0, 14109, 14100, 1, 0, 0, 0, 14109, 14104, 1, 0, 0, 0, 14110, 14115, 1, 0, 0, 0, 14111, 14115, 5, 97, 0, 0, 14112, 14115, 5, 60, 0, 0, 14113, 14115, 5, 78, 0, 0, 14114, 14079, 1, 0, 0, 0, 14114, 14080, 1, 0, 0, 0, 14114, 14081, 1, 0, 0, 0, 14114, 14082, 1, 0, 0, 0, 14114, 14083, 1, 0, 0, 0, 14114, 14084, 1, 0, 0, 0, 14114, 14096, 1, 0, 0, 0, 14114, 14099, 1, 0, 0, 0, 14114, 14111, 1, 0, 0, 0, 14114, 14112, 1, 0, 0, 0, 14114, 14113, 1, 0, 0, 0, 14115, 1901, 1, 0, 0, 0, 14116, 14117, 5, 871, 0, 0, 14117, 1903, 1, 0, 0, 0, 14118, 14119, 5, 867, 0, 0, 14119, 1905, 1, 0, 0, 0, 14120, 14121, 5, 877, 0, 0, 14121, 1907, 1, 0, 0, 0, 14122, 14123, 5, 875, 0, 0, 14123, 1909, 1, 0, 0, 0, 14124, 14126, 3, 1912, 956, 0, 14125, 14127, 3, 1914, 957, 0, 14126, 14125, 1, 0, 0, 0, 14126, 14127, 1, 0, 0, 0, 14127, 1911, 1, 0, 0, 0, 14128, 14140, 5, 862, 0, 0, 14129, 14140, 5, 864, 0, 0, 14130, 14134, 5, 866, 0, 0, 14131, 14133, 5, 894, 0, 0, 14132, 14131, 1, 0, 0, 0, 14133, 14136, 1, 0, 0, 0, 14134, 14132, 1, 0, 0, 0, 14134, 14135, 1, 0, 0, 0, 14135, 14137, 1, 0, 0, 0, 14136, 14134, 1, 0, 0, 0, 14137, 14140, 5, 895, 0, 0, 14138, 14140, 5, 888, 0, 0, 14139, 14128, 1, 0, 0, 0, 14139, 14129, 1, 0, 0, 0, 14139, 14130, 1, 0, 0, 0, 14139, 14138, 1, 0, 0, 0, 14140, 1913, 1, 0, 0, 0, 14141, 14142, 5, 686, 0, 0, 14142, 14143, 3, 1912, 956, 0, 14143, 1915, 1, 0, 0, 0, 14144, 14150, 3, 1908, 954, 0, 14145, 14146, 5, 12, 0, 0, 14146, 14150, 3, 1908, 954, 0, 14147, 14148, 5, 13, 0, 0, 14148, 14150, 3, 1908, 954, 0, 14149, 14144, 1, 0, 0, 0, 14149, 14145, 1, 0, 0, 0, 14149, 14147, 1, 0, 0, 0, 14150, 1917, 1, 0, 0, 0, 14151, 14152, 3, 1920, 960, 0, 14152, 1919, 1, 0, 0, 0, 14153, 14158, 3, 1930, 965, 0, 14154, 14158, 5, 853, 0, 0, 14155, 14158, 5, 52, 0, 0, 14156, 14158, 5, 90, 0, 0, 14157, 14153, 1, 0, 0, 0, 14157, 14154, 1, 0, 0, 0, 14157, 14155, 1, 0, 0, 0, 14157, 14156, 1, 0, 0, 0, 14158, 1921, 1, 0, 0, 0, 14159, 14164, 3, 1920, 960, 0, 14160, 14161, 5, 6, 0, 0, 14161, 14163, 3, 1920, 960, 0, 14162, 14160, 1, 0, 0, 0, 14163, 14166, 1, 0, 0, 0, 14164, 14162, 1, 0, 0, 0, 14164, 14165, 1, 0, 0, 0, 14165, 1923, 1, 0, 0, 0, 14166, 14164, 1, 0, 0, 0, 14167, 14174, 3, 1934, 967, 0, 14168, 14174, 3, 1938, 969, 0, 14169, 14174, 3, 1940, 970, 0, 14170, 14174, 3, 2160, 1080, 0, 14171, 14174, 5, 121, 0, 0, 14172, 14174, 5, 128, 0, 0, 14173, 14167, 1, 0, 0, 0, 14173, 14168, 1, 0, 0, 0, 14173, 14169, 1, 0, 0, 0, 14173, 14170, 1, 0, 0, 0, 14173, 14171, 1, 0, 0, 0, 14173, 14172, 1, 0, 0, 0, 14174, 1925, 1, 0, 0, 0, 14175, 14180, 3, 1934, 967, 0, 14176, 14180, 3, 1938, 969, 0, 14177, 14180, 3, 1940, 970, 0, 14178, 14180, 3, 2160, 1080, 0, 14179, 14175, 1, 0, 0, 0, 14179, 14176, 1, 0, 0, 0, 14179, 14177, 1, 0, 0, 0, 14179, 14178, 1, 0, 0, 0, 14180, 1927, 1, 0, 0, 0, 14181, 14186, 3, 1934, 967, 0, 14182, 14186, 3, 1938, 969, 0, 14183, 14186, 3, 2160, 1080, 0, 14184, 14186, 3, 1942, 971, 0, 14185, 14181, 1, 0, 0, 0, 14185, 14182, 1, 0, 0, 0, 14185, 14183, 1, 0, 0, 0, 14185, 14184, 1, 0, 0, 0, 14186, 1929, 1, 0, 0, 0, 14187, 14192, 3, 1934, 967, 0, 14188, 14192, 3, 1938, 969, 0, 14189, 14192, 3, 1940, 970, 0, 14190, 14192, 3, 1942, 971, 0, 14191, 14187, 1, 0, 0, 0, 14191, 14188, 1, 0, 0, 0, 14191, 14189, 1, 0, 0, 0, 14191, 14190, 1, 0, 0, 0, 14192, 1931, 1, 0, 0, 0, 14193, 14200, 3, 1934, 967, 0, 14194, 14200, 3, 2160, 1080, 0, 14195, 14200, 3, 1938, 969, 0, 14196, 14200, 3, 1940, 970, 0, 14197, 14200, 3, 1942, 971, 0, 14198, 14200, 3, 1944, 972, 0, 14199, 14193, 1, 0, 0, 0, 14199, 14194, 1, 0, 0, 0, 14199, 14195, 1, 0, 0, 0, 14199, 14196, 1, 0, 0, 0, 14199, 14197, 1, 0, 0, 0, 14199, 14198, 1, 0, 0, 0, 14200, 1933, 1, 0, 0, 0, 14201, 14203, 5, 851, 0, 0, 14202, 14204, 3, 1914, 957, 0, 14203, 14202, 1, 0, 0, 0, 14203, 14204, 1, 0, 0, 0, 14204, 14211, 1, 0, 0, 0, 14205, 14211, 5, 854, 0, 0, 14206, 14211, 5, 858, 0, 0, 14207, 14211, 3, 1758, 879, 0, 14208, 14211, 3, 1936, 968, 0, 14209, 14211, 3, 2160, 1080, 0, 14210, 14201, 1, 0, 0, 0, 14210, 14205, 1, 0, 0, 0, 14210, 14206, 1, 0, 0, 0, 14210, 14207, 1, 0, 0, 0, 14210, 14208, 1, 0, 0, 0, 14210, 14209, 1, 0, 0, 0, 14211, 1935, 1, 0, 0, 0, 14212, 14213, 5, 879, 0, 0, 14213, 1937, 1, 0, 0, 0, 14214, 14215, 7, 101, 0, 0, 14215, 1939, 1, 0, 0, 0, 14216, 14308, 5, 549, 0, 0, 14217, 14308, 5, 550, 0, 0, 14218, 14308, 3, 1682, 841, 0, 14219, 14308, 5, 552, 0, 0, 14220, 14308, 5, 553, 0, 0, 14221, 14308, 3, 1690, 845, 0, 14222, 14308, 5, 555, 0, 0, 14223, 14308, 5, 556, 0, 0, 14224, 14308, 5, 557, 0, 0, 14225, 14308, 5, 558, 0, 0, 14226, 14308, 5, 559, 0, 0, 14227, 14308, 5, 560, 0, 0, 14228, 14308, 5, 561, 0, 0, 14229, 14308, 5, 669, 0, 0, 14230, 14308, 5, 562, 0, 0, 14231, 14308, 5, 563, 0, 0, 14232, 14308, 5, 564, 0, 0, 14233, 14308, 5, 565, 0, 0, 14234, 14308, 5, 174, 0, 0, 14235, 14308, 5, 533, 0, 0, 14236, 14308, 5, 534, 0, 0, 14237, 14308, 5, 524, 0, 0, 14238, 14308, 5, 525, 0, 0, 14239, 14308, 5, 526, 0, 0, 14240, 14308, 5, 527, 0, 0, 14241, 14308, 5, 531, 0, 0, 14242, 14308, 5, 532, 0, 0, 14243, 14308, 5, 529, 0, 0, 14244, 14308, 5, 530, 0, 0, 14245, 14308, 5, 535, 0, 0, 14246, 14308, 5, 536, 0, 0, 14247, 14308, 5, 528, 0, 0, 14248, 14308, 5, 538, 0, 0, 14249, 14308, 5, 445, 0, 0, 14250, 14308, 5, 199, 0, 0, 14251, 14308, 5, 523, 0, 0, 14252, 14308, 5, 537, 0, 0, 14253, 14308, 5, 539, 0, 0, 14254, 14308, 5, 540, 0, 0, 14255, 14308, 5, 520, 0, 0, 14256, 14308, 5, 542, 0, 0, 14257, 14308, 5, 543, 0, 0, 14258, 14308, 5, 544, 0, 0, 14259, 14308, 5, 452, 0, 0, 14260, 14308, 5, 451, 0, 0, 14261, 14308, 5, 522, 0, 0, 14262, 14308, 5, 453, 0, 0, 14263, 14308, 5, 513, 0, 0, 14264, 14308, 5, 521, 0, 0, 14265, 14308, 5, 517, 0, 0, 14266, 14308, 5, 490, 0, 0, 14267, 14308, 5, 187, 0, 0, 14268, 14308, 5, 198, 0, 0, 14269, 14308, 5, 461, 0, 0, 14270, 14308, 5, 296, 0, 0, 14271, 14308, 5, 506, 0, 0, 14272, 14308, 5, 566, 0, 0, 14273, 14308, 5, 567, 0, 0, 14274, 14308, 5, 568, 0, 0, 14275, 14308, 5, 569, 0, 0, 14276, 14308, 5, 688, 0, 0, 14277, 14308, 5, 570, 0, 0, 14278, 14308, 3, 1678, 839, 0, 14279, 14308, 5, 79, 0, 0, 14280, 14308, 5, 652, 0, 0, 14281, 14308, 5, 572, 0, 0, 14282, 14308, 5, 574, 0, 0, 14283, 14308, 5, 575, 0, 0, 14284, 14308, 5, 576, 0, 0, 14285, 14308, 5, 577, 0, 0, 14286, 14308, 5, 578, 0, 0, 14287, 14308, 5, 579, 0, 0, 14288, 14308, 5, 580, 0, 0, 14289, 14308, 5, 581, 0, 0, 14290, 14308, 5, 582, 0, 0, 14291, 14308, 5, 583, 0, 0, 14292, 14308, 5, 584, 0, 0, 14293, 14308, 5, 585, 0, 0, 14294, 14308, 5, 586, 0, 0, 14295, 14308, 5, 587, 0, 0, 14296, 14308, 5, 595, 0, 0, 14297, 14308, 5, 596, 0, 0, 14298, 14308, 5, 597, 0, 0, 14299, 14308, 5, 598, 0, 0, 14300, 14308, 5, 675, 0, 0, 14301, 14308, 5, 599, 0, 0, 14302, 14308, 5, 600, 0, 0, 14303, 14308, 5, 601, 0, 0, 14304, 14308, 5, 602, 0, 0, 14305, 14308, 5, 673, 0, 0, 14306, 14308, 3, 1946, 973, 0, 14307, 14216, 1, 0, 0, 0, 14307, 14217, 1, 0, 0, 0, 14307, 14218, 1, 0, 0, 0, 14307, 14219, 1, 0, 0, 0, 14307, 14220, 1, 0, 0, 0, 14307, 14221, 1, 0, 0, 0, 14307, 14222, 1, 0, 0, 0, 14307, 14223, 1, 0, 0, 0, 14307, 14224, 1, 0, 0, 0, 14307, 14225, 1, 0, 0, 0, 14307, 14226, 1, 0, 0, 0, 14307, 14227, 1, 0, 0, 0, 14307, 14228, 1, 0, 0, 0, 14307, 14229, 1, 0, 0, 0, 14307, 14230, 1, 0, 0, 0, 14307, 14231, 1, 0, 0, 0, 14307, 14232, 1, 0, 0, 0, 14307, 14233, 1, 0, 0, 0, 14307, 14234, 1, 0, 0, 0, 14307, 14235, 1, 0, 0, 0, 14307, 14236, 1, 0, 0, 0, 14307, 14237, 1, 0, 0, 0, 14307, 14238, 1, 0, 0, 0, 14307, 14239, 1, 0, 0, 0, 14307, 14240, 1, 0, 0, 0, 14307, 14241, 1, 0, 0, 0, 14307, 14242, 1, 0, 0, 0, 14307, 14243, 1, 0, 0, 0, 14307, 14244, 1, 0, 0, 0, 14307, 14245, 1, 0, 0, 0, 14307, 14246, 1, 0, 0, 0, 14307, 14247, 1, 0, 0, 0, 14307, 14248, 1, 0, 0, 0, 14307, 14249, 1, 0, 0, 0, 14307, 14250, 1, 0, 0, 0, 14307, 14251, 1, 0, 0, 0, 14307, 14252, 1, 0, 0, 0, 14307, 14253, 1, 0, 0, 0, 14307, 14254, 1, 0, 0, 0, 14307, 14255, 1, 0, 0, 0, 14307, 14256, 1, 0, 0, 0, 14307, 14257, 1, 0, 0, 0, 14307, 14258, 1, 0, 0, 0, 14307, 14259, 1, 0, 0, 0, 14307, 14260, 1, 0, 0, 0, 14307, 14261, 1, 0, 0, 0, 14307, 14262, 1, 0, 0, 0, 14307, 14263, 1, 0, 0, 0, 14307, 14264, 1, 0, 0, 0, 14307, 14265, 1, 0, 0, 0, 14307, 14266, 1, 0, 0, 0, 14307, 14267, 1, 0, 0, 0, 14307, 14268, 1, 0, 0, 0, 14307, 14269, 1, 0, 0, 0, 14307, 14270, 1, 0, 0, 0, 14307, 14271, 1, 0, 0, 0, 14307, 14272, 1, 0, 0, 0, 14307, 14273, 1, 0, 0, 0, 14307, 14274, 1, 0, 0, 0, 14307, 14275, 1, 0, 0, 0, 14307, 14276, 1, 0, 0, 0, 14307, 14277, 1, 0, 0, 0, 14307, 14278, 1, 0, 0, 0, 14307, 14279, 1, 0, 0, 0, 14307, 14280, 1, 0, 0, 0, 14307, 14281, 1, 0, 0, 0, 14307, 14282, 1, 0, 0, 0, 14307, 14283, 1, 0, 0, 0, 14307, 14284, 1, 0, 0, 0, 14307, 14285, 1, 0, 0, 0, 14307, 14286, 1, 0, 0, 0, 14307, 14287, 1, 0, 0, 0, 14307, 14288, 1, 0, 0, 0, 14307, 14289, 1, 0, 0, 0, 14307, 14290, 1, 0, 0, 0, 14307, 14291, 1, 0, 0, 0, 14307, 14292, 1, 0, 0, 0, 14307, 14293, 1, 0, 0, 0, 14307, 14294, 1, 0, 0, 0, 14307, 14295, 1, 0, 0, 0, 14307, 14296, 1, 0, 0, 0, 14307, 14297, 1, 0, 0, 0, 14307, 14298, 1, 0, 0, 0, 14307, 14299, 1, 0, 0, 0, 14307, 14300, 1, 0, 0, 0, 14307, 14301, 1, 0, 0, 0, 14307, 14302, 1, 0, 0, 0, 14307, 14303, 1, 0, 0, 0, 14307, 14304, 1, 0, 0, 0, 14307, 14305, 1, 0, 0, 0, 14307, 14306, 1, 0, 0, 0, 14308, 1941, 1, 0, 0, 0, 14309, 14310, 7, 102, 0, 0, 14310, 1943, 1, 0, 0, 0, 14311, 14312, 7, 103, 0, 0, 14312, 1945, 1, 0, 0, 0, 14313, 14314, 7, 104, 0, 0, 14314, 1947, 1, 0, 0, 0, 14315, 14316, 3, 1950, 975, 0, 14316, 14318, 3, 1960, 980, 0, 14317, 14319, 3, 1958, 979, 0, 14318, 14317, 1, 0, 0, 0, 14318, 14319, 1, 0, 0, 0, 14319, 1949, 1, 0, 0, 0, 14320, 14322, 3, 1952, 976, 0, 14321, 14320, 1, 0, 0, 0, 14322, 14325, 1, 0, 0, 0, 14323, 14321, 1, 0, 0, 0, 14323, 14324, 1, 0, 0, 0, 14324, 1951, 1, 0, 0, 0, 14325, 14323, 1, 0, 0, 0, 14326, 14327, 3, 1954, 977, 0, 14327, 14328, 5, 276, 0, 0, 14328, 14329, 5, 689, 0, 0, 14329, 14347, 1, 0, 0, 0, 14330, 14331, 3, 1954, 977, 0, 14331, 14332, 5, 690, 0, 0, 14332, 14333, 3, 1956, 978, 0, 14333, 14347, 1, 0, 0, 0, 14334, 14335, 3, 1954, 977, 0, 14335, 14336, 5, 691, 0, 0, 14336, 14337, 5, 692, 0, 0, 14337, 14347, 1, 0, 0, 0, 14338, 14339, 3, 1954, 977, 0, 14339, 14340, 5, 691, 0, 0, 14340, 14341, 5, 693, 0, 0, 14341, 14347, 1, 0, 0, 0, 14342, 14343, 3, 1954, 977, 0, 14343, 14344, 5, 691, 0, 0, 14344, 14345, 5, 694, 0, 0, 14345, 14347, 1, 0, 0, 0, 14346, 14326, 1, 0, 0, 0, 14346, 14330, 1, 0, 0, 0, 14346, 14334, 1, 0, 0, 0, 14346, 14338, 1, 0, 0, 0, 14346, 14342, 1, 0, 0, 0, 14347, 1953, 1, 0, 0, 0, 14348, 14349, 5, 29, 0, 0, 14349, 1955, 1, 0, 0, 0, 14350, 14355, 3, 1910, 955, 0, 14351, 14355, 3, 1944, 972, 0, 14352, 14355, 3, 2160, 1080, 0, 14353, 14355, 3, 1938, 969, 0, 14354, 14350, 1, 0, 0, 0, 14354, 14351, 1, 0, 0, 0, 14354, 14352, 1, 0, 0, 0, 14354, 14353, 1, 0, 0, 0, 14355, 1957, 1, 0, 0, 0, 14356, 14357, 5, 7, 0, 0, 14357, 1959, 1, 0, 0, 0, 14358, 14359, 3, 1962, 981, 0, 14359, 14360, 5, 148, 0, 0, 14360, 14362, 3, 2004, 1002, 0, 14361, 14363, 3, 2140, 1070, 0, 14362, 14361, 1, 0, 0, 0, 14362, 14363, 1, 0, 0, 0, 14363, 14364, 1, 0, 0, 0, 14364, 14366, 5, 653, 0, 0, 14365, 14367, 3, 2154, 1077, 0, 14366, 14365, 1, 0, 0, 0, 14366, 14367, 1, 0, 0, 0, 14367, 1961, 1, 0, 0, 0, 14368, 14370, 3, 2150, 1075, 0, 14369, 14368, 1, 0, 0, 0, 14369, 14370, 1, 0, 0, 0, 14370, 14375, 1, 0, 0, 0, 14371, 14373, 3, 1964, 982, 0, 14372, 14374, 3, 1966, 983, 0, 14373, 14372, 1, 0, 0, 0, 14373, 14374, 1, 0, 0, 0, 14374, 14376, 1, 0, 0, 0, 14375, 14371, 1, 0, 0, 0, 14375, 14376, 1, 0, 0, 0, 14376, 1963, 1, 0, 0, 0, 14377, 14378, 5, 182, 0, 0, 14378, 1965, 1, 0, 0, 0, 14379, 14381, 3, 1970, 985, 0, 14380, 14379, 1, 0, 0, 0, 14381, 14382, 1, 0, 0, 0, 14382, 14380, 1, 0, 0, 0, 14382, 14383, 1, 0, 0, 0, 14383, 1967, 1, 0, 0, 0, 14384, 14385, 5, 18, 0, 0, 14385, 14386, 3, 2158, 1079, 0, 14386, 14387, 5, 19, 0, 0, 14387, 1969, 1, 0, 0, 0, 14388, 14392, 3, 1972, 986, 0, 14389, 14392, 5, 182, 0, 0, 14390, 14392, 3, 1968, 984, 0, 14391, 14388, 1, 0, 0, 0, 14391, 14389, 1, 0, 0, 0, 14391, 14390, 1, 0, 0, 0, 14392, 1971, 1, 0, 0, 0, 14393, 14420, 3, 1988, 994, 0, 14394, 14395, 5, 695, 0, 0, 14395, 14396, 5, 62, 0, 0, 14396, 14421, 3, 1986, 993, 0, 14397, 14399, 3, 1990, 995, 0, 14398, 14397, 1, 0, 0, 0, 14398, 14399, 1, 0, 0, 0, 14399, 14400, 1, 0, 0, 0, 14400, 14402, 3, 1992, 996, 0, 14401, 14403, 3, 1994, 997, 0, 14402, 14401, 1, 0, 0, 0, 14402, 14403, 1, 0, 0, 0, 14403, 14405, 1, 0, 0, 0, 14404, 14406, 3, 1996, 998, 0, 14405, 14404, 1, 0, 0, 0, 14405, 14406, 1, 0, 0, 0, 14406, 14408, 1, 0, 0, 0, 14407, 14409, 3, 1998, 999, 0, 14408, 14407, 1, 0, 0, 0, 14408, 14409, 1, 0, 0, 0, 14409, 14421, 1, 0, 0, 0, 14410, 14412, 3, 1974, 987, 0, 14411, 14410, 1, 0, 0, 0, 14411, 14412, 1, 0, 0, 0, 14412, 14413, 1, 0, 0, 0, 14413, 14415, 5, 175, 0, 0, 14414, 14416, 3, 1978, 989, 0, 14415, 14414, 1, 0, 0, 0, 14415, 14416, 1, 0, 0, 0, 14416, 14417, 1, 0, 0, 0, 14417, 14418, 3, 1984, 992, 0, 14418, 14419, 3, 1976, 988, 0, 14419, 14421, 1, 0, 0, 0, 14420, 14394, 1, 0, 0, 0, 14420, 14398, 1, 0, 0, 0, 14420, 14411, 1, 0, 0, 0, 14421, 14422, 1, 0, 0, 0, 14422, 14423, 5, 7, 0, 0, 14423, 1973, 1, 0, 0, 0, 14424, 14425, 5, 266, 0, 0, 14425, 14428, 5, 322, 0, 0, 14426, 14428, 5, 322, 0, 0, 14427, 14424, 1, 0, 0, 0, 14427, 14426, 1, 0, 0, 0, 14428, 1975, 1, 0, 0, 0, 14429, 14430, 3, 1496, 748, 0, 14430, 1977, 1, 0, 0, 0, 14431, 14432, 5, 2, 0, 0, 14432, 14433, 3, 1980, 990, 0, 14433, 14434, 5, 3, 0, 0, 14434, 1979, 1, 0, 0, 0, 14435, 14440, 3, 1982, 991, 0, 14436, 14437, 5, 6, 0, 0, 14437, 14439, 3, 1982, 991, 0, 14438, 14436, 1, 0, 0, 0, 14439, 14442, 1, 0, 0, 0, 14440, 14438, 1, 0, 0, 0, 14440, 14441, 1, 0, 0, 0, 14441, 1981, 1, 0, 0, 0, 14442, 14440, 1, 0, 0, 0, 14443, 14444, 3, 1988, 994, 0, 14444, 14445, 3, 1992, 996, 0, 14445, 1983, 1, 0, 0, 0, 14446, 14447, 7, 105, 0, 0, 14447, 1985, 1, 0, 0, 0, 14448, 14451, 5, 28, 0, 0, 14449, 14451, 3, 1924, 962, 0, 14450, 14448, 1, 0, 0, 0, 14450, 14449, 1, 0, 0, 0, 14451, 1987, 1, 0, 0, 0, 14452, 14453, 3, 2158, 1079, 0, 14453, 1989, 1, 0, 0, 0, 14454, 14455, 5, 696, 0, 0, 14455, 1991, 1, 0, 0, 0, 14456, 14457, 3, 1662, 831, 0, 14457, 1993, 1, 0, 0, 0, 14458, 14459, 5, 43, 0, 0, 14459, 14460, 3, 566, 283, 0, 14460, 1995, 1, 0, 0, 0, 14461, 14462, 5, 77, 0, 0, 14462, 14463, 5, 78, 0, 0, 14463, 1997, 1, 0, 0, 0, 14464, 14465, 3, 2000, 1000, 0, 14465, 14466, 3, 2162, 1081, 0, 14466, 1999, 1, 0, 0, 0, 14467, 14470, 3, 2002, 1001, 0, 14468, 14470, 5, 53, 0, 0, 14469, 14467, 1, 0, 0, 0, 14469, 14468, 1, 0, 0, 0, 14470, 2001, 1, 0, 0, 0, 14471, 14472, 7, 106, 0, 0, 14472, 2003, 1, 0, 0, 0, 14473, 14475, 3, 2006, 1003, 0, 14474, 14473, 1, 0, 0, 0, 14475, 14478, 1, 0, 0, 0, 14476, 14474, 1, 0, 0, 0, 14476, 14477, 1, 0, 0, 0, 14477, 2005, 1, 0, 0, 0, 14478, 14476, 1, 0, 0, 0, 14479, 14480, 3, 1960, 980, 0, 14480, 14481, 5, 7, 0, 0, 14481, 14507, 1, 0, 0, 0, 14482, 14507, 3, 2072, 1036, 0, 14483, 14507, 3, 2076, 1038, 0, 14484, 14507, 3, 2014, 1007, 0, 14485, 14507, 3, 2030, 1015, 0, 14486, 14507, 3, 2036, 1018, 0, 14487, 14507, 3, 2046, 1023, 0, 14488, 14507, 3, 2048, 1024, 0, 14489, 14507, 3, 2050, 1025, 0, 14490, 14507, 3, 2064, 1032, 0, 14491, 14507, 3, 2068, 1034, 0, 14492, 14507, 3, 2088, 1044, 0, 14493, 14507, 3, 2094, 1047, 0, 14494, 14507, 3, 2096, 1048, 0, 14495, 14507, 3, 2008, 1004, 0, 14496, 14507, 3, 2010, 1005, 0, 14497, 14507, 3, 2016, 1008, 0, 14498, 14507, 3, 2104, 1052, 0, 14499, 14507, 3, 2116, 1058, 0, 14500, 14507, 3, 2124, 1062, 0, 14501, 14507, 3, 2126, 1063, 0, 14502, 14507, 3, 2128, 1064, 0, 14503, 14507, 3, 2130, 1065, 0, 14504, 14507, 3, 2132, 1066, 0, 14505, 14507, 3, 2136, 1068, 0, 14506, 14479, 1, 0, 0, 0, 14506, 14482, 1, 0, 0, 0, 14506, 14483, 1, 0, 0, 0, 14506, 14484, 1, 0, 0, 0, 14506, 14485, 1, 0, 0, 0, 14506, 14486, 1, 0, 0, 0, 14506, 14487, 1, 0, 0, 0, 14506, 14488, 1, 0, 0, 0, 14506, 14489, 1, 0, 0, 0, 14506, 14490, 1, 0, 0, 0, 14506, 14491, 1, 0, 0, 0, 14506, 14492, 1, 0, 0, 0, 14506, 14493, 1, 0, 0, 0, 14506, 14494, 1, 0, 0, 0, 14506, 14495, 1, 0, 0, 0, 14506, 14496, 1, 0, 0, 0, 14506, 14497, 1, 0, 0, 0, 14506, 14498, 1, 0, 0, 0, 14506, 14499, 1, 0, 0, 0, 14506, 14500, 1, 0, 0, 0, 14506, 14501, 1, 0, 0, 0, 14506, 14502, 1, 0, 0, 0, 14506, 14503, 1, 0, 0, 0, 14506, 14504, 1, 0, 0, 0, 14506, 14505, 1, 0, 0, 0, 14507, 2007, 1, 0, 0, 0, 14508, 14509, 5, 697, 0, 0, 14509, 14510, 3, 2166, 1083, 0, 14510, 14511, 5, 7, 0, 0, 14511, 2009, 1, 0, 0, 0, 14512, 14513, 5, 603, 0, 0, 14513, 14514, 3, 2158, 1079, 0, 14514, 14516, 5, 2, 0, 0, 14515, 14517, 3, 2012, 1006, 0, 14516, 14515, 1, 0, 0, 0, 14516, 14517, 1, 0, 0, 0, 14517, 14518, 1, 0, 0, 0, 14518, 14519, 5, 3, 0, 0, 14519, 14520, 5, 7, 0, 0, 14520, 14531, 1, 0, 0, 0, 14521, 14522, 5, 57, 0, 0, 14522, 14523, 3, 2158, 1079, 0, 14523, 14525, 5, 2, 0, 0, 14524, 14526, 3, 2012, 1006, 0, 14525, 14524, 1, 0, 0, 0, 14525, 14526, 1, 0, 0, 0, 14526, 14527, 1, 0, 0, 0, 14527, 14528, 5, 3, 0, 0, 14528, 14529, 5, 7, 0, 0, 14529, 14531, 1, 0, 0, 0, 14530, 14512, 1, 0, 0, 0, 14530, 14521, 1, 0, 0, 0, 14531, 2011, 1, 0, 0, 0, 14532, 14533, 3, 1830, 915, 0, 14533, 2013, 1, 0, 0, 0, 14534, 14535, 3, 2028, 1014, 0, 14535, 14536, 3, 2002, 1001, 0, 14536, 14537, 3, 2162, 1081, 0, 14537, 14538, 5, 7, 0, 0, 14538, 2015, 1, 0, 0, 0, 14539, 14541, 5, 698, 0, 0, 14540, 14542, 3, 2018, 1009, 0, 14541, 14540, 1, 0, 0, 0, 14541, 14542, 1, 0, 0, 0, 14542, 14543, 1, 0, 0, 0, 14543, 14544, 5, 699, 0, 0, 14544, 14545, 3, 2020, 1010, 0, 14545, 14546, 5, 7, 0, 0, 14546, 2017, 1, 0, 0, 0, 14547, 14548, 7, 107, 0, 0, 14548, 2019, 1, 0, 0, 0, 14549, 14554, 3, 2022, 1011, 0, 14550, 14551, 5, 6, 0, 0, 14551, 14553, 3, 2022, 1011, 0, 14552, 14550, 1, 0, 0, 0, 14553, 14556, 1, 0, 0, 0, 14554, 14552, 1, 0, 0, 0, 14554, 14555, 1, 0, 0, 0, 14555, 2021, 1, 0, 0, 0, 14556, 14554, 1, 0, 0, 0, 14557, 14558, 3, 2026, 1013, 0, 14558, 14559, 3, 2002, 1001, 0, 14559, 14560, 3, 2024, 1012, 0, 14560, 2023, 1, 0, 0, 0, 14561, 14562, 3, 1924, 962, 0, 14562, 2025, 1, 0, 0, 0, 14563, 14564, 3, 2028, 1014, 0, 14564, 2027, 1, 0, 0, 0, 14565, 14568, 3, 566, 283, 0, 14566, 14568, 5, 28, 0, 0, 14567, 14565, 1, 0, 0, 0, 14567, 14566, 1, 0, 0, 0, 14568, 14575, 1, 0, 0, 0, 14569, 14570, 5, 4, 0, 0, 14570, 14571, 3, 2168, 1084, 0, 14571, 14572, 5, 5, 0, 0, 14572, 14574, 1, 0, 0, 0, 14573, 14569, 1, 0, 0, 0, 14574, 14577, 1, 0, 0, 0, 14575, 14573, 1, 0, 0, 0, 14575, 14576, 1, 0, 0, 0, 14576, 2029, 1, 0, 0, 0, 14577, 14575, 1, 0, 0, 0, 14578, 14579, 5, 224, 0, 0, 14579, 14580, 3, 2164, 1082, 0, 14580, 14581, 5, 94, 0, 0, 14581, 14582, 3, 2004, 1002, 0, 14582, 14584, 3, 2032, 1016, 0, 14583, 14585, 3, 2034, 1017, 0, 14584, 14583, 1, 0, 0, 0, 14584, 14585, 1, 0, 0, 0, 14585, 14586, 1, 0, 0, 0, 14586, 14587, 5, 653, 0, 0, 14587, 14588, 5, 224, 0, 0, 14588, 14589, 5, 7, 0, 0, 14589, 2031, 1, 0, 0, 0, 14590, 14591, 5, 701, 0, 0, 14591, 14592, 3, 1710, 855, 0, 14592, 14593, 5, 94, 0, 0, 14593, 14594, 3, 2004, 1002, 0, 14594, 14596, 1, 0, 0, 0, 14595, 14590, 1, 0, 0, 0, 14596, 14599, 1, 0, 0, 0, 14597, 14595, 1, 0, 0, 0, 14597, 14598, 1, 0, 0, 0, 14598, 2033, 1, 0, 0, 0, 14599, 14597, 1, 0, 0, 0, 14600, 14601, 5, 58, 0, 0, 14601, 14602, 3, 2004, 1002, 0, 14602, 2035, 1, 0, 0, 0, 14603, 14605, 5, 40, 0, 0, 14604, 14606, 3, 2038, 1019, 0, 14605, 14604, 1, 0, 0, 0, 14605, 14606, 1, 0, 0, 0, 14606, 14607, 1, 0, 0, 0, 14607, 14609, 3, 2040, 1020, 0, 14608, 14610, 3, 2044, 1022, 0, 14609, 14608, 1, 0, 0, 0, 14609, 14610, 1, 0, 0, 0, 14610, 14611, 1, 0, 0, 0, 14611, 14612, 5, 653, 0, 0, 14612, 14613, 5, 40, 0, 0, 14613, 14614, 5, 7, 0, 0, 14614, 2037, 1, 0, 0, 0, 14615, 14616, 3, 2162, 1081, 0, 14616, 2039, 1, 0, 0, 0, 14617, 14619, 3, 2042, 1021, 0, 14618, 14617, 1, 0, 0, 0, 14619, 14620, 1, 0, 0, 0, 14620, 14618, 1, 0, 0, 0, 14620, 14621, 1, 0, 0, 0, 14621, 2041, 1, 0, 0, 0, 14622, 14623, 5, 103, 0, 0, 14623, 14624, 3, 1830, 915, 0, 14624, 14625, 5, 94, 0, 0, 14625, 14626, 3, 2004, 1002, 0, 14626, 2043, 1, 0, 0, 0, 14627, 14628, 5, 58, 0, 0, 14628, 14629, 3, 2004, 1002, 0, 14629, 2045, 1, 0, 0, 0, 14630, 14632, 3, 2152, 1076, 0, 14631, 14630, 1, 0, 0, 0, 14631, 14632, 1, 0, 0, 0, 14632, 14633, 1, 0, 0, 0, 14633, 14634, 3, 2092, 1046, 0, 14634, 2047, 1, 0, 0, 0, 14635, 14637, 3, 2152, 1076, 0, 14636, 14635, 1, 0, 0, 0, 14636, 14637, 1, 0, 0, 0, 14637, 14638, 1, 0, 0, 0, 14638, 14639, 5, 702, 0, 0, 14639, 14640, 3, 2170, 1085, 0, 14640, 14641, 3, 2092, 1046, 0, 14641, 2049, 1, 0, 0, 0, 14642, 14644, 3, 2152, 1076, 0, 14643, 14642, 1, 0, 0, 0, 14643, 14644, 1, 0, 0, 0, 14644, 14645, 1, 0, 0, 0, 14645, 14646, 5, 62, 0, 0, 14646, 14647, 3, 2052, 1026, 0, 14647, 14648, 3, 2092, 1046, 0, 14648, 2051, 1, 0, 0, 0, 14649, 14650, 3, 2062, 1031, 0, 14650, 14671, 5, 68, 0, 0, 14651, 14653, 3, 1490, 745, 0, 14652, 14654, 3, 2056, 1028, 0, 14653, 14652, 1, 0, 0, 0, 14653, 14654, 1, 0, 0, 0, 14654, 14672, 1, 0, 0, 0, 14655, 14672, 3, 1496, 748, 0, 14656, 14672, 3, 1412, 706, 0, 14657, 14658, 5, 206, 0, 0, 14658, 14660, 3, 1710, 855, 0, 14659, 14661, 3, 2054, 1027, 0, 14660, 14659, 1, 0, 0, 0, 14660, 14661, 1, 0, 0, 0, 14661, 14672, 1, 0, 0, 0, 14662, 14664, 3, 2058, 1029, 0, 14663, 14662, 1, 0, 0, 0, 14663, 14664, 1, 0, 0, 0, 14664, 14665, 1, 0, 0, 0, 14665, 14666, 3, 1710, 855, 0, 14666, 14667, 5, 24, 0, 0, 14667, 14669, 3, 1710, 855, 0, 14668, 14670, 3, 2060, 1030, 0, 14669, 14668, 1, 0, 0, 0, 14669, 14670, 1, 0, 0, 0, 14670, 14672, 1, 0, 0, 0, 14671, 14651, 1, 0, 0, 0, 14671, 14655, 1, 0, 0, 0, 14671, 14656, 1, 0, 0, 0, 14671, 14657, 1, 0, 0, 0, 14671, 14663, 1, 0, 0, 0, 14672, 2053, 1, 0, 0, 0, 14673, 14674, 5, 101, 0, 0, 14674, 14675, 3, 1830, 915, 0, 14675, 2055, 1, 0, 0, 0, 14676, 14677, 5, 2, 0, 0, 14677, 14682, 3, 1710, 855, 0, 14678, 14679, 5, 6, 0, 0, 14679, 14681, 3, 1710, 855, 0, 14680, 14678, 1, 0, 0, 0, 14681, 14684, 1, 0, 0, 0, 14682, 14680, 1, 0, 0, 0, 14682, 14683, 1, 0, 0, 0, 14683, 14685, 1, 0, 0, 0, 14684, 14682, 1, 0, 0, 0, 14685, 14686, 5, 3, 0, 0, 14686, 2057, 1, 0, 0, 0, 14687, 14688, 5, 703, 0, 0, 14688, 2059, 1, 0, 0, 0, 14689, 14690, 5, 149, 0, 0, 14690, 14691, 3, 1710, 855, 0, 14691, 2061, 1, 0, 0, 0, 14692, 14693, 3, 564, 282, 0, 14693, 2063, 1, 0, 0, 0, 14694, 14696, 3, 2152, 1076, 0, 14695, 14694, 1, 0, 0, 0, 14695, 14696, 1, 0, 0, 0, 14696, 14697, 1, 0, 0, 0, 14697, 14698, 5, 704, 0, 0, 14698, 14700, 3, 2062, 1031, 0, 14699, 14701, 3, 2066, 1033, 0, 14700, 14699, 1, 0, 0, 0, 14700, 14701, 1, 0, 0, 0, 14701, 14702, 1, 0, 0, 0, 14702, 14703, 5, 68, 0, 0, 14703, 14704, 5, 35, 0, 0, 14704, 14705, 3, 1710, 855, 0, 14705, 14706, 3, 2092, 1046, 0, 14706, 2065, 1, 0, 0, 0, 14707, 14708, 5, 705, 0, 0, 14708, 14709, 3, 1908, 954, 0, 14709, 2067, 1, 0, 0, 0, 14710, 14712, 3, 2070, 1035, 0, 14711, 14713, 3, 2154, 1077, 0, 14712, 14711, 1, 0, 0, 0, 14712, 14713, 1, 0, 0, 0, 14713, 14715, 1, 0, 0, 0, 14714, 14716, 3, 2156, 1078, 0, 14715, 14714, 1, 0, 0, 0, 14715, 14716, 1, 0, 0, 0, 14716, 14717, 1, 0, 0, 0, 14717, 14718, 5, 7, 0, 0, 14718, 2069, 1, 0, 0, 0, 14719, 14720, 7, 108, 0, 0, 14720, 2071, 1, 0, 0, 0, 14721, 14736, 5, 707, 0, 0, 14722, 14723, 5, 265, 0, 0, 14723, 14737, 3, 2162, 1081, 0, 14724, 14731, 5, 708, 0, 0, 14725, 14726, 5, 206, 0, 0, 14726, 14728, 3, 1710, 855, 0, 14727, 14729, 3, 2054, 1027, 0, 14728, 14727, 1, 0, 0, 0, 14728, 14729, 1, 0, 0, 0, 14729, 14732, 1, 0, 0, 0, 14730, 14732, 3, 1496, 748, 0, 14731, 14725, 1, 0, 0, 0, 14731, 14730, 1, 0, 0, 0, 14732, 14737, 1, 0, 0, 0, 14733, 14735, 3, 2074, 1037, 0, 14734, 14733, 1, 0, 0, 0, 14734, 14735, 1, 0, 0, 0, 14735, 14737, 1, 0, 0, 0, 14736, 14722, 1, 0, 0, 0, 14736, 14724, 1, 0, 0, 0, 14736, 14734, 1, 0, 0, 0, 14737, 14738, 1, 0, 0, 0, 14738, 14739, 5, 7, 0, 0, 14739, 2073, 1, 0, 0, 0, 14740, 14741, 3, 2162, 1081, 0, 14741, 2075, 1, 0, 0, 0, 14742, 14744, 5, 709, 0, 0, 14743, 14745, 3, 2078, 1039, 0, 14744, 14743, 1, 0, 0, 0, 14744, 14745, 1, 0, 0, 0, 14745, 14746, 1, 0, 0, 0, 14746, 14748, 3, 1910, 955, 0, 14747, 14749, 3, 2080, 1040, 0, 14748, 14747, 1, 0, 0, 0, 14748, 14749, 1, 0, 0, 0, 14749, 14751, 1, 0, 0, 0, 14750, 14752, 3, 2082, 1041, 0, 14751, 14750, 1, 0, 0, 0, 14751, 14752, 1, 0, 0, 0, 14752, 14753, 1, 0, 0, 0, 14753, 14754, 5, 7, 0, 0, 14754, 14786, 1, 0, 0, 0, 14755, 14757, 5, 709, 0, 0, 14756, 14758, 3, 2078, 1039, 0, 14757, 14756, 1, 0, 0, 0, 14757, 14758, 1, 0, 0, 0, 14758, 14759, 1, 0, 0, 0, 14759, 14761, 3, 1934, 967, 0, 14760, 14762, 3, 2082, 1041, 0, 14761, 14760, 1, 0, 0, 0, 14761, 14762, 1, 0, 0, 0, 14762, 14763, 1, 0, 0, 0, 14763, 14764, 5, 7, 0, 0, 14764, 14786, 1, 0, 0, 0, 14765, 14767, 5, 709, 0, 0, 14766, 14768, 3, 2078, 1039, 0, 14767, 14766, 1, 0, 0, 0, 14767, 14768, 1, 0, 0, 0, 14768, 14769, 1, 0, 0, 0, 14769, 14770, 5, 710, 0, 0, 14770, 14772, 3, 1910, 955, 0, 14771, 14773, 3, 2082, 1041, 0, 14772, 14771, 1, 0, 0, 0, 14772, 14773, 1, 0, 0, 0, 14773, 14774, 1, 0, 0, 0, 14774, 14775, 5, 7, 0, 0, 14775, 14786, 1, 0, 0, 0, 14776, 14778, 5, 709, 0, 0, 14777, 14779, 3, 2078, 1039, 0, 14778, 14777, 1, 0, 0, 0, 14778, 14779, 1, 0, 0, 0, 14779, 14781, 1, 0, 0, 0, 14780, 14782, 3, 2082, 1041, 0, 14781, 14780, 1, 0, 0, 0, 14781, 14782, 1, 0, 0, 0, 14782, 14783, 1, 0, 0, 0, 14783, 14786, 5, 7, 0, 0, 14784, 14786, 5, 709, 0, 0, 14785, 14742, 1, 0, 0, 0, 14785, 14755, 1, 0, 0, 0, 14785, 14765, 1, 0, 0, 0, 14785, 14776, 1, 0, 0, 0, 14785, 14784, 1, 0, 0, 0, 14786, 2077, 1, 0, 0, 0, 14787, 14788, 7, 109, 0, 0, 14788, 2079, 1, 0, 0, 0, 14789, 14790, 5, 6, 0, 0, 14790, 14792, 3, 1710, 855, 0, 14791, 14789, 1, 0, 0, 0, 14792, 14793, 1, 0, 0, 0, 14793, 14791, 1, 0, 0, 0, 14793, 14794, 1, 0, 0, 0, 14794, 2081, 1, 0, 0, 0, 14795, 14796, 5, 101, 0, 0, 14796, 14797, 3, 2086, 1043, 0, 14797, 2083, 1, 0, 0, 0, 14798, 14799, 3, 1934, 967, 0, 14799, 14800, 5, 10, 0, 0, 14800, 14801, 3, 1710, 855, 0, 14801, 2085, 1, 0, 0, 0, 14802, 14807, 3, 2084, 1042, 0, 14803, 14804, 5, 6, 0, 0, 14804, 14806, 3, 2084, 1042, 0, 14805, 14803, 1, 0, 0, 0, 14806, 14809, 1, 0, 0, 0, 14807, 14805, 1, 0, 0, 0, 14807, 14808, 1, 0, 0, 0, 14808, 2087, 1, 0, 0, 0, 14809, 14807, 1, 0, 0, 0, 14810, 14811, 5, 717, 0, 0, 14811, 14813, 3, 2162, 1081, 0, 14812, 14814, 3, 2090, 1045, 0, 14813, 14812, 1, 0, 0, 0, 14813, 14814, 1, 0, 0, 0, 14814, 14815, 1, 0, 0, 0, 14815, 14816, 5, 7, 0, 0, 14816, 2089, 1, 0, 0, 0, 14817, 14818, 5, 6, 0, 0, 14818, 14819, 3, 2162, 1081, 0, 14819, 2091, 1, 0, 0, 0, 14820, 14821, 5, 718, 0, 0, 14821, 14822, 3, 2004, 1002, 0, 14822, 14823, 5, 653, 0, 0, 14823, 14825, 5, 718, 0, 0, 14824, 14826, 3, 2154, 1077, 0, 14825, 14824, 1, 0, 0, 0, 14825, 14826, 1, 0, 0, 0, 14826, 14827, 1, 0, 0, 0, 14827, 14828, 5, 7, 0, 0, 14828, 2093, 1, 0, 0, 0, 14829, 14830, 3, 2172, 1086, 0, 14830, 14831, 5, 7, 0, 0, 14831, 2095, 1, 0, 0, 0, 14832, 14833, 5, 206, 0, 0, 14833, 14847, 3, 1710, 855, 0, 14834, 14836, 3, 2102, 1051, 0, 14835, 14834, 1, 0, 0, 0, 14835, 14836, 1, 0, 0, 0, 14836, 14838, 1, 0, 0, 0, 14837, 14839, 3, 2098, 1049, 0, 14838, 14837, 1, 0, 0, 0, 14838, 14839, 1, 0, 0, 0, 14839, 14848, 1, 0, 0, 0, 14840, 14842, 3, 2098, 1049, 0, 14841, 14840, 1, 0, 0, 0, 14841, 14842, 1, 0, 0, 0, 14842, 14844, 1, 0, 0, 0, 14843, 14845, 3, 2102, 1051, 0, 14844, 14843, 1, 0, 0, 0, 14844, 14845, 1, 0, 0, 0, 14845, 14848, 1, 0, 0, 0, 14846, 14848, 1, 0, 0, 0, 14847, 14835, 1, 0, 0, 0, 14847, 14841, 1, 0, 0, 0, 14847, 14846, 1, 0, 0, 0, 14848, 14849, 1, 0, 0, 0, 14849, 14850, 5, 7, 0, 0, 14850, 2097, 1, 0, 0, 0, 14851, 14852, 5, 101, 0, 0, 14852, 14853, 3, 2100, 1050, 0, 14853, 2099, 1, 0, 0, 0, 14854, 14859, 3, 1710, 855, 0, 14855, 14856, 5, 6, 0, 0, 14856, 14858, 3, 1710, 855, 0, 14857, 14855, 1, 0, 0, 0, 14858, 14861, 1, 0, 0, 0, 14859, 14857, 1, 0, 0, 0, 14859, 14860, 1, 0, 0, 0, 14860, 2101, 1, 0, 0, 0, 14861, 14859, 1, 0, 0, 0, 14862, 14864, 5, 71, 0, 0, 14863, 14865, 5, 344, 0, 0, 14864, 14863, 1, 0, 0, 0, 14864, 14865, 1, 0, 0, 0, 14865, 14866, 1, 0, 0, 0, 14866, 14867, 3, 2118, 1059, 0, 14867, 2103, 1, 0, 0, 0, 14868, 14889, 5, 719, 0, 0, 14869, 14871, 3, 2138, 1069, 0, 14870, 14872, 3, 2112, 1056, 0, 14871, 14870, 1, 0, 0, 0, 14871, 14872, 1, 0, 0, 0, 14872, 14873, 1, 0, 0, 0, 14873, 14880, 5, 62, 0, 0, 14874, 14881, 3, 1496, 748, 0, 14875, 14876, 5, 206, 0, 0, 14876, 14878, 3, 2162, 1081, 0, 14877, 14879, 3, 2110, 1055, 0, 14878, 14877, 1, 0, 0, 0, 14878, 14879, 1, 0, 0, 0, 14879, 14881, 1, 0, 0, 0, 14880, 14874, 1, 0, 0, 0, 14880, 14875, 1, 0, 0, 0, 14881, 14890, 1, 0, 0, 0, 14882, 14887, 3, 1924, 962, 0, 14883, 14884, 5, 2, 0, 0, 14884, 14885, 3, 2108, 1054, 0, 14885, 14886, 5, 3, 0, 0, 14886, 14888, 1, 0, 0, 0, 14887, 14883, 1, 0, 0, 0, 14887, 14888, 1, 0, 0, 0, 14888, 14890, 1, 0, 0, 0, 14889, 14869, 1, 0, 0, 0, 14889, 14882, 1, 0, 0, 0, 14890, 14891, 1, 0, 0, 0, 14891, 14892, 5, 7, 0, 0, 14892, 2105, 1, 0, 0, 0, 14893, 14894, 3, 1924, 962, 0, 14894, 14895, 5, 20, 0, 0, 14895, 14896, 3, 1710, 855, 0, 14896, 14899, 1, 0, 0, 0, 14897, 14899, 3, 1710, 855, 0, 14898, 14893, 1, 0, 0, 0, 14898, 14897, 1, 0, 0, 0, 14899, 2107, 1, 0, 0, 0, 14900, 14905, 3, 2106, 1053, 0, 14901, 14902, 5, 6, 0, 0, 14902, 14904, 3, 2106, 1053, 0, 14903, 14901, 1, 0, 0, 0, 14904, 14907, 1, 0, 0, 0, 14905, 14903, 1, 0, 0, 0, 14905, 14906, 1, 0, 0, 0, 14906, 2109, 1, 0, 0, 0, 14907, 14905, 1, 0, 0, 0, 14908, 14909, 5, 101, 0, 0, 14909, 14910, 3, 1830, 915, 0, 14910, 2111, 1, 0, 0, 0, 14911, 14913, 3, 2114, 1057, 0, 14912, 14911, 1, 0, 0, 0, 14912, 14913, 1, 0, 0, 0, 14913, 14914, 1, 0, 0, 0, 14914, 14915, 5, 322, 0, 0, 14915, 2113, 1, 0, 0, 0, 14916, 14917, 5, 266, 0, 0, 14917, 2115, 1, 0, 0, 0, 14918, 14920, 5, 61, 0, 0, 14919, 14921, 3, 2122, 1061, 0, 14920, 14919, 1, 0, 0, 0, 14920, 14921, 1, 0, 0, 0, 14921, 14923, 1, 0, 0, 0, 14922, 14924, 3, 2120, 1060, 0, 14923, 14922, 1, 0, 0, 0, 14923, 14924, 1, 0, 0, 0, 14924, 14925, 1, 0, 0, 0, 14925, 14926, 3, 2138, 1069, 0, 14926, 14927, 5, 71, 0, 0, 14927, 14928, 3, 2118, 1059, 0, 14928, 14929, 5, 7, 0, 0, 14929, 2117, 1, 0, 0, 0, 14930, 14931, 3, 1830, 915, 0, 14931, 2119, 1, 0, 0, 0, 14932, 14933, 7, 110, 0, 0, 14933, 2121, 1, 0, 0, 0, 14934, 14950, 5, 265, 0, 0, 14935, 14950, 5, 291, 0, 0, 14936, 14950, 5, 211, 0, 0, 14937, 14950, 5, 244, 0, 0, 14938, 14939, 5, 132, 0, 0, 14939, 14950, 3, 1710, 855, 0, 14940, 14941, 5, 305, 0, 0, 14941, 14950, 3, 1710, 855, 0, 14942, 14950, 3, 1710, 855, 0, 14943, 14950, 5, 30, 0, 0, 14944, 14947, 7, 111, 0, 0, 14945, 14948, 3, 1710, 855, 0, 14946, 14948, 5, 30, 0, 0, 14947, 14945, 1, 0, 0, 0, 14947, 14946, 1, 0, 0, 0, 14947, 14948, 1, 0, 0, 0, 14948, 14950, 1, 0, 0, 0, 14949, 14934, 1, 0, 0, 0, 14949, 14935, 1, 0, 0, 0, 14949, 14936, 1, 0, 0, 0, 14949, 14937, 1, 0, 0, 0, 14949, 14938, 1, 0, 0, 0, 14949, 14940, 1, 0, 0, 0, 14949, 14942, 1, 0, 0, 0, 14949, 14943, 1, 0, 0, 0, 14949, 14944, 1, 0, 0, 0, 14950, 2123, 1, 0, 0, 0, 14951, 14953, 5, 262, 0, 0, 14952, 14954, 3, 2122, 1061, 0, 14953, 14952, 1, 0, 0, 0, 14953, 14954, 1, 0, 0, 0, 14954, 14955, 1, 0, 0, 0, 14955, 14956, 3, 2138, 1069, 0, 14956, 14957, 5, 7, 0, 0, 14957, 2125, 1, 0, 0, 0, 14958, 14959, 5, 159, 0, 0, 14959, 14960, 3, 2138, 1069, 0, 14960, 14961, 5, 7, 0, 0, 14961, 2127, 1, 0, 0, 0, 14962, 14963, 5, 78, 0, 0, 14963, 14964, 5, 7, 0, 0, 14964, 2129, 1, 0, 0, 0, 14965, 14967, 5, 163, 0, 0, 14966, 14968, 3, 2134, 1067, 0, 14967, 14966, 1, 0, 0, 0, 14967, 14968, 1, 0, 0, 0, 14968, 14969, 1, 0, 0, 0, 14969, 14970, 5, 7, 0, 0, 14970, 2131, 1, 0, 0, 0, 14971, 14973, 5, 317, 0, 0, 14972, 14974, 3, 2134, 1067, 0, 14973, 14972, 1, 0, 0, 0, 14973, 14974, 1, 0, 0, 0, 14974, 14975, 1, 0, 0, 0, 14975, 14976, 5, 7, 0, 0, 14976, 2133, 1, 0, 0, 0, 14977, 14979, 5, 33, 0, 0, 14978, 14980, 5, 266, 0, 0, 14979, 14978, 1, 0, 0, 0, 14979, 14980, 1, 0, 0, 0, 14980, 14981, 1, 0, 0, 0, 14981, 14982, 5, 155, 0, 0, 14982, 2135, 1, 0, 0, 0, 14983, 14984, 5, 331, 0, 0, 14984, 14985, 3, 566, 283, 0, 14985, 14986, 5, 95, 0, 0, 14986, 14987, 5, 53, 0, 0, 14987, 14988, 5, 7, 0, 0, 14988, 14996, 1, 0, 0, 0, 14989, 14992, 5, 311, 0, 0, 14990, 14993, 3, 566, 283, 0, 14991, 14993, 5, 30, 0, 0, 14992, 14990, 1, 0, 0, 0, 14992, 14991, 1, 0, 0, 0, 14993, 14994, 1, 0, 0, 0, 14994, 14996, 5, 7, 0, 0, 14995, 14983, 1, 0, 0, 0, 14995, 14989, 1, 0, 0, 0, 14996, 2137, 1, 0, 0, 0, 14997, 15000, 3, 1924, 962, 0, 14998, 15000, 5, 28, 0, 0, 14999, 14997, 1, 0, 0, 0, 14999, 14998, 1, 0, 0, 0, 15000, 2139, 1, 0, 0, 0, 15001, 15002, 5, 716, 0, 0, 15002, 15003, 3, 2142, 1071, 0, 15003, 2141, 1, 0, 0, 0, 15004, 15006, 3, 2144, 1072, 0, 15005, 15004, 1, 0, 0, 0, 15006, 15007, 1, 0, 0, 0, 15007, 15005, 1, 0, 0, 0, 15007, 15008, 1, 0, 0, 0, 15008, 2143, 1, 0, 0, 0, 15009, 15010, 5, 103, 0, 0, 15010, 15011, 3, 2146, 1073, 0, 15011, 15012, 5, 94, 0, 0, 15012, 15013, 3, 2004, 1002, 0, 15013, 2145, 1, 0, 0, 0, 15014, 15019, 3, 2148, 1074, 0, 15015, 15016, 5, 82, 0, 0, 15016, 15018, 3, 2148, 1074, 0, 15017, 15015, 1, 0, 0, 0, 15018, 15021, 1, 0, 0, 0, 15019, 15017, 1, 0, 0, 0, 15019, 15020, 1, 0, 0, 0, 15020, 2147, 1, 0, 0, 0, 15021, 15019, 1, 0, 0, 0, 15022, 15026, 3, 2158, 1079, 0, 15023, 15024, 5, 710, 0, 0, 15024, 15026, 3, 1910, 955, 0, 15025, 15022, 1, 0, 0, 0, 15025, 15023, 1, 0, 0, 0, 15026, 2149, 1, 0, 0, 0, 15027, 15028, 3, 1968, 984, 0, 15028, 2151, 1, 0, 0, 0, 15029, 15030, 3, 1968, 984, 0, 15030, 2153, 1, 0, 0, 0, 15031, 15032, 3, 2158, 1079, 0, 15032, 2155, 1, 0, 0, 0, 15033, 15034, 5, 103, 0, 0, 15034, 15035, 3, 2166, 1083, 0, 15035, 2157, 1, 0, 0, 0, 15036, 15039, 3, 1924, 962, 0, 15037, 15039, 3, 2160, 1080, 0, 15038, 15036, 1, 0, 0, 0, 15038, 15037, 1, 0, 0, 0, 15039, 2159, 1, 0, 0, 0, 15040, 15041, 7, 112, 0, 0, 15041, 2161, 1, 0, 0, 0, 15042, 15044, 3, 1878, 939, 0, 15043, 15042, 1, 0, 0, 0, 15043, 15044, 1, 0, 0, 0, 15044, 15046, 1, 0, 0, 0, 15045, 15047, 3, 1524, 762, 0, 15046, 15045, 1, 0, 0, 0, 15046, 15047, 1, 0, 0, 0, 15047, 15049, 1, 0, 0, 0, 15048, 15050, 3, 1598, 799, 0, 15049, 15048, 1, 0, 0, 0, 15049, 15050, 1, 0, 0, 0, 15050, 15052, 1, 0, 0, 0, 15051, 15053, 3, 1638, 819, 0, 15052, 15051, 1, 0, 0, 0, 15052, 15053, 1, 0, 0, 0, 15053, 15055, 1, 0, 0, 0, 15054, 15056, 3, 1568, 784, 0, 15055, 15054, 1, 0, 0, 0, 15055, 15056, 1, 0, 0, 0, 15056, 15058, 1, 0, 0, 0, 15057, 15059, 3, 1582, 791, 0, 15058, 15057, 1, 0, 0, 0, 15058, 15059, 1, 0, 0, 0, 15059, 15061, 1, 0, 0, 0, 15060, 15062, 3, 1790, 895, 0, 15061, 15060, 1, 0, 0, 0, 15061, 15062, 1, 0, 0, 0, 15062, 2163, 1, 0, 0, 0, 15063, 15064, 3, 2162, 1081, 0, 15064, 2165, 1, 0, 0, 0, 15065, 15066, 3, 2162, 1081, 0, 15066, 2167, 1, 0, 0, 0, 15067, 15068, 3, 1710, 855, 0, 15068, 2169, 1, 0, 0, 0, 15069, 15070, 3, 1710, 855, 0, 15070, 2171, 1, 0, 0, 0, 15071, 15073, 3, 8, 4, 0, 15072, 15074, 3, 2174, 1087, 0, 15073, 15072, 1, 0, 0, 0, 15073, 15074, 1, 0, 0, 0, 15074, 2173, 1, 0, 0, 0, 15075, 15077, 5, 71, 0, 0, 15076, 15078, 3, 1528, 764, 0, 15077, 15076, 1, 0, 0, 0, 15077, 15078, 1, 0, 0, 0, 15078, 15079, 1, 0, 0, 0, 15079, 15080, 3, 2118, 1059, 0, 15080, 2175, 1, 0, 0, 0, 1495, 2185, 2189, 2375, 2379, 2388, 2397, 2405, 2411, 2414, 2420, 2430, 2440, 2460, 2467, 2479, 2485, 2493, 2506, 2515, 2519, 2529, 2532, 2538, 2543, 2555, 2571, 2575, 2578, 2581, 2587, 2590, 2592, 2600, 2603, 2606, 2611, 2619, 2623, 2635, 2655, 2668, 2675, 2683, 2688, 2695, 2701, 2708, 2719, 2723, 2727, 2740, 2744, 2749, 2754, 2769, 2778, 2795, 2804, 2849, 2867, 2873, 2877, 2880, 2883, 2887, 2891, 2895, 2904, 2908, 2918, 2947, 2957, 2972, 2993, 2998, 3002, 3026, 3036, 3060, 3067, 3076, 3085, 3093, 3103, 3112, 3121, 3129, 3137, 3146, 3155, 3159, 3166, 3174, 3184, 3190, 3194, 3198, 3202, 3206, 3211, 3214, 3218, 3239, 3245, 3344, 3351, 3367, 3381, 3391, 3393, 3398, 3402, 3405, 3411, 3413, 3441, 3451, 3464, 3471, 3477, 3481, 3487, 3492, 3495, 3497, 3502, 3506, 3510, 3514, 3518, 3521, 3525, 3533, 3537, 3544, 3550, 3555, 3558, 3563, 3573, 3575, 3578, 3581, 3585, 3589, 3592, 3596, 3609, 3618, 3625, 3630, 3637, 3642, 3649, 3654, 3672, 3677, 3689, 3694, 3703, 3710, 3717, 3723, 3728, 3732, 3737, 3748, 3757, 3760, 3775, 3783, 3789, 3793, 3798, 3801, 3806, 3827, 3844, 3846, 3851, 3858, 3869, 3876, 3879, 3882, 3887, 3890, 3897, 3906, 3913, 3918, 3921, 3924, 3926, 3930, 3937, 3944, 3954, 3964, 3974, 3980, 3983, 3986, 3993, 4001, 4004, 4007, 4014, 4018, 4024, 4027, 4030, 4033, 4045, 4048, 4051, 4055, 4069, 4087, 4098, 4113, 4130, 4132, 4153, 4158, 4161, 4165, 4168, 4174, 4177, 4179, 4188, 4197, 4205, 4219, 4222, 4245, 4249, 4260, 4269, 4278, 4281, 4287, 4293, 4296, 4301, 4304, 4314, 4321, 4330, 4337, 4342, 4346, 4359, 4363, 4366, 4370, 4376, 4380, 4386, 4400, 4409, 4427, 4432, 4435, 4438, 4448, 4455, 4460, 4463, 4466, 4473, 4476, 4478, 4484, 4493, 4503, 4508, 4517, 4526, 4530, 4537, 4547, 4558, 4668, 4676, 4679, 4689, 4694, 4704, 4715, 4727, 4740, 4750, 4763, 4766, 4773, 4782, 4785, 4792, 4794, 4802, 4812, 4814, 4822, 4826, 4831, 4842, 4846, 4851, 4861, 4867, 4880, 4886, 4888, 4895, 4903, 4908, 4923, 4936, 4938, 4942, 4962, 4979, 4982, 4985, 4988, 4991, 4999, 5002, 5005, 5051, 5054, 5057, 5075, 5082, 5091, 5097, 5104, 5114, 5122, 5127, 5139, 5156, 5162, 5169, 5177, 5191, 5219, 5226, 5240, 5255, 5268, 5277, 5302, 5313, 5380, 5391, 5397, 5405, 5416, 5430, 5439, 5449, 5461, 5476, 5487, 5495, 5505, 5512, 5515, 5521, 5524, 5539, 5552, 5581, 5588, 5603, 5612, 5623, 5625, 5634, 5645, 5647, 5654, 5669, 5675, 5683, 5689, 5697, 5707, 5713, 5721, 5727, 5735, 5742, 5751, 5753, 5778, 5786, 5797, 5802, 5811, 5816, 5822, 5829, 5834, 5838, 5841, 5847, 5996, 6000, 6005, 6016, 6027, 6038, 6049, 6060, 6071, 6082, 6094, 6105, 6113, 6120, 6134, 6140, 6152, 6158, 6186, 6196, 6208, 6215, 6220, 6224, 6231, 6235, 6248, 6258, 6266, 6273, 6293, 6305, 6326, 6330, 6344, 6348, 6362, 6366, 6391, 6395, 6405, 6410, 6414, 6437, 6439, 6448, 6453, 6458, 6469, 6476, 6480, 6493, 6501, 6508, 6514, 6526, 6530, 6539, 6555, 6565, 6572, 6577, 6587, 6596, 6604, 6607, 6611, 6615, 6622, 6675, 6682, 6686, 6697, 6713, 6721, 6725, 6729, 6733, 6737, 6745, 6753, 6761, 6767, 6774, 6782, 6786, 6795, 6799, 6809, 6813, 6817, 6820, 6824, 6828, 6838, 6845, 6850, 6857, 6870, 6874, 6886, 6892, 6900, 6909, 6917, 6927, 6929, 6939, 6945, 6953, 6966, 6972, 6974, 6982, 6994, 7005, 7009, 7014, 7025, 7029, 7034, 7045, 7049, 7054, 7066, 7078, 7082, 7087, 7093, 7102, 7108, 7121, 7123, 7126, 7132, 7140, 7145, 7147, 7152, 7163, 7174, 7179, 7191, 7201, 7210, 7222, 7224, 7230, 7238, 7244, 7252, 7258, 7266, 7272, 7280, 7286, 7294, 7300, 7308, 7314, 7322, 7324, 7341, 7348, 7353, 7357, 7361, 7367, 7369, 7431, 7438, 7444, 7455, 7458, 7465, 7468, 7478, 7481, 7483, 7502, 7514, 7523, 7532, 7544, 7546, 7552, 7556, 7561, 7564, 7569, 7575, 7578, 7581, 7584, 7587, 7603, 7607, 7610, 7613, 7616, 7619, 7624, 7627, 7629, 7642, 7654, 7668, 7672, 7684, 7686, 7693, 7705, 7707, 7710, 7721, 7733, 7741, 7744, 7748, 7757, 7765, 7774, 7776, 7780, 7789, 7794, 7800, 7805, 7813, 7819, 7825, 7831, 7836, 7851, 7860, 7871, 7877, 7916, 7931, 7938, 7949, 7963, 7976, 7988, 7993, 8001, 8009, 8015, 8023, 8029, 8037, 8039, 8045, 8053, 8055, 8061, 8069, 8071, 8095, 8102, 8112, 8124, 8129, 8142, 8154, 8166, 8168, 8174, 8179, 8187, 8194, 8239, 8244, 8251, 8256, 8263, 8273, 8283, 8287, 8298, 8315, 8386, 8581, 8594, 8605, 8618, 8630, 8644, 8676, 8690, 8802, 8804, 8815, 8826, 8837, 8850, 8862, 8873, 8880, 9101, 9116, 9127, 9134, 9188, 9329, 9335, 9344, 9352, 9354, 9361, 9367, 9370, 9377, 9381, 9384, 9389, 9392, 9396, 9399, 9402, 9433, 9443, 9450, 9473, 9482, 9500, 9506, 9514, 9516, 9520, 9530, 9534, 9544, 9547, 9551, 9555, 9563, 9574, 9586, 9590, 9593, 9597, 9600, 9605, 9609, 9612, 9616, 9619, 9623, 9626, 9637, 9644, 9657, 9671, 9675, 9680, 9687, 9694, 9697, 9702, 9705, 9714, 9716, 9721, 9724, 9733, 9752, 9758, 9765, 9785, 9792, 9798, 9802, 9811, 9820, 9826, 9833, 9838, 9841, 9845, 9848, 9859, 9863, 9868, 9879, 9891, 9901, 9908, 9914, 9920, 9932, 9938, 9948, 9954, 9958, 9963, 9970, 9976, 9979, 9990, 9996, 10000, 10011, 10022, 10028, 10043, 10061, 10065, 10069, 10077, 10081, 10085, 10093, 10098, 10102, 10107, 10111, 10118, 10125, 10137, 10141, 10146, 10148, 10155, 10163, 10167, 10180, 10189, 10206, 10212, 10224, 10235, 10242, 10250, 10267, 10279, 10281, 10288, 10295, 10301, 10307, 10319, 10321, 10328, 10342, 10352, 10356, 10363, 10369, 10378, 10382, 10391, 10405, 10408, 10412, 10438, 10442, 10451, 10466, 10470, 10472, 10490, 10497, 10526, 10532, 10539, 10549, 10555, 10563, 10574, 10584, 10589, 10611, 10616, 10618, 10628, 10633, 10644, 10651, 10658, 10660, 10666, 10683, 10698, 10706, 10710, 10714, 10720, 10724, 10728, 10732, 10736, 10740, 10747, 10755, 10759, 10764, 10785, 10792, 10803, 10840, 10847, 10857, 10869, 10871, 10901, 10912, 10919, 10927, 10931, 10936, 10944, 10951, 10959, 10963, 10974, 10983, 10988, 11000, 11012, 11029, 11038, 11040, 11044, 11049, 11052, 11064, 11068, 11074, 11087, 11100, 11105, 11109, 11116, 11121, 11137, 11144, 11146, 11152, 11159, 11165, 11169, 11173, 11182, 11184, 11191, 11198, 11201, 11203, 11208, 11214, 11220, 11227, 11231, 11235, 11250, 11254, 11270, 11276, 11297, 11308, 11312, 11318, 11327, 11351, 11355, 11359, 11363, 11369, 11383, 11386, 11393, 11397, 11403, 11410, 11420, 11429, 11432, 11446, 11448, 11464, 11484, 11505, 11509, 11514, 11597, 11603, 11616, 11620, 11624, 11628, 11634, 11641, 11644, 11647, 11650, 11653, 11660, 11664, 11667, 11673, 11676, 11678, 11687, 11691, 11698, 11700, 11706, 11713, 11720, 11724, 11728, 11744, 11751, 11761, 11774, 11785, 11792, 11797, 11801, 11805, 11810, 11824, 11829, 11833, 11841, 11844, 11848, 11859, 11862, 11864, 11880, 11883, 11890, 11893, 11898, 11913, 11919, 11928, 11937, 11944, 11947, 11953, 11958, 11964, 11969, 11973, 11978, 11981, 11988, 11992, 11997, 12004, 12007, 12014, 12022, 12025, 12035, 12038, 12043, 12047, 12051, 12054, 12057, 12064, 12068, 12071, 12086, 12089, 12096, 12099, 12106, 12109, 12112, 12119, 12132, 12142, 12150, 12162, 12164, 12171, 12175, 12185, 12189, 12193, 12197, 12199, 12204, 12208, 12212, 12214, 12216, 12221, 12226, 12232, 12237, 12242, 12245, 12248, 12251, 12254, 12260, 12263, 12266, 12269, 12272, 12275, 12278, 12281, 12284, 12287, 12293, 12306, 12314, 12323, 12328, 12332, 12341, 12347, 12351, 12359, 12363, 12368, 12374, 12386, 12401, 12408, 12410, 12413, 12417, 12421, 12423, 12431, 12440, 12446, 12448, 12450, 12457, 12461, 12470, 12474, 12489, 12493, 12500, 12528, 12535, 12539, 12542, 12547, 12551, 12554, 12570, 12581, 12586, 12589, 12593, 12597, 12601, 12606, 12610, 12614, 12616, 12625, 12630, 12636, 12640, 12642, 12647, 12651, 12662, 12666, 12669, 12676, 12681, 12688, 12693, 12696, 12702, 12706, 12715, 12719, 12727, 12729, 12736, 12741, 12744, 12752, 12761, 12769, 12771, 12775, 12782, 12801, 12810, 12816, 12835, 12844, 12850, 12854, 12859, 12869, 12876, 12885, 12888, 12892, 12899, 12901, 12908, 12912, 12917, 12927, 12933, 12936, 12942, 12954, 12960, 12963, 12966, 12979, 12985, 12989, 12993, 12996, 13004, 13008, 13012, 13020, 13026, 13030, 13036, 13040, 13044, 13050, 13052, 13061, 13064, 13074, 13090, 13096, 13101, 13108, 13117, 13124, 13132, 13140, 13145, 13149, 13155, 13159, 13163, 13166, 13172, 13177, 13193, 13196, 13198, 13210, 13212, 13215, 13221, 13227, 13231, 13233, 13241, 13245, 13254, 13262, 13268, 13271, 13280, 13285, 13292, 13302, 13328, 13339, 13341, 13343, 13351, 13374, 13382, 13392, 13395, 13400, 13405, 13409, 13415, 13418, 13421, 13424, 13428, 13442, 13449, 13456, 13463, 13481, 13489, 13501, 13519, 13558, 13560, 13580, 13590, 13601, 13613, 13620, 13632, 13644, 13650, 13658, 13675, 13700, 13710, 13714, 13717, 13720, 13723, 13736, 13741, 13746, 13748, 13756, 13765, 13774, 13779, 13788, 13793, 13807, 13817, 13825, 13839, 13846, 13854, 13862, 13869, 13875, 13884, 13899, 13910, 13943, 13952, 13959, 13963, 13967, 13974, 13988, 13993, 13998, 14002, 14004, 14007, 14014, 14019, 14029, 14034, 14037, 14042, 14049, 14054, 14061, 14077, 14089, 14094, 14102, 14109, 14114, 14126, 14134, 14139, 14149, 14157, 14164, 14173, 14179, 14185, 14191, 14199, 14203, 14210, 14307, 14318, 14323, 14346, 14354, 14362, 14366, 14369, 14373, 14375, 14382, 14391, 14398, 14402, 14405, 14408, 14411, 14415, 14420, 14427, 14440, 14450, 14469, 14476, 14506, 14516, 14525, 14530, 14541, 14554, 14567, 14575, 14584, 14597, 14605, 14609, 14620, 14631, 14636, 14643, 14653, 14660, 14663, 14669, 14671, 14682, 14695, 14700, 14712, 14715, 14728, 14731, 14734, 14736, 14744, 14748, 14751, 14757, 14761, 14767, 14772, 14778, 14781, 14785, 14793, 14807, 14813, 14825, 14835, 14838, 14841, 14844, 14847, 14859, 14864, 14871, 14878, 14880, 14887, 14889, 14898, 14905, 14912, 14920, 14923, 14947, 14949, 14953, 14967, 14973, 14979, 14992, 14995, 14999, 15007, 15019, 15025, 15038, 15043, 15046, 15049, 15052, 15055, 15058, 15061, 15073, 15077] \ No newline at end of file diff --git a/redshift/RedshiftParser.tokens b/redshift/RedshiftParser.tokens new file mode 100644 index 0000000..2931e67 --- /dev/null +++ b/redshift/RedshiftParser.tokens @@ -0,0 +1,1740 @@ +Dollar=1 +OPEN_PAREN=2 +CLOSE_PAREN=3 +OPEN_BRACKET=4 +CLOSE_BRACKET=5 +COMMA=6 +SEMI=7 +COLON=8 +STAR=9 +EQUAL=10 +DOT=11 +PLUS=12 +MINUS=13 +SLASH=14 +CARET=15 +LT=16 +GT=17 +LESS_LESS=18 +GREATER_GREATER=19 +COLON_EQUALS=20 +LESS_EQUALS=21 +EQUALS_GREATER=22 +GREATER_EQUALS=23 +DOT_DOT=24 +NOT_EQUALS=25 +TYPECAST=26 +PERCENT=27 +PARAM=28 +Operator=29 +ALL=30 +ANALYSE=31 +ANALYZE=32 +AND=33 +ANY=34 +ARRAY=35 +AS=36 +ASC=37 +ASYMMETRIC=38 +BOTH=39 +CASE=40 +CAST=41 +CHECK=42 +COLLATE=43 +COLUMN=44 +CONSTRAINT=45 +CREATE=46 +CURRENT_CATALOG=47 +CURRENT_DATE=48 +CURRENT_ROLE=49 +CURRENT_TIME=50 +CURRENT_TIMESTAMP=51 +CURRENT_USER=52 +DEFAULT=53 +DEFERRABLE=54 +DESC=55 +DISTINCT=56 +DO=57 +ELSE=58 +EXCEPT=59 +FALSE_P=60 +FETCH=61 +FOR=62 +FOREIGN=63 +FROM=64 +GRANT=65 +GROUP_P=66 +HAVING=67 +IN_P=68 +INITIALLY=69 +INTERSECT=70 +INTO=71 +LATERAL_P=72 +LEADING=73 +LIMIT=74 +LOCALTIME=75 +LOCALTIMESTAMP=76 +NOT=77 +NULL_P=78 +OFFSET=79 +ON=80 +ONLY=81 +OR=82 +ORDER=83 +PLACING=84 +PRIMARY=85 +PUBLIC=86 +REFERENCES=87 +RETURNING=88 +SELECT=89 +SESSION_USER=90 +SOME=91 +SYMMETRIC=92 +TABLE=93 +THEN=94 +TO=95 +TRAILING=96 +TRUE_P=97 +UNION=98 +UNIQUE=99 +USER=100 +USING=101 +VARIADIC=102 +WHEN=103 +WHERE=104 +WINDOW=105 +WITH=106 +AUTHORIZATION=107 +BINARY=108 +BINDING=109 +COLLATION=110 +CONCURRENTLY=111 +CROSS=112 +CURRENT_SCHEMA=113 +FREEZE=114 +FULL=115 +ILIKE=116 +INNER_P=117 +IS=118 +ISNULL=119 +JOIN=120 +LEFT=121 +LIKE=122 +NATURAL=123 +NOTNULL=124 +OUTER_P=125 +OVER=126 +OVERLAPS=127 +RIGHT=128 +SIMILAR=129 +VERBOSE=130 +ABORT_P=131 +ABSOLUTE_P=132 +ACCESS=133 +ACTION=134 +ADD_P=135 +ADMIN=136 +AFTER=137 +AGGREGATE=138 +ALSO=139 +ALTER=140 +ALWAYS=141 +ASSERTION=142 +ASSIGNMENT=143 +AT=144 +ATTRIBUTE=145 +BACKWARD=146 +BEFORE=147 +BEGIN_P=148 +BY=149 +CACHE=150 +CALLED=151 +CASCADE=152 +CASCADED=153 +CATALOG=154 +CHAIN=155 +CHARACTERISTICS=156 +CHECKPOINT=157 +CLASS=158 +CLOSE=159 +CLUSTER=160 +COMMENT=161 +COMMENTS=162 +COMMIT=163 +COMMITTED=164 +CONFIGURATION=165 +CONNECTION=166 +CONSTRAINTS=167 +CONTENT_P=168 +CONTINUE_P=169 +CONVERSION_P=170 +COPY=171 +COST=172 +CSV=173 +JSON=174 +CURSOR=175 +CYCLE=176 +DATA_P=177 +DATA_CATALOG=178 +DATABASE=179 +DAY_P=180 +DEALLOCATE=181 +DECLARE=182 +DEFAULTS=183 +DEFERRED=184 +DEFINER=185 +DELETE_P=186 +DELIMITER=187 +DELIMITERS=188 +DICTIONARY=189 +DISABLE_P=190 +DISCARD=191 +DOCUMENT_P=192 +DOMAIN_P=193 +DOUBLE_P=194 +DROP=195 +EACH=196 +ENABLE_P=197 +ENCODING=198 +ENCRYPTED=199 +ENUM_P=200 +ESCAPE=201 +EVENT=202 +EXCLUDE=203 +EXCLUDING=204 +EXCLUSIVE=205 +EXECUTE=206 +EXPLAIN=207 +EXTENSION=208 +EXTERNAL=209 +FAMILY=210 +FIRST_P=211 +FOLLOWING=212 +FORCE=213 +FORWARD=214 +FUNCTION=215 +FUNCTIONS=216 +GLOBAL=217 +GRANTED=218 +HANDLER=219 +HEADER_P=220 +HOLD=221 +HOUR_P=222 +IDENTITY_P=223 +IF_P=224 +IMMEDIATE=225 +IMMUTABLE=226 +IMPLICIT_P=227 +INCLUDING=228 +INCREMENT=229 +INDEX=230 +INDEXES=231 +INHERIT=232 +INHERITS=233 +INLINE_P=234 +INSENSITIVE=235 +INSERT=236 +INSTEAD=237 +INVOKER=238 +ISOLATION=239 +KEY=240 +LABEL=241 +LANGUAGE=242 +LARGE_P=243 +LAST_P=244 +LEAKPROOF=245 +LEVEL=246 +LISTEN=247 +LOAD=248 +LOCAL=249 +LOCATION=250 +LOCK_P=251 +MAPPING=252 +MATCH=253 +MATCHED=254 +MATERIALIZED=255 +MAXVALUE=256 +MERGE=257 +MINUTE_P=258 +MINVALUE=259 +MODE=260 +MONTH_P=261 +MOVE=262 +NAME_P=263 +NAMES=264 +NEXT=265 +NO=266 +NOTHING=267 +NOTIFY=268 +NOWAIT=269 +NULLS_P=270 +OBJECT_P=271 +OF=272 +OFF=273 +OIDS=274 +OPERATOR=275 +OPTION=276 +OPTIONS=277 +OWNED=278 +OWNER=279 +PARSER=280 +PARTIAL=281 +PARTITION=282 +PASSING=283 +PASSWORD=284 +PLANS=285 +PRECEDING=286 +PREDICATE=287 +PREPARE=288 +PREPARED=289 +PRESERVE=290 +PRIOR=291 +PRIVILEGES=292 +PROCEDURAL=293 +PROCEDURE=294 +PROGRAM=295 +QUOTE=296 +RANGE=297 +READ=298 +REASSIGN=299 +RECHECK=300 +RECURSIVE=301 +REF=302 +REFRESH=303 +REINDEX=304 +RELATIVE_P=305 +RELEASE=306 +RENAME=307 +REPEATABLE=308 +REPLACE=309 +REPLICA=310 +RESET=311 +RESTART=312 +RESTRICT=313 +RETURNS=314 +REVOKE=315 +ROLE=316 +ROLLBACK=317 +ROWS=318 +RULE=319 +SAVEPOINT=320 +SCHEMA=321 +SCROLL=322 +SEARCH=323 +SECOND_P=324 +SECURITY=325 +SEQUENCE=326 +SEQUENCES=327 +SERIALIZABLE=328 +SERVER=329 +SESSION=330 +SET=331 +SHARE=332 +SHOW=333 +SIMPLE=334 +SNAPSHOT=335 +STABLE=336 +STANDALONE_P=337 +START=338 +STATEMENT=339 +STATISTICS=340 +STDIN=341 +STDOUT=342 +STORAGE=343 +STRICT_P=344 +STRIP_P=345 +SYSID=346 +SYSTEM_P=347 +TABLES=348 +TABLESPACE=349 +TEMP=350 +TEMPLATE=351 +TEMPORARY=352 +TEXT_P=353 +TRANSACTION=354 +TRIGGER=355 +TRUNCATE=356 +TRUSTED=357 +TYPE_P=358 +TYPES_P=359 +UNBOUNDED=360 +UNCOMMITTED=361 +UNENCRYPTED=362 +UNKNOWN=363 +UNLISTEN=364 +UNLOGGED=365 +UNTIL=366 +UPDATE=367 +VACUUM=368 +VALID=369 +VALIDATE=370 +VALIDATOR=371 +VARYING=372 +VERSION_P=373 +VIEW=374 +VOLATILE=375 +WHITESPACE_P=376 +WITHOUT=377 +WORK=378 +WRAPPER=379 +WRITE=380 +XML_P=381 +YEAR_P=382 +YES_P=383 +ZONE=384 +QUALIFY=385 +CONNECT=386 +TOP=387 +VARBYTE=388 +VARBINARY=389 +CONJUNCTION=390 +DEFINITION=391 +DATASHARE=392 +FILE=393 +PUBLICACCESSIBLE=394 +INCLUDENEW=395 +IAM_ROLE=396 +CATALOG_ROLE=397 +CATALOG_ID=398 +HIVE=399 +METASTORE=400 +URI=401 +POSTGRES=402 +MYSQL=403 +SECRET_ARN=404 +KINESIS=405 +KAFKA=406 +MSK=407 +AUTHENTICATION=408 +AUTHENTICATION_ARN=409 +SESSION_TOKEN=410 +MTLS=411 +MASKING=412 +RLS=413 +IDENTITY=414 +PROVIDER=415 +PROTECTED=416 +MODEL=417 +TARGET=418 +SAGEMAKER=419 +AUTO=420 +MODEL_TYPE=421 +PROBLEM_TYPE=422 +OBJECTIVE=423 +PREPROCESSORS=424 +HYPERPARAMETERS=425 +XGBOOST=426 +MLP=427 +LINEAR_LEARNER=428 +KMEANS=429 +FORECAST=430 +REGRESSION=431 +BINARY_CLASSIFICATION=432 +MULTICLASS_CLASSIFICATION=433 +S3_BUCKET=434 +TAGS=435 +KMS_KEY_ID=436 +S3_GARBAGE_COLLECT=437 +MAX_CELLS=438 +MAX_RUNTIME=439 +HORIZON=440 +FREQUENCY=441 +PERCENTILES=442 +MAX_BATCH_ROWS=443 +UNLOAD=444 +MANIFEST=445 +ADDQUOTES=446 +ALLOWOVERWRITE=447 +CLEANPATH=448 +MAXFILESIZE=449 +ROWGROUPSIZE=450 +BZIP2=451 +GZIP=452 +ZSTD=453 +DATABASES=454 +DATASHARES=455 +GRANTS=456 +USE=457 +CANCEL=458 +SESSION_AUTHORIZATION=459 +SESSION_CHARACTERISTICS=460 +COMPRESSION=461 +LIBRARY=462 +APPEND=463 +MB=464 +GB=465 +ACCOUNT=466 +NAMESPACE=467 +DESCRIBE=468 +NONATOMIC=469 +MANAGEDBY=470 +ADX=471 +REMOVE=472 +DUPLICATES=473 +BEDROCK=474 +MODEL_ID=475 +PROMPT=476 +SUFFIX=477 +REQUEST_TYPE=478 +RESPONSE_TYPE=479 +RAW=480 +UNIFIED=481 +SUPER=482 +CI=483 +CS=484 +PLPYTHONU=485 +FILLTARGET=486 +IGNOREEXTRA=487 +CREATEUSER=488 +NOCREATEUSER=489 +REGION=490 +PORT=491 +REDSHIFT=492 +IAM=493 +CREATEDB=494 +NOCREATEDB=495 +RESTRICTED=496 +UNLIMITED=497 +EXTERNALID=498 +TIMEOUT=499 +SYSLOG=500 +CREDENTIALS=501 +UNRESTRICTED=502 +PARAMETERS=503 +APPLICATION_ARN=504 +AUTO_CREATE_ROLES=505 +COMPROWS=506 +PROVIDER_URL=507 +PROVIDER_URL_PORT=508 +ATTRIBUTE_MAP=509 +PROVIDER_ARN=510 +ASSUME_ROLE_ARN=511 +PROPERTIES=512 +AVRO=513 +RCFILE=514 +SEQUENCEFILE=515 +TEXTFILE=516 +ORC=517 +ION=518 +LAMBDA=519 +FIXEDWIDTH=520 +PARQUET=521 +LZOP=522 +REMOVEQUOTES=523 +TRUNCATECOLUMNS=524 +FILLRECORD=525 +BLANKSASNULL=526 +EMPTYASNULL=527 +MAXERROR=528 +DATEFORMAT=529 +TIMEFORMAT=530 +ACCEPTINVCHARS=531 +ACCEPTANYDATE=532 +IGNOREHEADER=533 +IGNOREBLANKLINES=534 +COMPUPDATE=535 +STATUPDATE=536 +EXPLICIT_IDS=537 +READRATIO=538 +ROUNDEC=539 +TRIMBLANKS=540 +PRESET=541 +ACCESS_KEY_ID=542 +SECRET_ACCESS_KEY=543 +SESSION_TOKEN_KW=544 +HEADER=545 +SETTINGS=546 +FUNCTION_NAME=547 +ATOMIC_P=548 +BETWEEN=549 +BIGINT=550 +BIT=551 +BOOLEAN_P=552 +CHAR_P=553 +CHARACTER=554 +COALESCE=555 +DEC=556 +DECIMAL_P=557 +EXISTS=558 +EXTRACT=559 +FLOAT_P=560 +GREATEST=561 +INOUT=562 +INT_P=563 +INTEGER=564 +INTERVAL=565 +LEAST=566 +NATIONAL=567 +NCHAR=568 +NONE=569 +NULLIF=570 +NUMERIC=571 +OVERLAY=572 +PARAMETER=573 +POSITION=574 +PRECISION=575 +REAL=576 +ROW=577 +SETOF=578 +SMALLINT=579 +SUBSTRING=580 +TIME=581 +TIMESTAMP=582 +TREAT=583 +TRIM=584 +VALUES=585 +VARCHAR=586 +XMLATTRIBUTES=587 +XMLCOMMENT=588 +XMLAGG=589 +XML_IS_WELL_FORMED=590 +XML_IS_WELL_FORMED_DOCUMENT=591 +XML_IS_WELL_FORMED_CONTENT=592 +XPATH=593 +XPATH_EXISTS=594 +XMLCONCAT=595 +XMLELEMENT=596 +XMLEXISTS=597 +XMLFOREST=598 +XMLPARSE=599 +XMLPI=600 +XMLROOT=601 +XMLSERIALIZE=602 +CALL=603 +CURRENT_P=604 +ATTACH=605 +DETACH=606 +EXPRESSION=607 +GENERATED=608 +LOGGED=609 +STORED=610 +SERDE=611 +SERDEPROPERTIES=612 +INPUTFORMAT=613 +OUTPUTFORMAT=614 +FIELDS=615 +COLLECTION=616 +ITEMS=617 +TERMINATED=618 +ESCAPED=619 +DEFINED=620 +LINES=621 +KEYS=622 +PARTITIONED=623 +STRUCT=624 +MAP=625 +STRING=626 +DELIMITED=627 +USAGE=628 +IGNORE=629 +LANGUAGES=630 +JOB=631 +JOBS=632 +VIA=633 +ASSUMEROLE=634 +RETRY_TIMEOUT=635 +MAX_BATCH_SIZE=636 +MAX_PAYLOAD_IN_MB=637 +KB=638 +INCLUDE=639 +ROUTINE=640 +TRANSFORM=641 +IMPORT_P=642 +POLICY=643 +PRIORITY=644 +METHOD=645 +REFERENCING=646 +NEW=647 +OLD=648 +VALUE_P=649 +SUBSCRIPTION=650 +PUBLICATION=651 +OUT_P=652 +END_P=653 +ROUTINES=654 +SCHEMAS=655 +PROCEDURES=656 +INPUT_P=657 +SUPPORT=658 +PARALLEL=659 +SQL_P=660 +DEPENDS=661 +OVERRIDING=662 +CONFLICT=663 +SKIP_P=664 +LOCKED=665 +TIES=666 +ROLLUP=667 +CUBE=668 +GROUPING=669 +SETS=670 +TABLESAMPLE=671 +ORDINALITY=672 +XMLTABLE=673 +COLUMNS=674 +XMLNAMESPACES=675 +ROWTYPE=676 +NORMALIZED=677 +WITHIN=678 +FILTER=679 +GROUPS=680 +OTHERS=681 +NFC=682 +NFD=683 +NFKC=684 +NFKD=685 +UESCAPE=686 +VIEWS=687 +NORMALIZE=688 +DUMP=689 +PRINT_STRICT_PARAMS=690 +VARIABLE_CONFLICT=691 +ERROR=692 +USE_VARIABLE=693 +USE_COLUMN=694 +ALIAS=695 +CONSTANT=696 +PERFORM=697 +GET=698 +DIAGNOSTICS=699 +STACKED=700 +ELSIF=701 +WHILE=702 +REVERSE=703 +FOREACH=704 +SLICE=705 +EXIT=706 +RETURN=707 +QUERY=708 +RAISE=709 +SQLSTATE=710 +DEBUG=711 +LOG=712 +INFO=713 +NOTICE=714 +WARNING=715 +EXCEPTION=716 +ASSERT=717 +LOOP=718 +OPEN=719 +ABS=720 +CBRT=721 +CEIL=722 +CEILING=723 +DEGREES=724 +DIV=725 +EXP=726 +FACTORIAL=727 +FLOOR=728 +GCD=729 +LCM=730 +LN=731 +LOG10=732 +MIN_SCALE=733 +MOD=734 +PI=735 +POWER=736 +RADIANS=737 +ROUND=738 +SCALE=739 +SIGN=740 +SQRT=741 +TRIM_SCALE=742 +TRUNC=743 +WIDTH_BUCKET=744 +RANDOM=745 +SETSEED=746 +ACOS=747 +ACOSD=748 +ASIN=749 +ASIND=750 +ATAN=751 +ATAND=752 +ATAN2=753 +ATAN2D=754 +COS=755 +COSD=756 +COT=757 +COTD=758 +SIN=759 +SIND=760 +TAN=761 +TAND=762 +SINH=763 +COSH=764 +TANH=765 +ASINH=766 +ACOSH=767 +ATANH=768 +BIT_LENGTH=769 +CHAR_LENGTH=770 +CHARACTER_LENGTH=771 +LOWER=772 +OCTET_LENGTH=773 +UPPER=774 +ASCII=775 +BTRIM=776 +CHR=777 +CONCAT=778 +CONCAT_WS=779 +FORMAT=780 +INITCAP=781 +LENGTH=782 +LPAD=783 +LTRIM=784 +MD5=785 +PARSE_IDENT=786 +PG_CLIENT_ENCODING=787 +QUOTE_IDENT=788 +QUOTE_LITERAL=789 +QUOTE_NULLABLE=790 +REGEXP_COUNT=791 +REGEXP_INSTR=792 +REGEXP_LIKE=793 +REGEXP_MATCH=794 +REGEXP_MATCHES=795 +REGEXP_REPLACE=796 +REGEXP_SPLIT_TO_ARRAY=797 +REGEXP_SPLIT_TO_TABLE=798 +REGEXP_SUBSTR=799 +REPEAT=800 +RPAD=801 +RTRIM=802 +SPLIT_PART=803 +STARTS_WITH=804 +STRING_TO_ARRAY=805 +STRING_TO_TABLE=806 +STRPOS=807 +SUBSTR=808 +TO_ASCII=809 +TO_HEX=810 +TRANSLATE=811 +UNISTR=812 +AGE=813 +CLOCK_TIMESTAMP=814 +DATE_BIN=815 +DATE_PART=816 +DATE_TRUNC=817 +ISFINITE=818 +JUSTIFY_DAYS=819 +JUSTIFY_HOURS=820 +JUSTIFY_INTERVAL=821 +MAKE_DATE=822 +MAKE_INTERVAL=823 +MAKE_TIME=824 +MAKE_TIMESTAMP=825 +MAKE_TIMESTAMPTZ=826 +NOW=827 +STATEMENT_TIMESTAMP=828 +TIMEOFDAY=829 +TRANSACTION_TIMESTAMP=830 +TO_TIMESTAMP=831 +TO_CHAR=832 +TO_DATE=833 +TO_NUMBER=834 +ENCODE=835 +DISTKEY=836 +SORTKEY=837 +DISTSTYLE=838 +BACKUP=839 +COMPOUND=840 +INTERLEAVED=841 +EVEN=842 +CASE_SENSITIVE=843 +QUOTA=844 +TB=845 +BOOST=846 +RECLUSTER=847 +SORT=848 +PERCENT_WORD=849 +CASE_INSENSITIVE=850 +Identifier=851 +TemporaryIdentifier=852 +NamespaceUser=853 +QuotedIdentifier=854 +UnterminatedQuotedIdentifier=855 +InvalidQuotedIdentifier=856 +InvalidUnterminatedQuotedIdentifier=857 +UnicodeQuotedIdentifier=858 +UnterminatedUnicodeQuotedIdentifier=859 +InvalidUnicodeQuotedIdentifier=860 +InvalidUnterminatedUnicodeQuotedIdentifier=861 +StringConstant=862 +UnterminatedStringConstant=863 +UnicodeEscapeStringConstant=864 +UnterminatedUnicodeEscapeStringConstant=865 +BeginDollarStringConstant=866 +BinaryStringConstant=867 +UnterminatedBinaryStringConstant=868 +InvalidBinaryStringConstant=869 +InvalidUnterminatedBinaryStringConstant=870 +HexadecimalStringConstant=871 +UnterminatedHexadecimalStringConstant=872 +InvalidHexadecimalStringConstant=873 +InvalidUnterminatedHexadecimalStringConstant=874 +Integral=875 +NumericFail=876 +Numeric=877 +PLSQLVARIABLENAME=878 +PLSQLIDENTIFIER=879 +Whitespace=880 +Newline=881 +LineComment=882 +BlockComment=883 +UnterminatedBlockComment=884 +MetaCommand=885 +EndMetaCommand=886 +ErrorCharacter=887 +EscapeStringConstant=888 +UnterminatedEscapeStringConstant=889 +InvalidEscapeStringConstant=890 +InvalidUnterminatedEscapeStringConstant=891 +AfterEscapeStringConstantMode_NotContinued=892 +AfterEscapeStringConstantWithNewlineMode_NotContinued=893 +DollarText=894 +EndDollarStringConstant=895 +AfterEscapeStringConstantWithNewlineMode_Continued=896 +'$'=1 +'('=2 +')'=3 +'['=4 +']'=5 +','=6 +';'=7 +':'=8 +'*'=9 +'='=10 +'.'=11 +'+'=12 +'-'=13 +'/'=14 +'^'=15 +'<'=16 +'>'=17 +'<<'=18 +'>>'=19 +':='=20 +'<='=21 +'=>'=22 +'>='=23 +'..'=24 +'<>'=25 +'::'=26 +'%'=27 +'ALL'=30 +'ANALYSE'=31 +'ANALYZE'=32 +'AND'=33 +'ANY'=34 +'ARRAY'=35 +'AS'=36 +'ASC'=37 +'ASYMMETRIC'=38 +'BOTH'=39 +'CASE'=40 +'CAST'=41 +'CHECK'=42 +'COLLATE'=43 +'COLUMN'=44 +'CONSTRAINT'=45 +'CREATE'=46 +'CURRENT_CATALOG'=47 +'CURRENT_DATE'=48 +'CURRENT_ROLE'=49 +'CURRENT_TIME'=50 +'CURRENT_TIMESTAMP'=51 +'CURRENT_USER'=52 +'DEFAULT'=53 +'DEFERRABLE'=54 +'DESC'=55 +'DISTINCT'=56 +'DO'=57 +'ELSE'=58 +'EXCEPT'=59 +'FALSE'=60 +'FETCH'=61 +'FOR'=62 +'FOREIGN'=63 +'FROM'=64 +'GRANT'=65 +'GROUP'=66 +'HAVING'=67 +'IN'=68 +'INITIALLY'=69 +'INTERSECT'=70 +'INTO'=71 +'LATERAL'=72 +'LEADING'=73 +'LIMIT'=74 +'LOCALTIME'=75 +'LOCALTIMESTAMP'=76 +'NOT'=77 +'NULL'=78 +'OFFSET'=79 +'ON'=80 +'ONLY'=81 +'OR'=82 +'ORDER'=83 +'PLACING'=84 +'PRIMARY'=85 +'PUBLIC'=86 +'REFERENCES'=87 +'RETURNING'=88 +'SELECT'=89 +'SESSION_USER'=90 +'SOME'=91 +'SYMMETRIC'=92 +'TABLE'=93 +'THEN'=94 +'TO'=95 +'TRAILING'=96 +'TRUE'=97 +'UNION'=98 +'UNIQUE'=99 +'USER'=100 +'USING'=101 +'VARIADIC'=102 +'WHEN'=103 +'WHERE'=104 +'WINDOW'=105 +'WITH'=106 +'AUTHORIZATION'=107 +'BINARY'=108 +'BINDING'=109 +'COLLATION'=110 +'CONCURRENTLY'=111 +'CROSS'=112 +'CURRENT_SCHEMA'=113 +'FREEZE'=114 +'FULL'=115 +'ILIKE'=116 +'INNER'=117 +'IS'=118 +'ISNULL'=119 +'JOIN'=120 +'LEFT'=121 +'LIKE'=122 +'NATURAL'=123 +'NOTNULL'=124 +'OUTER'=125 +'OVER'=126 +'OVERLAPS'=127 +'RIGHT'=128 +'SIMILAR'=129 +'VERBOSE'=130 +'ABORT'=131 +'ABSOLUTE'=132 +'ACCESS'=133 +'ACTION'=134 +'ADD'=135 +'ADMIN'=136 +'AFTER'=137 +'AGGREGATE'=138 +'ALSO'=139 +'ALTER'=140 +'ALWAYS'=141 +'ASSERTION'=142 +'ASSIGNMENT'=143 +'AT'=144 +'ATTRIBUTE'=145 +'BACKWARD'=146 +'BEFORE'=147 +'BEGIN'=148 +'BY'=149 +'CACHE'=150 +'CALLED'=151 +'CASCADE'=152 +'CASCADED'=153 +'CATALOG'=154 +'CHAIN'=155 +'CHARACTERISTICS'=156 +'CHECKPOINT'=157 +'CLASS'=158 +'CLOSE'=159 +'CLUSTER'=160 +'COMMENT'=161 +'COMMENTS'=162 +'COMMIT'=163 +'COMMITTED'=164 +'CONFIGURATION'=165 +'CONNECTION'=166 +'CONSTRAINTS'=167 +'CONTENT'=168 +'CONTINUE'=169 +'CONVERSION'=170 +'COPY'=171 +'COST'=172 +'CSV'=173 +'JSON'=174 +'CURSOR'=175 +'CYCLE'=176 +'DATA'=177 +'DATA_CATALOG'=178 +'DATABASE'=179 +'DAY'=180 +'DEALLOCATE'=181 +'DECLARE'=182 +'DEFAULTS'=183 +'DEFERRED'=184 +'DEFINER'=185 +'DELETE'=186 +'DELIMITER'=187 +'DELIMITERS'=188 +'DICTIONARY'=189 +'DISABLE'=190 +'DISCARD'=191 +'DOCUMENT'=192 +'DOMAIN'=193 +'DOUBLE'=194 +'DROP'=195 +'EACH'=196 +'ENABLE'=197 +'ENCODING'=198 +'ENCRYPTED'=199 +'ENUM'=200 +'ESCAPE'=201 +'EVENT'=202 +'EXCLUDE'=203 +'EXCLUDING'=204 +'EXCLUSIVE'=205 +'EXECUTE'=206 +'EXPLAIN'=207 +'EXTENSION'=208 +'EXTERNAL'=209 +'FAMILY'=210 +'FIRST'=211 +'FOLLOWING'=212 +'FORCE'=213 +'FORWARD'=214 +'FUNCTION'=215 +'FUNCTIONS'=216 +'GLOBAL'=217 +'GRANTED'=218 +'HANDLER'=219 +'HOLD'=221 +'HOUR'=222 +'IF'=224 +'IMMEDIATE'=225 +'IMMUTABLE'=226 +'IMPLICIT'=227 +'INCLUDING'=228 +'INCREMENT'=229 +'INDEX'=230 +'INDEXES'=231 +'INHERIT'=232 +'INHERITS'=233 +'INLINE'=234 +'INSENSITIVE'=235 +'INSERT'=236 +'INSTEAD'=237 +'INVOKER'=238 +'ISOLATION'=239 +'KEY'=240 +'LABEL'=241 +'LANGUAGE'=242 +'LARGE'=243 +'LAST'=244 +'LEAKPROOF'=245 +'LEVEL'=246 +'LISTEN'=247 +'LOAD'=248 +'LOCAL'=249 +'LOCATION'=250 +'LOCK'=251 +'MAPPING'=252 +'MATCH'=253 +'MATCHED'=254 +'MATERIALIZED'=255 +'MAXVALUE'=256 +'MERGE'=257 +'MINUTE'=258 +'MINVALUE'=259 +'MODE'=260 +'MONTH'=261 +'MOVE'=262 +'NAME'=263 +'NAMES'=264 +'NEXT'=265 +'NO'=266 +'NOTHING'=267 +'NOTIFY'=268 +'NOWAIT'=269 +'NULLS'=270 +'OBJECT'=271 +'OF'=272 +'OFF'=273 +'OIDS'=274 +'OPERATOR'=275 +'OPTION'=276 +'OPTIONS'=277 +'OWNED'=278 +'OWNER'=279 +'PARSER'=280 +'PARTIAL'=281 +'PARTITION'=282 +'PASSING'=283 +'PASSWORD'=284 +'PLANS'=285 +'PRECEDING'=286 +'PREDICATE'=287 +'PREPARE'=288 +'PREPARED'=289 +'PRESERVE'=290 +'PRIOR'=291 +'PRIVILEGES'=292 +'PROCEDURAL'=293 +'PROCEDURE'=294 +'PROGRAM'=295 +'QUOTE'=296 +'RANGE'=297 +'READ'=298 +'REASSIGN'=299 +'RECHECK'=300 +'RECURSIVE'=301 +'REF'=302 +'REFRESH'=303 +'REINDEX'=304 +'RELATIVE'=305 +'RELEASE'=306 +'RENAME'=307 +'REPEATABLE'=308 +'REPLACE'=309 +'REPLICA'=310 +'RESET'=311 +'RESTART'=312 +'RESTRICT'=313 +'RETURNS'=314 +'REVOKE'=315 +'ROLE'=316 +'ROLLBACK'=317 +'ROWS'=318 +'RULE'=319 +'SAVEPOINT'=320 +'SCHEMA'=321 +'SCROLL'=322 +'SEARCH'=323 +'SECOND'=324 +'SECURITY'=325 +'SEQUENCE'=326 +'SEQUENCES'=327 +'SERIALIZABLE'=328 +'SERVER'=329 +'SET'=331 +'SHARE'=332 +'SHOW'=333 +'SIMPLE'=334 +'SNAPSHOT'=335 +'STABLE'=336 +'STANDALONE'=337 +'START'=338 +'STATEMENT'=339 +'STATISTICS'=340 +'STDIN'=341 +'STDOUT'=342 +'STORAGE'=343 +'STRICT'=344 +'STRIP'=345 +'SYSID'=346 +'SYSTEM'=347 +'TABLES'=348 +'TABLESPACE'=349 +'TEMP'=350 +'TEMPLATE'=351 +'TEMPORARY'=352 +'TEXT'=353 +'TRANSACTION'=354 +'TRIGGER'=355 +'TRUNCATE'=356 +'TRUSTED'=357 +'TYPE'=358 +'TYPES'=359 +'UNBOUNDED'=360 +'UNCOMMITTED'=361 +'UNENCRYPTED'=362 +'UNKNOWN'=363 +'UNLISTEN'=364 +'UNLOGGED'=365 +'UNTIL'=366 +'UPDATE'=367 +'VACUUM'=368 +'VALID'=369 +'VALIDATE'=370 +'VALIDATOR'=371 +'VARYING'=372 +'VERSION'=373 +'VIEW'=374 +'VOLATILE'=375 +'WHITESPACE'=376 +'WITHOUT'=377 +'WORK'=378 +'WRAPPER'=379 +'WRITE'=380 +'XML'=381 +'YEAR'=382 +'YES'=383 +'ZONE'=384 +'QUALIFY'=385 +'CONNECT'=386 +'TOP'=387 +'VARBYTE'=388 +'VARBINARY'=389 +'CONJUNCTION'=390 +'DEFINITION'=391 +'DATASHARE'=392 +'FILE'=393 +'PUBLICACCESSIBLE'=394 +'INCLUDENEW'=395 +'IAM_ROLE'=396 +'CATALOG_ROLE'=397 +'CATALOG_ID'=398 +'HIVE'=399 +'METASTORE'=400 +'URI'=401 +'POSTGRES'=402 +'MYSQL'=403 +'SECRET_ARN'=404 +'KINESIS'=405 +'KAFKA'=406 +'MSK'=407 +'AUTHENTICATION'=408 +'AUTHENTICATION_ARN'=409 +'MTLS'=411 +'MASKING'=412 +'RLS'=413 +'PROVIDER'=415 +'PROTECTED'=416 +'MODEL'=417 +'TARGET'=418 +'SAGEMAKER'=419 +'AUTO'=420 +'MODEL_TYPE'=421 +'PROBLEM_TYPE'=422 +'OBJECTIVE'=423 +'PREPROCESSORS'=424 +'HYPERPARAMETERS'=425 +'XGBOOST'=426 +'MLP'=427 +'LINEAR_LEARNER'=428 +'KMEANS'=429 +'FORECAST'=430 +'REGRESSION'=431 +'BINARY_CLASSIFICATION'=432 +'MULTICLASS_CLASSIFICATION'=433 +'S3_BUCKET'=434 +'TAGS'=435 +'KMS_KEY_ID'=436 +'S3_GARBAGE_COLLECT'=437 +'MAX_CELLS'=438 +'MAX_RUNTIME'=439 +'HORIZON'=440 +'FREQUENCY'=441 +'PERCENTILES'=442 +'MAX_BATCH_ROWS'=443 +'UNLOAD'=444 +'MANIFEST'=445 +'ADDQUOTES'=446 +'ALLOWOVERWRITE'=447 +'CLEANPATH'=448 +'MAXFILESIZE'=449 +'ROWGROUPSIZE'=450 +'BZIP2'=451 +'GZIP'=452 +'ZSTD'=453 +'DATABASES'=454 +'DATASHARES'=455 +'GRANTS'=456 +'USE'=457 +'CANCEL'=458 +'SESSION_AUTHORIZATION'=459 +'SESSION_CHARACTERISTICS'=460 +'COMPRESSION'=461 +'LIBRARY'=462 +'APPEND'=463 +'MB'=464 +'GB'=465 +'ACCOUNT'=466 +'NAMESPACE'=467 +'DESCRIBE'=468 +'NONATOMIC'=469 +'MANAGEDBY'=470 +'ADX'=471 +'REMOVE'=472 +'DUPLICATES'=473 +'BEDROCK'=474 +'MODEL_ID'=475 +'PROMPT'=476 +'SUFFIX'=477 +'REQUEST_TYPE'=478 +'RESPONSE_TYPE'=479 +'RAW'=480 +'UNIFIED'=481 +'SUPER'=482 +'CI'=483 +'CS'=484 +'PLPYTHONU'=485 +'FILLTARGET'=486 +'IGNOREEXTRA'=487 +'CREATEUSER'=488 +'NOCREATEUSER'=489 +'REGION'=490 +'PORT'=491 +'REDSHIFT'=492 +'IAM'=493 +'CREATEDB'=494 +'NOCREATEDB'=495 +'RESTRICTED'=496 +'UNLIMITED'=497 +'EXTERNALID'=498 +'TIMEOUT'=499 +'SYSLOG'=500 +'CREDENTIALS'=501 +'UNRESTRICTED'=502 +'PARAMETERS'=503 +'APPLICATION_ARN'=504 +'AUTO_CREATE_ROLES'=505 +'COMPROWS'=506 +'PROVIDER_URL'=507 +'PROVIDER_URL_PORT'=508 +'ATTRIBUTE_MAP'=509 +'PROVIDER_ARN'=510 +'ASSUME_ROLE_ARN'=511 +'PROPERTIES'=512 +'AVRO'=513 +'RCFILE'=514 +'SEQUENCEFILE'=515 +'TEXTFILE'=516 +'ORC'=517 +'ION'=518 +'LAMBDA'=519 +'FIXEDWIDTH'=520 +'PARQUET'=521 +'LZOP'=522 +'REMOVEQUOTES'=523 +'TRUNCATECOLUMNS'=524 +'FILLRECORD'=525 +'BLANKSASNULL'=526 +'EMPTYASNULL'=527 +'MAXERROR'=528 +'DATEFORMAT'=529 +'TIMEFORMAT'=530 +'ACCEPTINVCHARS'=531 +'ACCEPTANYDATE'=532 +'IGNOREHEADER'=533 +'IGNOREBLANKLINES'=534 +'COMPUPDATE'=535 +'STATUPDATE'=536 +'EXPLICIT_IDS'=537 +'READRATIO'=538 +'ROUNDEC'=539 +'TRIMBLANKS'=540 +'PRESET'=541 +'ACCESS_KEY_ID'=542 +'SECRET_ACCESS_KEY'=543 +'SESSION_TOKEN'=544 +'SETTINGS'=546 +'FUNCTION_NAME'=547 +'ATOMIC'=548 +'BETWEEN'=549 +'BIGINT'=550 +'BIT'=551 +'BOOLEAN'=552 +'CHAR'=553 +'CHARACTER'=554 +'COALESCE'=555 +'DEC'=556 +'DECIMAL'=557 +'EXISTS'=558 +'EXTRACT'=559 +'FLOAT'=560 +'GREATEST'=561 +'INOUT'=562 +'INT'=563 +'INTEGER'=564 +'INTERVAL'=565 +'LEAST'=566 +'NATIONAL'=567 +'NCHAR'=568 +'NONE'=569 +'NULLIF'=570 +'NUMERIC'=571 +'OVERLAY'=572 +'PARAMETER'=573 +'POSITION'=574 +'PRECISION'=575 +'REAL'=576 +'ROW'=577 +'SETOF'=578 +'SMALLINT'=579 +'SUBSTRING'=580 +'TIME'=581 +'TIMESTAMP'=582 +'TREAT'=583 +'TRIM'=584 +'VALUES'=585 +'VARCHAR'=586 +'XMLATTRIBUTES'=587 +'XMLCOMMENT'=588 +'XMLAGG'=589 +'XML_IS_WELL_FORMED'=590 +'XML_IS_WELL_FORMED_DOCUMENT'=591 +'XML_IS_WELL_FORMED_CONTENT'=592 +'XPATH'=593 +'XPATH_EXISTS'=594 +'XMLCONCAT'=595 +'XMLELEMENT'=596 +'XMLEXISTS'=597 +'XMLFOREST'=598 +'XMLPARSE'=599 +'XMLPI'=600 +'XMLROOT'=601 +'XMLSERIALIZE'=602 +'CALL'=603 +'CURRENT'=604 +'ATTACH'=605 +'DETACH'=606 +'EXPRESSION'=607 +'GENERATED'=608 +'LOGGED'=609 +'STORED'=610 +'SERDE'=611 +'SERDEPROPERTIES'=612 +'INPUTFORMAT'=613 +'OUTPUTFORMAT'=614 +'FIELDS'=615 +'COLLECTION'=616 +'ITEMS'=617 +'TERMINATED'=618 +'ESCAPED'=619 +'DEFINED'=620 +'LINES'=621 +'KEYS'=622 +'PARTITIONED'=623 +'STRUCT'=624 +'MAP'=625 +'STRING'=626 +'DELIMITED'=627 +'USAGE'=628 +'IGNORE'=629 +'LANGUAGES'=630 +'JOB'=631 +'JOBS'=632 +'VIA'=633 +'ASSUMEROLE'=634 +'RETRY_TIMEOUT'=635 +'MAX_BATCH_SIZE'=636 +'MAX_PAYLOAD_IN_MB'=637 +'KB'=638 +'INCLUDE'=639 +'ROUTINE'=640 +'TRANSFORM'=641 +'IMPORT'=642 +'POLICY'=643 +'PRIORITY'=644 +'METHOD'=645 +'REFERENCING'=646 +'NEW'=647 +'OLD'=648 +'VALUE'=649 +'SUBSCRIPTION'=650 +'PUBLICATION'=651 +'OUT'=652 +'END'=653 +'ROUTINES'=654 +'SCHEMAS'=655 +'PROCEDURES'=656 +'INPUT'=657 +'SUPPORT'=658 +'PARALLEL'=659 +'SQL'=660 +'DEPENDS'=661 +'OVERRIDING'=662 +'CONFLICT'=663 +'SKIP'=664 +'LOCKED'=665 +'TIES'=666 +'ROLLUP'=667 +'CUBE'=668 +'GROUPING'=669 +'SETS'=670 +'TABLESAMPLE'=671 +'ORDINALITY'=672 +'XMLTABLE'=673 +'COLUMNS'=674 +'XMLNAMESPACES'=675 +'ROWTYPE'=676 +'NORMALIZED'=677 +'WITHIN'=678 +'FILTER'=679 +'GROUPS'=680 +'OTHERS'=681 +'NFC'=682 +'NFD'=683 +'NFKC'=684 +'NFKD'=685 +'UESCAPE'=686 +'VIEWS'=687 +'NORMALIZE'=688 +'DUMP'=689 +'PRINT_STRICT_PARAMS'=690 +'VARIABLE_CONFLICT'=691 +'ERROR'=692 +'USE_VARIABLE'=693 +'USE_COLUMN'=694 +'ALIAS'=695 +'CONSTANT'=696 +'PERFORM'=697 +'GET'=698 +'DIAGNOSTICS'=699 +'STACKED'=700 +'ELSIF'=701 +'WHILE'=702 +'REVERSE'=703 +'FOREACH'=704 +'SLICE'=705 +'EXIT'=706 +'RETURN'=707 +'QUERY'=708 +'RAISE'=709 +'SQLSTATE'=710 +'DEBUG'=711 +'LOG'=712 +'INFO'=713 +'NOTICE'=714 +'WARNING'=715 +'EXCEPTION'=716 +'ASSERT'=717 +'LOOP'=718 +'OPEN'=719 +'ABS'=720 +'CBRT'=721 +'CEIL'=722 +'CEILING'=723 +'DEGREES'=724 +'DIV'=725 +'EXP'=726 +'FACTORIAL'=727 +'FLOOR'=728 +'GCD'=729 +'LCM'=730 +'LN'=731 +'LOG10'=732 +'MIN_SCALE'=733 +'MOD'=734 +'PI'=735 +'POWER'=736 +'RADIANS'=737 +'ROUND'=738 +'SCALE'=739 +'SIGN'=740 +'SQRT'=741 +'TRIM_SCALE'=742 +'TRUNC'=743 +'WIDTH_BUCKET'=744 +'RANDOM'=745 +'SETSEED'=746 +'ACOS'=747 +'ACOSD'=748 +'ASIN'=749 +'ASIND'=750 +'ATAN'=751 +'ATAND'=752 +'ATAN2'=753 +'ATAN2D'=754 +'COS'=755 +'COSD'=756 +'COT'=757 +'COTD'=758 +'SIN'=759 +'SIND'=760 +'TAN'=761 +'TAND'=762 +'SINH'=763 +'COSH'=764 +'TANH'=765 +'ASINH'=766 +'ACOSH'=767 +'ATANH'=768 +'BIT_LENGTH'=769 +'CHAR_LENGTH'=770 +'CHARACTER_LENGTH'=771 +'LOWER'=772 +'OCTET_LENGTH'=773 +'UPPER'=774 +'ASCII'=775 +'BTRIM'=776 +'CHR'=777 +'CONCAT'=778 +'CONCAT_WS'=779 +'FORMAT'=780 +'INITCAP'=781 +'LENGTH'=782 +'LPAD'=783 +'LTRIM'=784 +'MD5'=785 +'PARSE_IDENT'=786 +'PG_CLIENT_ENCODING'=787 +'QUOTE_IDENT'=788 +'QUOTE_LITERAL'=789 +'QUOTE_NULLABLE'=790 +'REGEXP_COUNT'=791 +'REGEXP_INSTR'=792 +'REGEXP_LIKE'=793 +'REGEXP_MATCH'=794 +'REGEXP_MATCHES'=795 +'REGEXP_REPLACE'=796 +'REGEXP_SPLIT_TO_ARRAY'=797 +'REGEXP_SPLIT_TO_TABLE'=798 +'REGEXP_SUBSTR'=799 +'REPEAT'=800 +'RPAD'=801 +'RTRIM'=802 +'SPLIT_PART'=803 +'STARTS_WITH'=804 +'STRING_TO_ARRAY'=805 +'STRING_TO_TABLE'=806 +'STRPOS'=807 +'SUBSTR'=808 +'TO_ASCII'=809 +'TO_HEX'=810 +'TRANSLATE'=811 +'UNISTR'=812 +'AGE'=813 +'CLOCK_TIMESTAMP'=814 +'DATE_BIN'=815 +'DATE_PART'=816 +'DATE_TRUNC'=817 +'ISFINITE'=818 +'JUSTIFY_DAYS'=819 +'JUSTIFY_HOURS'=820 +'JUSTIFY_INTERVAL'=821 +'MAKE_DATE'=822 +'MAKE_INTERVAL'=823 +'MAKE_TIME'=824 +'MAKE_TIMESTAMP'=825 +'MAKE_TIMESTAMPTZ'=826 +'NOW'=827 +'STATEMENT_TIMESTAMP'=828 +'TIMEOFDAY'=829 +'TRANSACTION_TIMESTAMP'=830 +'TO_TIMESTAMP'=831 +'TO_CHAR'=832 +'TO_DATE'=833 +'TO_NUMBER'=834 +'ENCODE'=835 +'DISTKEY'=836 +'SORTKEY'=837 +'DISTSTYLE'=838 +'BACKUP'=839 +'COMPOUND'=840 +'INTERLEAVED'=841 +'EVEN'=842 +'CASE_SENSITIVE'=843 +'QUOTA'=844 +'TB'=845 +'BOOST'=846 +'RECLUSTER'=847 +'SORT'=848 +'PERCENT'=849 +'CASE_INSENSITIVE'=850 +'\\\\'=886 +'\''=896 diff --git a/redshift/builtin_function.go b/redshift/builtin_function.go new file mode 100644 index 0000000..1b69427 --- /dev/null +++ b/redshift/builtin_function.go @@ -0,0 +1,835 @@ +package redshift + +import "sort" + +var ( + comparisonFunctions = []string{ + "num_nonnulls", + "num_nulls", + } + + mathematicalFunctions = []string{ + "abs", + "cbrt", + "ceil", + "ceiling", + "degrees", + "div", + "erf", + "erfc", + "exp", + "factorial", + "floor", + "gcd", + "lcm", + "ln", + "log", + "log10", + "min_scale", + "mod", + "pi", + "power", + "radians", + "round", + "scale", + "sign", + "sqrt", + "trim_scale", + "trunc", + "width_bucket", + "random", + "random_normal", + "setseed", + "acos", + "acosd", + "asin", + "asind", + "atan", + "atand", + "atan2", + "atan2d", + "cos", + "cosd", + "cot", + "cotd", + "sin", + "sind", + "tan", + "tand", + "sinh", + "cosh", + "tanh", + "asinh", + "acosh", + "atanh", + } + + stringFunctions = []string{ + "btrim", + "bit_length", + "char_length", + "character_length", + "lower", + "lpad", + "ltrim", + "normalize", + "octet_length", + "overlay", + "position", + "rpad", + "rtrim", + "substring", + "trim", + "upper", + "ascii", + "chr", + "concat", + "concat_ws", + "format", + "initcap", + "left", + "length", + "md5", + "parse_ident", + "pg_client_encoding", + "quote_ident", + "quote_literal", + "quote_nullable", + "regexp_count", + "regexp_instr", + "regexp_like", + "regexp_match", + "regexp_matches", + "regexp_replace", + "regexp_split_to_array", + "regexp_split_to_table", + "regexp_substr", + "repeat", + "replace", + "reverse", + "right", + "split_part", + "starts_with", + "string_to_array", + "string_to_table", + "strpos", + "substr", + "to_ascii", + "to_hex", + "translate", + "unistr", + } + + binaryStringFunctions = []string{ + "bit_length", + "btrim", + "ltrim", + "octet_length", + "overlay", + "position", + "rtrim", + "substring", + "trim", + "bit_count", + "get_bit", + "get_byte", + "length", + "md5", + "set_bit", + "set_byte", + "sha224", + "sha256", + "sha384", + "sha512", + "substr", + "convert", + "convert_from", + "convert_to", + "encode", + "decode", + } + + bitStringFunctions = []string{ + "bit_count", + "bit_length", + "length", + "octet_length", + "overlay", + "position", + "substring", + "get_bit", + "set_bit", + } + + dataTypeFormattingFunctions = []string{ + "to_char", + "to_date", + "to_number", + "to_timestamp", + } + + dateTimeFunctions = []string{ + "age", + "clock_timestamp", + "current_time", + "current_timestamp", + "date_add", + "date_bin", + "date_part", + "date_subtract", + "date_trunc", + "extract", + "isfinite", + "justify_days", + "justify_hours", + "justify_interval", + "localtime", + "localtimestamp", + "make_date", + "make_interval", + "make_time", + "make_timestamp", + "make_timestamptz", + "now", + "statement_timestamp", + "timeofday", + "transaction_timestamp", + "to_timestamp", + } + + enumSupportFunctions = []string{ + "enum_first", + "enum_last", + "enum_range", + } + + geometricFunctions = []string{ + "area", + "center", + "diagonal", + "diameter", + "height", + "isclosed", + "isopen", + "length", + "npoints", + "pclose", + "popen", + "radius", + "slope", + "width", + "box", + "bound_box", + "circle", + "line", + "lseg", + "path", + "point", + "polygon", + } + + networkAddressFunctions = []string{ + "abbrev", + "broadcast", + "family", + "host", + "hostmask", + "inet_merge", + "inet_same_family", + "masklen", + "netmask", + "network", + "set_masklen", + "text", + "trunc", + "macaddr8_set7bit", + } + + textSearchFunctions = []string{ + "array_to_tsvector", + "get_current_ts_config", + "length", + "numnode", + "plainto_tsquery", + "phraseto_tsquery", + "websearch_to_tsquery", + "querytree", + "setweight", + "strip", + "to_tsquery", + "to_tsvector", + "json_to_tsvector", + "jsonb_to_tsvector", + "ts_delete", + "ts_filter", + "ts_headline", + "ts_rank", + "ts_rank_cd", + "ts_rewrite", + "tsquery_phrase", + "tsvector_to_array", + "unnest", + "ts_debug", + "ts_lexize", + "ts_parse", + "ts_token_type", + "ts_stat", + } + + uuidFunctions = []string{ + "gen_random_uuid", + } + + xmlFunctions = []string{ + "xmlcomment", + "xmlconcat", + "xmlelement", + "xmlforest", + "xmlpi", + "xmlroot", + "xmlagg", + "XMLEXISTS", + "xml_is_well_formed", + "xml_is_well_formed_document", + "xml_is_well_formed_content", + "xpath", + "xpath_exists", + "table_to_xml", + "query_to_xml", + "cursor_to_xml", + "table_to_xmlschema", + "query_to_xmlschema", + "cursor_to_xmlschema", + "table_to_xml_and_xmlschema", + "query_to_xml_and_xmlschema", + "schema_to_xml", + "schema_to_xmlschema", + "schema_to_xml_and_xmlschema", + "database_to_xml", + "database_to_xmlschema", + "database_to_xml_and_xmlschema", + } + + jsonFunctions = []string{ + "to_json", + "to_jsonb", + "array_to_json", + "json_array", + "row_to_json", + "json_build_array", + "jsonb_build_array", + "json_build_object", + "jsonb_build_object", + "json_object", + "jsonb_object", + "json_array_elements", + "jsonb_array_elements", + "json_array_elements_text", + "jsonb_array_elements_text", + "json_array_length", + "jsonb_array_length", + "json_each", + "jsonb_each", + "json_each_text", + "jsonb_each_text", + "json_extract_path", + "jsonb_extract_path", + "json_extract_path_text", + "jsonb_extract_path_text", + "json_object_keys", + "jsonb_object_keys", + "json_populate_record", + "jsonb_populate_record", + "json_populate_recordset", + "jsonb_populate_recordset", + "json_to_record", + "jsonb_to_record", + "json_to_recordset", + "jsonb_to_recordset", + "jsonb_set", + "jsonb_set_lax", + "jsonb_insert", + "json_strip_nulls", + "jsonb_strip_nulls", + "jsonb_path_exists", + "jsonb_path_match", + "jsonb_path_query", + "jsonb_path_query_array", + "jsonb_path_query_first", + "jsonb_path_exists_tz", + "jsonb_path_match_tz", + "jsonb_path_query_tz", + "jsonb_path_query_array_tz", + "jsonb_path_query_first_tz", + "jsonb_pretty", + "json_typeof", + "jsonb_typeof", + "exists", + } + + sequenceManipulationFunctions = []string{ + "nextval", + "setval", + "currval", + "lastval", + } + + conditionalFunctions = []string{ + "COALESCE", + "NULLIF", + "GREATEST", + "LEAST", + } + + arrayFunctions = []string{ + "array_append", + "array_cat", + "array_dims", + "array_fill", + "array_length", + "array_lower", + "array_ndims", + "array_position", + "array_positions", + "array_prepend", + "array_remove", + "array_replace", + "array_sample", + "array_shuffle", + "array_to_string", + "array_upper", + "cardinality", + "trim_array", + "unnest", + } + + rangeFunctions = []string{ + "lower", + "upper", + "isempty", + "lower_inc", + "upper_inc", + "lower_inf", + "upper_inf", + "range_merge", + "multirange", + "unnest", + } + + aggregateFunctions = []string{ + "any_value", + "array_agg", + "avg", + "bit_and", + "bit_or", + "bit_xor", + "bool_and", + "bool_or", + "count", + "every", + "json_agg", + "jsonb_agg", + "json_objectagg", + "json_object_agg", + "jsonb_object_agg", + "json_object_agg_strict", + "jsonb_object_agg_strict", + "json_object_agg_unique", + "jsonb_object_agg_unique", + "json_arrayagg", + "json_object_agg_unique_strict", + "jsonb_object_agg_unique_strict", + "max", + "min", + "range_agg", + "range_intersect_agg", + "json_agg_strict", + "jsonb_agg_strict", + "string_agg", + "sum", + "xmlagg", + "corr", + "covar_pop", + "covar_samp", + "regr_avgx", + "regr_avgy", + "regr_count", + "regr_intercept", + "regr_r2", + "regr_slope", + "regr_sxx", + "regr_sxy", + "regr_syy", + "stddev", + "stddev_pop", + "stddev_samp", + "variance", + "var_pop", + "var_samp", + "mode", + "percentile_cont", + "percentile_disc", + "rank", + "dense_rank", + "percent_rank", + "cume_dist", + "GROUPING", + } + + windowFunctions = []string{ + "row_number", + "rank", + "dense_rank", + "percent_rank", + "cume_dist", + "ntile", + "lag", + "lead", + "first_value", + "last_value", + "nth_value", + } + + setReturningFunctions = []string{ + "generate_series", + "generate_subscripts", + } + + systemInformationFunctions = []string{ + "current_database", + "current_query", + "current_schema", + "current_schemas", + "inet_client_addr", + "inet_client_port", + "inet_server_addr", + "inet_server_port", + "pg_backend_pid", + "pg_blocking_pids", + "pg_conf_load_time", + "pg_current_logfile", + "pg_my_temp_schema", + "pg_is_other_temp_schema", + "pg_jit_available", + "pg_listening_channels", + "pg_notification_queue_usage", + "pg_postmaster_start_time", + "pg_safe_snapshot_blocking_pids", + "pg_trigger_depth", + "version", + "has_any_column_privilege", + "has_column_privilege", + "has_database_privilege", + "has_foreign_data_wrapper_privilege", + "has_function_privilege", + "has_language_privilege", + "has_parameter_privilege", + "has_schema_privilege", + "has_sequence_privilege", + "has_server_privilege", + "has_table_privilege", + "has_tablespace_privilege", + "has_type_privilege", + "pg_has_role", + "row_security_active", + "acldefault", + "aclexplode", + "makeaclitem", + "pg_collation_is_visible", + "pg_conversion_is_visible", + "pg_function_is_visible", + "pg_opclass_is_visible", + "pg_operator_is_visible", + "pg_opfamily_is_visible", + "pg_statistics_obj_is_visible", + "pg_table_is_visible", + "pg_ts_config_is_visible", + "pg_ts_dict_is_visible", + "pg_ts_parser_is_visible", + "pg_ts_template_is_visible", + "pg_type_is_visible", + "format_type", + "pg_char_to_encoding", + "pg_encoding_to_char", + "pg_get_catalog_foreign_keys", + "pg_get_constraintdef", + "pg_get_expr", + "pg_get_functiondef", + "pg_get_function_arguments", + "pg_get_function_identity_arguments", + "pg_get_function_result", + "pg_get_indexdef", + "pg_get_keywords", + "pg_get_partkeydef", + "pg_get_ruledef", + "pg_get_serial_sequence", + "pg_get_statisticsobjdef", + "pg_get_triggerdef", + "pg_get_userbyid", + "pg_get_viewdef", + "pg_index_column_has_property", + "pg_index_has_property", + "pg_indexam_has_property", + "pg_options_to_table", + "pg_settings_get_flags", + "pg_tablespace_databases", + "pg_tablespace_location", + "pg_typeof", + "COLLATION FOR", + "to_regclass", + "to_regcollation", + "to_regnamespace", + "to_regoper", + "to_regoperator", + "to_regproc", + "to_regprocedure", + "to_regrole", + "to_regtype", + "pg_describe_object", + "pg_identify_object", + "pg_identify_object_as_address", + "pg_get_object_address", + "col_description", + "obj_description", + "shobj_description", + "pg_input_is_valid", + "pg_input_error_info", + "pg_current_xact_id", + "pg_current_xact_id_if_assigned", + "pg_xact_status", + "pg_current_snapshot", + "pg_snapshot_xip", + "pg_snapshot_xmax", + "pg_snapshot_xmin", + "pg_visible_in_snapshot", + "txid_current", + "txid_current_if_assigned", + "txid_current_snapshot", + "txid_snapshot_xip", + "txid_snapshot_xmax", + "txid_snapshot_xmin", + "txid_visible_in_snapshot", + "txid_status", + "pg_xact_commit_timestamp", + "pg_xact_commit_timestamp_origin", + "pg_last_committed_xact", + "pg_control_checkpoint", + "pg_control_system", + "pg_control_init", + "pg_control_recovery", + } + + systemAdministrationFunctions = []string{ + "current_setting", + "set_config", + "pg_cancel_backend", + "pg_log_backend_memory_contexts", + "pg_reload_conf", + "pg_rotate_logfile", + "pg_terminate_backend", + "pg_create_restore_point", + "pg_current_wal_flush_lsn", + "pg_current_wal_insert_lsn", + "pg_current_wal_lsn", + "pg_backup_start", + "pg_backup_stop", + "pg_switch_wal", + "pg_walfile_name", + "pg_walfile_name_offset", + "pg_split_walfile_name", + "pg_wal_lsn_diff", + "pg_is_in_recovery", + "pg_last_wal_receive_lsn", + "pg_last_wal_replay_lsn", + "pg_last_xact_replay_timestamp", + "pg_get_wal_resource_managers", + "pg_is_wal_replay_paused", + "pg_get_wal_replay_pause_state", + "pg_promote", + "pg_wal_replay_pause", + "pg_wal_replay_resume", + "pg_export_snapshot", + "pg_log_standby_snapshot", + "pg_create_physical_replication_slot", + "pg_drop_replication_slot", + "pg_create_logical_replication_slot", + "pg_copy_physical_replication_slot", + "pg_copy_logical_replication_slot", + "pg_logical_slot_get_changes", + "pg_logical_slot_peek_changes", + "pg_logical_slot_get_binary_changes", + "pg_logical_slot_peek_binary_changes", + "pg_replication_slot_advance", + "pg_replication_origin_create", + "pg_replication_origin_drop", + "pg_replication_origin_oid", + "pg_replication_origin_session_setup", + "pg_replication_origin_session_reset", + "pg_replication_origin_session_is_setup", + "pg_replication_origin_session_progress", + "pg_replication_origin_xact_setup", + "pg_replication_origin_xact_reset", + "pg_replication_origin_advance", + "pg_replication_origin_progress", + "pg_logical_emit_message", + "pg_column_size", + "pg_column_compression", + "pg_database_size", + "pg_indexes_size", + "pg_relation_size", + "pg_size_bytes", + "pg_size_pretty", + "pg_table_size", + "pg_tablespace_size", + "pg_total_relation_size", + "pg_relation_filenode", + "pg_relation_filepath", + "pg_filenode_relation", + "pg_collation_actual_version", + "pg_database_collation_actual_version", + "pg_import_system_collations", + "pg_partition_tree", + "pg_partition_ancestors", + "pg_partition_root", + "brin_summarize_new_values", + "brin_summarize_range", + "brin_desummarize_range", + "gin_clean_pending_list", + "pg_ls_dir", + "pg_ls_logdir", + "pg_ls_waldir", + "pg_ls_logicalmapdir", + "pg_ls_logicalsnapdir", + "pg_ls_replslotdir", + "pg_ls_archive_statusdir", + "pg_ls_tmpdir", + "pg_read_file", + "pg_read_binary_file", + "pg_stat_file", + "pg_advisory_lock", + "pg_advisory_lock_shared", + "pg_advisory_unlock", + "pg_advisory_unlock_all", + "pg_advisory_unlock_shared", + "pg_advisory_xact_lock", + "pg_advisory_xact_lock_shared", + "pg_try_advisory_lock", + "pg_try_advisory_lock_shared", + "pg_try_advisory_xact_lock", + "pg_try_advisory_xact_lock_shared", + } + + triggerFunctions = []string{ + "suppress_redundant_updates_trigger", + "tsvector_update_trigger", + "tsvector_update_trigger_column", + } + + eventTriggerFunctions = []string{ + "pg_event_trigger_ddl_commands", + "pg_event_trigger_dropped_objects", + "pg_event_trigger_table_rewrite_oid", + "pg_event_trigger_table_rewrite_reason", + } + + statisticsFunctions = []string{ + "pg_event_trigger_table_rewrite_reason", + } + + builtinFunctions = []string{} +) + +func init() { + funcMap := make(map[string]bool) + + for _, f := range comparisonFunctions { + funcMap[f] = true + } + for _, f := range mathematicalFunctions { + funcMap[f] = true + } + for _, f := range stringFunctions { + funcMap[f] = true + } + for _, f := range binaryStringFunctions { + funcMap[f] = true + } + for _, f := range bitStringFunctions { + funcMap[f] = true + } + for _, f := range dataTypeFormattingFunctions { + funcMap[f] = true + } + for _, f := range dateTimeFunctions { + funcMap[f] = true + } + for _, f := range enumSupportFunctions { + funcMap[f] = true + } + for _, f := range geometricFunctions { + funcMap[f] = true + } + for _, f := range networkAddressFunctions { + funcMap[f] = true + } + for _, f := range textSearchFunctions { + funcMap[f] = true + } + for _, f := range uuidFunctions { + funcMap[f] = true + } + for _, f := range xmlFunctions { + funcMap[f] = true + } + for _, f := range jsonFunctions { + funcMap[f] = true + } + for _, f := range sequenceManipulationFunctions { + funcMap[f] = true + } + for _, f := range conditionalFunctions { + funcMap[f] = true + } + for _, f := range arrayFunctions { + funcMap[f] = true + } + for _, f := range rangeFunctions { + funcMap[f] = true + } + for _, f := range aggregateFunctions { + funcMap[f] = true + } + for _, f := range windowFunctions { + funcMap[f] = true + } + for _, f := range setReturningFunctions { + funcMap[f] = true + } + for _, f := range systemInformationFunctions { + funcMap[f] = true + } + for _, f := range systemAdministrationFunctions { + funcMap[f] = true + } + for _, f := range triggerFunctions { + funcMap[f] = true + } + for _, f := range eventTriggerFunctions { + funcMap[f] = true + } + for _, f := range statisticsFunctions { + funcMap[f] = true + } + + for f := range funcMap { + builtinFunctions = append(builtinFunctions, f) + } + + sort.Strings(builtinFunctions) +} + +func GetBuiltinFunctions() []string { + var result []string + result = append(result, builtinFunctions...) + return result +} diff --git a/redshift/examples/redshift/abort.sql b/redshift/examples/redshift/abort.sql new file mode 100644 index 0000000..b44c5eb --- /dev/null +++ b/redshift/examples/redshift/abort.sql @@ -0,0 +1,33 @@ +-- ABORT command examples from AWS Redshift documentation +-- ABORT stops the current transaction and discards all updates +-- It is equivalent to ROLLBACK + +-- Example 1: Basic ABORT +-- Create a table +CREATE TABLE movie_gross( + name varchar(30), + gross bigint +); + +-- Start a transaction and insert data +BEGIN; +INSERT INTO movie_gross VALUES ( 'Raiders of the Lost Ark', 23400000); +INSERT INTO movie_gross VALUES ( 'Star Wars', 10000000 ); + +-- Roll back the transaction using ABORT +ABORT; + +-- Example 2: ABORT with WORK keyword +BEGIN; +INSERT INTO movie_gross VALUES ( 'The Empire Strikes Back', 20000000); +ABORT WORK; + +-- Example 3: ABORT with TRANSACTION keyword +BEGIN; +INSERT INTO movie_gross VALUES ( 'Return of the Jedi', 15000000); +ABORT TRANSACTION; + +-- All variations of ABORT +ABORT; +ABORT WORK; +ABORT TRANSACTION; \ No newline at end of file diff --git a/redshift/examples/redshift/abort_command.sql b/redshift/examples/redshift/abort_command.sql new file mode 100644 index 0000000..4e0e1a7 --- /dev/null +++ b/redshift/examples/redshift/abort_command.sql @@ -0,0 +1,83 @@ +-- ABORT command test cases based on AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ABORT.html + +-- Basic ABORT syntax +ABORT; + +-- ABORT with WORK keyword +ABORT WORK; + +-- ABORT with TRANSACTION keyword +ABORT TRANSACTION; + +-- Example from AWS documentation: Create table and abort transaction +CREATE TABLE movie_gross( + name varchar(30), + gross bigint +); + +BEGIN; + +INSERT INTO movie_gross VALUES ( 'Raiders of the Lost Ark', 23400000); +INSERT INTO movie_gross VALUES ( 'Star Wars', 10000000 ); + +-- Abort the transaction (all inserts will be rolled back) +ABORT; + +-- Test ABORT after multiple operations +BEGIN; +CREATE TABLE test_abort (id int, name varchar(50)); +INSERT INTO test_abort VALUES (1, 'test1'); +INSERT INTO test_abort VALUES (2, 'test2'); +UPDATE test_abort SET name = 'updated' WHERE id = 1; +DELETE FROM test_abort WHERE id = 2; +ABORT; + +-- ABORT with WORK in a transaction +BEGIN TRANSACTION; +INSERT INTO movie_gross VALUES ('The Empire Strikes Back', 20000000); +ABORT WORK; + +-- ABORT with TRANSACTION keyword in a transaction +START TRANSACTION; +DELETE FROM movie_gross WHERE name = 'Star Wars'; +ABORT TRANSACTION; + +-- Multiple ABORTs in sequence (each outside transaction) +ABORT; +ABORT WORK; +ABORT TRANSACTION; + +-- ABORT in nested transactions with savepoints +BEGIN; +INSERT INTO movie_gross VALUES ('Return of the Jedi', 15000000); +SAVEPOINT sp1; +INSERT INTO movie_gross VALUES ('The Phantom Menace', 10000000); +SAVEPOINT sp2; +INSERT INTO movie_gross VALUES ('Attack of the Clones', 8000000); +ABORT; + +-- Mixed transaction control statements +BEGIN; +INSERT INTO movie_gross VALUES ('Revenge of the Sith', 12000000); +-- Can use ABORT instead of ROLLBACK +ABORT; + +-- Verify ABORT works the same as ROLLBACK +BEGIN WORK; +CREATE TEMP TABLE abort_test (col1 int); +INSERT INTO abort_test VALUES (1), (2), (3); +ABORT WORK; + +-- ABORT after DDL operations +BEGIN; +CREATE TABLE abort_ddl_test (id int, data text); +ALTER TABLE abort_ddl_test ADD COLUMN created_at timestamp; +CREATE INDEX idx_abort_test ON abort_ddl_test(id); +ABORT TRANSACTION; + +-- Clean up +DROP TABLE IF EXISTS movie_gross; +DROP TABLE IF EXISTS test_abort; +DROP TABLE IF EXISTS abort_test; +DROP TABLE IF EXISTS abort_ddl_test; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_database.sql b/redshift/examples/redshift/alter_database.sql new file mode 100644 index 0000000..ea6bd89 --- /dev/null +++ b/redshift/examples/redshift/alter_database.sql @@ -0,0 +1,69 @@ +-- ALTER DATABASE Test Cases for Amazon Redshift +-- Based on: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html + +-- Test 1: RENAME TO +-- Rename a database from tickit_sandbox to tickit_test +ALTER DATABASE tickit_sandbox RENAME TO tickit_test; + +-- Rename a database with mixed case +ALTER DATABASE MyDatabase RENAME TO NewDatabaseName; + +-- Test 2: OWNER TO +-- Change database owner to dwuser +ALTER DATABASE tickit OWNER TO dwuser; + +-- Change owner with mixed case username +ALTER DATABASE analytics_db OWNER TO DataAnalyst; + +-- Test 3: CONNECTION LIMIT +-- Set connection limit to specific number +ALTER DATABASE sampledb CONNECTION LIMIT 100; + +-- Set connection limit to 1 (minimum practical limit) +ALTER DATABASE test_db CONNECTION LIMIT 1; + +-- Set connection limit to unlimited +ALTER DATABASE production_db CONNECTION LIMIT UNLIMITED; + +-- Test 4: COLLATE options +-- Set collation to case sensitive (full name) +ALTER DATABASE sampledb COLLATE CASE_SENSITIVE; + +-- Set collation to case sensitive (abbreviation) +ALTER DATABASE reports_db COLLATE CS; + +-- Set collation to case insensitive (full name) +ALTER DATABASE analytics COLLATE CASE_INSENSITIVE; + +-- Set collation to case insensitive (abbreviation) +ALTER DATABASE staging_db COLLATE CI; + +-- Test 5: Complex identifiers +-- Database names with underscores +ALTER DATABASE my_test_database RENAME TO my_production_database; + +-- Database names with numbers +ALTER DATABASE db2024 OWNER TO admin123; + +-- Test 6: Edge cases from documentation +-- Cannot rename system databases (these should be parsed but would fail at execution) +-- ALTER DATABASE dev RENAME TO dev_new; -- Would fail: cannot rename dev +-- ALTER DATABASE template0 RENAME TO template0_new; -- Would fail: cannot rename template0 +-- ALTER DATABASE template1 RENAME TO template1_new; -- Would fail: cannot rename template1 + +-- Test 7: Mixed case in options +ALTER DATABASE TestDB CONNECTION LIMIT 50; +ALTER DATABASE TestDB COLLATE CASE_INSENSITIVE; + +-- Test 8: Real-world scenarios +-- Development to production promotion +ALTER DATABASE app_dev RENAME TO app_staging; + +-- Security update - change owner +ALTER DATABASE customer_data OWNER TO security_admin; + +-- Performance tuning - limit connections +ALTER DATABASE reporting CONNECTION LIMIT 25; + +-- Data warehouse configuration +ALTER DATABASE warehouse COLLATE CI; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_datashare.sql b/redshift/examples/redshift/alter_datashare.sql new file mode 100644 index 0000000..ec5b2af --- /dev/null +++ b/redshift/examples/redshift/alter_datashare.sql @@ -0,0 +1,94 @@ +-- ALTER DATASHARE test cases +-- Based on: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATASHARE.html + +-- Basic ALTER DATASHARE: Add a schema +ALTER DATASHARE salesshare ADD SCHEMA public; + +-- Add a specific table +ALTER DATASHARE salesshare ADD TABLE public.tickit_sales_redshift; + +-- Add multiple tables +ALTER DATASHARE salesshare ADD TABLE public.sales, public.customers, marketing.campaigns; + +-- Add table without schema qualification (uses current schema) +ALTER DATASHARE salesshare ADD TABLE events; + +-- Remove a table +ALTER DATASHARE salesshare REMOVE TABLE public.tickit_sales_redshift; + +-- Remove multiple tables +ALTER DATASHARE salesshare REMOVE TABLE public.sales, public.customers; + +-- Add all tables in a schema +ALTER DATASHARE salesshare ADD ALL TABLES IN SCHEMA public; + +-- Add all tables in multiple schemas +ALTER DATASHARE salesshare ADD ALL TABLES IN SCHEMA public, marketing, sales; + +-- Add a function with arguments +ALTER DATASHARE salesshare ADD FUNCTION public.compute_total(integer, decimal); + +-- Add multiple functions +ALTER DATASHARE salesshare ADD FUNCTION public.get_user_name(integer), public.calculate_tax(decimal, decimal); + +-- Add function without arguments +ALTER DATASHARE salesshare ADD FUNCTION public.get_current_timestamp(); + +-- Remove a function +ALTER DATASHARE salesshare REMOVE FUNCTION public.compute_total(integer, decimal); + +-- Add all functions in a schema +ALTER DATASHARE salesshare ADD ALL FUNCTIONS IN SCHEMA public; + +-- Add all functions in multiple schemas +ALTER DATASHARE salesshare ADD ALL FUNCTIONS IN SCHEMA public, utility, analytics; + +-- Remove all functions in a schema +ALTER DATASHARE salesshare REMOVE ALL FUNCTIONS IN SCHEMA public; + +-- Set PUBLICACCESSIBLE to TRUE +ALTER DATASHARE salesshare SET PUBLICACCESSIBLE TRUE; + +-- Set PUBLICACCESSIBLE to FALSE +ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE; + +-- Set PUBLICACCESSIBLE with equals sign +ALTER DATASHARE salesshare SET PUBLICACCESSIBLE = TRUE; + +-- Set INCLUDENEW for a schema +ALTER DATASHARE salesshare SET INCLUDENEW TRUE FOR SCHEMA public; + +-- Set INCLUDENEW to FALSE +ALTER DATASHARE salesshare SET INCLUDENEW FALSE FOR SCHEMA marketing; + +-- Set INCLUDENEW with equals sign +ALTER DATASHARE salesshare SET INCLUDENEW = TRUE FOR SCHEMA sales; + +-- Complex example: Add multiple schemas +ALTER DATASHARE analytics_share ADD SCHEMA finance, operations, hr; + +-- Complex example: Remove multiple object types (multiple statements needed) +ALTER DATASHARE analytics_share REMOVE SCHEMA finance; +ALTER DATASHARE analytics_share REMOVE TABLE operations.inventory; +ALTER DATASHARE analytics_share REMOVE FUNCTION hr.calculate_bonus(integer, decimal); + +-- Add tables with mixed schema qualification +ALTER DATASHARE myshare ADD TABLE schema1.table1, table2, schema2.table3; + +-- Function with multiple argument types +ALTER DATASHARE funcshare ADD FUNCTION analytics.process_data(varchar, integer, date, boolean); + +-- Function with array types +ALTER DATASHARE funcshare ADD FUNCTION public.aggregate_values(integer[]); + +-- Multiple configuration changes (requires separate statements) +ALTER DATASHARE configshare SET PUBLICACCESSIBLE TRUE; +ALTER DATASHARE configshare SET INCLUDENEW TRUE FOR SCHEMA public; + +-- Edge cases with special names +ALTER DATASHARE "My-DataShare" ADD SCHEMA "schema-with-dashes"; +ALTER DATASHARE my_share ADD TABLE "Table With Spaces"; +ALTER DATASHARE share123 ADD FUNCTION "schema"."function-name"(text); + +-- Remove all tables from multiple schemas +ALTER DATASHARE cleanup_share REMOVE ALL TABLES IN SCHEMA temp, staging, archive; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_default_privileges.sql b/redshift/examples/redshift/alter_default_privileges.sql new file mode 100644 index 0000000..c4d965b --- /dev/null +++ b/redshift/examples/redshift/alter_default_privileges.sql @@ -0,0 +1,113 @@ +-- ALTER DEFAULT PRIVILEGES examples from AWS Redshift documentation +-- https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DEFAULT_PRIVILEGES.html + +-- Grant SELECT on all future tables to a user group +ALTER DEFAULT PRIVILEGES +FOR USER report_admin +GRANT SELECT ON TABLES +TO GROUP report_readers; + +-- Grant SELECT on all future tables to all users +ALTER DEFAULT PRIVILEGES +GRANT SELECT ON TABLES +TO PUBLIC; + +-- Grant INSERT on future tables in specific schema +ALTER DEFAULT PRIVILEGES +IN SCHEMA sales +GRANT INSERT ON TABLES +TO GROUP sales_admin; + +-- Grant multiple privileges to multiple users +ALTER DEFAULT PRIVILEGES +GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES +TO user1, user2, user3; + +-- Grant privileges with GRANT OPTION +ALTER DEFAULT PRIVILEGES +GRANT SELECT ON TABLES +TO admin_user WITH GRANT OPTION; + +-- Grant privileges to a role +ALTER DEFAULT PRIVILEGES +GRANT SELECT, INSERT ON TABLES +TO ROLE data_analyst; + +-- Grant privileges for specific user's future objects +ALTER DEFAULT PRIVILEGES +FOR USER data_owner +GRANT ALL PRIVILEGES ON TABLES +TO GROUP data_team; + +-- Grant privileges in multiple schemas +ALTER DEFAULT PRIVILEGES +IN SCHEMA sales, marketing, finance +GRANT SELECT ON TABLES +TO GROUP analysts; + +-- Revoke privileges +ALTER DEFAULT PRIVILEGES +IN SCHEMA sales +REVOKE INSERT ON TABLES +FROM GROUP sales_admin; + +-- Revoke GRANT OPTION +ALTER DEFAULT PRIVILEGES +REVOKE GRANT OPTION FOR SELECT ON TABLES +FROM admin_user; + +-- Revoke all privileges +ALTER DEFAULT PRIVILEGES +REVOKE ALL PRIVILEGES ON TABLES +FROM PUBLIC; + +-- Grant EXECUTE on functions +ALTER DEFAULT PRIVILEGES +GRANT EXECUTE ON FUNCTIONS +TO GROUP dev_test; + +-- Revoke EXECUTE on functions from PUBLIC +ALTER DEFAULT PRIVILEGES +REVOKE EXECUTE ON FUNCTIONS +FROM PUBLIC; + +-- Grant EXECUTE on procedures with specific user +ALTER DEFAULT PRIVILEGES +FOR USER proc_owner +GRANT EXECUTE ON PROCEDURES +TO GROUP app_users; + +-- Grant ALL on procedures in schema +ALTER DEFAULT PRIVILEGES +IN SCHEMA app_schema +GRANT ALL PRIVILEGES ON PROCEDURES +TO ROLE app_admin; + +-- Complex example with multiple options +ALTER DEFAULT PRIVILEGES +FOR USER schema_owner +IN SCHEMA production, staging +GRANT SELECT, INSERT, UPDATE ON TABLES +TO GROUP prod_users, GROUP staging_users; + +-- Grant REFERENCES privilege +ALTER DEFAULT PRIVILEGES +GRANT REFERENCES ON TABLES +TO user_with_fk_perms; + +-- Grant TRUNCATE privilege +ALTER DEFAULT PRIVILEGES +IN SCHEMA cleanup_schema +GRANT TRUNCATE ON TABLES +TO GROUP maintenance_team; + +-- Multiple users in FOR USER clause +ALTER DEFAULT PRIVILEGES +FOR USER user1, user2, user3 +GRANT SELECT ON TABLES +TO PUBLIC; + +-- Revoke specific privileges while keeping others +ALTER DEFAULT PRIVILEGES +REVOKE UPDATE, DELETE ON TABLES +FROM GROUP read_only_users; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_external_schema.sql b/redshift/examples/redshift/alter_external_schema.sql new file mode 100644 index 0000000..862124e --- /dev/null +++ b/redshift/examples/redshift/alter_external_schema.sql @@ -0,0 +1,60 @@ +-- ALTER EXTERNAL SCHEMA examples for Amazon Redshift +-- Based on: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_EXTERNAL_SCHEMA.html + +-- 1. Modify IAM role for external schema +-- Using default IAM role +ALTER EXTERNAL SCHEMA spectrum_schema +IAM_ROLE default; + +-- Using SESSION IAM role +ALTER EXTERNAL SCHEMA spectrum_schema +IAM_ROLE 'SESSION'; + +-- Using specific IAM role ARN +ALTER EXTERNAL SCHEMA spectrum_schema +IAM_ROLE 'arn:aws:iam::012345678901:role/testrole'; + +-- 2. Implementing mTLS authentication with ACM certificate +ALTER EXTERNAL SCHEMA kafka_schema +AUTHENTICATION mtls +AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:444455556666:certificate/certificate_ID'; + +-- 3. Modifying mTLS authentication with Secrets Manager +ALTER EXTERNAL SCHEMA kafka_schema +AUTHENTICATION mtls +SECRET_ARN 'arn:aws:secretsmanager:us-east-1:012345678910:secret:myMTLSSecret'; + +-- 4. Modifying Kafka cluster URI +ALTER EXTERNAL SCHEMA kafka_schema +URI 'lkc-ghidef-67890.centralus.azure.glb.confluent.cloud:9092'; + +-- 5. Setting authentication to none +ALTER EXTERNAL SCHEMA spectrum_schema +AUTHENTICATION none; + +-- 6. Setting authentication to IAM +ALTER EXTERNAL SCHEMA spectrum_schema +AUTHENTICATION iam; + +-- 7. Multiple clauses in single statement +ALTER EXTERNAL SCHEMA kafka_schema +AUTHENTICATION mtls +AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:444455556666:certificate/new_certificate_ID' +URI 'new-kafka-cluster.region.provider.com:9092'; + +-- 8. Another example with multiple clauses +ALTER EXTERNAL SCHEMA spectrum_schema +IAM_ROLE 'arn:aws:iam::123456789012:role/MySpectrumRole' +AUTHENTICATION iam; + +-- Note: To change the owner of an external schema, use ALTER SCHEMA command: +-- This works for both regular and external schemas in Redshift + +-- Change owner to specific user +ALTER SCHEMA spectrum_schema OWNER TO dwuser; + +-- Change owner to another user +ALTER SCHEMA kafka_schema OWNER TO analytics_user; + +-- Note: Only the schema owner, a superuser, or a user with ALTER privilege +-- on the schema can execute ALTER SCHEMA commands \ No newline at end of file diff --git a/redshift/examples/redshift/alter_external_view.sql b/redshift/examples/redshift/alter_external_view.sql new file mode 100644 index 0000000..5795dac --- /dev/null +++ b/redshift/examples/redshift/alter_external_view.sql @@ -0,0 +1,139 @@ +-- ALTER EXTERNAL VIEW test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_EXTERNAL_VIEW.html + +-- Basic ALTER EXTERNAL VIEW with REMOVE DEFINITION +ALTER EXTERNAL VIEW sample_schema.glue_data_catalog_view REMOVE DEFINITION; + +-- ALTER EXTERNAL VIEW with FORCE and REMOVE DEFINITION +ALTER EXTERNAL VIEW sample_schema.glue_data_catalog_view FORCE REMOVE DEFINITION; + +-- ALTER EXTERNAL VIEW with new query definition +ALTER EXTERNAL VIEW external_schema.my_external_view AS ( + SELECT + column1, + column2, + column3 + FROM external_schema.external_table + WHERE condition = 'value' +); + +-- ALTER EXTERNAL VIEW with catalog notation +ALTER EXTERNAL VIEW my_catalog.my_schema.my_view AS ( + SELECT * FROM my_catalog.my_schema.base_table +); + +-- ALTER EXTERNAL VIEW with awsdatacatalog notation +ALTER EXTERNAL VIEW awsdatacatalog.mydb.customer_view AS ( + SELECT + customer_id, + customer_name, + customer_email + FROM awsdatacatalog.mydb.customers +); + +-- ALTER EXTERNAL VIEW with FORCE and new complex query +ALTER EXTERNAL VIEW external_schema.sales_summary_view FORCE AS ( + SELECT + region, + product_category, + SUM(sales_amount) as total_sales, + COUNT(*) as transaction_count, + AVG(sales_amount) as avg_sale + FROM external_schema.sales_data + WHERE sale_date >= '2023-01-01' + GROUP BY region, product_category + ORDER BY total_sales DESC +); + +-- ALTER EXTERNAL VIEW with join query +ALTER EXTERNAL VIEW external_schema.customer_orders_view AS ( + SELECT + c.customer_id, + c.customer_name, + o.order_id, + o.order_date, + o.total_amount + FROM external_schema.customers c + JOIN external_schema.orders o ON c.customer_id = o.customer_id + WHERE o.order_status = 'completed' +); + +-- ALTER EXTERNAL VIEW with subquery +ALTER EXTERNAL VIEW external_schema.top_products_view AS ( + SELECT + product_id, + product_name, + total_revenue + FROM ( + SELECT + p.product_id, + p.product_name, + SUM(oi.quantity * oi.price) as total_revenue + FROM external_schema.products p + JOIN external_schema.order_items oi ON p.product_id = oi.product_id + GROUP BY p.product_id, p.product_name + ) AS product_revenues + WHERE total_revenue > 10000 +); + +-- ALTER EXTERNAL VIEW with CTE +ALTER EXTERNAL VIEW external_schema.monthly_sales_view AS ( + WITH monthly_totals AS ( + SELECT + DATE_TRUNC('month', sale_date) as sale_month, + SUM(amount) as monthly_total + FROM external_schema.sales + GROUP BY DATE_TRUNC('month', sale_date) + ) + SELECT + sale_month, + monthly_total, + LAG(monthly_total) OVER (ORDER BY sale_month) as prev_month_total, + monthly_total - LAG(monthly_total) OVER (ORDER BY sale_month) as month_over_month_change + FROM monthly_totals +); + +-- ALTER EXTERNAL VIEW with UNION +ALTER EXTERNAL VIEW external_schema.all_transactions_view AS ( + SELECT transaction_id, transaction_date, amount, 'online' as source + FROM external_schema.online_transactions + UNION ALL + SELECT transaction_id, transaction_date, amount, 'store' as source + FROM external_schema.store_transactions +); + +-- ALTER EXTERNAL VIEW - remove definition for different schema notations +ALTER EXTERNAL VIEW my_external_schema.my_view REMOVE DEFINITION; +ALTER EXTERNAL VIEW my_catalog.my_schema.my_view REMOVE DEFINITION; +ALTER EXTERNAL VIEW awsdatacatalog.database_name.view_name REMOVE DEFINITION; + +-- ALTER EXTERNAL VIEW with FORCE - remove definition for different views +ALTER EXTERNAL VIEW external_schema.stale_view FORCE REMOVE DEFINITION; +ALTER EXTERNAL VIEW catalog1.schema1.outdated_view FORCE REMOVE DEFINITION; + +-- Complex example with multiple joins and aggregations +ALTER EXTERNAL VIEW external_schema.comprehensive_sales_report FORCE AS ( + SELECT + c.customer_segment, + p.product_category, + r.region_name, + DATE_TRUNC('quarter', s.sale_date) as sale_quarter, + COUNT(DISTINCT s.transaction_id) as transaction_count, + COUNT(DISTINCT c.customer_id) as unique_customers, + SUM(s.quantity) as total_units_sold, + SUM(s.amount) as total_revenue, + AVG(s.amount) as avg_transaction_value, + MAX(s.amount) as max_transaction_value + FROM external_schema.sales s + JOIN external_schema.customers c ON s.customer_id = c.customer_id + JOIN external_schema.products p ON s.product_id = p.product_id + JOIN external_schema.regions r ON s.region_id = r.region_id + WHERE s.sale_date >= DATEADD(year, -2, CURRENT_DATE) + GROUP BY + c.customer_segment, + p.product_category, + r.region_name, + DATE_TRUNC('quarter', s.sale_date) + HAVING SUM(s.amount) > 1000 + ORDER BY sale_quarter DESC, total_revenue DESC +); \ No newline at end of file diff --git a/redshift/examples/redshift/alter_function.sql b/redshift/examples/redshift/alter_function.sql new file mode 100644 index 0000000..77cf0d3 --- /dev/null +++ b/redshift/examples/redshift/alter_function.sql @@ -0,0 +1,75 @@ +-- ALTER FUNCTION examples for Amazon Redshift +-- Based on: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_FUNCTION.html + +-- Example 1: Basic function rename +-- Rename a function with three parameters +ALTER FUNCTION first_quarter_revenue(bigint, numeric, int) +RENAME TO quarterly_revenue; + +-- Example 2: Function rename with schema qualification +-- Rename a function in a specific schema +ALTER FUNCTION sales.calculate_commission(numeric, numeric) +RENAME TO compute_commission; + +-- Example 3: Change function owner to a specific user +ALTER FUNCTION quarterly_revenue(bigint, numeric) +OWNER TO etl_user; + +-- Example 4: Change function owner to CURRENT_USER +ALTER FUNCTION process_data(varchar, timestamp) +OWNER TO CURRENT_USER; + +-- Example 5: Change function owner to SESSION_USER +ALTER FUNCTION analytics.generate_report(date, date, varchar) +OWNER TO SESSION_USER; + +-- Example 6: Python UDF with named parameters - rename +-- Note: Python UDFs will be deprecated after November 1, 2025 +ALTER FUNCTION calculate_tax(amount numeric, rate numeric) +RENAME TO compute_tax; + +-- Example 7: Function with complex types +ALTER FUNCTION transform_json(json_data varchar(max), options varchar) +OWNER TO data_team; + +-- Example 8: Function with no parameters +ALTER FUNCTION get_current_timestamp() +RENAME TO fetch_current_time; + +-- Example 9: Multiple functions with same name but different signatures +-- First function with two parameters +ALTER FUNCTION process_order(order_id bigint, status varchar) +RENAME TO handle_order; + +-- Second function with three parameters (different signature) +ALTER FUNCTION process_order(order_id bigint, status varchar, priority int) +RENAME TO handle_priority_order; + +-- Example 10: Schema-qualified function with owner change +ALTER FUNCTION warehouse.calculate_inventory(product_id int, warehouse_id int, as_of_date date) +OWNER TO inventory_manager; + +-- Example 11: Function with decimal precision types +ALTER FUNCTION finance.calculate_interest(principal decimal(15,2), rate decimal(5,4), years int) +RENAME TO compute_interest; + +-- Example 12: Function with character varying types +ALTER FUNCTION marketing.parse_campaign(campaign_data varchar(500), delimiter char(1)) +OWNER TO marketing_team; + +-- Example 13: Function with timestamp types +ALTER FUNCTION log_analytics.parse_log_entry(log_line text, log_timestamp timestamp without time zone) +RENAME TO analyze_log_entry; + +-- Example 14: Function with boolean return type +ALTER FUNCTION validate_email(email varchar(255)) +OWNER TO validation_service; + +-- Example 15: Complex multi-schema scenario +-- Function in one schema being renamed +ALTER FUNCTION staging.clean_customer_data(raw_data text, validation_rules json) +RENAME TO sanitize_customer_data; + +-- Then changing owner +ALTER FUNCTION staging.sanitize_customer_data(raw_data text, validation_rules json) +OWNER TO data_quality_team; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_group.sql b/redshift/examples/redshift/alter_group.sql new file mode 100644 index 0000000..81b33d8 --- /dev/null +++ b/redshift/examples/redshift/alter_group.sql @@ -0,0 +1,96 @@ +-- ALTER GROUP test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_GROUP.html + +-- Test 1: Basic ADD USER - add single user to a group +ALTER GROUP admin_group ADD USER dwuser; + +-- Test 2: ADD USER with multiple users +ALTER GROUP admin_group ADD USER u1, u2; + +-- Test 3: ADD USER with more users +ALTER GROUP sales_group ADD USER alice, bob, charlie; + +-- Test 4: Basic DROP USER - remove single user from a group +ALTER GROUP admin_group DROP USER dwuser; + +-- Test 5: DROP USER with multiple users +ALTER GROUP admin_group DROP USER u1, u2; + +-- Test 6: DROP USER with more users +ALTER GROUP sales_group DROP USER alice, bob, charlie; + +-- Test 7: Basic RENAME TO +ALTER GROUP admin_group RENAME TO administrators; + +-- Test 8: RENAME TO with different name +ALTER GROUP sales_group RENAME TO sales_team; + +-- Test 9: Group names with underscores +ALTER GROUP test_group ADD USER test_user; +ALTER GROUP test_group RENAME TO new_test_group; + +-- Test 10: Mixed case group and user names +ALTER GROUP TestGroup ADD USER TestUser; +ALTER GROUP TestGroup DROP USER TestUser; +ALTER GROUP TestGroup RENAME TO NewTestGroup; + +-- Test 11: Quoted identifiers +ALTER GROUP "admin group" ADD USER "dw user"; +ALTER GROUP "admin group" DROP USER "dw user"; +ALTER GROUP "admin group" RENAME TO "administrator group"; + +-- Test 12: Long user lists +ALTER GROUP developers ADD USER dev1, dev2, dev3, dev4, dev5, dev6, dev7, dev8, dev9, dev10; +ALTER GROUP developers DROP USER dev1, dev2, dev3, dev4, dev5, dev6, dev7, dev8, dev9, dev10; + +-- Test 13: Various group name patterns +ALTER GROUP grp123 ADD USER usr456; +ALTER GROUP group_123_test ADD USER user_456_test; +ALTER GROUP grp$test ADD USER usr$test; + +-- Test 14: User names with numbers and special characters +ALTER GROUP data_analysts ADD USER analyst1, analyst2, analyst_lead; +ALTER GROUP data_analysts ADD USER data$user, test_user123, user_456; + +-- Test 15: Comments in statements +ALTER GROUP admin_group ADD USER dwuser; -- Adding user to admin group +ALTER GROUP admin_group DROP USER dwuser; -- Removing user from admin group +ALTER GROUP admin_group RENAME TO administrators; -- Renaming the group + +-- Test 16: Multi-line formatting +ALTER GROUP admin_group + ADD USER + user1, + user2, + user3; + +ALTER GROUP admin_group + DROP USER + user1, + user2, + user3; + +ALTER GROUP admin_group + RENAME TO + new_admin_group; + +-- Test 17: Reserved keywords as identifiers (quoted) +ALTER GROUP "group" ADD USER "user"; +ALTER GROUP "alter" ADD USER "add"; +ALTER GROUP "drop" RENAME TO "rename"; + +-- Test 18: Empty group operations (edge cases for testing) +ALTER GROUP empty_group ADD USER single_user; +ALTER GROUP empty_group DROP USER single_user; + +-- Test 19: Sequential operations on same group +ALTER GROUP project_group ADD USER member1; +ALTER GROUP project_group ADD USER member2, member3; +ALTER GROUP project_group DROP USER member1; +ALTER GROUP project_group RENAME TO project_team; + +-- Test 20: Groups with similar names +ALTER GROUP group1 ADD USER user1; +ALTER GROUP group2 ADD USER user2; +ALTER GROUP group11 ADD USER user11; +ALTER GROUP group_1 ADD USER user_1; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_identity_provider.sql b/redshift/examples/redshift/alter_identity_provider.sql new file mode 100644 index 0000000..c393cd8 --- /dev/null +++ b/redshift/examples/redshift/alter_identity_provider.sql @@ -0,0 +1,95 @@ +-- ALTER IDENTITY PROVIDER test cases +-- Based on AWS Redshift documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_IDENTITY_PROVIDER.html + +-- Test Case 1: Basic ALTER with PARAMETERS for Azure AD OAuth +ALTER IDENTITY PROVIDER oauth_standard + PARAMETERS '{"issuer":"https://sts.windows.net/2sdfdsf-d475-420d-b5ac-667adad7c702/", + "client_id":"87f4aa26-78b7-410e-bf29-57b39929ef9a", + "client_secret":"BUAH~ewrqewrqwerUUY^%tHe1oNZShoiU7", + "audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift"]}'; + +-- Test Case 2: ALTER with NAMESPACE for IAM Identity Center +ALTER IDENTITY PROVIDER "my-redshift-idc-application" + NAMESPACE 'MYCO'; + +-- Test Case 3: ALTER with IAM_ROLE +ALTER IDENTITY PROVIDER awsidc_provider + IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftIdentityProviderRole'; + +-- Test Case 4: Enable AUTO_CREATE_ROLES with default settings +ALTER IDENTITY PROVIDER oauth_provider + AUTO_CREATE_ROLES TRUE; + +-- Test Case 5: Enable AUTO_CREATE_ROLES with INCLUDE filter +ALTER IDENTITY PROVIDER oauth_provider + AUTO_CREATE_ROLES TRUE INCLUDE GROUPS LIKE 'admin_%'; + +-- Test Case 6: Enable AUTO_CREATE_ROLES with EXCLUDE filter +ALTER IDENTITY PROVIDER azure_ad_provider + AUTO_CREATE_ROLES TRUE EXCLUDE GROUPS LIKE 'temp_%'; + +-- Test Case 7: Disable AUTO_CREATE_ROLES +ALTER IDENTITY PROVIDER oauth_provider + AUTO_CREATE_ROLES FALSE; + +-- Test Case 8: DISABLE identity provider +ALTER IDENTITY PROVIDER "redshift-idc-app" DISABLE; + +-- Test Case 9: ENABLE identity provider +ALTER IDENTITY PROVIDER "redshift-idc-app" ENABLE; + +-- Test Case 10: Multiple parameters in one ALTER statement +ALTER IDENTITY PROVIDER oauth_standard + PARAMETERS '{"issuer":"https://login.microsoftonline.com/...", + "client_id":"app-id-123", + "client_secret":"secret-value"}' + NAMESPACE 'PRODUCTION' + AUTO_CREATE_ROLES TRUE INCLUDE GROUPS LIKE 'prod_%'; + +-- Test Case 11: ALTER with quoted identifier containing special characters +ALTER IDENTITY PROVIDER "my-provider-123" + PARAMETERS '{"config":"value"}'; + +-- Test Case 12: ALTER with simple unquoted identifier +ALTER IDENTITY PROVIDER simple_provider + NAMESPACE 'DEFAULT'; + +-- Test Case 13: Complex AUTO_CREATE_ROLES pattern +ALTER IDENTITY PROVIDER oauth_provider + AUTO_CREATE_ROLES TRUE EXCLUDE GROUPS LIKE '%_test_%'; + +-- Test Case 14: Minimal ALTER - just disable +ALTER IDENTITY PROVIDER minimal_provider DISABLE; + +-- Test Case 15: IAM Identity Center with all applicable options +ALTER IDENTITY PROVIDER "idc-application" + NAMESPACE 'MYCOMPANY' + IAM_ROLE 'arn:aws:iam::987654321098:role/MyIdentityRole' + AUTO_CREATE_ROLES TRUE INCLUDE GROUPS LIKE 'aws_%' + ENABLE; + +-- Test Case 16: Parameters with nested JSON +ALTER IDENTITY PROVIDER complex_oauth + PARAMETERS '{"issuer":"https://auth.example.com", + "client_id":"complex-app", + "client_secret":"complex-secret", + "audience":["aud1", "aud2", "aud3"], + "additional_config":{"timeout":300, "retry":true}}'; + +-- Test Case 17: Multiple actions without PARAMETERS +ALTER IDENTITY PROVIDER no_params_provider + NAMESPACE 'TEST' + AUTO_CREATE_ROLES FALSE + DISABLE; + +-- Test Case 18: Pattern with wildcards on both sides +ALTER IDENTITY PROVIDER pattern_provider + AUTO_CREATE_ROLES TRUE INCLUDE GROUPS LIKE '%admin%'; + +-- Test Case 19: Empty namespace +ALTER IDENTITY PROVIDER empty_namespace_provider + NAMESPACE ''; + +-- Test Case 20: Long IAM role ARN +ALTER IDENTITY PROVIDER long_arn_provider + IAM_ROLE 'arn:aws:iam::123456789012:role/service-role/RedshiftIdentityProviderServiceRole-us-east-1-production'; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_masking_policy.sql b/redshift/examples/redshift/alter_masking_policy.sql new file mode 100644 index 0000000..8843534 --- /dev/null +++ b/redshift/examples/redshift/alter_masking_policy.sql @@ -0,0 +1,215 @@ +-- ALTER MASKING POLICY test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_MASKING_POLICY.html + +-- Basic ALTER MASKING POLICY statements + +-- 1. Simple masking expression with a constant +ALTER MASKING POLICY mask_credit_card +USING ('XXXX-XXXX-XXXX-XXXX'); + +-- 2. Masking expression with explicit cast (required for constants) +ALTER MASKING POLICY mask_ssn +USING ('XXX-XX-XXXX'::VARCHAR(11)); + +-- 3. Masking expression using NULL +ALTER MASKING POLICY hide_sensitive_data +USING (NULL); + +-- 4. Masking expression with column reference +ALTER MASKING POLICY partial_mask +USING (column_name); + +-- Complex masking expressions + +-- 5. Using built-in functions +ALTER MASKING POLICY mask_email +USING (SUBSTRING(email FROM 1 FOR 3) || '****@****'); + +-- 6. Using mathematical operations +ALTER MASKING POLICY mask_salary +USING (salary * 0); + +-- 7. Using CASE expression for conditional masking +ALTER MASKING POLICY conditional_mask +USING ( + CASE + WHEN user_level > 5 THEN actual_value + ELSE 'REDACTED' + END +); + +-- 8. Multiple column masking with complex logic +ALTER MASKING POLICY complex_mask +USING ( + CASE + WHEN role = 'admin' THEN original_value + WHEN role = 'user' THEN SUBSTRING(original_value FROM 1 FOR 3) || '***' + ELSE 'HIDDEN' + END +); + +-- 9. Using concatenation and string functions +ALTER MASKING POLICY mask_phone +USING ( + '(' || SUBSTRING(phone FROM 1 FOR 3) || ') XXX-XXXX' +); + +-- 10. Numeric masking with arithmetic +ALTER MASKING POLICY mask_revenue +USING ( + CASE + WHEN amount > 1000000 THEN 1000000 + WHEN amount > 100000 THEN amount / 10 * 10 + ELSE 0 + END +); + +-- 11. Date masking expressions +ALTER MASKING POLICY mask_birthdate +USING ( + DATE_TRUNC('year', birthdate) +); + +-- 12. Boolean masking +ALTER MASKING POLICY mask_flag +USING ( + CASE + WHEN is_sensitive THEN FALSE + ELSE is_sensitive + END +); + +-- User-defined function examples + +-- 13. Using a SQL UDF +ALTER MASKING POLICY mask_with_udf +USING ( + my_masking_function(input_column) +); + +-- 14. Using a Python UDF +ALTER MASKING POLICY mask_with_python +USING ( + python_mask_function(data_column, user_role) +); + +-- 15. Using an AWS Lambda UDF +ALTER MASKING POLICY mask_with_lambda +USING ( + lambda_mask_handler(sensitive_data) +); + +-- Edge cases and special scenarios + +-- 16. Empty parentheses (would be invalid but testing parser) +-- ALTER MASKING POLICY invalid_mask USING (); + +-- 17. Multiple nested functions +ALTER MASKING POLICY nested_functions +USING ( + UPPER(TRIM(SUBSTRING(LOWER(input_text) FROM 1 FOR 5))) +); + +-- 18. Complex nested CASE expressions +ALTER MASKING POLICY nested_case +USING ( + CASE + WHEN region = 'US' THEN + CASE + WHEN state = 'CA' THEN 'CALIFORNIA-MASKED' + ELSE 'US-MASKED' + END + WHEN region = 'EU' THEN 'EU-GDPR-MASKED' + ELSE 'INTERNATIONAL-MASKED' + END +); + +-- 19. Using IS NULL/IS NOT NULL +ALTER MASKING POLICY null_check_mask +USING ( + CASE + WHEN input_value IS NULL THEN 'NO DATA' + WHEN input_value IS NOT NULL THEN 'MASKED' + END +); + +-- 20. Logical operators +ALTER MASKING POLICY logic_mask +USING ( + CASE + WHEN is_public AND NOT is_sensitive THEN original_value + WHEN is_internal OR is_sensitive THEN 'RESTRICTED' + ELSE 'DEFAULT-MASK' + END +); + +-- 21. Comparison operators +ALTER MASKING POLICY comparison_mask +USING ( + CASE + WHEN age >= 18 AND age <= 65 THEN 'ADULT' + WHEN age < 18 THEN 'MINOR' + ELSE 'SENIOR' + END +); + +-- 22. Mixed data type casting +ALTER MASKING POLICY type_cast_mask +USING ( + CAST(numeric_value AS VARCHAR) || '-MASKED' +); + +-- 23. Alternative cast syntax using :: +ALTER MASKING POLICY alt_cast_mask +USING ( + text_value::INTEGER * 0 +); + +-- Test with different identifier formats + +-- 24. Quoted identifiers +ALTER MASKING POLICY "Mask Policy with Spaces" +USING ('MASKED'); + +-- 25. Mixed case identifiers +ALTER MASKING POLICY MixedCasePolicy +USING (DefaultMaskValue); + +-- 26. Underscore in policy names +ALTER MASKING POLICY mask_policy_with_underscores +USING ('_MASKED_'); + +-- 27. Numbers in policy names +ALTER MASKING POLICY mask_policy_2024 +USING ('MASKED_2024'); + +-- With and without semicolons + +-- 28. With semicolon +ALTER MASKING POLICY with_semicolon +USING ('MASKED'); + +-- 29. Without semicolon +ALTER MASKING POLICY without_semicolon +USING ('MASKED') + +-- 30. Multiple statements +ALTER MASKING POLICY first_policy USING ('FIRST'); +ALTER MASKING POLICY second_policy USING ('SECOND'); + +-- Comments in statements + +-- 31. With inline comments +ALTER MASKING POLICY commented_policy +USING ( + -- This masks sensitive data + 'COMMENTED_MASK' +); + +-- 32. With block comments +ALTER MASKING POLICY block_comment_policy +USING ( + /* Multi-line + comment block */ + 'BLOCK_MASKED' +); \ No newline at end of file diff --git a/redshift/examples/redshift/alter_materialized_view.sql b/redshift/examples/redshift/alter_materialized_view.sql new file mode 100644 index 0000000..48fbdd6 --- /dev/null +++ b/redshift/examples/redshift/alter_materialized_view.sql @@ -0,0 +1,65 @@ +-- ALTER MATERIALIZED VIEW test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_MATERIALIZED_VIEW.html + +-- Basic AUTO REFRESH examples +ALTER MATERIALIZED VIEW tickets_mv AUTO REFRESH YES; +ALTER MATERIALIZED VIEW tickets_mv AUTO REFRESH NO; + +-- With schema qualification +ALTER MATERIALIZED VIEW sales.revenue_mv AUTO REFRESH YES; +ALTER MATERIALIZED VIEW analytics.customer_summary_mv AUTO REFRESH NO; + +-- ALTER DISTKEY examples +ALTER MATERIALIZED VIEW sales_mv ALTER DISTKEY customer_id; +ALTER MATERIALIZED VIEW inventory_mv ALTER DISTKEY product_id; +ALTER MATERIALIZED VIEW orders_mv ALTER DISTKEY order_date; + +-- ALTER DISTSTYLE examples +ALTER MATERIALIZED VIEW customer_mv ALTER DISTSTYLE ALL; +ALTER MATERIALIZED VIEW product_mv ALTER DISTSTYLE EVEN; +ALTER MATERIALIZED VIEW transaction_mv ALTER DISTSTYLE KEY DISTKEY transaction_id; +ALTER MATERIALIZED VIEW analytics_mv ALTER DISTSTYLE AUTO; + +-- ALTER SORTKEY examples +ALTER MATERIALIZED VIEW sales_mv ALTER SORTKEY (sale_date); +ALTER MATERIALIZED VIEW customer_orders_mv ALTER SORTKEY (customer_id, order_date); +ALTER MATERIALIZED VIEW inventory_mv ALTER SORTKEY (warehouse_id, product_id, stock_date); + +-- COMPOUND SORTKEY examples +ALTER MATERIALIZED VIEW sales_analytics_mv ALTER COMPOUND SORTKEY (region, sale_date, product_category); +ALTER MATERIALIZED VIEW customer_behavior_mv ALTER COMPOUND SORTKEY (customer_segment, activity_date); + +-- SORTKEY AUTO/NONE examples +ALTER MATERIALIZED VIEW automated_mv ALTER SORTKEY AUTO; +ALTER MATERIALIZED VIEW manual_mv ALTER SORTKEY NONE; + +-- ROW LEVEL SECURITY examples +ALTER MATERIALIZED VIEW sensitive_data_mv ROW LEVEL SECURITY ON; +ALTER MATERIALIZED VIEW public_data_mv ROW LEVEL SECURITY OFF; + +-- ROW LEVEL SECURITY with CONJUNCTION TYPE +ALTER MATERIALIZED VIEW employee_data_mv ROW LEVEL SECURITY ON CONJUNCTION TYPE AND; +ALTER MATERIALIZED VIEW department_data_mv ROW LEVEL SECURITY ON CONJUNCTION TYPE OR; +ALTER MATERIALIZED VIEW project_data_mv ROW LEVEL SECURITY OFF CONJUNCTION TYPE AND; + +-- ROW LEVEL SECURITY FOR DATASHARES +ALTER MATERIALIZED VIEW shared_analytics_mv ROW LEVEL SECURITY ON FOR DATASHARES; +ALTER MATERIALIZED VIEW shared_reports_mv ROW LEVEL SECURITY OFF FOR DATASHARES; +ALTER MATERIALIZED VIEW shared_metrics_mv ROW LEVEL SECURITY ON CONJUNCTION TYPE AND FOR DATASHARES; +ALTER MATERIALIZED VIEW shared_insights_mv ROW LEVEL SECURITY ON CONJUNCTION TYPE OR FOR DATASHARES; + +-- Complex examples with quoted identifiers +ALTER MATERIALIZED VIEW "Sales-Analytics" AUTO REFRESH YES; +ALTER MATERIALIZED VIEW "Customer Orders" ALTER DISTKEY "Customer ID"; +ALTER MATERIALIZED VIEW "Product-Inventory" ALTER DISTSTYLE KEY DISTKEY "Product-Code"; +ALTER MATERIALIZED VIEW "Monthly-Reports" ALTER SORTKEY ("Report-Date", "Region-Code"); + +-- Examples with mixed case identifiers +ALTER MATERIALIZED VIEW CustomerOrdersMV AUTO REFRESH NO; +ALTER MATERIALIZED VIEW ProductInventoryMV ALTER DISTKEY ProductID; +ALTER MATERIALIZED VIEW SalesAnalyticsMV ALTER COMPOUND SORTKEY (SaleDate, RegionCode); + +-- Note: OWNER TO and RENAME TO operations for materialized views use ALTER TABLE syntax in Redshift +-- These are included for reference but would use ALTER TABLE command: +-- ALTER TABLE mv_name OWNER TO new_owner; +-- ALTER TABLE mv_name RENAME TO new_name; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_procedure.sql b/redshift/examples/redshift/alter_procedure.sql new file mode 100644 index 0000000..ba84069 --- /dev/null +++ b/redshift/examples/redshift/alter_procedure.sql @@ -0,0 +1,79 @@ +-- ALTER PROCEDURE examples from AWS documentation +-- https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_PROCEDURE.html + +-- Example 1: Rename a procedure with full argument specification +ALTER PROCEDURE first_quarter_revenue(volume INOUT bigint, at_price IN numeric, result OUT int) +RENAME TO quarterly_revenue; + +-- Example 2: Rename a procedure with simplified argument list (only types) +ALTER PROCEDURE first_quarter_revenue(bigint, numeric) +RENAME TO quarterly_revenue; + +-- Example 3: Change procedure owner +ALTER PROCEDURE quarterly_revenue(bigint, numeric) +OWNER TO etl_user; + +-- Additional test cases + +-- Rename procedure without arguments +ALTER PROCEDURE simple_proc RENAME TO renamed_proc; + +-- Rename procedure with schema qualification +ALTER PROCEDURE myschema.my_procedure(integer, varchar) RENAME TO new_procedure; + +-- Change owner to CURRENT_USER +ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO CURRENT_USER; + +-- Change owner to SESSION_USER +ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO SESSION_USER; + +-- Procedure with multiple arguments and different modes +ALTER PROCEDURE complex_proc( + input_val IN integer, + output_val OUT varchar, + inout_val INOUT timestamp +) RENAME TO renamed_complex_proc; + +-- Procedure with named arguments +ALTER PROCEDURE calc_stats( + p_start_date IN date, + p_end_date IN date, + p_result OUT numeric +) OWNER TO analytics_user; + +-- Procedure with array types +ALTER PROCEDURE array_proc(arr_param integer[]) RENAME TO new_array_proc; + +-- Procedure with complex data types +ALTER PROCEDURE json_proc(data json) OWNER TO data_team; + +-- Procedure with multiple IN parameters +ALTER PROCEDURE multi_param_proc( + param1 IN varchar(100), + param2 IN integer, + param3 IN boolean +) RENAME TO updated_multi_param_proc; + +-- Procedure with no parameters but with empty parentheses +ALTER PROCEDURE empty_param_proc() OWNER TO admin_user; + +-- Mixed argument modes without names +ALTER PROCEDURE mixed_modes(IN integer, OUT varchar, INOUT numeric) +RENAME TO new_mixed_modes; + +-- Schema-qualified procedure with owner change +ALTER PROCEDURE finance.calculate_revenue(date, date) +OWNER TO finance_admin; + +-- Procedure with numeric precision types +ALTER PROCEDURE precise_calc( + amount IN numeric(10,2), + rate IN decimal(5,4), + result OUT numeric(15,2) +) RENAME TO precise_calculation; + +-- Test case with quoted identifiers +ALTER PROCEDURE "Special Proc"(integer) RENAME TO regular_proc; + +-- Test case with mixed case identifiers +ALTER PROCEDURE MixedCaseProc(varchar) OWNER TO new_owner; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_rls_policy.sql b/redshift/examples/redshift/alter_rls_policy.sql new file mode 100644 index 0000000..05c2079 --- /dev/null +++ b/redshift/examples/redshift/alter_rls_policy.sql @@ -0,0 +1,92 @@ +-- ALTER RLS POLICY test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_RLS_POLICY.html + +-- Note: ALTER RLS POLICY in Redshift only supports modifying the USING clause. +-- RENAME TO, OWNER TO, and WITH CHECK are not supported based on AWS documentation. + +-- Basic ALTER RLS POLICY with simple predicate +ALTER RLS POLICY policy_concerts USING (catgroup = 'concerts'); + +-- ALTER RLS POLICY with more specific filter +ALTER RLS POLICY policy_concerts USING (catgroup = 'piano concerts'); + +-- ALTER RLS POLICY with multiple conditions using AND +ALTER RLS POLICY sales_policy USING (region = 'US' AND year = 2024); + +-- ALTER RLS POLICY with OR condition +ALTER RLS POLICY user_access_policy USING (username = 'alice' OR username = 'bob'); + +-- ALTER RLS POLICY with complex predicate using current_user +ALTER RLS POLICY user_data_policy USING (owner = current_user AND status = 'active'); + +-- ALTER RLS POLICY with IN clause +ALTER RLS POLICY regional_policy USING (region IN ('US', 'CA', 'MX')); + +-- ALTER RLS POLICY with NOT IN clause +ALTER RLS POLICY exclusion_policy USING (category NOT IN ('restricted', 'confidential')); + +-- ALTER RLS POLICY with numeric comparison +ALTER RLS POLICY price_policy USING (price > 100 AND price <= 1000); + +-- ALTER RLS POLICY with BETWEEN clause +ALTER RLS POLICY date_range_policy USING (event_date BETWEEN '2024-01-01' AND '2024-12-31'); + +-- ALTER RLS POLICY with IS NULL check +ALTER RLS POLICY null_check_policy USING (deleted_at IS NULL); + +-- ALTER RLS POLICY with IS NOT NULL check +ALTER RLS POLICY required_field_policy USING (customer_id IS NOT NULL); + +-- ALTER RLS POLICY with function call +ALTER RLS POLICY time_based_policy USING (created_at > dateadd(day, -30, current_date)); + +-- ALTER RLS POLICY with nested conditions +ALTER RLS POLICY complex_policy USING ((status = 'active' AND region = 'US') OR (status = 'premium' AND region = 'EU')); + +-- ALTER RLS POLICY with table alias reference +ALTER RLS POLICY qualified_policy USING (orders.customer_id = current_user_id); + +-- ALTER RLS POLICY with mixed data types +ALTER RLS POLICY mixed_type_policy USING (is_active = true AND priority >= 5); + +-- ALTER RLS POLICY with NOT condition +ALTER RLS POLICY negation_policy USING (NOT (category = 'internal' OR category = 'system')); + +-- ALTER RLS POLICY with case-sensitive string comparison +ALTER RLS POLICY case_sensitive_policy USING (department = 'Engineering'); + +-- ALTER RLS POLICY with quoted identifier +ALTER RLS POLICY "Special-Policy-Name" USING (status = 'approved'); + +-- ALTER RLS POLICY with numeric literals +ALTER RLS POLICY numeric_policy USING (amount > 1000.50 AND quantity < 100); + +-- ALTER RLS POLICY - comprehensive example combining multiple features +ALTER RLS POLICY comprehensive_access_policy USING ( + (user_role IN ('admin', 'manager') OR user_id = current_user_id) + AND status NOT IN ('deleted', 'archived') + AND created_date >= '2024-01-01' + AND (region = 'US' OR global_access = true) +); + +-- ALTER RLS POLICY with semicolon terminator +ALTER RLS POLICY terminated_policy USING (active = true); + +-- ALTER RLS POLICY with single item IN list +ALTER RLS POLICY single_in_policy USING (role IN ('viewer')); + +-- ALTER RLS POLICY with deeply nested parentheses +ALTER RLS POLICY nested_parens_policy USING (((((active = true))))); + +-- ALTER RLS POLICY with all comparison operators +ALTER RLS POLICY comparison_policy USING ( + col1 = 'value1' + AND col2 <> 'value2' + AND col3 < 100 + AND col4 > 50 + AND col5 <= 200 + AND col6 >= 10 +); + +-- ALTER RLS POLICY with != operator (alternative to <>) +ALTER RLS POLICY not_equal_policy USING (status != 'inactive'); \ No newline at end of file diff --git a/redshift/examples/redshift/alter_role.sql b/redshift/examples/redshift/alter_role.sql new file mode 100644 index 0000000..4eb1eff --- /dev/null +++ b/redshift/examples/redshift/alter_role.sql @@ -0,0 +1,64 @@ +-- Basic ALTER ROLE statements + +-- Rename a role +ALTER ROLE sample_role1 RENAME TO sample_role2; +ALTER ROLE old_analytics_role RENAME TO new_analytics_role; +ALTER ROLE temp_role RENAME TO permanent_role; + +-- Change role owner +ALTER ROLE sample_role1 OWNER TO user1; +ALTER ROLE sample_role1 WITH OWNER TO user1; +ALTER ROLE analytics_role OWNER TO admin_user; +ALTER ROLE data_role WITH OWNER TO data_admin; + +-- Update external ID for identity provider +ALTER ROLE sample_role1 EXTERNALID TO "XYZ456"; +ALTER ROLE sample_role1 WITH EXTERNALID TO "XYZ456"; +ALTER ROLE federated_role EXTERNALID TO "ABC123DEF456"; +ALTER ROLE sso_role WITH EXTERNALID TO "SSO_ID_12345"; + +-- Multiple operations require separate statements (per AWS docs) +-- Cannot combine RENAME TO with OWNER TO in a single statement +ALTER ROLE sample_role1 RENAME TO sample_role2; +ALTER ROLE sample_role2 OWNER TO user2; + +-- Can combine OWNER TO with EXTERNALID +ALTER ROLE role1 OWNER TO admin; +ALTER ROLE role1 EXTERNALID TO "EXT123"; + +-- Sequential operations +ALTER ROLE test_role RENAME TO prod_role; +ALTER ROLE prod_role OWNER TO prod_admin; +ALTER ROLE prod_role EXTERNALID TO "PROD_ID"; + +-- Complex role names +ALTER ROLE "MyRole" RENAME TO "YourRole"; +ALTER ROLE role_with_underscore RENAME TO role_without_underscore; +ALTER ROLE "role-with-dash" RENAME TO "role_with_underscore"; + +-- Various user names in OWNER TO +ALTER ROLE role1 OWNER TO "john.doe"; +ALTER ROLE role1 OWNER TO user_with_underscore; +ALTER ROLE role1 OWNER TO "user-with-dash"; + +-- External IDs with different formats +ALTER ROLE role1 EXTERNALID TO "simple"; +ALTER ROLE role1 EXTERNALID TO "with spaces and special chars!@#$%"; +ALTER ROLE role1 EXTERNALID TO "123456789"; +ALTER ROLE role1 EXTERNALID TO "arn:aws:iam::123456789012:role/MyRole"; +ALTER ROLE role1 EXTERNALID TO ""; -- Empty external ID + +-- WITH keyword usage variations +ALTER ROLE role1 WITH RENAME TO role2; +ALTER ROLE role1 RENAME TO role2; -- WITH is optional + +-- Real-world examples +ALTER ROLE etl_reader_role RENAME TO etl_full_access_role; +ALTER ROLE bi_analyst_role OWNER TO bi_admin_user; +ALTER ROLE aws_federated_role EXTERNALID TO "arn:aws:iam::987654321098:role/RedshiftAccess"; + +-- Edge cases +ALTER ROLE a RENAME TO b; -- Single character role names +ALTER ROLE role123 RENAME TO role456; -- Numeric suffixes +ALTER ROLE ROLE RENAME TO NEWROLE; -- Keyword as identifier (if allowed) +ALTER ROLE "SELECT" RENAME TO "INSERT"; -- SQL keywords as quoted identifiers \ No newline at end of file diff --git a/redshift/examples/redshift/alter_schema.sql b/redshift/examples/redshift/alter_schema.sql new file mode 100644 index 0000000..287d156 --- /dev/null +++ b/redshift/examples/redshift/alter_schema.sql @@ -0,0 +1,70 @@ +-- ALTER SCHEMA test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_SCHEMA.html + +-- Basic rename schema +ALTER SCHEMA sales RENAME TO us_sales; + +-- Rename with quoted identifiers +ALTER SCHEMA "my_schema" RENAME TO "new_schema"; + +-- Rename with mixed case identifiers +ALTER SCHEMA MySchema RENAME TO YourSchema; + +-- Change schema owner +ALTER SCHEMA us_sales OWNER TO dwuser; + +-- Change owner with quoted identifier +ALTER SCHEMA "production" OWNER TO "app_user"; + +-- Set schema quota with GB (default unit) +ALTER SCHEMA us_sales QUOTA 300 GB; + +-- Set schema quota with MB +ALTER SCHEMA test_schema QUOTA 500 MB; + +-- Set schema quota with TB +ALTER SCHEMA warehouse QUOTA 2 TB; + +-- Set schema quota without unit (defaults to GB) +ALTER SCHEMA analytics QUOTA 100; + +-- Set unlimited quota +ALTER SCHEMA us_sales QUOTA UNLIMITED; + +-- Complex examples with different identifier types +ALTER SCHEMA public OWNER TO admin_user; +ALTER SCHEMA "My-Schema-123" RENAME TO "My_Schema_456"; +ALTER SCHEMA data_warehouse QUOTA 1500 GB; + +-- Edge cases +ALTER SCHEMA a RENAME TO b; +ALTER SCHEMA schema123 OWNER TO user456; +ALTER SCHEMA _underscore_schema QUOTA 50 MB; + +-- Comments in statements +ALTER SCHEMA old_schema -- This schema is being renamed + RENAME TO new_schema; + +ALTER SCHEMA production /* Change owner for maintenance */ + OWNER TO maintenance_user; + +-- Multi-line formatting +ALTER SCHEMA + sales_data +RENAME TO + historical_sales_data; + +ALTER SCHEMA + reporting +QUOTA + 750 GB; + +-- Schema names with numbers +ALTER SCHEMA schema2023 RENAME TO schema2024; +ALTER SCHEMA data_v1 OWNER TO data_admin; +ALTER SCHEMA temp_123 QUOTA UNLIMITED; + +-- Reserved keywords as identifiers (when quoted) +ALTER SCHEMA "alter" RENAME TO "update"; +ALTER SCHEMA "schema" OWNER TO "user"; +ALTER SCHEMA "quota" QUOTA 100 GB; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_system.sql b/redshift/examples/redshift/alter_system.sql new file mode 100644 index 0000000..e137e9d --- /dev/null +++ b/redshift/examples/redshift/alter_system.sql @@ -0,0 +1,89 @@ +-- ALTER SYSTEM command test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_SYSTEM.html + +-- Test 1: Enable AWS Glue Data Catalog automounting using TRUE +ALTER SYSTEM SET data_catalog_auto_mount = true; + +-- Test 2: Enable AWS Glue Data Catalog automounting using T +ALTER SYSTEM SET data_catalog_auto_mount = t; + +-- Test 3: Enable AWS Glue Data Catalog automounting using ON +ALTER SYSTEM SET data_catalog_auto_mount = on; + +-- Test 4: Disable AWS Glue Data Catalog automounting using FALSE +ALTER SYSTEM SET data_catalog_auto_mount = false; + +-- Test 5: Disable AWS Glue Data Catalog automounting using F +ALTER SYSTEM SET data_catalog_auto_mount = f; + +-- Test 6: Disable AWS Glue Data Catalog automounting using OFF +ALTER SYSTEM SET data_catalog_auto_mount = off; + +-- Test 7: Enable metadata security using TRUE +ALTER SYSTEM SET metadata_security = true; + +-- Test 8: Enable metadata security using T +ALTER SYSTEM SET metadata_security = t; + +-- Test 9: Enable metadata security using ON +ALTER SYSTEM SET metadata_security = on; + +-- Test 10: Disable metadata security using FALSE +ALTER SYSTEM SET metadata_security = false; + +-- Test 11: Disable metadata security using F +ALTER SYSTEM SET metadata_security = f; + +-- Test 12: Disable metadata security using OFF +ALTER SYSTEM SET metadata_security = off; + +-- Test 13: Set default identity namespace with simple name +ALTER SYSTEM SET default_identity_namespace = 'MYCO'; + +-- Test 14: Set default identity namespace with longer name +ALTER SYSTEM SET default_identity_namespace = 'MyCompanyIdentity'; + +-- Test 15: Set default identity namespace with underscore +ALTER SYSTEM SET default_identity_namespace = 'MY_COMPANY'; + +-- Test 16: Set default identity namespace with numbers +ALTER SYSTEM SET default_identity_namespace = 'Company123'; + +-- Test 17: Mixed case boolean values (case-insensitive) +ALTER SYSTEM SET data_catalog_auto_mount = TRUE; +ALTER SYSTEM SET data_catalog_auto_mount = True; +ALTER SYSTEM SET data_catalog_auto_mount = ON; +ALTER SYSTEM SET data_catalog_auto_mount = On; + +-- Test 18: Mixed case for FALSE values +ALTER SYSTEM SET metadata_security = FALSE; +ALTER SYSTEM SET metadata_security = False; +ALTER SYSTEM SET metadata_security = OFF; +ALTER SYSTEM SET metadata_security = Off; + +-- Test 19: Single character boolean values with different cases +ALTER SYSTEM SET data_catalog_auto_mount = T; +ALTER SYSTEM SET data_catalog_auto_mount = F; +ALTER SYSTEM SET metadata_security = t; +ALTER SYSTEM SET metadata_security = f; + +-- Test 20: Real-world scenario - Enable catalog automounting and metadata security +ALTER SYSTEM SET data_catalog_auto_mount = true; +ALTER SYSTEM SET metadata_security = true; + +-- Test 21: Real-world scenario - Set up identity namespace and enable security +ALTER SYSTEM SET default_identity_namespace = 'ACME_CORP'; +ALTER SYSTEM SET metadata_security = on; + +-- Test 22: Empty string for identity namespace (edge case) +ALTER SYSTEM SET default_identity_namespace = ''; + +-- Test 23: Identity namespace with special characters +ALTER SYSTEM SET default_identity_namespace = 'Company-Name'; +ALTER SYSTEM SET default_identity_namespace = 'Company.Name'; + +-- Note: The following are expected to be invalid and should be tested for error handling: +-- ALTER SYSTEM SET invalid_parameter = true; +-- ALTER SYSTEM SET data_catalog_auto_mount = 'invalid'; +-- ALTER SYSTEM SET default_identity_namespace = true; +-- ALTER SYSTEM SET metadata_security = 'MYCO'; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_table.sql b/redshift/examples/redshift/alter_table.sql new file mode 100644 index 0000000..d3a120a --- /dev/null +++ b/redshift/examples/redshift/alter_table.sql @@ -0,0 +1,240 @@ +-- ALTER TABLE Test Cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE.html + +-- =========================== +-- 1. ADD COLUMN Operations +-- =========================== + +-- Basic ADD COLUMN +ALTER TABLE sales ADD COLUMN region VARCHAR(50); + +-- ADD COLUMN with constraints +ALTER TABLE employees ADD COLUMN email VARCHAR(255) NOT NULL; + +-- ADD COLUMN with encoding +ALTER TABLE events ADD COLUMN event_data VARCHAR(MAX) ENCODE ZSTD; + +-- ADD COLUMN with default value +ALTER TABLE orders ADD COLUMN status VARCHAR(20) DEFAULT 'pending'; + +-- ADD COLUMN without COLUMN keyword +ALTER TABLE products ADD price DECIMAL(10,2); + +-- ADD COLUMN with multiple constraints +ALTER TABLE users ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL; + +-- =========================== +-- 2. DROP COLUMN Operations +-- =========================== + +-- Basic DROP COLUMN +ALTER TABLE sales DROP COLUMN temp_data; + +-- DROP COLUMN with CASCADE +ALTER TABLE employees DROP COLUMN department_id CASCADE; + +-- DROP COLUMN with RESTRICT +ALTER TABLE products DROP COLUMN old_price RESTRICT; + +-- DROP COLUMN without COLUMN keyword +ALTER TABLE orders DROP shipping_notes; + +-- =========================== +-- 3. ALTER COLUMN Operations +-- =========================== + +-- ALTER COLUMN TYPE +ALTER TABLE customers ALTER COLUMN phone TYPE VARCHAR(20); + +-- ALTER COLUMN SET ENCODE +ALTER TABLE events ALTER COLUMN event_data ENCODE LZO; + +-- =========================== +-- 4. RENAME Operations +-- =========================== + +-- RENAME TABLE +ALTER TABLE old_customers RENAME TO customers_archive; + +-- RENAME COLUMN +ALTER TABLE products RENAME COLUMN product_name TO name; + +-- RENAME TABLE with IF EXISTS +ALTER TABLE IF EXISTS temp_table RENAME TO permanent_table; + +-- =========================== +-- 5. CONSTRAINT Operations +-- =========================== + +-- ADD PRIMARY KEY constraint +ALTER TABLE employees ADD CONSTRAINT pk_employees PRIMARY KEY (employee_id); + +-- ADD UNIQUE constraint +ALTER TABLE users ADD CONSTRAINT uk_users_email UNIQUE (email); + +-- ADD FOREIGN KEY constraint +ALTER TABLE orders ADD CONSTRAINT fk_orders_customer + FOREIGN KEY (customer_id) REFERENCES customers(customer_id); + +-- ADD FOREIGN KEY with referential actions +ALTER TABLE order_items ADD CONSTRAINT fk_items_order + FOREIGN KEY (order_id) REFERENCES orders(order_id); + +-- ADD unnamed constraint +ALTER TABLE inventory ADD UNIQUE (product_id, warehouse_id); + +-- DROP CONSTRAINT +ALTER TABLE orders DROP CONSTRAINT fk_orders_customer; + +-- DROP CONSTRAINT with CASCADE +ALTER TABLE products DROP CONSTRAINT pk_products CASCADE; + +-- =========================== +-- 6. Distribution Key Operations +-- =========================== + +-- ALTER DISTKEY +ALTER TABLE sales ALTER DISTKEY customer_id; + +-- ALTER DISTSTYLE KEY with DISTKEY +ALTER TABLE events ALTER DISTSTYLE KEY DISTKEY event_id; + +-- ALTER DISTSTYLE to ALL +ALTER TABLE small_lookup ALTER DISTSTYLE ALL; + +-- ALTER DISTSTYLE to EVEN +ALTER TABLE large_table ALTER DISTSTYLE EVEN; + +-- ALTER DISTSTYLE to AUTO +ALTER TABLE transactions ALTER DISTSTYLE AUTO; + +-- =========================== +-- 7. Sort Key Operations +-- =========================== + +-- ALTER SORTKEY with single column +ALTER TABLE sales ALTER SORTKEY (sale_date); + +-- ALTER COMPOUND SORTKEY with multiple columns +ALTER TABLE events ALTER COMPOUND SORTKEY (event_date, event_type); + +-- ALTER INTERLEAVED SORTKEY +ALTER TABLE customer_data ALTER SORTKEY (customer_id, order_date); + +-- ALTER SORTKEY AUTO +ALTER TABLE analytics_table ALTER SORTKEY AUTO; + +-- ALTER SORTKEY NONE +ALTER TABLE temp_table ALTER SORTKEY NONE; + +-- =========================== +-- 8. Encoding Operations +-- =========================== + +-- ALTER ENCODE AUTO +ALTER TABLE large_table ALTER ENCODE AUTO; + +-- ALTER ENCODE AUTO PRESERVE YES +ALTER TABLE historical_data ALTER ENCODE AUTO; + +-- ALTER ENCODE AUTO PRESERVE NO +ALTER TABLE staging_table ALTER ENCODE AUTO; + +-- ALTER specific column encoding +ALTER TABLE events ALTER COLUMN event_data ENCODE ZSTD; + +-- =========================== +-- 9. Owner Operations +-- =========================== + +-- Change table owner +ALTER TABLE sales OWNER TO analytics_user; + +-- Change owner with IF EXISTS +ALTER TABLE temp_data OWNER TO etl_user; + +-- =========================== +-- 10. Row Level Security Operations +-- =========================== + +-- Enable row level security +ALTER TABLE sensitive_data ROW LEVEL SECURITY ON; + +-- Disable row level security +ALTER TABLE public_data ROW LEVEL SECURITY OFF; + +-- Enable masking for datashares +ALTER TABLE shared_table MASKING ON FOR DATASHARES; +-- Disable masking for datashares +ALTER TABLE unmasked_table MASKING OFF FOR DATASHARES; + +-- =========================== +-- 11. External Table Operations +-- =========================== + +-- SET TABLE PROPERTIES +ALTER TABLE spectrum.sales SET TABLE PROPERTIES ('numRows'='1000000', 'compressionType'='gzip'); + +-- APPEND FROM another table +ALTER TABLE sales_history APPEND FROM sales_staging; + +-- SET LOCATION for external table +ALTER TABLE spectrum.events SET LOCATION 's3://mybucket/data/events/2024/'; + +-- SET FILE FORMAT +ALTER TABLE spectrum.logs SET FILE FORMAT PARQUET; + +-- ADD PARTITION +ALTER TABLE spectrum.sales ADD PARTITION (year=2024, month=1) + LOCATION 's3://mybucket/sales/2024/01/'; + +-- ADD PARTITION IF NOT EXISTS +ALTER TABLE spectrum.events ADD IF NOT EXISTS PARTITION (date='2024-01-01') + LOCATION 's3://mybucket/events/2024-01-01/'; + +-- DROP PARTITION +ALTER TABLE spectrum.sales DROP PARTITION (year=2023, month=12); + +-- =========================== +-- 12. Complex Multi-Action Operations +-- =========================== + +-- Multiple column operations in single statement +ALTER TABLE products + ADD COLUMN category VARCHAR(50), + ADD COLUMN subcategory VARCHAR(50), + ALTER COLUMN price TYPE DECIMAL(12,2), + DROP COLUMN old_category; + +-- Add multiple constraints +ALTER TABLE orders + ADD CONSTRAINT pk_orders PRIMARY KEY (order_id), + ADD CONSTRAINT fk_customer FOREIGN KEY (customer_id) REFERENCES customers(id); + +-- Comprehensive table modification +ALTER TABLE sales_fact + ALTER DISTKEY customer_id, + ALTER SORTKEY (sale_date, product_id), + ADD COLUMN region_id INTEGER ENCODE AZ64, + DROP CONSTRAINT old_constraint CASCADE; + +-- =========================== +-- 13. Edge Cases and Special Syntax +-- =========================== + +-- Table with quoted identifier +ALTER TABLE "MixedCase_Table" ADD COLUMN "New Column" VARCHAR(100); + +-- Column names requiring quotes +ALTER TABLE sales RENAME COLUMN "old-column" TO "new_column"; + +-- Using non-reserved keywords as identifiers +ALTER TABLE data ADD COLUMN data VARCHAR(100); + +-- Complex data type modifications +ALTER TABLE measurements ALTER COLUMN reading TYPE NUMERIC(15,6); + +-- Multiple encoding types +ALTER TABLE performance_data + ALTER COLUMN metric1 ENCODE MOSTLY32, + ALTER COLUMN metric2 ENCODE DELTA32K; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_table_append.sql b/redshift/examples/redshift/alter_table_append.sql new file mode 100644 index 0000000..cc4189c --- /dev/null +++ b/redshift/examples/redshift/alter_table_append.sql @@ -0,0 +1,64 @@ +-- ALTER TABLE APPEND command tests +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE_APPEND.html + +-- Basic ALTER TABLE APPEND +ALTER TABLE sales APPEND FROM sales_monthly; +ALTER TABLE events APPEND FROM staging_events; +ALTER TABLE customers APPEND FROM temp_customers; + +-- With schema qualification +ALTER TABLE public.sales APPEND FROM staging.sales_monthly; +ALTER TABLE analytics.fact_sales APPEND FROM staging.sales_data; +ALTER TABLE warehouse.products APPEND FROM temp.product_import; + +-- With IGNOREEXTRA option +-- Discards extra columns in source table that are not in target table +ALTER TABLE sales APPEND FROM sales_listing IGNOREEXTRA; +ALTER TABLE events APPEND FROM staging_events_extended IGNOREEXTRA; +ALTER TABLE customers APPEND FROM temp_customers_full IGNOREEXTRA; + +-- With schema qualification and IGNOREEXTRA +ALTER TABLE public.sales APPEND FROM staging.sales_extended IGNOREEXTRA; +ALTER TABLE analytics.fact_sales APPEND FROM staging.sales_data_full IGNOREEXTRA; + +-- With FILLTARGET option +-- Fills extra columns in target table with default values or NULL +ALTER TABLE sales_report APPEND FROM sales_month FILLTARGET; +ALTER TABLE event_summary APPEND FROM event_data FILLTARGET; +ALTER TABLE customer_analytics APPEND FROM customer_base FILLTARGET; + +-- With schema qualification and FILLTARGET +ALTER TABLE public.sales_report APPEND FROM staging.sales_month FILLTARGET; +ALTER TABLE analytics.fact_sales_extended APPEND FROM staging.sales_basic FILLTARGET; + +-- From materialized views +ALTER TABLE target_tbl APPEND FROM my_streaming_materialized_view; +ALTER TABLE sales_fact APPEND FROM sales_stream_mv; +ALTER TABLE events_archive APPEND FROM events_stream_mv; + +-- With schema qualification for materialized views +ALTER TABLE public.target_table APPEND FROM streaming.my_materialized_view; +ALTER TABLE analytics.fact_table APPEND FROM staging.stream_mv; + +-- Materialized views with options +ALTER TABLE sales_archive APPEND FROM sales_stream_mv IGNOREEXTRA; +ALTER TABLE events_extended APPEND FROM events_stream_mv FILLTARGET; + +-- Complex examples with various naming conventions +ALTER TABLE "Sales_Table" APPEND FROM "Monthly_Sales"; +ALTER TABLE table_with_underscores APPEND FROM source_table_123; +ALTER TABLE "MixedCase_Table" APPEND FROM "source_MixedCase" IGNOREEXTRA; +ALTER TABLE target123 APPEND FROM source456 FILLTARGET; + +-- Long identifiers +ALTER TABLE very_long_table_name_with_many_words APPEND FROM another_very_long_source_table_name; +ALTER TABLE schema_with_long_name.table_with_long_name APPEND FROM source_schema.source_table_with_long_name IGNOREEXTRA; + +-- Edge cases and various patterns +ALTER TABLE t1 APPEND FROM t2; +ALTER TABLE t APPEND FROM s IGNOREEXTRA; +ALTER TABLE target APPEND FROM source FILLTARGET; +ALTER TABLE "TARGET" APPEND FROM "SOURCE"; +ALTER TABLE schema1.table1 APPEND FROM schema2.table2; +ALTER TABLE s1.t1 APPEND FROM s2.t2 IGNOREEXTRA; +ALTER TABLE s.t APPEND FROM s.t2 FILLTARGET; \ No newline at end of file diff --git a/redshift/examples/redshift/alter_user.sql b/redshift/examples/redshift/alter_user.sql new file mode 100644 index 0000000..9aeddca --- /dev/null +++ b/redshift/examples/redshift/alter_user.sql @@ -0,0 +1,117 @@ +-- ALTER USER test cases +-- Based on: https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_USER.html + +-- Basic ALTER USER with single option +ALTER USER admin CREATEDB; +ALTER USER dbuser NOCREATEDB; +ALTER USER admin CREATEUSER; +ALTER USER regular_user NOCREATEUSER; + +-- SYSLOG ACCESS options +ALTER USER admin SYSLOG ACCESS UNRESTRICTED; +ALTER USER regular_user SYSLOG ACCESS RESTRICTED; + +-- Password management +ALTER USER admin PASSWORD 'newSecurePass123!'; +ALTER USER admin PASSWORD 'adminPass9' VALID UNTIL '2017-12-31 23:59'; +ALTER USER dbuser PASSWORD DISABLE; + +-- MD5 password hash +ALTER USER admin PASSWORD 'md5153c434b4b77c89e6b94f12c5393af5b'; + +-- SHA256 password hash with salt +ALTER USER admin PASSWORD 'sha256|4e2bf2c96c5cad3d65a85b5dc0d5236a933e8d1285f4beefabf769afe633b1b5|5df545aa401d27d9c5c2d2704299b8d1ba66f760a343fa4568fa70c584d05cee'; + +-- Rename user +ALTER USER admin RENAME TO sysadmin; + +-- Connection limits +ALTER USER dbuser CONNECTION LIMIT 10; +ALTER USER admin CONNECTION LIMIT UNLIMITED; + +-- Session timeout +ALTER USER dbuser SESSION TIMEOUT 300; +ALTER USER admin SESSION TIMEOUT 900; +ALTER USER dbuser RESET SESSION TIMEOUT; + +-- SET and RESET parameters +ALTER USER admin SET search_path TO myschema, public; +ALTER USER dbuser SET statement_timeout = 60000; +ALTER USER admin SET enable_result_cache_for_session TO false; +ALTER USER dbuser RESET search_path; +ALTER USER admin RESET ALL; + +-- External ID for identity provider +ALTER USER bob EXTERNALID "ABC123"; +ALTER USER myco_aad:bob EXTERNALID "ABC123" PASSWORD DISABLE; +ALTER USER "mycompany.com:alice" EXTERNALID "XYZ456"; + +-- Multiple options with WITH keyword +ALTER USER admin WITH CREATEDB CREATEUSER; +ALTER USER dbuser WITH NOCREATEDB NOCREATEUSER SYSLOG ACCESS RESTRICTED; +ALTER USER newuser WITH PASSWORD 'tempPass123' VALID UNTIL '2024-12-31 23:59:59'; + +-- Multiple options without WITH keyword +ALTER USER admin CREATEDB CREATEUSER CONNECTION LIMIT UNLIMITED; +ALTER USER regular_user NOCREATEDB NOCREATEUSER CONNECTION LIMIT 5 SESSION TIMEOUT 600; +ALTER USER dbuser PASSWORD 'newPass456!' SYSLOG ACCESS RESTRICTED SET search_path = myschema; + +-- Complex combinations +ALTER USER admin + CREATEDB + CREATEUSER + SYSLOG ACCESS UNRESTRICTED + PASSWORD 'SuperSecure!123' + CONNECTION LIMIT UNLIMITED + SESSION TIMEOUT 3600 + SET enable_result_cache_for_session = true; + +ALTER USER readonly_user + NOCREATEDB + NOCREATEUSER + SYSLOG ACCESS RESTRICTED + CONNECTION LIMIT 3 + SESSION TIMEOUT 300 + SET statement_timeout TO 30000 + SET search_path TO public; + +-- External identity provider with namespace +ALTER USER "mycompany.aad:john.doe" EXTERNALID "AAD-12345" PASSWORD DISABLE; +ALTER USER "aws:iam:123456789012:user/jane" EXTERNALID "IAM-67890"; + +-- Case sensitivity tests +alter user DBUSER createdb; +ALTER USER "MixedCase_User" NOCREATEDB; +ALTER USER "user.with.dots" PASSWORD 'test123'; + +-- Edge cases with special characters in usernames +ALTER USER "user-with-hyphens" CREATEDB; +ALTER USER "user_with_underscores" NOCREATEUSER; +ALTER USER "123_numeric_start" PASSWORD DISABLE; + +-- Setting multiple parameters +ALTER USER admin + SET search_path TO schema1, schema2, public + SET statement_timeout = 120000 + SET enable_result_cache_for_session TO true; + +-- Resetting multiple parameters +ALTER USER dbuser + RESET search_path + RESET statement_timeout + PASSWORD 'newPassword123'; + +-- Valid until with different date formats +ALTER USER temp_user PASSWORD 'tempPass' VALID UNTIL '2024-12-31'; +ALTER USER contractor PASSWORD 'contractPass' VALID UNTIL '2025-06-30 15:30:00'; +ALTER USER seasonal_user PASSWORD 'seasonPass' VALID UNTIL '2024-08-31 23:59:59.999'; + +-- Connection limit edge cases +ALTER USER test_user CONNECTION LIMIT 0; +ALTER USER power_user CONNECTION LIMIT 1000; +ALTER USER special_user CONNECTION LIMIT 1; + +-- Session timeout edge cases +ALTER USER quick_user SESSION TIMEOUT 60; +ALTER USER long_user SESSION TIMEOUT 86400; +ALTER USER standard_user SESSION TIMEOUT 1800; \ No newline at end of file diff --git a/redshift/examples/redshift/analyze.sql b/redshift/examples/redshift/analyze.sql new file mode 100644 index 0000000..f09e435 --- /dev/null +++ b/redshift/examples/redshift/analyze.sql @@ -0,0 +1,55 @@ +-- ANALYZE statement test cases +-- https://docs.aws.amazon.com/redshift/latest/dg/r_ANALYZE.html + +-- Basic ANALYZE statements +ANALYZE; -- Analyze all tables in the current database +ANALYSE; -- Alternative spelling + +-- ANALYZE with VERBOSE option +ANALYZE VERBOSE; +ANALYSE VERBOSE; + +-- ANALYZE specific table +ANALYZE listing; +ANALYZE sales; +ANALYZE venue; +ANALYZE event; + +-- ANALYZE specific table with VERBOSE +ANALYZE VERBOSE listing; +ANALYZE VERBOSE sales; + +-- ANALYZE specific columns +ANALYZE listing(listid); +ANALYZE listing(listid, sellerid, eventid); +ANALYZE venue(venueid, venuename); +ANALYZE sales(salesid, listid, sellerid, buyerid); + +-- ANALYZE with PREDICATE COLUMNS option +ANALYZE venue PREDICATE COLUMNS; +ANALYZE listing PREDICATE COLUMNS; +ANALYZE sales PREDICATE COLUMNS; + +-- ANALYZE with ALL COLUMNS option (default behavior) +ANALYZE venue ALL COLUMNS; +ANALYZE listing ALL COLUMNS; +ANALYZE sales ALL COLUMNS; + +-- ANALYZE with VERBOSE and column options +ANALYZE VERBOSE venue PREDICATE COLUMNS; +ANALYZE VERBOSE listing ALL COLUMNS; + +-- Schema-qualified table names +ANALYZE public.sales; +ANALYZE public.venue(venueid, venuename); +ANALYZE public.listing PREDICATE COLUMNS; + +-- Multiple tables cannot be specified (these would be separate statements) +ANALYZE listing; +ANALYZE sales; +ANALYZE venue; + +-- Real-world examples from documentation +ANALYZE VERBOSE listing(listid, sellerid, eventid, dateid); +ANALYZE venue(venueid, venuename, venuecity, venuestate); +ANALYZE sales(salesid, listid, sellerid, buyerid, eventid, dateid, qtysold, pricepaid, commission); \ No newline at end of file diff --git a/redshift/examples/redshift/analyze_compression.sql b/redshift/examples/redshift/analyze_compression.sql new file mode 100644 index 0000000..a771c11 --- /dev/null +++ b/redshift/examples/redshift/analyze_compression.sql @@ -0,0 +1,54 @@ +-- ANALYZE COMPRESSION statement test cases +-- https://docs.aws.amazon.com/redshift/latest/dg/r_ANALYZE_COMPRESSION.html + +-- Basic ANALYZE COMPRESSION statements +ANALYZE COMPRESSION; -- Analyze all tables in current database +ANALYSE COMPRESSION; -- Alternative spelling + +-- ANALYZE COMPRESSION for specific table +ANALYZE COMPRESSION listing; +ANALYZE COMPRESSION sales; +ANALYZE COMPRESSION venue; +ANALYZE COMPRESSION event; + +-- ANALYZE COMPRESSION for specific columns +ANALYZE COMPRESSION listing(listid); +ANALYZE COMPRESSION listing(listid, sellerid, eventid, dateid); +ANALYZE COMPRESSION sales(qtysold, commission, saletime); +ANALYZE COMPRESSION venue(venuename, venuecity, venuestate); + +-- ANALYZE COMPRESSION with COMPROWS option +ANALYZE COMPRESSION listing COMPROWS 1000; -- Minimum value +ANALYZE COMPRESSION listing COMPROWS 100000; -- Default value +ANALYZE COMPRESSION listing COMPROWS 500000; -- Custom sample size +ANALYZE COMPRESSION sales COMPROWS 1000000; -- 1 million rows +ANALYZE COMPRESSION venue COMPROWS 1000000000; -- Maximum value (1 billion) + +-- ANALYZE COMPRESSION with columns and COMPROWS +ANALYZE COMPRESSION listing(listid, sellerid) COMPROWS 250000; +ANALYZE COMPRESSION sales(qtysold, commission, saletime) COMPROWS 750000; + +-- Schema-qualified table names +ANALYZE COMPRESSION public.listing; +ANALYZE COMPRESSION public.sales COMPROWS 200000; +ANALYZE COMPRESSION public.venue(venuename, venuecity) COMPROWS 50000; + +-- Real-world examples from documentation +ANALYZE COMPRESSION listing; +ANALYZE COMPRESSION sales(qtysold, commission, saletime); +ANALYZE COMPRESSION listing COMPROWS 500000; + +-- Edge cases for COMPROWS +ANALYZE COMPRESSION listing COMPROWS 1000; -- Minimum allowed +ANALYZE COMPRESSION listing COMPROWS 5000; -- Below default (will be upgraded) +ANALYZE COMPRESSION listing COMPROWS 99999; -- Just below default +ANALYZE COMPRESSION listing COMPROWS 100001; -- Just above default +ANALYZE COMPRESSION listing COMPROWS 999999999; -- Just below maximum +ANALYZE COMPRESSION listing COMPROWS 1000000000; -- Maximum allowed + +-- Complex examples combining features +ANALYZE COMPRESSION customer(c_custkey, c_name, c_address, c_city, c_nation, c_region) COMPROWS 250000; +ANALYZE COMPRESSION lineitem(l_orderkey, l_partkey, l_suppkey, l_quantity, l_extendedprice) COMPROWS 1000000; + +-- Note: SORTKEY columns are automatically skipped during compression analysis +-- Note: Cannot specify multiple tables in one ANALYZE COMPRESSION statement \ No newline at end of file diff --git a/redshift/examples/redshift/attach_masking_policy.sql b/redshift/examples/redshift/attach_masking_policy.sql new file mode 100644 index 0000000..6d457f1 --- /dev/null +++ b/redshift/examples/redshift/attach_masking_policy.sql @@ -0,0 +1,132 @@ +-- ATTACH MASKING POLICY test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ATTACH_MASKING_POLICY.html + +-- Basic attach to a single column for a user +ATTACH MASKING POLICY credit_card_mask +ON customer_data +(credit_card_number) +TO john_doe; + +-- Attach policy to multiple columns for a user +ATTACH MASKING POLICY pii_mask +ON employee_table +(ssn, phone_number, email) +TO alice_smith; + +-- Attach policy with input columns +ATTACH MASKING POLICY conditional_mask +ON sales_data +(revenue, profit) +USING (region, department) +TO bob_johnson; + +-- Attach policy to a role +ATTACH MASKING POLICY salary_mask +ON hr_data +(salary, bonus) +TO ROLE finance_team; + +-- Attach policy to PUBLIC (all users) +ATTACH MASKING POLICY default_mask +ON sensitive_table +(personal_info) +TO PUBLIC; + +-- Attach policy with priority +ATTACH MASKING POLICY high_priority_mask +ON customer_info +(account_number) +TO susan_lee +PRIORITY 10; + +-- Attach policy with multiple input and output columns +ATTACH MASKING POLICY complex_mask +ON transaction_table +(card_number, cvv, expiry_date) +USING (transaction_type, user_role, access_level) +TO ROLE security_admin +PRIORITY 5; + +-- Attach policy to SUPER data type paths +ATTACH MASKING POLICY json_mask +ON customer_json +(person.name.first_name, person.name.last_name, person.contact.email) +TO david_wong; + +-- Attach policy with SUPER paths in USING clause +ATTACH MASKING POLICY super_conditional_mask +ON json_data +(sensitive_data.credit_info) +USING (user_profile.access_level, user_profile.department) +TO ROLE data_analyst; + +-- Attach policy with mixed column types +ATTACH MASKING POLICY mixed_mask +ON hybrid_table +(regular_column, super_data.nested.field) +USING (access_type) +TO PUBLIC +PRIORITY 0; + +-- Attach policy with quoted identifiers +ATTACH MASKING POLICY "Special-Mask-Policy" +ON "Customer-Table" +("Credit-Card", "SSN-Number") +TO "user-with-dash"; + +-- Attach policy with quoted identifier and role +ATTACH MASKING POLICY policy_123 +ON "sales_2023" +("total_revenue", "customer_id") +TO ROLE "Sales-Team-Role" +PRIORITY 3; + +-- Complex example with all features +ATTACH MASKING POLICY comprehensive_mask +ON financial_records +(account_balance, routing_number, account_holder.personal.ssn) +USING (user_clearance_level, department_code, access_timestamp) +TO ROLE executive_team +PRIORITY 99; + +-- Multiple policies for different users on same table +ATTACH MASKING POLICY basic_mask +ON employee_records +(salary) +TO PUBLIC +PRIORITY 0; + +ATTACH MASKING POLICY detailed_mask +ON employee_records +(salary, bonus, stock_options) +TO ROLE hr_manager +PRIORITY 10; + +-- Edge cases with special characters in identifiers +ATTACH MASKING POLICY "mask@policy#1" +ON "table$special%chars" +("column&name*1", "column^name!2") +TO "user@company.com"; + +-- Maximum length identifiers (63 characters) +ATTACH MASKING POLICY very_long_policy_name_that_reaches_maximum_allowed_length_12345 +ON table_with_very_long_name_that_also_reaches_maximum_length_123 +(column_with_extremely_long_name_reaching_sixty_three_chars_12345) +TO user_with_long_name_reaching_maximum_allowed_identifier_length; + +-- Comments in statements +-- This policy masks sensitive financial data +ATTACH MASKING POLICY financial_mask +ON bank_accounts -- Main banking table +(account_number, balance) -- Sensitive columns +TO ROLE teller -- Bank teller role +PRIORITY 5; -- Medium priority + +/* Multi-line comment example + This attaches a comprehensive masking policy + for GDPR compliance */ +ATTACH MASKING POLICY gdpr_mask +ON eu_customers +(name, email, phone, address) +TO PUBLIC +PRIORITY 1; \ No newline at end of file diff --git a/redshift/examples/redshift/attach_rls_policy.sql b/redshift/examples/redshift/attach_rls_policy.sql new file mode 100644 index 0000000..507a765 --- /dev/null +++ b/redshift/examples/redshift/attach_rls_policy.sql @@ -0,0 +1,76 @@ +-- Basic ATTACH RLS POLICY examples based on AWS documentation + +-- Example 1: Attach policy to a single table for specific roles +ATTACH RLS POLICY policy_concerts +ON tickit_category_redshift +TO ROLE analyst, ROLE dbadmin; + +-- Example 2: Attach policy to a table for specific users +ATTACH RLS POLICY sales_policy +ON sales_data +TO john_doe, jane_smith; + +-- Example 3: Attach policy with TABLE keyword +ATTACH RLS POLICY regional_policy +ON TABLE customer_orders +TO ROLE regional_manager; + +-- Example 4: Attach policy to multiple tables +ATTACH RLS POLICY data_protection_policy +ON orders, customers, transactions +TO ROLE data_analyst, ROLE compliance_officer; + +-- Example 5: Attach policy to PUBLIC (all users) +ATTACH RLS POLICY basic_filter_policy +ON employee_directory +TO PUBLIC; + +-- Example 6: Mixed targets - users, roles, and PUBLIC +ATTACH RLS POLICY mixed_access_policy +ON inventory_table +TO admin_user, ROLE warehouse_manager, PUBLIC; + +-- Example 7: Schema-qualified table names +ATTACH RLS POLICY schema_policy +ON sales.orders, sales.customers +TO ROLE sales_team; + +-- Example 8: Complex multi-table, multi-role attachment +ATTACH RLS POLICY comprehensive_policy +ON TABLE finance.transactions, finance.accounts, finance.budgets +TO ROLE finance_analyst, ROLE finance_manager, ROLE auditor; + +-- Example 9: Single character identifiers (edge case) +ATTACH RLS POLICY p +ON t +TO ROLE r; + +-- Example 10: Longer identifier names +ATTACH RLS POLICY very_long_policy_name_for_testing_limits +ON table_with_a_very_long_name_to_test_parser +TO ROLE role_with_long_name, user_with_long_name; + +-- Example 11: Multiple users without roles +ATTACH RLS POLICY user_only_policy +ON products +TO user1, user2, user3, user4; + +-- Example 12: Multiple roles without users +ATTACH RLS POLICY role_only_policy +ON categories +TO ROLE role1, ROLE role2, ROLE role3; + +-- Example 13: Views and materialized views (as mentioned in docs) +ATTACH RLS POLICY view_policy +ON my_view, my_materialized_view +TO ROLE view_reader; + +-- Example 14: Database.schema.table format +ATTACH RLS POLICY cross_schema_policy +ON mydb.public.orders, mydb.sales.customers +TO ROLE cross_schema_user; + +-- Example 15: Policy with numbers in names +ATTACH RLS POLICY policy_2024_q1 +ON sales_2024_q1 +TO ROLE analyst_2024; \ No newline at end of file diff --git a/redshift/examples/redshift/begin.sql b/redshift/examples/redshift/begin.sql new file mode 100644 index 0000000..2a5a174 --- /dev/null +++ b/redshift/examples/redshift/begin.sql @@ -0,0 +1,97 @@ +-- BEGIN command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_BEGIN.html + +-- Basic BEGIN statements +BEGIN; +begin; + +-- BEGIN with WORK keyword +BEGIN WORK; +begin work; + +-- BEGIN with TRANSACTION keyword +BEGIN TRANSACTION; +begin transaction; + +-- START TRANSACTION (alternative syntax) +START TRANSACTION; +start transaction; + +-- BEGIN with isolation levels +-- Note: All isolation levels are processed as SERIALIZABLE in Redshift +BEGIN ISOLATION LEVEL SERIALIZABLE; +BEGIN ISOLATION LEVEL READ UNCOMMITTED; +BEGIN ISOLATION LEVEL READ COMMITTED; +BEGIN ISOLATION LEVEL REPEATABLE READ; + +BEGIN WORK ISOLATION LEVEL SERIALIZABLE; +BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED; +BEGIN WORK ISOLATION LEVEL READ COMMITTED; +BEGIN WORK ISOLATION LEVEL REPEATABLE READ; + +BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE; +BEGIN TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; +BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED; +BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ; + +-- START TRANSACTION with isolation levels +START TRANSACTION ISOLATION LEVEL SERIALIZABLE; +START TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; +START TRANSACTION ISOLATION LEVEL READ COMMITTED; +START TRANSACTION ISOLATION LEVEL REPEATABLE READ; + +-- BEGIN with access modes +BEGIN READ WRITE; +BEGIN READ ONLY; +begin read write; +begin read only; + +BEGIN WORK READ WRITE; +BEGIN WORK READ ONLY; + +BEGIN TRANSACTION READ WRITE; +BEGIN TRANSACTION READ ONLY; + +-- START TRANSACTION with access modes +START TRANSACTION READ WRITE; +START TRANSACTION READ ONLY; + +-- BEGIN with both isolation level and access mode +BEGIN ISOLATION LEVEL SERIALIZABLE READ WRITE; +BEGIN ISOLATION LEVEL SERIALIZABLE READ ONLY; +BEGIN ISOLATION LEVEL READ UNCOMMITTED READ WRITE; +BEGIN ISOLATION LEVEL READ UNCOMMITTED READ ONLY; +BEGIN ISOLATION LEVEL READ COMMITTED READ WRITE; +BEGIN ISOLATION LEVEL READ COMMITTED READ ONLY; +BEGIN ISOLATION LEVEL REPEATABLE READ READ WRITE; +BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY; + +-- BEGIN WORK with both isolation level and access mode +BEGIN WORK ISOLATION LEVEL SERIALIZABLE READ WRITE; +BEGIN WORK ISOLATION LEVEL SERIALIZABLE READ ONLY; +BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED READ WRITE; +BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED READ ONLY; + +-- BEGIN TRANSACTION with both isolation level and access mode +BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE; +BEGIN TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY; +BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE; +BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ ONLY; + +-- START TRANSACTION with both isolation level and access mode +START TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE; +START TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY; +START TRANSACTION ISOLATION LEVEL REPEATABLE READ READ WRITE; +START TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY; + +-- Example from AWS documentation +begin; +begin read write; + +-- Mixed case variations +Begin; +BEGIN; +BeGiN wOrK; +Start Transaction; +START transaction ISOLATION level SERIALIZABLE; +begin TRANSACTION isolation LEVEL read COMMITTED READ only; \ No newline at end of file diff --git a/redshift/examples/redshift/c_create_commands.sql b/redshift/examples/redshift/c_create_commands.sql new file mode 100644 index 0000000..311c6d7 --- /dev/null +++ b/redshift/examples/redshift/c_create_commands.sql @@ -0,0 +1,235 @@ +-- Test cases for CREATE commands starting with C + +-- ==================================== +-- CREATE EXTERNAL FUNCTION +-- ==================================== + +-- Basic external function +CREATE EXTERNAL FUNCTION public.f_distance (float, float, float, float) +RETURNS float +STABLE +LAMBDA 'lambda_distance' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftLambdaRole'; + +-- External function with no arguments +CREATE EXTERNAL FUNCTION get_current_time() +RETURNS timestamp +IMMUTABLE +LAMBDA 'lambda_get_time' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftLambdaRole'; + +-- External function with multiple data types +CREATE EXTERNAL FUNCTION process_json(varchar(65535), varchar(256)) +RETURNS varchar(65535) +STABLE +LAMBDA 'lambda_json_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftLambdaRole'; + +-- External function with OR REPLACE +CREATE OR REPLACE EXTERNAL FUNCTION calculate_score(integer, integer, integer) +RETURNS decimal(10,2) +STABLE +LAMBDA 'lambda_score_calculator' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftLambdaRole'; + +-- ==================================== +-- CREATE EXTERNAL MODEL +-- ==================================== + +-- Basic external model from S3 +CREATE EXTERNAL MODEL customer_churn_model +FROM 's3://mybucket/models/customer_churn.tar.gz' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftMLRole'; + +-- External model with function name +CREATE EXTERNAL MODEL sales_forecast_model +FROM 's3://mybucket/models/sales_forecast.tar.gz' +FUNCTION_NAME predict_sales +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftMLRole'; + +-- External model with settings +CREATE EXTERNAL MODEL fraud_detection_model +FROM 's3://mybucket/models/fraud_detection.tar.gz' +FUNCTION_NAME detect_fraud +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftMLRole' +SETTINGS ( + MAX_BATCH_SIZE '1000', + MAX_PAYLOAD_IN_MB '5' +); + +-- ==================================== +-- CREATE EXTERNAL SCHEMA +-- ==================================== + +-- External schema from AWS Glue Data Catalog +CREATE EXTERNAL SCHEMA spectrum_schema +FROM DATA_CATALOG +DATABASE 'spectrum_db' +REGION 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole' +CREATE EXTERNAL DATABASE IF NOT EXISTS; + +-- External schema from Hive metastore +CREATE EXTERNAL SCHEMA hive_schema +FROM HIVE METASTORE +DATABASE 'hive_db' +URI 'ec2-123-456-789-012.compute-1.amazonaws.com' +PORT 9083 +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole'; + +-- External schema from PostgreSQL +CREATE EXTERNAL SCHEMA postgres_schema +FROM POSTGRES +DATABASE 'mypostgresdb' +URI 'hostname.region.rds.amazonaws.com' +PORT 5432 +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftRole' +SECRET_ARN 'arn:aws:secretsmanager:region:123456789012:secret:postgres-secret'; + +-- External schema from MySQL +CREATE EXTERNAL SCHEMA mysql_schema +FROM MYSQL +DATABASE 'mysqldb' +URI 'hostname.region.rds.amazonaws.com' +PORT 3306 +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftRole' +SECRET_ARN 'arn:aws:secretsmanager:region:123456789012:secret:mysql-secret'; + +-- External schema from Redshift +CREATE EXTERNAL SCHEMA redshift_schema +FROM REDSHIFT +DATABASE 'remote_db' +REGION 'us-west-2' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftRole'; + +-- External schema with IF NOT EXISTS +CREATE EXTERNAL SCHEMA IF NOT EXISTS spectrum_schema2 +FROM DATA_CATALOG +DATABASE 'spectrum_db2' +REGION 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole'; + +-- External schema from Kinesis +CREATE EXTERNAL SCHEMA kinesis_schema +FROM KINESIS +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftKinesisRole'; + +-- ==================================== +-- CREATE EXTERNAL VIEW +-- ==================================== + +-- Basic external view +CREATE EXTERNAL VIEW spectrum_view AS +SELECT col1, col2, col3 +FROM spectrum_schema.external_table +WHERE col1 > 100; + +-- External view with column list +CREATE EXTERNAL VIEW sales_summary_view (region, total_sales, avg_price) AS +SELECT region, SUM(sales_amount), AVG(unit_price) +FROM spectrum_schema.sales_data +GROUP BY region; + +-- External view with OR REPLACE +CREATE OR REPLACE EXTERNAL VIEW customer_360_view AS +SELECT c.customer_id, c.name, o.order_count, p.total_spent +FROM spectrum_schema.customers c +JOIN spectrum_schema.order_summary o ON c.customer_id = o.customer_id +JOIN spectrum_schema.payment_summary p ON c.customer_id = p.customer_id; + +-- ==================================== +-- CREATE IDENTITY PROVIDER +-- ==================================== + +-- Azure identity provider +CREATE IDENTITY PROVIDER azure_idp +TYPE 'Azure' +NAMESPACE 'aad:myazuretenant.onmicrosoft.com'; + +-- Azure identity provider with provider URL +CREATE IDENTITY PROVIDER azure_idp_with_params +TYPE 'Azure' +PROVIDER_URL 'https://login.microsoftonline.com/tenant-id/v2.0'; + +-- Custom identity provider +CREATE IDENTITY PROVIDER custom_saml_idp +TYPE 'Custom' +PROVIDER_URL 'https://idp.mycompany.com'; + +-- ==================================== +-- CREATE LIBRARY +-- ==================================== + +-- Basic Python library +CREATE LIBRARY pandas_lib +LANGUAGE PLPYTHONU +FROM 's3://mybucket/python-libs/pandas-layer.zip'; + +-- Library with credentials +CREATE LIBRARY numpy_lib +LANGUAGE PLPYTHONU +FROM 's3://mybucket/python-libs/numpy-layer.zip' +CREDENTIALS 'aws_access_key_id=AKIAIOSFODNN7EXAMPLE;aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'; + +-- Library with region +CREATE LIBRARY scipy_lib +LANGUAGE PLPYTHONU +FROM 's3://mybucket/python-libs/scipy-layer.zip' +REGION AS 'us-west-2'; + +-- Library with OR REPLACE +CREATE OR REPLACE LIBRARY ml_utils_lib +LANGUAGE PLPYTHONU +FROM 's3://mybucket/python-libs/ml-utils.zip' +CREDENTIALS 'aws_access_key_id=AKIAIOSFODNN7EXAMPLE;aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY' +REGION AS 'us-east-1'; + +-- ==================================== +-- CREATE MASKING POLICY +-- ==================================== + +-- Basic masking policy for SSN +CREATE MASKING POLICY mask_ssn +WITH (ssn varchar(11)) +USING ( + CASE + WHEN current_user = 'admin' THEN ssn + ELSE 'XXX-XX-' || SUBSTRING(ssn, 8, 4) + END +); + +-- Masking policy for credit card with role-based access +CREATE MASKING POLICY mask_credit_card +WITH (cc_number varchar(19)) +USING ( + CASE + WHEN current_user IN ('finance_admin', 'compliance_officer') THEN cc_number + WHEN current_user_has_role('finance_read') THEN 'XXXX-XXXX-XXXX-' || SUBSTRING(cc_number, 16, 4) + ELSE 'XXXX-XXXX-XXXX-XXXX' + END +); + +-- Masking policy with USING clause +CREATE MASKING POLICY mask_salary +WITH (salary decimal(10,2)) +USING ( + CASE + WHEN is_manager = true AND department = user_department THEN salary + WHEN is_hr = true THEN salary + ELSE 0 + END +); + +-- Complex masking policy for email +CREATE MASKING POLICY mask_email +WITH (email varchar(255)) +USING ( + CASE + WHEN current_user = 'data_analyst' THEN + SUBSTRING(email, 1, 3) || '***@' || SPLIT_PART(email, '@', 2) + WHEN pg_has_role(current_user, 'marketing_team', 'MEMBER') THEN + email + ELSE + 'hidden@example.com' + END +); diff --git a/redshift/examples/redshift/call.sql b/redshift/examples/redshift/call.sql new file mode 100644 index 0000000..292bb01 --- /dev/null +++ b/redshift/examples/redshift/call.sql @@ -0,0 +1,119 @@ +-- CALL command examples from AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CALL_procedure.html + +-- Example 1: Simple procedure call without parameters +CALL refresh_materialized_view(); + +-- Example 2: Procedure with positional parameters +CALL update_customer_stats(2023, 'Q4'); + +-- Example 3: Procedure with named parameters using => syntax +CALL process_orders(start_date => '2023-01-01', end_date => '2023-12-31', status => 'completed'); + +-- Example 4: Procedure with mixed positional and named parameters +CALL generate_report(2023, report_type => 'annual', include_details => true); + +-- Example 5: Schema-qualified procedure call +CALL finance.calculate_revenue('2023-01-01', '2023-12-31'); + +-- Example 6: Procedure with numeric parameters +CALL test_sp1(5, 'abc'); + +-- Example 7: Procedure with INOUT parameters (from documentation example) +CALL test_sp2(2, '2019'); + +-- Example 8: Procedure call with function as parameter +CALL log_query_id(pg_last_query_id()); + +-- Example 9: Procedure with boolean parameters +CALL update_settings(enable_logging => true, debug_mode => false); + +-- Example 10: Procedure with NULL parameter +CALL reset_user_data(user_id => 12345, clear_history => NULL); + +-- Example 11: Procedure with string concatenation +CALL send_notification('Alert: ' + 'System maintenance scheduled'); + +-- Example 12: Nested procedure call example (outer procedure) +CALL outer_proc(5); + +-- Example 13: Procedure with cursor output (would be used in transaction) +CALL get_customers_by_city('MOROCCO 0', 'thecursor'); + +-- Example 14: Procedure that creates temp table +CALL get_customers_by_city_temp_table('MOROCCO 0', 'mytemptable'); + +-- Example 15: Complex procedure with multiple parameter types +CALL complex_calculation( + input_value => 100.50, + multiplier => 1.5, + use_cache => true, + description => 'Monthly calculation' +); + +-- Example 16: Procedure with array-like string parameter +CALL process_batch('item1,item2,item3', batch_size => 10); + +-- Example 17: Procedure with date calculations +CALL generate_monthly_report( + start_date => '2023-01-01'::date, + months => 12 +); + +-- Example 18: Procedure with quoted identifiers +CALL "Special Procedure"(param1 => 'value1'); + +-- Example 19: Procedure with numeric precision +CALL financial_calculation(amount => 12345.67, rate => 0.0525); + +-- Example 20: Procedure with mixed case identifiers +CALL MixedCaseProc(InputParam => 'test'); + +-- Example 21: Procedure with parentheses in expressions +CALL calculate_total((base_amount * tax_rate) + shipping_cost); + +-- Example 22: Procedure with nested function calls +CALL log_operation( + operation_id => extract(epoch from current_timestamp), + details => upper(trim(' operation completed ')) +); + +-- Example 23: Procedure using = syntax for named parameters +CALL update_configuration(setting_name = 'timeout', setting_value = '300'); + +-- Example 24: Simple procedure with single numeric parameter +CALL increment_counter(1); + +-- Example 25: Procedure with multiple string parameters +CALL create_user_profile( + username => 'john_doe', + email => 'john@example.com', + department => 'Engineering' +); + +-- Example 26: Procedure with boolean logic +CALL validate_data( + check_duplicates => true, + strict_mode => false, + auto_fix => true +); + +-- Example 27: Procedure with mathematical expressions +CALL calculate_metrics( + value1 => 100 + 50, + value2 => 200 * 1.5, + value3 => (300 / 2) - 25 +); + +-- Example 28: Long procedure name with underscores +CALL very_long_procedure_name_with_many_parameters( + param_one => 'value1', + param_two => 'value2', + param_three => 'value3' +); + +-- Example 29: Procedure with special characters in strings +CALL process_text(input_text => 'Text with "quotes" and ''apostrophes'''); + +-- Example 30: Minimal procedure call with empty parameters +CALL simple_procedure(); \ No newline at end of file diff --git a/redshift/examples/redshift/cancel.sql b/redshift/examples/redshift/cancel.sql new file mode 100644 index 0000000..e8373f2 --- /dev/null +++ b/redshift/examples/redshift/cancel.sql @@ -0,0 +1,13 @@ +-- CANCEL statement examples for Redshift +-- https://docs.aws.amazon.com/redshift/latest/dg/r_CANCEL.html + +-- Basic CANCEL statement +CANCEL 18764; + +-- CANCEL with custom message +CANCEL 18764 'Long-running query terminated by administrator'; + +-- Multiple CANCEL statements +CANCEL 12345; +CANCEL 67890 'Query canceled due to resource constraints'; +CANCEL 11111 'Maintenance window - canceling all active queries'; \ No newline at end of file diff --git a/redshift/examples/redshift/close.sql b/redshift/examples/redshift/close.sql new file mode 100644 index 0000000..8e318dd --- /dev/null +++ b/redshift/examples/redshift/close.sql @@ -0,0 +1,97 @@ +-- CLOSE command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CLOSE.html + +-- Basic CLOSE statements +CLOSE cursor1; +close cursor1; + +-- CLOSE with simple cursor names +CLOSE my_cursor; +CLOSE cursor_name; +CLOSE test_cursor; + +-- CLOSE with underscore in cursor names +CLOSE my_cursor_name; +CLOSE cursor_with_long_name; +CLOSE test_cursor_123; + +-- CLOSE with numeric suffixes +CLOSE cursor1; +CLOSE cursor2; +CLOSE cursor123; +CLOSE my_cursor_1; +CLOSE test_cursor_99; + +-- CLOSE with quoted identifiers +CLOSE "my cursor"; +CLOSE "Cursor Name"; +CLOSE "cursor-with-dashes"; +CLOSE "cursor.with.dots"; +CLOSE "cursor with spaces"; + +-- CLOSE with mixed case cursor names +CLOSE MyCursor; +CLOSE CURSOR_NAME; +CLOSE TestCursor; +CLOSE myCursor; +CLOSE cursorName; + +-- CLOSE with special characters in quoted names +CLOSE "cursor@special"; +CLOSE "cursor#123"; +CLOSE "cursor$name"; +CLOSE "cursor%test"; + +-- CLOSE with reserved words as cursor names (when quoted) +CLOSE "close"; +CLOSE "begin"; +CLOSE "transaction"; +CLOSE "work"; +CLOSE "table"; + +-- CLOSE with single character cursor names +CLOSE a; +CLOSE b; +CLOSE c; +CLOSE x; +CLOSE y; +CLOSE z; + +-- CLOSE with typical cursor naming patterns +CLOSE emp_cursor; +CLOSE dept_cursor; +CLOSE sales_cursor; +CLOSE product_cursor; +CLOSE customer_cursor; + +-- CLOSE with procedural cursor names +CLOSE proc_cursor; +CLOSE func_cursor; +CLOSE temp_cursor; +CLOSE result_cursor; +CLOSE output_cursor; + +-- CLOSE with database object naming patterns +CLOSE users_cur; +CLOSE orders_cur; +CLOSE items_cur; +CLOSE transactions_cur; +CLOSE reports_cur; + +-- Example from typical cursor usage patterns +close sales_report_cursor; +close monthly_summary_cursor; +close customer_detail_cursor; + +-- Mixed case variations +Close cursor1; +CLOSE cursor2; +ClOsE cursor3; +close CURSOR4; +CLOSE CursorName; + +-- Complex cursor names +CLOSE complex_cursor_name_with_underscores; +CLOSE "Complex Cursor Name With Spaces"; +CLOSE cursor_123_test_abc; +CLOSE "cursor-name-with-dashes-123"; \ No newline at end of file diff --git a/redshift/examples/redshift/comment.sql b/redshift/examples/redshift/comment.sql new file mode 100644 index 0000000..9140ac6 --- /dev/null +++ b/redshift/examples/redshift/comment.sql @@ -0,0 +1,108 @@ +-- COMMENT command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_COMMENT.html + +-- Basic TABLE comments (from AWS documentation examples) +COMMENT ON TABLE sales IS 'This table stores tickets sales data'; +COMMENT ON TABLE event IS 'Contains listings of individual events.'; + +-- Remove table comment using NULL +COMMENT ON TABLE sales IS NULL; + +-- COLUMN comments (from AWS documentation examples) +COMMENT ON COLUMN sales.eventid IS 'Foreign-key reference to the EVENT table.'; + +-- More COLUMN comment examples +COMMENT ON COLUMN event.eventname IS 'Name of the event'; +COMMENT ON COLUMN sales.qtysold IS 'Quantity of tickets sold'; +COMMENT ON COLUMN sales.pricepaid IS 'Total price paid for tickets'; + +-- Remove column comment +COMMENT ON COLUMN sales.eventid IS NULL; + +-- DATABASE comments +COMMENT ON DATABASE dev IS 'Development database'; +COMMENT ON DATABASE prod IS 'Production database'; +COMMENT ON DATABASE test IS 'Testing environment database'; + +-- Remove database comment +COMMENT ON DATABASE dev IS NULL; + +-- VIEW comments +COMMENT ON VIEW sales_summary IS 'Summary view of sales data'; +COMMENT ON VIEW monthly_revenue IS 'Monthly revenue aggregation view'; + +-- Remove view comment +COMMENT ON VIEW sales_summary IS NULL; + +-- SCHEMA comments +COMMENT ON SCHEMA public IS 'Default public schema'; +COMMENT ON SCHEMA analytics IS 'Schema for analytics tables'; +COMMENT ON SCHEMA staging IS 'Staging area for data loading'; + +-- Remove schema comment +COMMENT ON SCHEMA analytics IS NULL; + +-- CONSTRAINT comments +COMMENT ON CONSTRAINT sales_pkey ON sales IS 'Primary key constraint'; +COMMENT ON CONSTRAINT fk_sales_event ON sales IS 'Foreign key to event table'; +COMMENT ON CONSTRAINT chk_qty_positive ON sales IS 'Check constraint for positive quantity'; + +-- Remove constraint comment +COMMENT ON CONSTRAINT sales_pkey ON sales IS NULL; + +-- Schema-qualified object names +COMMENT ON TABLE public.sales IS 'Sales table in public schema'; +COMMENT ON TABLE analytics.monthly_sales IS 'Monthly sales aggregation'; +COMMENT ON COLUMN public.event.eventname IS 'Event name in public schema'; +COMMENT ON VIEW analytics.revenue_view IS 'Revenue view in analytics schema'; + +-- Quoted identifiers +COMMENT ON TABLE "Sales Data" IS 'Table with quoted name'; +COMMENT ON COLUMN "Sales Data"."Event ID" IS 'Column with quoted names'; +COMMENT ON SCHEMA "Analytics Schema" IS 'Schema with quoted name'; + +-- Mixed case variations +comment on table Sales IS 'Mixed case comment'; +Comment On Table EVENT is 'Mixed case keywords'; +COMMENT on column sales.eventid is 'Mixed case column comment'; + +-- Comments with special characters and escapes +COMMENT ON TABLE sales IS 'This table stores ''quoted'' text'; +COMMENT ON TABLE event IS 'Table with "double quotes" in comment'; +COMMENT ON TABLE venue IS 'Table with newline +and continuation'; + +-- Long comments +COMMENT ON TABLE sales IS 'This is a very long comment that describes the sales table in great detail, including information about its purpose, structure, data sources, update frequency, and business rules that apply to the data stored within it'; + +-- Empty comments (effectively removes comment) +COMMENT ON TABLE sales IS ''; + +-- Complex schema and table names +COMMENT ON TABLE my_schema.my_table IS 'Table in custom schema'; +COMMENT ON COLUMN my_schema.my_table.my_column IS 'Column in custom schema'; + +-- Numeric and special characters in names (quoted) +COMMENT ON TABLE "Table123" IS 'Table with numbers'; +COMMENT ON COLUMN "Table_with_underscores".col_name IS 'Column with underscores'; + +-- Real-world example scenarios +COMMENT ON TABLE customer IS 'Customer master data table containing demographic and contact information'; +COMMENT ON TABLE orders IS 'Order transaction table with purchase details and timestamps'; +COMMENT ON TABLE order_items IS 'Line items for each order with product details and quantities'; + +COMMENT ON COLUMN customer.customer_id IS 'Unique identifier for customer (primary key)'; +COMMENT ON COLUMN customer.email IS 'Customer email address (unique)'; +COMMENT ON COLUMN customer.created_date IS 'Date when customer record was created'; + +COMMENT ON COLUMN orders.order_id IS 'Unique order identifier (primary key)'; +COMMENT ON COLUMN orders.customer_id IS 'Foreign key reference to customer table'; +COMMENT ON COLUMN orders.order_date IS 'Date when order was placed'; +COMMENT ON COLUMN orders.total_amount IS 'Total order amount in USD'; + +-- Remove all the example comments +COMMENT ON TABLE customer IS NULL; +COMMENT ON TABLE orders IS NULL; +COMMENT ON TABLE order_items IS NULL; +COMMENT ON COLUMN customer.customer_id IS NULL; +COMMENT ON COLUMN orders.order_id IS NULL; \ No newline at end of file diff --git a/redshift/examples/redshift/commit.sql b/redshift/examples/redshift/commit.sql new file mode 100644 index 0000000..adcdf2d --- /dev/null +++ b/redshift/examples/redshift/commit.sql @@ -0,0 +1,72 @@ +-- COMMIT command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_COMMIT.html + +-- Basic COMMIT statements +COMMIT; +commit; + +-- COMMIT with WORK keyword (optional synonym) +COMMIT WORK; +commit work; + +-- COMMIT with TRANSACTION keyword (optional synonym) +COMMIT TRANSACTION; +commit transaction; + +-- END statements (alternative syntax for COMMIT) +END; +end; + +-- END with WORK keyword +END WORK; +end work; + +-- END with TRANSACTION keyword +END TRANSACTION; +end transaction; + +-- Examples from AWS documentation +commit; +commit work; +commit transaction; + +-- Mixed case variations +Commit; +COMMIT; +CoMmIt WoRk; +End; +END; +end WORK; +END transaction; +End Transaction; + +-- Real-world usage examples +-- Transaction block with commit +BEGIN; +INSERT INTO test_table VALUES (1, 'test'); +COMMIT; + +-- Transaction block with commit work +BEGIN WORK; +UPDATE test_table SET column1 = 'updated' WHERE id = 1; +COMMIT WORK; + +-- Transaction block with commit transaction +BEGIN TRANSACTION; +DELETE FROM test_table WHERE id = 1; +COMMIT TRANSACTION; + +-- Transaction block with end +BEGIN; +CREATE TEMP TABLE temp_test AS SELECT * FROM source_table; +END; + +-- Transaction block with end work +BEGIN WORK; +INSERT INTO target_table SELECT * FROM temp_test; +END WORK; + +-- Transaction block with end transaction +BEGIN TRANSACTION; +DROP TABLE temp_test; +END TRANSACTION; \ No newline at end of file diff --git a/redshift/examples/redshift/copy.sql b/redshift/examples/redshift/copy.sql new file mode 100644 index 0000000..230681e --- /dev/null +++ b/redshift/examples/redshift/copy.sql @@ -0,0 +1,281 @@ +-- Redshift COPY command test cases +-- These examples focus on Redshift-specific features that differ from PostgreSQL COPY + +-- Basic S3 COPY with IAM Role +COPY customer +FROM 's3://mybucket/customer/customer.tbl' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole'; + +-- S3 COPY with default IAM Role +COPY sales +FROM 's3://mybucket/data/sales/' +IAM_ROLE default; + +-- S3 COPY with multiple options +COPY listing +FROM 's3://mybucket/data/listing/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER '|' +IGNOREHEADER 1 +DATEFORMAT 'auto' +TIMEFORMAT 'auto' +MAXERROR 10 +ACCEPTINVCHARS +GZIP; + +-- S3 COPY with manifest file +COPY customer +FROM 's3://mybucket/cust.manifest' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +MANIFEST +DELIMITER '|' +GZIP +DATEFORMAT 'auto' +MAXERROR 10; + +-- S3 COPY with encryption +COPY venue +FROM 's3://mybucket/encrypted/venue/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ENCRYPTED +DELIMITER '|' +GZIP +REMOVEQUOTES +BLANKSASNULL +EMPTYASNULL +EXPLICIT_IDS; + +-- S3 COPY with region specification +COPY sales +FROM 's3://mybucket-eu/sales/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +REGION 'eu-west-1' +DELIMITER '\t' +BZIP2; + +-- DynamoDB COPY +COPY favoritemovies +FROM 'dynamodb://Movies' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +READRATIO 50; + +-- DynamoDB COPY with column mapping +COPY myredshifttable (col1, col2, col3) +FROM 'dynamodb://ProductCatalog' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +READRATIO 25 +DATEFORMAT 'auto' +TIMEFORMAT 'auto' +COMPUPDATE OFF +STATUPDATE ON; + +-- EMR COPY +COPY sales +FROM 'emr://j-SAMPLE2B500FC/myoutput/part-*' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER '\t' +LZOP; + +-- CSV format COPY +COPY category +FROM 's3://mybucket/data/category_csv.txt' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT CSV +QUOTE '"' +DELIMITER ',' +IGNOREHEADER 1; + +-- CSV format with AS keyword +COPY venue +FROM 's3://mybucket/venue.csv' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT AS CSV +IGNOREHEADER AS 1 +DATEFORMAT AS 'MM/DD/YYYY' +REGION AS 'us-west-2'; + +-- JSON format with auto +COPY category +FROM 's3://mybucket/category_object_auto.json' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +JSON 'auto' +TRUNCATECOLUMNS; + +-- JSON format with JSONPaths file +COPY venue +FROM 's3://mybucket/venue_pipe.json' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +JSON 's3://mybucket/venue_jsonpath.json' +ACCEPTINVCHARS +DATEFORMAT 'auto' +MAXERROR 10 +REGION 'us-west-2'; + +-- Avro format +COPY category +FROM 's3://mybucket/category_object.avro' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT AS AVRO 'auto'; + +-- Avro with schema file +COPY product +FROM 's3://mybucket/data/product.avro' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +AVRO 's3://mybucket/schema/product.avsc' +ACCEPTANYDATE +BLANKSASNULL; + +-- Parquet format +COPY listing +FROM 's3://mybucket/data/listings/parquet/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT AS PARQUET; + +-- ORC format +COPY sales +FROM 's3://mybucket/data/sales/orc/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT AS ORC +DATEFORMAT 'auto' +TIMEFORMAT 'auto'; + +-- Fixed width format +COPY venue_fw +FROM 's3://mybucket/data/venue_fw.txt' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FIXEDWIDTH 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6' +ACCEPTINVCHARS ' ' +BLANKSASNULL; + +-- Multiple compression formats +COPY sales_gzip FROM 's3://mybucket/sales.gz' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' GZIP; + +COPY sales_bzip2 FROM 's3://mybucket/sales.bz2' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' BZIP2; + +COPY sales_lzop FROM 's3://mybucket/sales.lzo' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' LZOP; + +COPY sales_zstd FROM 's3://mybucket/sales.zst' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' ZSTD; + +-- Data conversion options +COPY event +FROM 's3://mybucket/data/allevents_pipe.txt' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER '|' +TIMEFORMAT 'YYYY-MM-DD HH:MI:SS' +IGNOREHEADER 1 +ACCEPTINVCHARS '?' +NULL AS '\000' +ESCAPE +ROUNDEC +TRIMBLANKS +TRUNCATECOLUMNS +IGNOREBLANKLINES +ACCEPTANYDATE +EMPTYASNULL +BLANKSASNULL +FILLRECORD +REMOVEQUOTES; + +-- Load operation options +COPY sales +FROM 's3://mybucket/sales/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER '\t' +COMPUPDATE PRESET +STATUPDATE ON +MAXERROR 100 +NOLOAD; + +-- Error handling options +COPY venue +FROM 's3://mybucket/venue_errors/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER ',' +IGNOREALLERRORS; + +-- Time format options +COPY timestamp_table +FROM 's3://mybucket/timestamps/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +TIMEFORMAT 'auto'; + +COPY epoch_table +FROM 's3://mybucket/epochs/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +TIMEFORMAT 'epochsecs'; + +COPY epoch_milli_table +FROM 's3://mybucket/epochs_milli/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +TIMEFORMAT 'epochmillisecs'; + +-- Encoding options +COPY international_sales +FROM 's3://mybucket/international/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ENCODING UTF16 +DELIMITER '\t' +ACCEPTINVCHARS; + +-- Access key authorization (not recommended but supported) +COPY sales +FROM 's3://mybucket/sales/' +ACCESS_KEY_ID 'AKIAIOSFODNN7EXAMPLE' +SECRET_ACCESS_KEY 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY' +DELIMITER '|'; + +-- Session token for temporary credentials +COPY venue +FROM 's3://mybucket/venue/' +ACCESS_KEY_ID 'AKIAIOSFODNN7EXAMPLE' +SECRET_ACCESS_KEY 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY' +SESSION_TOKEN 'AQoDYXdzEPT//////////wEXAMPLEtc764bNrC9SAPBSM22wDOk4x4HIZ8j4FZTwdQWLWsKWHGBuFqwAeMicRXmxfpSPfIeoIYRqTflfKD8YUuwthAx7mSEI/qkPpKPi/kMcGd' +DELIMITER ','; + +-- CREDENTIALS clause +COPY customer +FROM 's3://mybucket/customer/' +CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER '|'; + +-- Complex multi-option example +COPY sales_fact ( + sale_id, + product_id, + customer_id, + sale_date, + quantity, + amount +) +FROM 's3://mybucket/sales/2023/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT AS CSV +QUOTE AS '"' +DELIMITER ',' +IGNOREHEADER 1 +DATEFORMAT 'YYYY-MM-DD' +TIMEFORMAT 'YYYY-MM-DD HH24:MI:SS' +REGION 'us-east-1' +GZIP +MAXERROR 50 +ACCEPTINVCHARS '?' +BLANKSASNULL +EMPTYASNULL +ESCAPE +EXPLICIT_IDS +ROUNDEC +TRIMBLANKS +COMPUPDATE OFF +STATUPDATE ON; + +-- COPY with COMPROWS option +COPY large_table +FROM 's3://mybucket/large_table/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER '|' +COMPROWS 1000000 +COMPUPDATE PRESET; \ No newline at end of file diff --git a/redshift/examples/redshift/create_database.sql b/redshift/examples/redshift/create_database.sql new file mode 100644 index 0000000..6fb9dc8 --- /dev/null +++ b/redshift/examples/redshift/create_database.sql @@ -0,0 +1,75 @@ +-- CREATE DATABASE examples for Amazon Redshift +-- Based on: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html + +-- Basic database creation +CREATE DATABASE mydb; + +-- Database with owner +CREATE DATABASE tickit WITH OWNER dwuser; + +-- Database with owner (using = sign) +CREATE DATABASE tickit2 WITH OWNER = dwuser; + +-- Database with connection limit +CREATE DATABASE salesdb WITH CONNECTION LIMIT 100; + +-- Database with unlimited connections +CREATE DATABASE devdb WITH CONNECTION LIMIT UNLIMITED; + +-- Database with specific isolation level +CREATE DATABASE sampledb ISOLATION LEVEL SNAPSHOT; + +-- Database with serializable isolation level +CREATE DATABASE transactionaldb ISOLATION LEVEL SERIALIZABLE; + +-- Case-insensitive database +CREATE DATABASE cidb COLLATE CASE_INSENSITIVE; + +-- Case-insensitive database using CI shorthand +CREATE DATABASE cidb2 COLLATE CI; + +-- Case-sensitive database +CREATE DATABASE csdb COLLATE CASE_SENSITIVE; + +-- Case-sensitive database using CS shorthand +CREATE DATABASE csdb2 COLLATE CS; + +-- Database with multiple options +CREATE DATABASE proddb + WITH OWNER produser + CONNECTION LIMIT 50 + COLLATE CASE_INSENSITIVE + ISOLATION LEVEL SNAPSHOT; + +-- Database with all options +CREATE DATABASE enterprisedb + OWNER = admin + CONNECTION LIMIT 200 + COLLATE CI + ISOLATION LEVEL SNAPSHOT; + +-- Database from integration (for data sharing) - Complex syntax commented out for now +-- CREATE DATABASE shared_db +-- FROM INTEGRATION '12345678-1234-1234-1234-123456789012' +-- DATABASE 'source_database' +-- SET +-- ACCEPTINVCHARS TRUE +-- QUERY_ALL_STATES FALSE +-- REFRESH_INTERVAL 3600 +-- TRUNCATECOLUMNS TRUE +-- HISTORY_MODE FALSE; + +-- Database from integration with WITH clause options - Complex syntax commented out for now +-- CREATE DATABASE hybrid_db +-- FROM INTEGRATION 'abcdef12-3456-7890-abcd-ef1234567890' +-- DATABASE 'remote_db' +-- ACCEPTINVCHARS FALSE +-- WITH OWNER dataowner +-- CONNECTION LIMIT 75 +-- ISOLATION LEVEL SNAPSHOT; + +-- Database with semicolon +CREATE DATABASE testdb; + +-- Database without semicolon (also valid) +CREATE DATABASE testdb2 \ No newline at end of file diff --git a/redshift/examples/redshift/create_datashare.sql b/redshift/examples/redshift/create_datashare.sql new file mode 100644 index 0000000..54d7abf --- /dev/null +++ b/redshift/examples/redshift/create_datashare.sql @@ -0,0 +1,47 @@ +-- CREATE DATASHARE examples from AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATASHARE.html + +-- Basic datashare creation +CREATE DATASHARE salesshare; + +-- Create a datashare with public accessibility set to false (default) +CREATE DATASHARE private_share PUBLICACCESSIBLE FALSE; + +-- Create a datashare with public accessibility set to true +CREATE DATASHARE public_share PUBLICACCESSIBLE TRUE; + +-- Create a datashare with SET keyword before PUBLICACCESSIBLE +CREATE DATASHARE share_with_set SET PUBLICACCESSIBLE TRUE; + +-- Create a datashare with equal sign in PUBLICACCESSIBLE +CREATE DATASHARE share_with_equal PUBLICACCESSIBLE = TRUE; + +-- Create a datashare with SET and equal sign +CREATE DATASHARE share_set_equal SET PUBLICACCESSIBLE = FALSE; + +-- Create a datashare managed by AWS Data Exchange +CREATE DATASHARE adx_share MANAGEDBY ADX; + +-- Create a public datashare managed by AWS Data Exchange (from documentation example) +CREATE DATASHARE demoshare SET PUBLICACCESSIBLE TRUE, MANAGEDBY ADX; + +-- Various combinations +CREATE DATASHARE combined_share1 PUBLICACCESSIBLE TRUE, MANAGEDBY ADX; +CREATE DATASHARE combined_share2 SET PUBLICACCESSIBLE = FALSE, MANAGEDBY ADX; +CREATE DATASHARE combined_share3 MANAGEDBY ADX, PUBLICACCESSIBLE TRUE; +CREATE DATASHARE combined_share4 MANAGEDBY ADX, SET PUBLICACCESSIBLE = TRUE; + +-- Different identifier formats +CREATE DATASHARE "quoted_share"; +CREATE DATASHARE schema_qualified.share_name; +CREATE DATASHARE _underscore_share; +CREATE DATASHARE share123; + +-- Multiple options with different orderings +CREATE DATASHARE multi_option1 PUBLICACCESSIBLE FALSE, MANAGEDBY ADX; +CREATE DATASHARE multi_option2 MANAGEDBY ADX, PUBLICACCESSIBLE FALSE; + +-- Edge cases +CREATE DATASHARE minimal_share ; +CREATE DATASHARE share_no_value PUBLICACCESSIBLE; +CREATE DATASHARE share_set_no_value SET PUBLICACCESSIBLE; \ No newline at end of file diff --git a/redshift/examples/redshift/create_external_function.sql b/redshift/examples/redshift/create_external_function.sql new file mode 100644 index 0000000..5fc3332 --- /dev/null +++ b/redshift/examples/redshift/create_external_function.sql @@ -0,0 +1,234 @@ +-- CREATE EXTERNAL FUNCTION test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_FUNCTION.html + +-- Basic CREATE EXTERNAL FUNCTION examples +CREATE EXTERNAL FUNCTION exfunc_sum(INT, INT) +RETURNS INT +VOLATILE +LAMBDA 'lambda_sum' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with VARCHAR parameters and return type +CREATE EXTERNAL FUNCTION exfunc_upper(VARCHAR) +RETURNS VARCHAR +STABLE +LAMBDA 'lambda_upper' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with multiple parameters of different types +CREATE EXTERNAL FUNCTION exfunc_multiplication(INT, INT, INT) +RETURNS INT +VOLATILE +LAMBDA 'lambda_multiplication' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with RETRY_TIMEOUT option +CREATE EXTERNAL FUNCTION exfunc_with_timeout(VARCHAR(100)) +RETURNS VARCHAR(200) +VOLATILE +LAMBDA 'lambda_with_timeout' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +RETRY_TIMEOUT 30000; + +-- Function with MAX_BATCH_ROWS option +CREATE EXTERNAL FUNCTION exfunc_batch_processing(INT, VARCHAR(50)) +RETURNS VARCHAR(100) +STABLE +LAMBDA 'lambda_batch_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +MAX_BATCH_ROWS 1000; + +-- Function with MAX_BATCH_SIZE option in KB +CREATE EXTERNAL FUNCTION exfunc_with_batch_size_kb(TEXT) +RETURNS TEXT +VOLATILE +LAMBDA 'lambda_text_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +MAX_BATCH_SIZE 512 KB; + +-- Function with MAX_BATCH_SIZE option in MB +CREATE EXTERNAL FUNCTION exfunc_with_batch_size_mb(SUPER) +RETURNS SUPER +STABLE +LAMBDA 'lambda_super_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +MAX_BATCH_SIZE 10 MB; + +-- Function with all optional parameters +CREATE EXTERNAL FUNCTION exfunc_complete(VARCHAR(255), INT, DECIMAL(10,2)) +RETURNS JSON +VOLATILE +LAMBDA 'lambda_complete_function' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +RETRY_TIMEOUT 25000 +MAX_BATCH_ROWS 500 +MAX_BATCH_SIZE 2 MB; + +-- CREATE OR REPLACE EXTERNAL FUNCTION +CREATE OR REPLACE EXTERNAL FUNCTION exfunc_replaceable(BIGINT) +RETURNS BOOLEAN +STABLE +LAMBDA 'lambda_replaceable' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with DEFAULT IAM_ROLE +CREATE EXTERNAL FUNCTION exfunc_default_role(SMALLINT, SMALLINT) +RETURNS REAL +VOLATILE +LAMBDA 'lambda_default_role' +IAM_ROLE DEFAULT; + +-- Function with timestamp parameters +CREATE EXTERNAL FUNCTION exfunc_timestamp_processing(TIMESTAMP, DATE) +RETURNS TIMESTAMPTZ +STABLE +LAMBDA 'lambda_timestamp_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with time zone types +CREATE EXTERNAL FUNCTION exfunc_timezone(TIMESTAMP WITH TIME ZONE) +RETURNS TIME WITHOUT TIME ZONE +VOLATILE +LAMBDA 'lambda_timezone_converter' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with JSONB parameters +CREATE EXTERNAL FUNCTION exfunc_json_processor(JSONB, VARCHAR(100)) +RETURNS JSONB +STABLE +LAMBDA 'lambda_json_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with geometric types +CREATE EXTERNAL FUNCTION exfunc_geometry(GEOMETRY) +RETURNS GEOGRAPHY +VOLATILE +LAMBDA 'lambda_geo_converter' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with HLLSKETCH type +CREATE EXTERNAL FUNCTION exfunc_hll_analysis(HLLSKETCH) +RETURNS BIGINT +STABLE +LAMBDA 'lambda_hll_estimator' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with INTERVAL type +CREATE EXTERNAL FUNCTION exfunc_interval_calc(INTERVAL, INT) +RETURNS INTERVAL +VOLATILE +LAMBDA 'lambda_interval_calculator' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with DOUBLE PRECISION +CREATE EXTERNAL FUNCTION exfunc_precision_calc(DOUBLE PRECISION, NUMERIC(15,5)) +RETURNS DOUBLE PRECISION +STABLE +LAMBDA 'lambda_precision_calculator' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with no parameters +CREATE EXTERNAL FUNCTION exfunc_no_params() +RETURNS VARCHAR(50) +VOLATILE +LAMBDA 'lambda_no_params' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Complex function with many parameters +CREATE EXTERNAL FUNCTION exfunc_complex( + VARCHAR(100), + INT, + DECIMAL(18,6), + TIMESTAMP, + BOOLEAN, + TEXT, + JSONB +) +RETURNS SUPER +VOLATILE +LAMBDA 'lambda_complex_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +RETRY_TIMEOUT 60000 +MAX_BATCH_ROWS 100 +MAX_BATCH_SIZE 5 MB; + +-- Function for data validation +CREATE EXTERNAL FUNCTION exfunc_validate_email(VARCHAR(255)) +RETURNS BOOLEAN +STABLE +LAMBDA 'lambda_email_validator' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function for data transformation +CREATE EXTERNAL FUNCTION exfunc_transform_data(SUPER) +RETURNS SUPER +VOLATILE +LAMBDA 'lambda_data_transformer' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +MAX_BATCH_SIZE 1024 KB; + +-- Function with TIMETZ type +CREATE EXTERNAL FUNCTION exfunc_time_processing(TIMETZ) +RETURNS TIME WITH TIME ZONE +STABLE +LAMBDA 'lambda_time_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function for machine learning predictions +CREATE OR REPLACE EXTERNAL FUNCTION exfunc_ml_predict( + REAL, + REAL, + REAL, + REAL +) +RETURNS REAL +STABLE +LAMBDA 'lambda_ml_model' +IAM_ROLE 'arn:aws:iam::123456789012:role/ML-Redshift-Role' +RETRY_TIMEOUT 45000 +MAX_BATCH_ROWS 10000; + +-- Function for text analysis +CREATE EXTERNAL FUNCTION exfunc_sentiment_analysis(TEXT) +RETURNS VARCHAR(20) +STABLE +LAMBDA 'lambda_sentiment_analyzer' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-NLP-Role' +MAX_BATCH_SIZE 256 KB; + +-- Function with CHAR type with length +CREATE EXTERNAL FUNCTION exfunc_char_processor(CHAR(10)) +RETURNS CHAR(20) +VOLATILE +LAMBDA 'lambda_char_processor' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function with various numeric types +CREATE EXTERNAL FUNCTION exfunc_numeric_operations( + NUMERIC(10,2), + DECIMAL(15,4), + INTEGER, + BIGINT, + SMALLINT +) +RETURNS NUMERIC(20,6) +STABLE +LAMBDA 'lambda_numeric_calculator' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; + +-- Function for API integration +CREATE EXTERNAL FUNCTION exfunc_api_call(VARCHAR(500), VARCHAR(100)) +RETURNS JSONB +VOLATILE +LAMBDA 'lambda_api_gateway' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-API-Role' +RETRY_TIMEOUT 30000 +MAX_BATCH_ROWS 50; + +-- Function with maximum batch size without unit (defaults to bytes) +CREATE EXTERNAL FUNCTION exfunc_default_size_unit(VARCHAR(1000)) +RETURNS TEXT +STABLE +LAMBDA 'lambda_text_analyzer' +IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test' +MAX_BATCH_SIZE 1048576; \ No newline at end of file diff --git a/redshift/examples/redshift/create_external_model.sql b/redshift/examples/redshift/create_external_model.sql new file mode 100644 index 0000000..873e431 --- /dev/null +++ b/redshift/examples/redshift/create_external_model.sql @@ -0,0 +1,337 @@ +-- CREATE EXTERNAL MODEL test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_create_external_model.html + +-- Basic CREATE EXTERNAL MODEL with minimal required settings +CREATE EXTERNAL MODEL customer_review_model +FUNCTION customer_review_llm +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0' +); + +-- CREATE EXTERNAL MODEL with DEFAULT IAM_ROLE +CREATE EXTERNAL MODEL sentiment_model +FUNCTION sentiment_analysis_llm +IAM_ROLE DEFAULT +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1' +); + +-- CREATE EXTERNAL MODEL with PROMPT setting +CREATE EXTERNAL MODEL product_description_model +FUNCTION generate_product_description +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + PROMPT 'Generate a compelling product description for the following item:' +); + +-- CREATE EXTERNAL MODEL with SUFFIX setting +CREATE EXTERNAL MODEL marketing_copy_model +FUNCTION create_marketing_copy +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + SUFFIX 'Please ensure the response is under 500 characters and includes a call to action.' +); + +-- CREATE EXTERNAL MODEL with REQUEST_TYPE RAW +CREATE EXTERNAL MODEL raw_text_model +FUNCTION process_raw_text +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + REQUEST_TYPE RAW +); + +-- CREATE EXTERNAL MODEL with REQUEST_TYPE UNIFIED +CREATE EXTERNAL MODEL unified_text_model +FUNCTION process_unified_text +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + REQUEST_TYPE UNIFIED +); + +-- CREATE EXTERNAL MODEL with RESPONSE_TYPE VARCHAR +CREATE EXTERNAL MODEL varchar_response_model +FUNCTION generate_varchar_response +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + RESPONSE_TYPE VARCHAR +); + +-- CREATE EXTERNAL MODEL with RESPONSE_TYPE SUPER +CREATE EXTERNAL MODEL super_response_model +FUNCTION generate_super_response +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL with all optional settings +CREATE EXTERNAL MODEL comprehensive_text_model +FUNCTION comprehensive_text_processor +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + PROMPT 'You are a helpful AI assistant analyzing customer feedback. Please provide insights on the following:', + SUFFIX 'Format your response as structured JSON with sentiment, key_themes, and recommendations fields.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for customer service automation +CREATE EXTERNAL MODEL customer_service_model +FUNCTION automate_customer_response +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + PROMPT 'You are a professional customer service representative. Respond to the following customer inquiry with empathy and provide helpful solutions:', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE VARCHAR +); + +-- CREATE EXTERNAL MODEL for data summarization +CREATE EXTERNAL MODEL data_summary_model +FUNCTION summarize_business_data +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + PROMPT 'Analyze the following business data and provide a concise executive summary:', + SUFFIX 'Include key metrics, trends, and actionable insights in your summary.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE VARCHAR +); + +-- CREATE EXTERNAL MODEL for content generation +CREATE EXTERNAL MODEL content_generator_model +FUNCTION generate_marketing_content +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + PROMPT 'Create engaging marketing content based on the provided product information:', + SUFFIX 'Ensure the content is optimized for social media engagement and includes relevant hashtags.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE VARCHAR +); + +-- CREATE EXTERNAL MODEL for code review assistance +CREATE EXTERNAL MODEL code_review_model +FUNCTION review_code_snippet +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + PROMPT 'Review the following code snippet and provide feedback on best practices, potential issues, and improvements:', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for translation services +CREATE EXTERNAL MODEL translation_model +FUNCTION translate_text +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + PROMPT 'Translate the following text accurately while preserving the original meaning and tone:', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE VARCHAR +); + +-- CREATE EXTERNAL MODEL for financial analysis +CREATE EXTERNAL MODEL financial_analysis_model +FUNCTION analyze_financial_data +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + PROMPT 'Analyze the following financial data and provide professional insights:', + SUFFIX 'Include risk assessment, performance indicators, and strategic recommendations.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for email automation +CREATE EXTERNAL MODEL email_automation_model +FUNCTION generate_automated_email +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + PROMPT 'Generate a professional email based on the provided context and recipient information:', + SUFFIX 'Ensure appropriate tone, clear call-to-action, and professional formatting.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE VARCHAR +); + +-- CREATE EXTERNAL MODEL for legal document analysis +CREATE EXTERNAL MODEL legal_analysis_model +FUNCTION analyze_legal_document +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + PROMPT 'Analyze the following legal document and extract key information:', + SUFFIX 'Highlight important clauses, potential risks, and compliance requirements.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for research assistance +CREATE EXTERNAL MODEL research_assistant_model +FUNCTION assist_with_research +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + PROMPT 'Provide comprehensive research assistance on the following topic:', + SUFFIX 'Include relevant sources, key findings, and actionable recommendations.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for healthcare data analysis +CREATE EXTERNAL MODEL healthcare_analysis_model +FUNCTION analyze_healthcare_data +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + PROMPT 'Analyze the following healthcare data while maintaining patient privacy:', + SUFFIX 'Provide insights on trends, patterns, and potential interventions.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for educational content creation +CREATE EXTERNAL MODEL educational_content_model +FUNCTION create_educational_content +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + PROMPT 'Create engaging educational content based on the provided learning objectives:', + SUFFIX 'Ensure content is age-appropriate, engaging, and includes interactive elements.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE VARCHAR +); + +-- CREATE EXTERNAL MODEL with Amazon Titan model +CREATE EXTERNAL MODEL titan_text_model +FUNCTION process_with_titan +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'amazon.titan-text-express-v1' +); + +-- CREATE EXTERNAL MODEL with Cohere model +CREATE EXTERNAL MODEL cohere_command_model +FUNCTION process_with_cohere +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'cohere.command-text-v14' +); + +-- CREATE EXTERNAL MODEL with AI21 Labs model +CREATE EXTERNAL MODEL ai21_jurassic_model +FUNCTION process_with_ai21 +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'ai21.j2-ultra-v1' +); + +-- CREATE EXTERNAL MODEL for complex prompt engineering +CREATE EXTERNAL MODEL advanced_prompt_model +FUNCTION advanced_text_processing +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + PROMPT 'You are an expert data analyst. Given the following structured data, please perform a comprehensive analysis following these steps: 1) Data quality assessment 2) Statistical summary 3) Pattern identification 4) Anomaly detection 5) Predictive insights. Data to analyze:', + SUFFIX 'Present your findings in a structured format with clear sections for each analysis step. Include confidence levels for your predictions and recommendations for data-driven decision making.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for multi-language support +CREATE EXTERNAL MODEL multilingual_model +FUNCTION process_multilingual_text +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + PROMPT 'Process the following text which may be in multiple languages. Detect the language(s) and provide appropriate analysis:', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for real-time recommendations +CREATE EXTERNAL MODEL recommendation_model +FUNCTION generate_recommendations +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + PROMPT 'Based on the provided user behavior and preferences data, generate personalized recommendations:', + SUFFIX 'Rank recommendations by relevance score and include explanations for each suggestion.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for sentiment analysis with detailed output +CREATE EXTERNAL MODEL detailed_sentiment_model +FUNCTION analyze_sentiment_detailed +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-sonnet-20240229-v1:0', + PROMPT 'Perform detailed sentiment analysis on the following text. Consider emotional tone, intent, urgency, and contextual factors:', + SUFFIX 'Provide sentiment score (-1 to 1), confidence level, key emotional indicators, and actionable insights.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for competitive analysis +CREATE EXTERNAL MODEL competitive_analysis_model +FUNCTION analyze_competition +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-3-haiku-20240307-v1:0', + PROMPT 'Analyze the following competitive landscape data and provide strategic insights:', + SUFFIX 'Include market positioning, competitive advantages, threats, and strategic recommendations.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); + +-- CREATE EXTERNAL MODEL for document classification +CREATE EXTERNAL MODEL document_classifier_model +FUNCTION classify_documents +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftBedrockRole' +MODEL_TYPE BEDROCK +SETTINGS ( + MODEL_ID 'anthropic.claude-v2:1', + PROMPT 'Classify the following document into appropriate categories and extract key metadata:', + SUFFIX 'Provide classification confidence, document type, key entities, and suggested filing category.', + REQUEST_TYPE UNIFIED, + RESPONSE_TYPE SUPER +); \ No newline at end of file diff --git a/redshift/examples/redshift/create_external_schema.sql b/redshift/examples/redshift/create_external_schema.sql new file mode 100644 index 0000000..7454550 --- /dev/null +++ b/redshift/examples/redshift/create_external_schema.sql @@ -0,0 +1,302 @@ +-- CREATE EXTERNAL SCHEMA test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html + +-- Basic Data Catalog external schema +CREATE EXTERNAL SCHEMA spectrum +FROM DATA CATALOG +DATABASE 'spectrumdb' +REGION 'us-west-2' +IAM_ROLE 'arn:aws:iam::123456789012:role/MySpectrumRole'; + +-- Data Catalog with IF NOT EXISTS +CREATE EXTERNAL SCHEMA IF NOT EXISTS spectrum_catalog +FROM DATA CATALOG +DATABASE 'my_glue_database' +REGION 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole'; + +-- Data Catalog with DEFAULT IAM_ROLE +CREATE EXTERNAL SCHEMA default_role_schema +FROM DATA CATALOG +DATABASE 'analytics_db' +REGION 'eu-west-1' +IAM_ROLE DEFAULT; + +-- Data Catalog with SESSION IAM_ROLE +CREATE EXTERNAL SCHEMA session_role_schema +FROM DATA CATALOG +DATABASE 'session_db' +REGION 'us-west-1' +IAM_ROLE 'SESSION'; + +-- Data Catalog with CATALOG_ROLE using SESSION +CREATE EXTERNAL SCHEMA catalog_session_schema +FROM DATA CATALOG +DATABASE 'shared_catalog_db' +REGION 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole' +CATALOG_ROLE 'SESSION'; + +-- Data Catalog with CATALOG_ROLE using ARN +CREATE EXTERNAL SCHEMA catalog_arn_schema +FROM DATA CATALOG +DATABASE 'cross_account_db' +REGION 'us-west-2' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole' +CATALOG_ROLE 'arn:aws:iam::987654321098:role/CrossAccountCatalogRole'; + +-- Data Catalog with CREATE EXTERNAL DATABASE +CREATE EXTERNAL SCHEMA auto_create_db_schema +FROM DATA CATALOG +DATABASE 'new_external_db' +REGION 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole' +CREATE EXTERNAL DATABASE IF NOT EXISTS; + +-- Data Catalog with CATALOG_ID for cross-account +CREATE EXTERNAL SCHEMA cross_account_schema +FROM DATA CATALOG +DATABASE 'cross_account_database' +REGION 'us-west-2' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole' +CATALOG_ID '987654321098'; + +-- Data Catalog with all optional parameters +CREATE EXTERNAL SCHEMA comprehensive_catalog_schema +FROM DATA CATALOG +DATABASE 'comprehensive_db' +REGION 'eu-central-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole' +CATALOG_ROLE 'arn:aws:iam::123456789012:role/CatalogAccessRole' +CREATE EXTERNAL DATABASE IF NOT EXISTS +CATALOG_ID '123456789012'; + +-- Hive Metastore external schema +CREATE EXTERNAL SCHEMA hive_schema +FROM HIVE METASTORE +DATABASE 'hive_db' +URI 'thrift://myserver:9083' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole'; + +-- Hive Metastore with custom port +CREATE EXTERNAL SCHEMA hive_custom_port_schema +FROM HIVE METASTORE +DATABASE 'production_hive_db' +URI 'thrift://hive-metastore.company.com' +PORT 9084 +IAM_ROLE 'arn:aws:iam::123456789012:role/HiveAccessRole'; + +-- PostgreSQL federated query schema +CREATE EXTERNAL SCHEMA postgres_federated +FROM POSTGRES +DATABASE 'postgres_production' +URI 'postgres-cluster.cluster-xyz.us-east-1.rds.amazonaws.com' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftFederatedRole' +SECRET_ARN 'arn:aws:secretsmanager:us-east-1:123456789012:secret:postgres-credentials-AbCdEf'; + +-- PostgreSQL with custom port and schema +CREATE EXTERNAL SCHEMA postgres_custom_schema +FROM POSTGRES +DATABASE 'analytics_db' +SCHEMA 'public' +URI 'postgres-server.company.com' +PORT 5433 +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftFederatedRole' +SECRET_ARN 'arn:aws:secretsmanager:us-east-1:123456789012:secret:postgres-analytics-XyZaBc'; + +-- PostgreSQL with DEFAULT IAM_ROLE +CREATE EXTERNAL SCHEMA postgres_default_role +FROM POSTGRES +DATABASE 'reporting_db' +URI 'postgres.internal.company.com' +IAM_ROLE DEFAULT +SECRET_ARN 'arn:aws:secretsmanager:us-east-1:123456789012:secret:postgres-reporting-123456'; + +-- MySQL federated query schema +CREATE EXTERNAL SCHEMA mysql_federated +FROM MYSQL +DATABASE 'mysql_production' +URI 'mysql-cluster.cluster-abc.us-west-2.rds.amazonaws.com' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftFederatedRole' +SECRET_ARN 'arn:aws:secretsmanager:us-west-2:123456789012:secret:mysql-credentials-DefGhi'; + +-- MySQL with custom port +CREATE EXTERNAL SCHEMA mysql_custom_port +FROM MYSQL +DATABASE 'legacy_mysql_db' +URI 'mysql-legacy.company.com' +PORT 3307 +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftFederatedRole' +SECRET_ARN 'arn:aws:secretsmanager:us-west-2:123456789012:secret:mysql-legacy-789012'; + +-- Kinesis streaming schema +CREATE EXTERNAL SCHEMA kinesis_stream_schema +FROM KINESIS +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftKinesisRole'; + +-- Kinesis with DEFAULT IAM_ROLE +CREATE EXTERNAL SCHEMA kinesis_default_role +FROM KINESIS +IAM_ROLE DEFAULT; + +-- Kafka streaming schema with URI +CREATE EXTERNAL SCHEMA kafka_stream_schema +FROM KAFKA +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftKafkaRole' +URI 'kafka-broker1:9092,kafka-broker2:9092,kafka-broker3:9092'; + +-- Kafka with authentication none +CREATE EXTERNAL SCHEMA kafka_no_auth +FROM KAFKA +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftKafkaRole' +URI 'kafka-cluster.company.com:9092' +AUTHENTICATION NONE; + +-- Kafka with IAM authentication +CREATE EXTERNAL SCHEMA kafka_iam_auth +FROM KAFKA +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftKafkaRole' +URI 'kafka-secure.company.com:9093' +AUTHENTICATION IAM; + +-- Kafka with mTLS authentication +CREATE EXTERNAL SCHEMA kafka_mtls_auth +FROM KAFKA +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftKafkaRole' +URI 'kafka-mtls.company.com:9094' +AUTHENTICATION MTLS +AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012'; + +-- MSK (Managed Streaming for Kafka) schema +CREATE EXTERNAL SCHEMA msk_stream_schema +FROM MSK +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftMSKRole' +URI 'b-1.msk-cluster.abc123.c2.kafka.us-east-1.amazonaws.com:9092'; + +-- MSK with IAM authentication +CREATE EXTERNAL SCHEMA msk_iam_auth +FROM MSK +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftMSKRole' +URI 'b-1.secure-msk.def456.c2.kafka.us-west-2.amazonaws.com:9098' +AUTHENTICATION IAM; + +-- MSK with mTLS authentication +CREATE EXTERNAL SCHEMA msk_mtls_auth +FROM MSK +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftMSKRole' +URI 'b-1.mtls-msk.ghi789.c2.kafka.eu-west-1.amazonaws.com:9094' +AUTHENTICATION MTLS +AUTHENTICATION_ARN 'arn:aws:acm:eu-west-1:123456789012:certificate/87654321-4321-4321-4321-210987654321'; + +-- Cross-database query schema (Redshift to Redshift) +CREATE EXTERNAL SCHEMA cross_db_schema +FROM REDSHIFT +DATABASE 'prod_analytics' +SCHEMA 'reporting'; + +-- Cross-database without explicit schema +CREATE EXTERNAL SCHEMA cross_db_no_schema +FROM REDSHIFT +DATABASE 'data_warehouse'; + +-- Data Catalog without explicit "DATA CATALOG" keywords +CREATE EXTERNAL SCHEMA implicit_catalog +FROM +DATABASE 'implicit_db' +REGION 'ap-southeast-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftSpectrumRole'; + +-- Complex schema names with underscores +CREATE EXTERNAL SCHEMA data_lake_analytics_schema +FROM DATA CATALOG +DATABASE 'data_lake_db' +REGION 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/DataLakeAccessRole'; + +-- Schema for IoT data from Kinesis +CREATE EXTERNAL SCHEMA iot_telemetry_schema +FROM KINESIS +IAM_ROLE 'arn:aws:iam::123456789012:role/IoTDataProcessingRole'; + +-- Schema for real-time analytics with Kafka +CREATE EXTERNAL SCHEMA realtime_analytics +FROM KAFKA +IAM_ROLE 'arn:aws:iam::123456789012:role/RealtimeAnalyticsRole' +URI 'kafka1.analytics.com:9092,kafka2.analytics.com:9092' +AUTHENTICATION IAM; + +-- Multi-tenant schema with catalog role +CREATE EXTERNAL SCHEMA tenant_a_schema +FROM DATA CATALOG +DATABASE 'tenant_a_data' +REGION 'us-west-2' +IAM_ROLE 'arn:aws:iam::123456789012:role/MultiTenantRole' +CATALOG_ROLE 'arn:aws:iam::111111111111:role/TenantACatalogRole'; + +-- Development environment schema +CREATE EXTERNAL SCHEMA IF NOT EXISTS dev_spectrum +FROM DATA CATALOG +DATABASE 'development_db' +REGION 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/DevEnvironmentRole' +CREATE EXTERNAL DATABASE IF NOT EXISTS; + +-- Production PostgreSQL mirror +CREATE EXTERNAL SCHEMA prod_postgres_mirror +FROM POSTGRES +DATABASE 'production_mirror' +SCHEMA 'analytics' +URI 'readonly-postgres.prod.company.com' +PORT 5432 +IAM_ROLE 'arn:aws:iam::123456789012:role/ProductionReadOnlyRole' +SECRET_ARN 'arn:aws:secretsmanager:us-east-1:123456789012:secret:prod-postgres-readonly-AbCdEf'; + +-- Legacy MySQL integration +CREATE EXTERNAL SCHEMA legacy_mysql_integration +FROM MYSQL +DATABASE 'legacy_erp_system' +URI 'mysql-legacy.internal.company.com' +PORT 3306 +IAM_ROLE 'arn:aws:iam::123456789012:role/LegacySystemIntegrationRole' +SECRET_ARN 'arn:aws:secretsmanager:us-east-1:123456789012:secret:legacy-mysql-credentials-XyZ123'; + +-- Hive data lake integration +CREATE EXTERNAL SCHEMA hive_data_lake +FROM HIVE METASTORE +DATABASE 'enterprise_data_lake' +URI 'thrift://hive-metastore.datalake.company.com:9083' +IAM_ROLE 'arn:aws:iam::123456789012:role/DataLakeHiveRole'; + +-- Cross-region data access +CREATE EXTERNAL SCHEMA cross_region_data +FROM DATA CATALOG +DATABASE 'cross_region_analytics' +REGION 'eu-central-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/CrossRegionAccessRole' +CATALOG_ID '987654321098'; + +-- Streaming schema for log analysis +CREATE EXTERNAL SCHEMA log_analysis_stream +FROM KINESIS +IAM_ROLE 'arn:aws:iam::123456789012:role/LogAnalysisRole'; + +-- High-security Kafka with mTLS +CREATE EXTERNAL SCHEMA secure_kafka_feed +FROM KAFKA +IAM_ROLE 'arn:aws:iam::123456789012:role/SecureDataFeedRole' +URI 'secure-kafka.compliance.company.com:9094' +AUTHENTICATION MTLS +AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:123456789012:certificate/security-cert-123456'; + +-- MSK for financial data +CREATE EXTERNAL SCHEMA financial_data_msk +FROM MSK +IAM_ROLE 'arn:aws:iam::123456789012:role/FinancialDataRole' +URI 'b-1.financial-msk.xyz789.c2.kafka.us-east-1.amazonaws.com:9098' +AUTHENTICATION IAM; + +-- Simple cross-database query for reporting +CREATE EXTERNAL SCHEMA reporting_cross_db +FROM REDSHIFT +DATABASE 'reporting_warehouse' +SCHEMA 'public'; \ No newline at end of file diff --git a/redshift/examples/redshift/create_external_table.sql b/redshift/examples/redshift/create_external_table.sql new file mode 100644 index 0000000..a3315c7 --- /dev/null +++ b/redshift/examples/redshift/create_external_table.sql @@ -0,0 +1,197 @@ +-- CREATE EXTERNAL TABLE test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_TABLE.html + +-- Basic external table with PARQUET format +CREATE EXTERNAL TABLE spectrum.sales ( + salesid INTEGER, + listid INTEGER, + sellerid INTEGER, + buyerid INTEGER, + eventid INTEGER, + dateid SMALLINT, + qtysold SMALLINT, + pricepaid DECIMAL(8,2), + commission DECIMAL(8,2), + saletime TIMESTAMP +) +STORED AS PARQUET +LOCATION 's3://awssampledbuswest2/tickit/sales/'; + +-- External table with IF NOT EXISTS +CREATE EXTERNAL TABLE IF NOT EXISTS spectrum.events ( + eventid INTEGER, + venueid SMALLINT, + catid SMALLINT, + dateid SMALLINT, + eventname VARCHAR(200), + starttime TIMESTAMP +) +STORED AS TEXTFILE +LOCATION 's3://mybucket/event_data/'; + +-- External table with partitioning +CREATE EXTERNAL TABLE spectrum.sales_part ( + salesid INTEGER, + listid INTEGER, + sellerid INTEGER, + buyerid INTEGER, + eventid INTEGER, + qtysold SMALLINT, + pricepaid DECIMAL(8,2), + commission DECIMAL(8,2), + saletime TIMESTAMP +) +PARTITIONED BY ( + saledate DATE, + region VARCHAR(10) +) +STORED AS PARQUET +LOCATION 's3://mybucket/sales_partitioned/'; + +-- External table with ROW FORMAT DELIMITED +CREATE EXTERNAL TABLE spectrum.csv_table ( + id INT, + name VARCHAR(100), + age INT, + city VARCHAR(50) +) +ROW FORMAT DELIMITED +FIELDS TERMINATED BY ',' +LINES TERMINATED BY '\n' +NULL DEFINED AS 'NULL' +STORED AS TEXTFILE +LOCATION 's3://mybucket/csv_data/'; + +-- External table with custom SERDE +CREATE EXTERNAL TABLE spectrum.json_table ( + docid BIGINT, + username VARCHAR(50), + posted TIMESTAMP, + message VARCHAR(500) +) +ROW FORMAT SERDE 'org.apache.hive.serde2.lazy.LazySimpleSerDe' +WITH SERDEPROPERTIES ( + 'field.delim' = '\t', + 'serialization.null.format' = '' +) +STORED AS TEXTFILE +LOCATION 's3://mybucket/json_data/'; + +-- External table with ORC format and table properties +CREATE EXTERNAL TABLE spectrum.orc_table ( + col1 INTEGER, + col2 VARCHAR(100), + col3 BOOLEAN, + col4 DOUBLE PRECISION +) +STORED AS ORC +LOCATION 's3://mybucket/orc_data/' +TABLE PROPERTIES ( + 'compression_type' = 'snappy', + 'orc.compress' = 'SNAPPY' +); + +-- External table with AVRO format +CREATE EXTERNAL TABLE spectrum.avro_table ( + id BIGINT, + email VARCHAR(255), + ts TIMESTAMP +) +STORED AS AVRO +LOCATION 's3://mybucket/avro_data/' +TABLE PROPERTIES ( + 'avro.schema.url' = 's3://mybucket/schemas/user.avsc' +); + +-- External table with RCFILE format +CREATE EXTERNAL TABLE spectrum.rcfile_table ( + key STRING, + value STRING +) +STORED AS RCFILE +LOCATION 's3://mybucket/rcfile_data/'; + +-- External table with SEQUENCEFILE format +CREATE EXTERNAL TABLE spectrum.seqfile_table ( + user_id BIGINT, + activity VARCHAR(100), + timestamp TIMESTAMP +) +STORED AS SEQUENCEFILE +LOCATION 's3://mybucket/sequence_data/'; + +-- External table with custom input/output formats +CREATE EXTERNAL TABLE spectrum.custom_format_table ( + data VARCHAR(MAX) +) +STORED AS INPUTFORMAT 'com.example.CustomInputFormat' +OUTPUTFORMAT 'com.example.CustomOutputFormat' +LOCATION 's3://mybucket/custom_data/'; + +-- External table with comprehensive table properties +CREATE EXTERNAL TABLE spectrum.data_table ( + id INTEGER, + data VARCHAR(500), + created_date DATE +) +PARTITIONED BY (year INT, month INT) +STORED AS PARQUET +LOCATION 's3://mybucket/data/' +TABLE PROPERTIES ( + 'compression_type' = 'gzip', + 'data_cleansing_enabled' = 'true', + 'invalid_char_handling' = 'REPLACE', + 'replacement_char' = '?', + 'numeric_overflow_handling' = 'SET_TO_NULL', + 'write.parallel' = 'on', + 'write.maxfilesize.mb' = '100' +); + +-- External table using manifest file +CREATE EXTERNAL TABLE spectrum.sales_manifest ( + salesid INTEGER, + listid INTEGER, + sellerid INTEGER, + buyerid INTEGER +) +STORED AS PARQUET +LOCATION 's3://mybucket/sales_manifest.json'; + +-- External table with complex data types +CREATE EXTERNAL TABLE spectrum.complex_types ( + id INTEGER, + name VARCHAR(100), + address SUPER, + phone_numbers SUPER, + metadata SUPER +) +STORED AS PARQUET +LOCATION 's3://mybucket/complex_data/'; + +-- External table with escaped delimiters +CREATE EXTERNAL TABLE spectrum.escaped_data ( + col1 VARCHAR(100), + col2 VARCHAR(100), + col3 VARCHAR(100) +) +ROW FORMAT DELIMITED +FIELDS TERMINATED BY '|' ESCAPED BY '\\' +LINES TERMINATED BY '\n' +STORED AS TEXTFILE +LOCATION 's3://mybucket/escaped_data/'; + +-- External table with all ROW FORMAT DELIMITED options +CREATE EXTERNAL TABLE spectrum.full_delimited ( + id INT, + data VARCHAR(1000), + tags SUPER, + properties SUPER +) +ROW FORMAT DELIMITED +FIELDS TERMINATED BY '\001' +COLLECTION ITEMS TERMINATED BY '\002' +MAP KEYS TERMINATED BY '\003' +LINES TERMINATED BY '\n' +NULL DEFINED AS '\\N' +STORED AS TEXTFILE +LOCATION 's3://mybucket/full_delimited_data/'; \ No newline at end of file diff --git a/redshift/examples/redshift/create_external_view.sql b/redshift/examples/redshift/create_external_view.sql new file mode 100644 index 0000000..96de5b1 --- /dev/null +++ b/redshift/examples/redshift/create_external_view.sql @@ -0,0 +1,343 @@ +-- CREATE EXTERNAL VIEW test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_VIEW.html + +-- Basic external view creation +CREATE EXTERNAL VIEW sample_schema.glue_data_catalog_view +AS SELECT * FROM sample_database.remote_table; + +-- External view with IF NOT EXISTS +CREATE EXTERNAL VIEW sample_schema.conditional_view +IF NOT EXISTS +AS SELECT * FROM sample_database.remote_table; + +-- Protected external view (from AWS documentation example) +CREATE EXTERNAL PROTECTED VIEW sample_schema.glue_data_catalog_view +IF NOT EXISTS +AS SELECT * FROM sample_database.remote_table; + +-- External view with quoted table name (handling special characters) +CREATE EXTERNAL PROTECTED VIEW sample_schema.special_table_view +IF NOT EXISTS +AS SELECT * FROM sample_database."remote-table-name"; + +-- External view with awsdatacatalog prefix +CREATE EXTERNAL VIEW awsdatacatalog.analytics_db.customer_view +AS SELECT customer_id, customer_name, email FROM customer_data.customers; + +-- External view with catalog_name.schema_name.view_name format +CREATE EXTERNAL VIEW my_catalog.analytics_schema.sales_view +AS SELECT * FROM sales_data.transactions; + +-- External view with complex SELECT statement +CREATE EXTERNAL VIEW spectrum_schema.aggregated_sales_view +AS SELECT + region, + product_category, + SUM(sales_amount) as total_sales, + COUNT(*) as transaction_count, + AVG(sales_amount) as avg_sale_amount +FROM sales_data.transactions +WHERE sale_date >= '2023-01-01' +GROUP BY region, product_category +HAVING SUM(sales_amount) > 1000 +ORDER BY total_sales DESC; + +-- External view with JOIN operations +CREATE EXTERNAL VIEW analytics_schema.customer_orders_view +AS SELECT + c.customer_id, + c.customer_name, + c.email, + o.order_id, + o.order_date, + o.total_amount +FROM customer_data.customers c +JOIN order_data.orders o ON c.customer_id = o.customer_id; + +-- External view with multiple JOINs +CREATE EXTERNAL VIEW reporting_schema.detailed_order_view +AS SELECT + c.customer_name, + o.order_id, + o.order_date, + p.product_name, + oi.quantity, + oi.unit_price, + (oi.quantity * oi.unit_price) as line_total +FROM customer_data.customers c +JOIN order_data.orders o ON c.customer_id = o.customer_id +JOIN order_data.order_items oi ON o.order_id = oi.order_id +JOIN product_data.products p ON oi.product_id = p.product_id; + +-- External view with subquery +CREATE EXTERNAL VIEW analytics_schema.high_value_customers_view +AS SELECT + customer_id, + customer_name, + email, + total_orders, + total_spent +FROM ( + SELECT + c.customer_id, + c.customer_name, + c.email, + COUNT(o.order_id) as total_orders, + SUM(o.total_amount) as total_spent + FROM customer_data.customers c + LEFT JOIN order_data.orders o ON c.customer_id = o.customer_id + GROUP BY c.customer_id, c.customer_name, c.email +) customer_stats +WHERE total_spent > 5000; + +-- External view with CASE statements +CREATE EXTERNAL VIEW analytics_schema.customer_segmentation_view +AS SELECT + customer_id, + customer_name, + total_spent, + CASE + WHEN total_spent >= 10000 THEN 'Premium' + WHEN total_spent >= 5000 THEN 'Gold' + WHEN total_spent >= 1000 THEN 'Silver' + ELSE 'Bronze' + END as customer_tier +FROM ( + SELECT + c.customer_id, + c.customer_name, + COALESCE(SUM(o.total_amount), 0) as total_spent + FROM customer_data.customers c + LEFT JOIN order_data.orders o ON c.customer_id = o.customer_id + GROUP BY c.customer_id, c.customer_name +); + +-- External view with window functions +CREATE EXTERNAL VIEW analytics_schema.sales_ranking_view +AS SELECT + employee_id, + employee_name, + department, + sales_amount, + RANK() OVER (PARTITION BY department ORDER BY sales_amount DESC) as dept_rank, + ROW_NUMBER() OVER (ORDER BY sales_amount DESC) as overall_rank +FROM sales_data.employee_sales; + +-- External view with date functions +CREATE EXTERNAL VIEW reporting_schema.monthly_sales_view +AS SELECT + EXTRACT(YEAR FROM order_date) as sales_year, + EXTRACT(MONTH FROM order_date) as sales_month, + COUNT(*) as order_count, + SUM(total_amount) as monthly_revenue +FROM order_data.orders +GROUP BY EXTRACT(YEAR FROM order_date), EXTRACT(MONTH FROM order_date) +ORDER BY sales_year, sales_month; + +-- External view with string functions +CREATE EXTERNAL VIEW analytics_schema.customer_contact_view +AS SELECT + customer_id, + UPPER(customer_name) as customer_name_upper, + LOWER(email) as email_lower, + SUBSTRING(phone_number, 1, 3) as area_code, + LENGTH(customer_name) as name_length +FROM customer_data.customers +WHERE email IS NOT NULL; + +-- External view with UNION +CREATE EXTERNAL VIEW reporting_schema.all_transactions_view +AS SELECT + 'ONLINE' as channel, + transaction_id, + customer_id, + amount, + transaction_date +FROM online_sales.transactions +UNION ALL +SELECT + 'RETAIL' as channel, + transaction_id, + customer_id, + amount, + transaction_date +FROM retail_sales.transactions; + +-- External view with EXISTS clause +CREATE EXTERNAL VIEW analytics_schema.customers_with_orders_view +AS SELECT + customer_id, + customer_name, + email, + registration_date +FROM customer_data.customers c +WHERE EXISTS ( + SELECT 1 + FROM order_data.orders o + WHERE o.customer_id = c.customer_id +); + +-- External view with NOT EXISTS clause +CREATE EXTERNAL VIEW analytics_schema.customers_without_orders_view +AS SELECT + customer_id, + customer_name, + email, + registration_date +FROM customer_data.customers c +WHERE NOT EXISTS ( + SELECT 1 + FROM order_data.orders o + WHERE o.customer_id = c.customer_id +); + +-- External view with IN clause +CREATE EXTERNAL VIEW analytics_schema.premium_product_sales_view +AS SELECT + order_id, + product_id, + quantity, + unit_price, + (quantity * unit_price) as line_total +FROM order_data.order_items +WHERE product_id IN ('PROD001', 'PROD002', 'PROD003'); + +-- External view with BETWEEN clause +CREATE EXTERNAL VIEW reporting_schema.recent_orders_view +AS SELECT + order_id, + customer_id, + order_date, + total_amount, + status +FROM order_data.orders +WHERE order_date BETWEEN '2023-01-01' AND '2023-12-31'; + +-- External view with LIKE pattern matching +CREATE EXTERNAL VIEW analytics_schema.tech_customers_view +AS SELECT + customer_id, + customer_name, + email, + company_name +FROM customer_data.customers +WHERE company_name LIKE '%Tech%' OR company_name LIKE '%Software%'; + +-- External view with NULL handling +CREATE EXTERNAL VIEW analytics_schema.complete_customer_profiles_view +AS SELECT + customer_id, + customer_name, + COALESCE(email, 'No Email') as email_status, + COALESCE(phone_number, 'No Phone') as phone_status, + CASE + WHEN email IS NOT NULL AND phone_number IS NOT NULL THEN 'Complete' + WHEN email IS NOT NULL OR phone_number IS NOT NULL THEN 'Partial' + ELSE 'Incomplete' + END as profile_completeness +FROM customer_data.customers; + +-- External view with mathematical operations +CREATE EXTERNAL VIEW analytics_schema.order_metrics_view +AS SELECT + order_id, + customer_id, + subtotal, + tax_rate, + (subtotal * tax_rate / 100) as tax_amount, + (subtotal + (subtotal * tax_rate / 100)) as total_amount, + ROUND((subtotal * tax_rate / 100), 2) as rounded_tax +FROM order_data.orders +WHERE subtotal > 0; + +-- External view with complex aggregations +CREATE EXTERNAL VIEW reporting_schema.product_performance_view +AS SELECT + p.product_id, + p.product_name, + p.category, + COUNT(oi.order_item_id) as times_ordered, + SUM(oi.quantity) as total_quantity_sold, + AVG(oi.unit_price) as avg_selling_price, + MIN(oi.unit_price) as min_selling_price, + MAX(oi.unit_price) as max_selling_price, + SUM(oi.quantity * oi.unit_price) as total_revenue +FROM product_data.products p +LEFT JOIN order_data.order_items oi ON p.product_id = oi.product_id +GROUP BY p.product_id, p.product_name, p.category +ORDER BY total_revenue DESC; + +-- External view with different schema naming patterns +CREATE EXTERNAL VIEW external_analytics.regional_sales_summary +AS SELECT + region, + COUNT(*) as total_orders, + SUM(total_amount) as total_revenue +FROM sales_data.regional_orders +GROUP BY region; + +-- External view with underscored naming +CREATE EXTERNAL VIEW data_warehouse.customer_lifetime_value +AS SELECT + customer_id, + first_order_date, + last_order_date, + total_orders, + total_spent, + (total_spent / total_orders) as avg_order_value +FROM customer_analytics.customer_summary; + +-- External view with mixed case naming +CREATE EXTERNAL VIEW DataLake.CustomerAnalytics +AS SELECT + CustomerId as customer_id, + CustomerName as customer_name, + TotalPurchases as total_purchases +FROM ExternalData.Customers; + +-- Protected view with complex query +CREATE EXTERNAL PROTECTED VIEW secure_analytics.financial_summary +AS SELECT + fiscal_year, + quarter, + revenue, + expenses, + (revenue - expenses) as profit, + CASE + WHEN (revenue - expenses) > 0 THEN 'Profitable' + ELSE 'Loss' + END as profit_status +FROM financial_data.quarterly_results +WHERE fiscal_year >= 2020; + +-- External view with IF NOT EXISTS and complex naming +CREATE EXTERNAL VIEW cross_platform.unified_customer_data +IF NOT EXISTS +AS SELECT + mobile_app.user_id as customer_id, + mobile_app.app_usage_hours, + web_platform.page_views, + retail_pos.in_store_purchases +FROM mobile_data.app_usage mobile_app +FULL OUTER JOIN web_data.user_activity web_platform + ON mobile_app.user_id = web_platform.user_id +FULL OUTER JOIN retail_data.pos_transactions retail_pos + ON mobile_app.user_id = retail_pos.customer_id; + +-- Simple view for testing basic functionality +CREATE EXTERNAL VIEW simple_view +AS SELECT id, name FROM basic_table; + +-- View with fully qualified external schema reference +CREATE EXTERNAL VIEW spectrum_database.public.inventory_status +AS SELECT + product_id, + warehouse_location, + quantity_on_hand, + reorder_level, + CASE + WHEN quantity_on_hand <= reorder_level THEN 'REORDER' + WHEN quantity_on_hand <= (reorder_level * 1.5) THEN 'LOW' + ELSE 'NORMAL' + END as stock_status +FROM inventory_data.warehouse_stock; \ No newline at end of file diff --git a/redshift/examples/redshift/create_function.sql b/redshift/examples/redshift/create_function.sql new file mode 100644 index 0000000..93b492e --- /dev/null +++ b/redshift/examples/redshift/create_function.sql @@ -0,0 +1,263 @@ +-- CREATE FUNCTION test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_FUNCTION.html + +-- Basic Python UDF examples + +-- Python UDF with STABLE volatility (recommended prefix 'f_') +CREATE FUNCTION f_py_greater (a float, b float) +RETURNS float STABLE AS $$ + if a > b: + return a + return b +$$ LANGUAGE plpythonu; + +-- Python UDF with multiple parameter types +CREATE FUNCTION f_py_calculator (x integer, y integer, operation varchar) +RETURNS integer VOLATILE AS $$ + if operation == 'add': + return x + y + elif operation == 'subtract': + return x - y + elif operation == 'multiply': + return x * y + elif operation == 'divide': + if y != 0: + return x // y + else: + return None + return 0 +$$ LANGUAGE plpythonu; + +-- Python UDF with IMMUTABLE volatility +CREATE FUNCTION f_py_square (num float) +RETURNS float IMMUTABLE AS $$ + return num * num +$$ LANGUAGE plpythonu; + +-- Python UDF with boolean return +CREATE FUNCTION f_py_is_even (num integer) +RETURNS boolean STABLE AS $$ + return num % 2 == 0 +$$ LANGUAGE plpythonu; + +-- Python UDF with string manipulation +CREATE FUNCTION f_py_clean_string (input_str varchar) +RETURNS varchar STABLE AS $$ + if input_str is None: + return '' + return input_str.strip().lower() +$$ LANGUAGE plpythonu; + +-- Python UDF with date handling +CREATE FUNCTION f_py_days_between (start_date date, end_date date) +RETURNS integer STABLE AS $$ + if start_date is None or end_date is None: + return None + diff = end_date - start_date + return diff.days +$$ LANGUAGE plpythonu; + +-- Basic SQL UDF examples + +-- SQL UDF with STABLE volatility +CREATE FUNCTION f_sql_greater (float, float) +RETURNS float STABLE AS $$ + SELECT CASE WHEN $1 > $2 THEN $1 ELSE $2 END +$$ LANGUAGE sql; + +-- SQL UDF with multiple parameters +CREATE FUNCTION f_sql_discount_price (original_price decimal, discount_percent decimal) +RETURNS decimal STABLE AS $$ + SELECT $1 * (1 - $2 / 100) +$$ LANGUAGE sql; + +-- SQL UDF with IMMUTABLE volatility +CREATE FUNCTION f_sql_circle_area (radius float) +RETURNS float IMMUTABLE AS $$ + SELECT 3.14159 * $1 * $1 +$$ LANGUAGE sql; + +-- SQL UDF with string operations +CREATE FUNCTION f_sql_full_name (first_name varchar, last_name varchar) +RETURNS varchar STABLE AS $$ + SELECT $1 || ' ' || $2 +$$ LANGUAGE sql; + +-- SQL UDF with conditional logic +CREATE FUNCTION f_sql_grade_letter (score integer) +RETURNS varchar STABLE AS $$ + SELECT CASE + WHEN $1 >= 90 THEN 'A' + WHEN $1 >= 80 THEN 'B' + WHEN $1 >= 70 THEN 'C' + WHEN $1 >= 60 THEN 'D' + ELSE 'F' + END +$$ LANGUAGE sql; + +-- OR REPLACE examples + +-- Replace existing function +CREATE OR REPLACE FUNCTION f_py_greater (a float, b float) +RETURNS float STABLE AS $$ + # Updated version with null handling + if a is None and b is None: + return None + elif a is None: + return b + elif b is None: + return a + else: + return a if a > b else b +$$ LANGUAGE plpythonu; + +-- Replace SQL function +CREATE OR REPLACE FUNCTION f_sql_greater (float, float) +RETURNS float STABLE AS $$ + SELECT CASE + WHEN $1 IS NULL AND $2 IS NULL THEN NULL + WHEN $1 IS NULL THEN $2 + WHEN $2 IS NULL THEN $1 + WHEN $1 > $2 THEN $1 + ELSE $2 + END +$$ LANGUAGE sql; + +-- Advanced data type examples + +-- Function with DECIMAL parameters +CREATE FUNCTION f_sql_compound_interest (principal decimal(10,2), rate decimal(5,4), years integer) +RETURNS decimal(10,2) STABLE AS $$ + SELECT $1 * POWER(1 + $2, $3) +$$ LANGUAGE sql; + +-- Function with TIMESTAMP parameters +CREATE FUNCTION f_sql_business_days (start_ts timestamp, end_ts timestamp) +RETURNS integer STABLE AS $$ + SELECT CASE + WHEN $1 IS NULL OR $2 IS NULL THEN NULL + ELSE DATEDIFF(day, $1, $2) + END +$$ LANGUAGE sql; + +-- Function with VARCHAR with length +CREATE FUNCTION f_sql_format_phone (phone varchar(15)) +RETURNS varchar(20) STABLE AS $$ + SELECT '(' || SUBSTRING($1, 1, 3) || ') ' || + SUBSTRING($1, 4, 3) || '-' || + SUBSTRING($1, 7, 4) +$$ LANGUAGE sql; + +-- Function with CHAR parameters +CREATE FUNCTION f_sql_initial (first_name char(50)) +RETURNS char(1) STABLE AS $$ + SELECT LEFT(TRIM($1), 1) +$$ LANGUAGE sql; + +-- Complex Python UDF examples + +-- Python UDF with JSON-like string manipulation +CREATE FUNCTION f_py_extract_json_field (json_str varchar, field_name varchar) +RETURNS varchar VOLATILE AS $$ + import json + try: + data = json.loads(json_str) + return str(data.get(field_name, '')) + except: + return '' +$$ LANGUAGE plpythonu; + +-- Python UDF with mathematical operations +CREATE FUNCTION f_py_fibonacci (n integer) +RETURNS bigint STABLE AS $$ + if n <= 0: + return 0 + elif n == 1: + return 1 + else: + a, b = 0, 1 + for i in range(2, n + 1): + a, b = b, a + b + return b +$$ LANGUAGE plpythonu; + +-- Python UDF with array-like operations +CREATE FUNCTION f_py_word_count (text_input varchar) +RETURNS integer STABLE AS $$ + if text_input is None: + return 0 + words = text_input.split() + return len(words) +$$ LANGUAGE plpythonu; + +-- Edge cases and special scenarios + +-- Function with no parameters +CREATE FUNCTION f_sql_current_year () +RETURNS integer STABLE AS $$ + SELECT EXTRACT(year FROM GETDATE()) +$$ LANGUAGE sql; + +-- Function with ANYELEMENT type (generic) +CREATE FUNCTION f_sql_first_non_null (anyelement, anyelement) +RETURNS anyelement STABLE AS $$ + SELECT COALESCE($1, $2) +$$ LANGUAGE sql; + +-- Function with maximum parameters (approaching the 32 limit) +CREATE FUNCTION f_py_sum_many ( + a integer, b integer, c integer, d integer, e integer, + f integer, g integer, h integer, i integer, j integer +) +RETURNS integer STABLE AS $$ + values = [a, b, c, d, e, f, g, h, i, j] + return sum(v for v in values if v is not None) +$$ LANGUAGE plpythonu; + +-- VOLATILE function example (different results possible) +CREATE FUNCTION f_py_random_int (min_val integer, max_val integer) +RETURNS integer VOLATILE AS $$ + import random + return random.randint(min_val, max_val) +$$ LANGUAGE plpythonu; + +-- Function with SUPER data type (Redshift-specific) +CREATE FUNCTION f_sql_super_length (input_super super) +RETURNS integer STABLE AS $$ + SELECT JSON_ARRAY_LENGTH($1) +$$ LANGUAGE sql; + +-- Function with GEOMETRY type +CREATE FUNCTION f_sql_geometry_area (geom geometry) +RETURNS float STABLE AS $$ + SELECT ST_AREA($1) +$$ LANGUAGE sql; + +-- Function with GEOGRAPHY type +CREATE FUNCTION f_sql_geography_distance (geog1 geography, geog2 geography) +RETURNS float STABLE AS $$ + SELECT ST_DISTANCE($1, $2) +$$ LANGUAGE sql; + +-- Function with HLLSKETCH type +CREATE FUNCTION f_sql_hll_cardinality (sketch hllsketch) +RETURNS bigint STABLE AS $$ + SELECT HLL_CARDINALITY($1) +$$ LANGUAGE sql; + +-- Complex SQL UDF with subquery-like logic +CREATE FUNCTION f_sql_tax_calculation (income decimal(12,2), tax_rate decimal(5,4)) +RETURNS decimal(12,2) STABLE AS $$ + SELECT CASE + WHEN $1 <= 0 THEN 0 + WHEN $2 < 0 THEN 0 + WHEN $2 > 1 THEN $1 + ELSE $1 * $2 + END +$$ LANGUAGE sql; + +-- Functions demonstrating nested calls capability +CREATE FUNCTION f_sql_nested_discount (price decimal(10,2), discount1 decimal(5,4), discount2 decimal(5,4)) +RETURNS decimal(10,2) STABLE AS $$ + SELECT f_sql_discount_price(f_sql_discount_price($1, $2), $3) +$$ LANGUAGE sql; \ No newline at end of file diff --git a/redshift/examples/redshift/create_group.sql b/redshift/examples/redshift/create_group.sql new file mode 100644 index 0000000..b8945f7 --- /dev/null +++ b/redshift/examples/redshift/create_group.sql @@ -0,0 +1,28 @@ +-- CREATE GROUP examples for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_GROUP.html + +-- Basic CREATE GROUP without any users +CREATE GROUP sales_group; + +-- CREATE GROUP with a single user +CREATE GROUP admin_group WITH USER admin1; + +-- CREATE GROUP with multiple users (using WITH) +CREATE GROUP admin_group WITH USER admin1, admin2; + +-- CREATE GROUP with multiple users (without WITH keyword - optional) +CREATE GROUP dev_group USER developer1, developer2, developer3; + +-- CREATE GROUP with mixed case names +CREATE GROUP Marketing_Team WITH USER john_doe, jane_smith; + +-- CREATE GROUP with underscore in group name +CREATE GROUP data_analytics_group WITH USER analyst1, analyst2, analyst3, analyst4; + +-- CREATE GROUP for different departments +CREATE GROUP hr_department WITH USER hr_manager, hr_specialist; +CREATE GROUP finance_team USER accountant1, accountant2, treasurer; +CREATE GROUP it_operations WITH USER sysadmin, netadmin, dbadmin; + +-- Note: Group names starting with two underscores are reserved for internal Redshift use +-- This would fail: CREATE GROUP __internal_group; \ No newline at end of file diff --git a/redshift/examples/redshift/create_identity_provider.sql b/redshift/examples/redshift/create_identity_provider.sql new file mode 100644 index 0000000..8415d15 --- /dev/null +++ b/redshift/examples/redshift/create_identity_provider.sql @@ -0,0 +1,104 @@ +-- CREATE IDENTITY PROVIDER test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_IDENTITY_PROVIDER.html + +-- Example 1: Azure OAuth Identity Provider with complete parameters +CREATE IDENTITY PROVIDER oauth_standard +TYPE azure +NAMESPACE 'aad' +PARAMETERS '{"issuer":"https://sts.windows.net/2sdfdsf-d475-420d-b5ac-667adad7c702/", "client_id":"87f4aa26-78b7-410e-bf29-57b39929ef9a", "client_secret":"BUAH~ewrqewrqwerUUY^%tHe1oNZShoiU7", "audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift"] }'; + +-- Example 2: AWS IAM Identity Center (AWSIDC) with quoted provider name +CREATE IDENTITY PROVIDER "redshift-idc-app" +TYPE AWSIDC +NAMESPACE 'awsidc' +APPLICATION_ARN 'arn:aws:sso::123456789012:application/ssoins-12345f67fe123d4/apl-a0b0a12dc123b1a4' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole'; + +-- Example 3: IAM Identity Center with explicit type name +CREATE IDENTITY PROVIDER my_idc_provider +TYPE IAM_IDENTITY_CENTER +NAMESPACE 'corporate_sso' +APPLICATION_ARN 'arn:aws:sso::987654321098:application/ssoins-98765a43bc987c2/apl-z9y8x7w6v5u4t3s2' +IAM_ROLE 'arn:aws:iam::987654321098:role/RedshiftFederatedRole'; + +-- Example 4: OAuth2 provider with minimal configuration +CREATE IDENTITY PROVIDER simple_oauth +TYPE OAUTH2 +NAMESPACE 'oauth' +PARAMETERS '{"issuer":"https://login.example.com", "client_id":"client123"}'; + +-- Example 5: Provider with AUTO_CREATE_ROLES set to TRUE +CREATE IDENTITY PROVIDER auto_roles_provider +TYPE AWSIDC +NAMESPACE 'auto_sso' +APPLICATION_ARN 'arn:aws:sso::111111111111:application/ssoins-11111a11aa111a1/apl-1a1a1a1a1a1a1a1a' +IAM_ROLE 'arn:aws:iam::111111111111:role/AutoRole' +AUTO_CREATE_ROLES TRUE; + +-- Example 6: Provider with AUTO_CREATE_ROLES TRUE and INCLUDE GROUPS filter +CREATE IDENTITY PROVIDER filtered_provider +TYPE AWSIDC +NAMESPACE 'filtered_sso' +APPLICATION_ARN 'arn:aws:sso::222222222222:application/ssoins-22222b22bb222b2/apl-2b2b2b2b2b2b2b2b' +IAM_ROLE 'arn:aws:iam::222222222222:role/FilteredRole' +AUTO_CREATE_ROLES TRUE INCLUDE GROUPS LIKE 'dev_%'; + +-- Example 7: Provider with AUTO_CREATE_ROLES TRUE and EXCLUDE GROUPS filter +CREATE IDENTITY PROVIDER exclusive_provider +TYPE AWSIDC +NAMESPACE 'exclusive_sso' +APPLICATION_ARN 'arn:aws:sso::333333333333:application/ssoins-33333c33cc333c3/apl-3c3c3c3c3c3c3c3c' +IAM_ROLE 'arn:aws:iam::333333333333:role/ExclusiveRole' +AUTO_CREATE_ROLES TRUE EXCLUDE GROUPS LIKE 'temp_%'; + +-- Example 8: Provider with AUTO_CREATE_ROLES set to FALSE +CREATE IDENTITY PROVIDER manual_provider +TYPE AWSIDC +NAMESPACE 'manual_sso' +APPLICATION_ARN 'arn:aws:sso::444444444444:application/ssoins-44444d44dd444d4/apl-4d4d4d4d4d4d4d4d' +IAM_ROLE 'arn:aws:iam::444444444444:role/ManualRole' +AUTO_CREATE_ROLES FALSE; + +-- Example 9: Azure provider with complex JSON parameters +CREATE IDENTITY PROVIDER complex_azure +TYPE azure +NAMESPACE 'complex_aad' +PARAMETERS '{"issuer":"https://sts.windows.net/abcd1234-5678-90ef-ghij-klmnopqrstuv/", "client_id":"12345678-90ab-cdef-1234-567890abcdef", "client_secret":"secretvalue~with~special~characters", "audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift", "https://custom.app.example.com"], "additional_claims":{"custom_claim":"value"}}'; + +-- Example 10: Provider with underscores in name (unquoted) +CREATE IDENTITY PROVIDER my_company_provider +TYPE OAUTH2 +NAMESPACE 'company_oauth' +PARAMETERS '{"issuer":"https://auth.company.com", "client_id":"company_client_123", "client_secret":"company_secret_456"}'; + +-- Example 11: Provider with hyphenated name (quoted) +CREATE IDENTITY PROVIDER "my-company-provider" +TYPE azure +NAMESPACE 'company-aad' +PARAMETERS '{"issuer":"https://login.microsoftonline.com/tenant-id/", "client_id":"azure-client-id"}'; + +-- Example 12: Minimal AWSIDC provider +CREATE IDENTITY PROVIDER minimal_idc +TYPE AWSIDC +NAMESPACE 'min' +APPLICATION_ARN 'arn:aws:sso::555555555555:application/ssoins-55555e55ee555e5/apl-5e5e5e5e5e5e5e5e' +IAM_ROLE 'arn:aws:iam::555555555555:role/MinimalRole'; + +-- Example 13: Provider with special characters in namespace +CREATE IDENTITY PROVIDER special_chars +TYPE OAUTH2 +NAMESPACE 'oauth-2.0_provider' +PARAMETERS '{"issuer":"https://special-auth.example.com/oauth2/", "client_id":"special_client"}'; + +-- Example 14: Provider with empty parameters JSON +CREATE IDENTITY PROVIDER empty_params +TYPE OAUTH2 +NAMESPACE 'empty' +PARAMETERS '{}'; + +-- Example 15: Provider with very long ARN and role +CREATE IDENTITY PROVIDER long_arn_provider +TYPE IAM_IDENTITY_CENTER +NAMESPACE 'long_namespace_for_testing_purposes' +APPLICATION_ARN 'arn:aws:sso::999999999999:application/ssoins-99999z99zz999z9/apl-9z9z9z9z9z9z9z9z' +IAM_ROLE 'arn:aws:iam::999999999999:role/VeryLongRoleNameForTestingPurposesWithManyCharacters'; \ No newline at end of file diff --git a/redshift/examples/redshift/create_library.sql b/redshift/examples/redshift/create_library.sql new file mode 100644 index 0000000..fe3af26 --- /dev/null +++ b/redshift/examples/redshift/create_library.sql @@ -0,0 +1,93 @@ +-- CREATE LIBRARY test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_LIBRARY.html + +-- Basic CREATE LIBRARY with S3 source and IAM role +CREATE LIBRARY f_urlparse +LANGUAGE plpythonu +FROM 's3://amzn-s3-demo-bucket/urlparse3-1.0.3.zip' +CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/RedshiftRole' +REGION AS 'us-east-1' +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftRole'; + +-- CREATE LIBRARY with HTTP source (no credentials needed) +CREATE LIBRARY f_urlparse +LANGUAGE plpythonu +FROM 'https://example.com/packages/urlparse3-1.0.3.zip' +IAM_ROLE default; + +-- CREATE OR REPLACE LIBRARY with S3 source +CREATE OR REPLACE LIBRARY my_python_lib +LANGUAGE plpythonu +FROM 's3://my-bucket/libraries/my-library-1.2.3.zip' +REGION 'us-west-2' +IAM_ROLE 'arn:aws:iam::987654321098:role/MyRedshiftRole'; + +-- CREATE LIBRARY with minimal syntax (HTTP source, default IAM role) +CREATE LIBRARY simple_lib +LANGUAGE plpythonu +FROM 'https://pypi.org/packages/simple-lib-1.0.zip' +IAM_ROLE default; + +-- CREATE LIBRARY with quoted library name +CREATE LIBRARY "my-library-name" +LANGUAGE plpythonu +FROM 's3://data-bucket/python-libs/special-chars-lib.zip' +IAM_ROLE 'arn:aws:iam::111222333444:role/DataRole'; + +-- CREATE LIBRARY with complex S3 path +CREATE LIBRARY advanced_analytics +LANGUAGE plpythonu +FROM 's3://analytics-bucket/python-libraries/2023/advanced-analytics-v2.1.0.zip' +REGION AS 'eu-west-1' +IAM_ROLE 'arn:aws:iam::555666777888:role/AnalyticsRole'; + +-- CREATE LIBRARY with underscores in name +CREATE LIBRARY data_processing_utils +LANGUAGE plpythonu +FROM 's3://corp-bucket/libraries/data_processing_utils_v1.5.zip' +CREDENTIALS 'aws_iam_role=arn:aws:iam::999888777666:role/DataProcessingRole' +REGION 'ap-southeast-1' +IAM_ROLE 'arn:aws:iam::999888777666:role/DataProcessingRole'; + +-- CREATE LIBRARY with numbers in name +CREATE LIBRARY ml_lib_v2 +LANGUAGE plpythonu +FROM 'https://github.com/example/releases/download/v2.0/ml_lib_v2.zip' +IAM_ROLE default; + +-- CREATE OR REPLACE with HTTPS source +CREATE OR REPLACE LIBRARY json_utils +LANGUAGE plpythonu +FROM 'https://files.example.com/libraries/json-utilities-3.4.1.zip' +IAM_ROLE 'arn:aws:iam::123123123123:role/UtilsRole'; + +-- CREATE LIBRARY with deep S3 path structure +CREATE LIBRARY nested_lib +LANGUAGE plpythonu +FROM 's3://enterprise-data/departments/analytics/libraries/python/2024/Q1/nested-lib-1.0.0.zip' +REGION AS 'us-east-2' +IAM_ROLE 'arn:aws:iam::456456456456:role/EnterpriseRole'; + +-- CREATE LIBRARY with dollar sign in IAM role (testing edge cases) +CREATE LIBRARY test_lib +LANGUAGE plpythonu +FROM 's3://test-bucket/test-lib.zip' +IAM_ROLE 'arn:aws:iam::789789789789:role/Test$Role'; + +-- CREATE LIBRARY with case variations (should be case-insensitive) +create library lower_case_lib +language plpythonu +from 's3://bucket/lib.zip' +iam_role default; + +CREATE LIBRARY UPPER_CASE_LIB +LANGUAGE PLPYTHONU +FROM 'S3://BUCKET/LIB.ZIP' +IAM_ROLE DEFAULT; + +-- CREATE LIBRARY with mixed case +Create Library Mixed_Case_Lib +Language PlPythonU +From 's3://bucket/mixed-lib.zip' +Region as 'us-west-1' +Iam_Role 'arn:aws:iam::111111111111:role/MixedRole'; \ No newline at end of file diff --git a/redshift/examples/redshift/create_masking_policy.sql b/redshift/examples/redshift/create_masking_policy.sql new file mode 100644 index 0000000..11c8944 --- /dev/null +++ b/redshift/examples/redshift/create_masking_policy.sql @@ -0,0 +1,382 @@ +-- CREATE MASKING POLICY test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MASKING_POLICY.html + +-- Basic CREATE MASKING POLICY statements + +-- 1. Simple masking policy with constant value and explicit cast +CREATE MASKING POLICY mask_credit_card_full +WITH (credit_card VARCHAR(256)) +USING ('000000XXXX0000'::TEXT); + +-- 2. Masking policy with NULL value +CREATE MASKING POLICY hide_sensitive_data +WITH (sensitive_column VARCHAR(100)) +USING (NULL); + +-- 3. Masking policy with column reference (pass-through for some users) +CREATE MASKING POLICY passthrough_policy +WITH (data_column TEXT) +USING (data_column); + +-- 4. Multiple input columns +CREATE MASKING POLICY multi_column_mask +WITH (first_name VARCHAR(50), last_name VARCHAR(100)) +USING ('REDACTED'); + +-- 5. Numeric data masking with zero +CREATE MASKING POLICY zero_salary +WITH (salary DECIMAL(10,2)) +USING (0::DECIMAL(10,2)); + +-- Complex masking expressions with functions + +-- 6. Partial credit card masking using SUBSTRING +CREATE MASKING POLICY mask_credit_card_partial +WITH (credit_card VARCHAR(256)) +USING (SUBSTRING(credit_card FROM 1 FOR 6) || 'XXXXX' || SUBSTRING(credit_card FROM 12 FOR 4)); + +-- 7. Email masking preserving domain +CREATE MASKING POLICY mask_email_partial +WITH (email VARCHAR(255)) +USING (SUBSTRING(email FROM 1 FOR 3) || '****@' || SUBSTRING(email FROM POSITION('@' IN email) + 1)); + +-- 8. Phone number masking +CREATE MASKING POLICY mask_phone +WITH (phone VARCHAR(15)) +USING ('(' || SUBSTRING(phone FROM 1 FOR 3) || ') XXX-XXXX'); + +-- 9. Date masking - year only +CREATE MASKING POLICY mask_birthdate_year +WITH (birthdate DATE) +USING (DATE_TRUNC('year', birthdate)); + +-- 10. Using built-in string functions +CREATE MASKING POLICY mask_with_upper +WITH (name VARCHAR(100)) +USING (UPPER('REDACTED')); + +-- CASE expressions for conditional masking + +-- 11. Simple CASE expression based on data value +CREATE MASKING POLICY conditional_salary_mask +WITH (salary DECIMAL(10,2), role VARCHAR(50)) +USING ( + CASE + WHEN role = 'admin' THEN salary + WHEN role = 'manager' THEN salary / 10 * 10 + ELSE 0::DECIMAL(10,2) + END +); + +-- 12. Complex CASE with multiple conditions +CREATE MASKING POLICY region_based_mask +WITH (customer_data TEXT, region VARCHAR(20), user_level INTEGER) +USING ( + CASE + WHEN region = 'US' AND user_level > 5 THEN customer_data + WHEN region = 'EU' THEN 'GDPR_MASKED' + WHEN region = 'APAC' THEN SUBSTRING(customer_data FROM 1 FOR 5) || '***' + ELSE 'INTERNATIONAL_MASKED' + END +); + +-- 13. Nested CASE expressions +CREATE MASKING POLICY nested_case_mask +WITH (data_value TEXT, department VARCHAR(30), clearance_level INTEGER) +USING ( + CASE + WHEN department = 'FINANCE' THEN + CASE + WHEN clearance_level >= 8 THEN data_value + WHEN clearance_level >= 5 THEN 'FINANCE_PARTIAL' + ELSE 'FINANCE_RESTRICTED' + END + WHEN department = 'HR' THEN + CASE + WHEN clearance_level >= 7 THEN data_value + ELSE 'HR_CONFIDENTIAL' + END + ELSE 'DEPARTMENT_MASKED' + END +); + +-- Mathematical operations + +-- 14. Arithmetic operations for numeric masking +CREATE MASKING POLICY numeric_arithmetic_mask +WITH (revenue DECIMAL(15,2)) +USING (revenue * 0.1); + +-- 15. Division and rounding for approximate values +CREATE MASKING POLICY approximate_revenue +WITH (revenue BIGINT) +USING ((revenue / 1000) * 1000); + +-- 16. Modulo operation for pattern masking +CREATE MASKING POLICY modulo_mask +WITH (id INTEGER) +USING (id % 1000); + +-- Logical operations + +-- 17. AND/OR operations in CASE +CREATE MASKING POLICY logical_operations_mask +WITH (data TEXT, is_public BOOLEAN, is_sensitive BOOLEAN) +USING ( + CASE + WHEN is_public AND NOT is_sensitive THEN data + WHEN NOT is_public OR is_sensitive THEN 'RESTRICTED' + ELSE 'DEFAULT_MASK' + END +); + +-- 18. IS NULL/IS NOT NULL checks +CREATE MASKING POLICY null_check_mask +WITH (optional_data VARCHAR(200)) +USING ( + CASE + WHEN optional_data IS NULL THEN 'NO_DATA' + WHEN optional_data IS NOT NULL THEN 'DATA_PRESENT' + END +); + +-- Comparison operations + +-- 19. Age-based masking with comparisons +CREATE MASKING POLICY age_based_mask +WITH (age INTEGER, personal_info TEXT) +USING ( + CASE + WHEN age >= 18 AND age <= 65 THEN 'ADULT_INFO' + WHEN age < 18 THEN 'MINOR_INFO' + WHEN age > 65 THEN 'SENIOR_INFO' + ELSE 'UNKNOWN_AGE' + END +); + +-- 20. String length comparisons +CREATE MASKING POLICY length_based_mask +WITH (text_data VARCHAR(1000)) +USING ( + CASE + WHEN LENGTH(text_data) > 100 THEN 'LONG_TEXT_MASKED' + WHEN LENGTH(text_data) > 50 THEN SUBSTRING(text_data FROM 1 FOR 50) || '...' + ELSE text_data + END +); + +-- Type casting examples + +-- 21. CAST function for type conversion +CREATE MASKING POLICY cast_function_mask +WITH (numeric_id INTEGER) +USING (CAST(numeric_id AS VARCHAR) || '-MASKED'); + +-- 22. :: operator for type casting +CREATE MASKING POLICY cast_operator_mask +WITH (price_text VARCHAR(20)) +USING ((price_text::DECIMAL * 0.9)::VARCHAR); + +-- 23. Multiple type conversions +CREATE MASKING POLICY multi_cast_mask +WITH (value_text VARCHAR(50)) +USING (CAST(CAST(value_text AS INTEGER) * 100 AS VARCHAR) || '%'); + +-- User-defined function references (assuming they exist) + +-- 24. SQL UDF reference +CREATE MASKING POLICY udf_sql_mask +WITH (credit_card VARCHAR(256)) +USING (redact_credit_card_sql(credit_card)); + +-- 25. Python UDF reference +CREATE MASKING POLICY udf_python_mask +WITH (personal_data TEXT) +USING (redact_personal_data_python(personal_data)); + +-- 26. Lambda UDF reference +CREATE MASKING POLICY udf_lambda_mask +WITH (sensitive_json SUPER) +USING (lambda_json_masker(sensitive_json)); + +-- Advanced expressions + +-- 27. Function calls with multiple parameters +CREATE MASKING POLICY multi_param_function +WITH (start_date DATE, end_date DATE) +USING (DATEDIFF('day', start_date, end_date)::VARCHAR || ' days'); + +-- 28. Nested function calls +CREATE MASKING POLICY nested_functions +WITH (raw_text VARCHAR(500)) +USING (UPPER(TRIM(SUBSTRING(LOWER(raw_text) FROM 1 FOR 10)))); + +-- 29. Concatenation with multiple strings +CREATE MASKING POLICY concat_mask +WITH (category VARCHAR(50), subcategory VARCHAR(50)) +USING (category || '-' || subcategory || '-MASKED'); + +-- 30. Complex SUBSTRING with FROM and FOR +CREATE MASKING POLICY complex_substring +WITH (long_text TEXT) +USING (SUBSTRING(long_text FROM 5 FOR 20) || '...[TRUNCATED]'); + +-- Different data types + +-- 31. BOOLEAN data type +CREATE MASKING POLICY boolean_mask +WITH (is_active BOOLEAN) +USING (FALSE); + +-- 32. DATE data type with functions +CREATE MASKING POLICY date_mask +WITH (created_date DATE) +USING (DATE_TRUNC('month', created_date)); + +-- 33. TIMESTAMP data type +CREATE MASKING POLICY timestamp_mask +WITH (logged_at TIMESTAMP) +USING (DATE_TRUNC('hour', logged_at)); + +-- 34. DECIMAL with precision and scale +CREATE MASKING POLICY decimal_mask +WITH (precise_amount DECIMAL(12,4)) +USING (0.0000::DECIMAL(12,4)); + +-- 35. BIGINT data type +CREATE MASKING POLICY bigint_mask +WITH (large_number BIGINT) +USING (large_number / 1000000 * 1000000); + +-- 36. SUPER data type (Redshift-specific) +CREATE MASKING POLICY super_mask +WITH (json_data SUPER) +USING ('{"masked": true}'::SUPER); + +-- IF NOT EXISTS examples + +-- 37. CREATE with IF NOT EXISTS +CREATE MASKING POLICY IF NOT EXISTS conditional_create_mask +WITH (data VARCHAR(100)) +USING ('CONDITIONALLY_MASKED'); + +-- 38. IF NOT EXISTS with complex expression +CREATE MASKING POLICY IF NOT EXISTS complex_conditional_mask +WITH (value INTEGER, status VARCHAR(20)) +USING ( + CASE + WHEN status = 'ACTIVE' THEN CAST(value AS VARCHAR) + ELSE 'INACTIVE_MASKED' + END +); + +-- Multiple column types in single policy + +-- 39. Mixed data types +CREATE MASKING POLICY mixed_types_mask +WITH (id INTEGER, name VARCHAR(100), amount DECIMAL(10,2), created_at TIMESTAMP) +USING ( + CASE + WHEN amount > 1000 THEN name || ' (HIGH_VALUE)' + WHEN amount > 100 THEN 'MEDIUM_VALUE_USER' + ELSE 'LOW_VALUE_USER' + END +); + +-- 40. Text data types variations +CREATE MASKING POLICY text_variations_mask +WITH (char_field CHAR(10), varchar_field VARCHAR(255), text_field TEXT) +USING ( + CASE + WHEN LENGTH(text_field) > 100 THEN 'LONG_TEXT' + WHEN LENGTH(varchar_field) > 50 THEN 'MEDIUM_TEXT' + ELSE 'SHORT_TEXT' + END +); + +-- Parentheses and operator precedence + +-- 41. Complex parentheses grouping +CREATE MASKING POLICY parentheses_mask +WITH (a INTEGER, b INTEGER, c INTEGER) +USING ((a + b) * c / 100); + +-- 42. Mixed operators with precedence +CREATE MASKING POLICY precedence_mask +WITH (base_value DECIMAL(10,2), multiplier DECIMAL(5,2), offset INTEGER) +USING (base_value * multiplier + offset::DECIMAL(10,2)); + +-- Edge cases + +-- 43. Empty string masking +CREATE MASKING POLICY empty_string_mask +WITH (data VARCHAR(100)) +USING (''); + +-- 44. Single character masking +CREATE MASKING POLICY single_char_mask +WITH (code CHAR(1)) +USING ('X'); + +-- 45. Very long identifier names +CREATE MASKING POLICY very_long_policy_name_for_testing_identifier_limits +WITH (very_long_column_name_for_testing VARCHAR(50)) +USING ('LONG_NAME_MASKED'); + +-- Comments within statements + +-- 46. Line comments in expression +CREATE MASKING POLICY commented_mask +WITH (value INTEGER) +USING ( + -- This masks by setting to zero + 0 +); + +-- 47. Block comments in expression +CREATE MASKING POLICY block_commented_mask +WITH (text_value TEXT) +USING ( + /* This is a multi-line + block comment explaining + the masking strategy */ + 'BLOCK_COMMENTED_MASK' +); + +-- Semicolon variations + +-- 48. With semicolon +CREATE MASKING POLICY with_semicolon_mask +WITH (data TEXT) +USING ('SEMICOLON_TERMINATED'); + +-- 49. Without semicolon +CREATE MASKING POLICY without_semicolon_mask +WITH (data TEXT) +USING ('NO_SEMICOLON') + +-- 50. Multiple statements +CREATE MASKING POLICY first_batch_policy +WITH (data1 TEXT) +USING ('FIRST'); + +CREATE MASKING POLICY second_batch_policy +WITH (data2 TEXT) +USING ('SECOND'); + +-- Quoted identifiers + +-- 51. Policy name with spaces +CREATE MASKING POLICY "Policy with Spaces" +WITH (data VARCHAR(100)) +USING ('SPACED_POLICY_MASKED'); + +-- 52. Column name with spaces +CREATE MASKING POLICY quoted_column_mask +WITH ("Column With Spaces" TEXT) +USING ('QUOTED_COLUMN_MASKED'); + +-- 53. Mixed quoted and unquoted +CREATE MASKING POLICY "Mixed Case Policy" +WITH (regular_column VARCHAR(50), "Special Column" TEXT) +USING ('MIXED_QUOTED_MASKED'); \ No newline at end of file diff --git a/redshift/examples/redshift/create_materialized_view.sql b/redshift/examples/redshift/create_materialized_view.sql new file mode 100644 index 0000000..a71842d --- /dev/null +++ b/redshift/examples/redshift/create_materialized_view.sql @@ -0,0 +1,228 @@ +-- CREATE MATERIALIZED VIEW test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-create-sql-command.html + +-- Basic CREATE MATERIALIZED VIEW +CREATE MATERIALIZED VIEW tickets_mv AS +SELECT catgroup, SUM(qtysold) as sold +FROM category c, event e, sales s +WHERE c.catid = e.catid AND e.eventid = s.eventid +GROUP BY catgroup; + +-- With schema qualification +CREATE MATERIALIZED VIEW sales.revenue_mv AS +SELECT product_id, SUM(amount) as total_revenue +FROM sales.transactions +GROUP BY product_id; + +-- With quoted identifiers +CREATE MATERIALIZED VIEW "Customer-Summary" AS +SELECT "Customer ID", COUNT(*) as order_count +FROM "Order-History" +GROUP BY "Customer ID"; + +-- BACKUP clause examples +CREATE MATERIALIZED VIEW backup_mv BACKUP YES AS +SELECT customer_id, COUNT(*) as orders +FROM customer_orders +GROUP BY customer_id; + +CREATE MATERIALIZED VIEW no_backup_mv BACKUP NO AS +SELECT product_id, AVG(rating) as avg_rating +FROM product_reviews +GROUP BY product_id; + +-- DISTSTYLE examples +CREATE MATERIALIZED VIEW even_dist_mv DISTSTYLE EVEN AS +SELECT region, SUM(sales) as total_sales +FROM regional_sales +GROUP BY region; + +CREATE MATERIALIZED VIEW all_dist_mv DISTSTYLE ALL AS +SELECT category, COUNT(*) as product_count +FROM products +GROUP BY category; + +CREATE MATERIALIZED VIEW key_dist_mv DISTSTYLE KEY AS +SELECT customer_id, SUM(amount) as total_spent +FROM purchases +GROUP BY customer_id; + +-- DISTKEY examples +CREATE MATERIALIZED VIEW customer_dist_mv DISTKEY(customer_id) AS +SELECT customer_id, order_date, amount +FROM orders; + +CREATE MATERIALIZED VIEW product_dist_mv DISTKEY(product_id) AS +SELECT product_id, sale_date, quantity +FROM sales; + +-- SORTKEY examples +CREATE MATERIALIZED VIEW date_sorted_mv SORTKEY(order_date) AS +SELECT order_date, customer_id, amount +FROM orders; + +CREATE MATERIALIZED VIEW multi_sorted_mv SORTKEY(region, sale_date) AS +SELECT region, sale_date, product_id, quantity +FROM regional_sales; + +CREATE MATERIALIZED VIEW compound_sorted_mv COMPOUND SORTKEY(customer_id, order_date) AS +SELECT customer_id, order_date, product_id, amount +FROM customer_orders; + +CREATE MATERIALIZED VIEW interleaved_sorted_mv INTERLEAVED SORTKEY(product_id, sale_date) AS +SELECT product_id, sale_date, customer_id, quantity +FROM product_sales; + +-- AUTO REFRESH examples +CREATE MATERIALIZED VIEW auto_refresh_mv AUTO REFRESH YES AS +SELECT category, AVG(price) as avg_price +FROM products +GROUP BY category; + +CREATE MATERIALIZED VIEW manual_refresh_mv AUTO REFRESH NO AS +SELECT warehouse_id, SUM(inventory) as total_inventory +FROM warehouse_stock +GROUP BY warehouse_id; + +-- Combined attributes examples +CREATE MATERIALIZED VIEW full_featured_mv +BACKUP YES +DISTSTYLE KEY +DISTKEY(customer_id) +SORTKEY(order_date, product_id) +AUTO REFRESH YES +AS +SELECT customer_id, order_date, product_id, SUM(amount) as total_amount +FROM order_details +GROUP BY customer_id, order_date, product_id; + +CREATE MATERIALIZED VIEW complex_mv +BACKUP NO +DISTSTYLE ALL +COMPOUND SORTKEY(region, category) +AUTO REFRESH NO +AS +SELECT region, category, COUNT(*) as product_count, AVG(price) as avg_price +FROM product_catalog +GROUP BY region, category; + +-- Cross-database reference (Spectrum/Federated) +CREATE MATERIALIZED VIEW cross_db_mv AS +SELECT cityname, population +FROM external_db.public.cities +WHERE population > 100000; + +-- Complex SELECT statements +CREATE MATERIALIZED VIEW join_mv AS +SELECT c.customer_name, p.product_name, SUM(o.quantity) as total_quantity +FROM customers c +JOIN orders o ON c.customer_id = o.customer_id +JOIN products p ON o.product_id = p.product_id +GROUP BY c.customer_name, p.product_name; + +CREATE MATERIALIZED VIEW union_mv AS +SELECT 'Q1' as quarter, product_id, SUM(sales) as total_sales +FROM q1_sales +GROUP BY product_id +UNION ALL +SELECT 'Q2' as quarter, product_id, SUM(sales) as total_sales +FROM q2_sales +GROUP BY product_id; + +-- Window function example (if supported) +CREATE MATERIALIZED VIEW window_mv AS +SELECT customer_id, order_date, amount, + SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_date) as running_total +FROM orders; + +-- CASE expression example +CREATE MATERIALIZED VIEW case_mv AS +SELECT product_id, + CASE + WHEN price < 100 THEN 'Low' + WHEN price BETWEEN 100 AND 500 THEN 'Medium' + ELSE 'High' + END as price_category, + COUNT(*) as product_count +FROM products +GROUP BY product_id, price_category; + +-- Aggregate functions +CREATE MATERIALIZED VIEW agg_mv AS +SELECT category, + COUNT(*) as total_products, + SUM(price) as total_value, + AVG(price) as avg_price, + MIN(price) as min_price, + MAX(price) as max_price +FROM products +GROUP BY category; + +-- DISTINCT example +CREATE MATERIALIZED VIEW distinct_mv AS +SELECT DISTINCT customer_id, region +FROM customer_locations; + +-- Subquery example +CREATE MATERIALIZED VIEW subquery_mv AS +SELECT customer_id, total_orders +FROM ( + SELECT customer_id, COUNT(*) as total_orders + FROM orders + GROUP BY customer_id +) sub +WHERE total_orders > 5; + +-- Multiple JOIN types +CREATE MATERIALIZED VIEW multi_join_mv AS +SELECT c.customer_name, o.order_id, p.product_name, od.quantity +FROM customers c +LEFT JOIN orders o ON c.customer_id = o.customer_id +INNER JOIN order_details od ON o.order_id = od.order_id +RIGHT JOIN products p ON od.product_id = p.product_id; + +-- WITH clause (CTE) - if supported +CREATE MATERIALIZED VIEW cte_mv AS +SELECT region, total_sales, avg_sales +FROM ( + SELECT region, + SUM(amount) as total_sales, + AVG(amount) as avg_sales + FROM sales + GROUP BY region +) regional_stats +WHERE total_sales > 10000; + +-- Function calls +CREATE MATERIALIZED VIEW function_mv AS +SELECT + EXTRACT(YEAR FROM order_date) as order_year, + EXTRACT(MONTH FROM order_date) as order_month, + COUNT(*) as order_count, + SUM(amount) as total_amount +FROM orders +GROUP BY order_year, order_month; + +-- NULL handling +CREATE MATERIALIZED VIEW null_handling_mv AS +SELECT + customer_id, + CASE WHEN email IS NULL THEN 'No Email' ELSE 'Has Email' END as email_status, + COUNT(*) as customer_count +FROM customers +GROUP BY customer_id, email_status; + +-- Complex WHERE conditions +CREATE MATERIALIZED VIEW complex_where_mv AS +SELECT product_id, category, price +FROM products +WHERE (price > 100 AND category IN ('Electronics', 'Computers')) + OR (price BETWEEN 50 AND 100 AND category LIKE 'Home%') + AND NOT (product_id IN (SELECT discontinued_id FROM discontinued_products)); + +-- Multiple schema qualification +CREATE MATERIALIZED VIEW schema_qualified_mv AS +SELECT s.sale_id, c.customer_name, p.product_name +FROM sales_db.public.sales s +JOIN customer_db.public.customers c ON s.customer_id = c.customer_id +JOIN product_db.public.products p ON s.product_id = p.product_id; \ No newline at end of file diff --git a/redshift/examples/redshift/create_model.sql b/redshift/examples/redshift/create_model.sql new file mode 100644 index 0000000..aa51148 --- /dev/null +++ b/redshift/examples/redshift/create_model.sql @@ -0,0 +1,278 @@ +-- CREATE MODEL Test Cases +-- Based on AWS Redshift documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html + +-- Basic CREATE MODEL with table source +CREATE MODEL customer_churn_model +FROM customer_data +TARGET churn +FUNCTION predict_churn +IAM_ROLE default; + +-- CREATE MODEL with SELECT statement +CREATE MODEL sales_forecast_model +FROM ( + SELECT product_id, sales_date, quantity, price + FROM sales_history + WHERE sales_date >= '2023-01-01' +) +TARGET quantity +FUNCTION forecast_sales +IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftMLRole'; + +-- CREATE MODEL with job name +CREATE MODEL pretrained_model +FROM 'existing-training-job' +FUNCTION classify_sentiment +IAM_ROLE default; + +-- CREATE MODEL with function parameters and return type +CREATE MODEL price_prediction_model +FROM product_features +TARGET price +FUNCTION predict_price(INTEGER, VARCHAR(50), DECIMAL(10,2)) +RETURNS DECIMAL(10,2) +IAM_ROLE 'arn:aws:iam::123456789012:role/MLRole'; + +-- CREATE MODEL with SageMaker endpoint +CREATE MODEL external_model +FROM training_data +TARGET outcome +FUNCTION predict_outcome +SAGEMAKER 'my-endpoint' +IAM_ROLE default; + +-- CREATE MODEL with SageMaker endpoint and model name +CREATE MODEL external_model_v2 +FROM training_data +TARGET outcome +FUNCTION predict_outcome +SAGEMAKER 'my-endpoint':'model-v2' +IAM_ROLE default; + +-- CREATE MODEL with AUTO OFF +CREATE MODEL manual_model +FROM user_behavior +TARGET conversion +FUNCTION predict_conversion +IAM_ROLE default +AUTO OFF; + +-- CREATE MODEL with specific model type +CREATE MODEL xgboost_model +FROM training_dataset +TARGET label +FUNCTION classify_label +IAM_ROLE default +MODEL_TYPE XGBOOST; + +-- CREATE MODEL with MLP model type +CREATE MODEL neural_network_model +FROM features_table +TARGET target_variable +FUNCTION nn_predict +IAM_ROLE default +MODEL_TYPE MLP; + +-- CREATE MODEL with Linear Learner +CREATE MODEL linear_model +FROM regression_data +TARGET continuous_target +FUNCTION linear_predict +IAM_ROLE default +MODEL_TYPE LINEAR_LEARNER; + +-- CREATE MODEL with K-Means clustering +CREATE MODEL clustering_model +FROM customer_segments +FUNCTION cluster_customers +IAM_ROLE default +MODEL_TYPE KMEANS; + +-- CREATE MODEL with forecasting +CREATE MODEL time_series_model +FROM historical_data +TARGET sales_value +FUNCTION forecast_sales +IAM_ROLE default +MODEL_TYPE FORECAST; + +-- CREATE MODEL with problem type - regression +CREATE MODEL regression_model +FROM numerical_data +TARGET continuous_value +FUNCTION predict_value +IAM_ROLE default +PROBLEM_TYPE (REGRESSION); + +-- CREATE MODEL with problem type - binary classification +CREATE MODEL binary_classifier +FROM binary_features +TARGET binary_target +FUNCTION binary_predict +IAM_ROLE default +PROBLEM_TYPE (BINARY_CLASSIFICATION); + +-- CREATE MODEL with problem type - multiclass classification +CREATE MODEL multiclass_classifier +FROM categorical_features +TARGET category +FUNCTION classify_category +IAM_ROLE default +PROBLEM_TYPE (MULTICLASS_CLASSIFICATION); + +-- CREATE MODEL with objective +CREATE MODEL accuracy_model +FROM classification_data +TARGET class_label +FUNCTION classify +IAM_ROLE default +OBJECTIVE ('Accuracy'); + +-- CREATE MODEL with MSE objective +CREATE MODEL mse_model +FROM regression_features +TARGET numeric_target +FUNCTION regress +IAM_ROLE default +OBJECTIVE ('MSE'); + +-- CREATE MODEL with preprocessors +CREATE MODEL preprocessed_model +FROM raw_data +TARGET outcome +FUNCTION predict_processed +IAM_ROLE default +PREPROCESSORS 'normalize,encode_categorical'; + +-- CREATE MODEL with default hyperparameters +CREATE MODEL default_hp_model +FROM training_set +TARGET response +FUNCTION predict_response +IAM_ROLE default +HYPERPARAMETERS DEFAULT; + +-- CREATE MODEL with custom hyperparameters +CREATE MODEL custom_hp_model +FROM feature_matrix +TARGET target_col +FUNCTION custom_predict +IAM_ROLE default +HYPERPARAMETERS DEFAULT EXCEPT ( + learning_rate '0.1', + max_depth '6', + subsample '0.8' +); + +-- CREATE MODEL with basic settings +CREATE MODEL settings_model +FROM data_table +TARGET prediction_target +FUNCTION predict_with_settings +IAM_ROLE default +SETTINGS ( + S3_BUCKET 'my-ml-bucket', + TAGS 'project=ml,team=data-science' +); + +-- CREATE MODEL with comprehensive settings +CREATE MODEL full_settings_model +FROM comprehensive_data +TARGET full_target +FUNCTION comprehensive_predict +IAM_ROLE 'arn:aws:iam::123456789012:role/ComprehensiveMLRole' +SETTINGS ( + S3_BUCKET 'comprehensive-ml-bucket', + TAGS 'environment=prod,cost-center=analytics', + KMS_KEY_ID 'arn:aws:kms:us-west-2:123456789012:key/12345678-1234-1234-1234-123456789012', + S3_GARBAGE_COLLECT ON, + MAX_CELLS 1000000, + MAX_RUNTIME 7200, + HORIZON 30, + FREQUENCY 24, + PERCENTILES '0.1,0.5,0.9', + MAX_BATCH_ROWS 10000 +); + +-- CREATE MODEL with all optional clauses +CREATE MODEL complete_model +FROM ( + SELECT feature1, feature2, feature3, target_variable + FROM ml_training_data + WHERE data_quality_score > 0.8 +) +TARGET target_variable +FUNCTION complete_prediction(INTEGER, DECIMAL(10,2), VARCHAR(100)) +RETURNS DECIMAL(8,4) +SAGEMAKER 'production-endpoint':'model-v3' +IAM_ROLE 'arn:aws:iam::123456789012:role/ProductionMLRole' +AUTO ON +MODEL_TYPE XGBOOST +PROBLEM_TYPE (BINARY_CLASSIFICATION) +OBJECTIVE ('F1') +PREPROCESSORS 'standard_scaler,one_hot_encoder' +HYPERPARAMETERS DEFAULT EXCEPT ( + n_estimators '100', + learning_rate '0.05', + max_depth '8', + min_child_weight '3' +) +SETTINGS ( + S3_BUCKET 'production-ml-models', + TAGS 'version=3.0,model=xgboost,status=production', + KMS_KEY_ID 'arn:aws:kms:us-east-1:123456789012:key/production-key', + S3_GARBAGE_COLLECT OFF, + MAX_CELLS 5000000, + MAX_RUNTIME 10800, + MAX_BATCH_ROWS 50000 +); + +-- CREATE MODEL with quoted identifiers +CREATE MODEL "Model With Spaces" +FROM "Table With Spaces" +TARGET "Target Column" +FUNCTION "Prediction Function" +IAM_ROLE default; + +-- CREATE MODEL with schema-qualified names +CREATE MODEL analytics.customer_model +FROM analytics.customer_features +TARGET analytics.churn_flag +FUNCTION analytics.predict_churn +IAM_ROLE default; + +-- CREATE MODEL for time series forecasting with specific settings +CREATE MODEL forecast_model +FROM time_series_data +TARGET sales_amount +FUNCTION forecast_sales_ts +IAM_ROLE default +MODEL_TYPE FORECAST +SETTINGS ( + S3_BUCKET 'forecast-models', + HORIZON 90, + FREQUENCY 1440, + PERCENTILES '0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9' +); + +-- CREATE MODEL with complex SELECT statement +CREATE MODEL complex_select_model +FROM ( + SELECT + c.customer_id, + c.age, + c.income, + COUNT(o.order_id) as order_count, + AVG(o.order_total) as avg_order_value, + MAX(o.order_date) as last_order_date, + CASE WHEN c.subscription_status = 'active' THEN 1 ELSE 0 END as is_subscriber + FROM customers c + LEFT JOIN orders o ON c.customer_id = o.customer_id + WHERE c.created_date >= '2022-01-01' + GROUP BY c.customer_id, c.age, c.income, c.subscription_status + HAVING COUNT(o.order_id) > 0 +) +TARGET is_subscriber +FUNCTION predict_subscription_likelihood +IAM_ROLE 'arn:aws:iam::123456789012:role/AnalyticsMLRole' +AUTO ON; \ No newline at end of file diff --git a/redshift/examples/redshift/create_procedure.sql b/redshift/examples/redshift/create_procedure.sql new file mode 100644 index 0000000..e4f248b --- /dev/null +++ b/redshift/examples/redshift/create_procedure.sql @@ -0,0 +1,574 @@ +-- CREATE PROCEDURE test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_PROCEDURE.html + +-- Basic procedure examples + +-- Simple procedure with input parameters +CREATE PROCEDURE test_sp1(f1 int, f2 varchar(20)) AS $$ +DECLARE + min_val int; +BEGIN + DROP TABLE IF EXISTS tmp_tbl; + CREATE TEMP TABLE tmp_tbl(id int); + INSERT INTO tmp_tbl values (f1),(10001),(10002); + SELECT INTO min_val MIN(id) FROM tmp_tbl; + RAISE INFO 'min_val = %, f2 = %', min_val, f2; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with IN, OUT, INOUT parameters +CREATE PROCEDURE test_sp2( + f1 IN int, + f2 INOUT varchar(256), + out_var OUT varchar(256) +) AS $$ +DECLARE + loop_var int; +BEGIN + IF f1 is null OR f2 is null THEN + RAISE EXCEPTION 'input cannot be null'; + END IF; + DROP TABLE IF EXISTS tmp_tbl; + CREATE TEMP TABLE tmp_tbl(id int); + FOR loop_var IN 1..f1 LOOP + INSERT INTO tmp_tbl VALUES (loop_var); + END LOOP; + SELECT INTO out_var 'INFO: loop_var = ' || loop_var || ', f2 = ' || f2; + f2 := 'updated f2'; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with parameter mode variations +CREATE PROCEDURE test_modes( + input_param IN integer, + output_param OUT varchar(100), + inout_param INOUT decimal(10,2) +) AS $$ +DECLARE + temp_value decimal(10,2); +BEGIN + temp_value := inout_param * input_param; + output_param := 'Calculated value: ' || temp_value::varchar; + inout_param := temp_value; +END; +$$ LANGUAGE plpgsql; + +-- OR REPLACE examples + +-- Replace existing procedure +CREATE OR REPLACE PROCEDURE test_sp1(f1 int, f2 varchar(20)) AS $$ +DECLARE + min_val int; + max_val int; +BEGIN + DROP TABLE IF EXISTS tmp_tbl; + CREATE TEMP TABLE tmp_tbl(id int); + INSERT INTO tmp_tbl values (f1),(10001),(10002); + SELECT INTO min_val, max_val MIN(id), MAX(id) FROM tmp_tbl; + RAISE INFO 'min_val = %, max_val = %, f2 = %', min_val, max_val, f2; +END; +$$ LANGUAGE plpgsql; + +-- NONATOMIC procedures + +-- NONATOMIC procedure that automatically commits +CREATE PROCEDURE test_nonatomic_sp(input_id int) NONATOMIC AS $$ +DECLARE + rec record; +BEGIN + -- Each statement auto-commits in NONATOMIC mode + DROP TABLE IF EXISTS test_table; + CREATE TABLE test_table(id int); + INSERT INTO test_table VALUES (input_id); + + FOR rec IN SELECT * FROM test_table LOOP + RAISE INFO 'Processing id: %', rec.id; + END LOOP; + + DROP TABLE test_table; +END; +$$ LANGUAGE plpgsql; + +-- NONATOMIC with transaction control +CREATE OR REPLACE PROCEDURE test_transaction_sp(batch_size int) NONATOMIC AS $$ +DECLARE + counter int := 0; + current_id int; +BEGIN + DROP TABLE IF EXISTS batch_table; + CREATE TABLE batch_table(id int, processed boolean default false); + + -- Insert test data + FOR current_id IN 1..batch_size * 3 LOOP + INSERT INTO batch_table(id) VALUES (current_id); + counter := counter + 1; + + -- Commit every batch_size records + IF counter % batch_size = 0 THEN + COMMIT; + RAISE INFO 'Committed batch of % records', batch_size; + END IF; + END LOOP; + + COMMIT; -- Final commit +END; +$$ LANGUAGE plpgsql; + +-- Security options + +-- SECURITY INVOKER procedure (default) +CREATE PROCEDURE test_security_invoker(table_name varchar(100)) +SECURITY INVOKER AS $$ +BEGIN + -- Runs with caller's privileges + EXECUTE 'SELECT COUNT(*) FROM ' || table_name; + RAISE INFO 'Accessed table: %', table_name; +END; +$$ LANGUAGE plpgsql; + +-- SECURITY DEFINER procedure +CREATE PROCEDURE test_security_definer(user_id int) +SECURITY DEFINER AS $$ +DECLARE + user_count int; +BEGIN + -- Runs with procedure owner's privileges + SELECT COUNT(*) INTO user_count FROM pg_user WHERE usesysid = user_id; + RAISE INFO 'User count for ID %: %', user_id, user_count; +END; +$$ LANGUAGE plpgsql; + +-- SET configuration parameter examples + +-- Procedure with configuration parameter +CREATE PROCEDURE test_config_sp(search_query varchar(100)) +SET search_path = public, temp_schema AS $$ +BEGIN + -- search_path is temporarily set for this procedure + DROP TABLE IF EXISTS search_results; + CREATE TEMP TABLE search_results(result_text varchar(200)); + INSERT INTO search_results VALUES ('Found: ' || search_query); + RAISE INFO 'Search completed for: %', search_query; +END; +$$ LANGUAGE plpgsql; + +-- Multiple configuration parameters +CREATE PROCEDURE test_multi_config_sp(log_level varchar(10)) +SET log_min_messages = info +SET work_mem = '256MB' AS $$ +BEGIN + RAISE INFO 'Procedure started with log level: %', log_level; + -- Memory and logging settings are temporarily modified + PERFORM pg_sleep(1); + RAISE INFO 'Procedure completed'; +END; +$$ LANGUAGE plpgsql; + +-- Data type examples + +-- Procedure with various data types +CREATE PROCEDURE test_datatypes_sp( + small_num smallint, + big_num bigint, + precise_num decimal(10,2), + float_num real, + double_num double precision, + bool_val boolean, + char_val char(10), + varchar_val varchar(255), + date_val date, + timestamp_val timestamp, + text_val text +) AS $$ +DECLARE + result_text text; +BEGIN + result_text := 'Values: ' || small_num || ', ' || big_num || ', ' || precise_num; + result_text := result_text || ', ' || float_num || ', ' || double_num; + result_text := result_text || ', ' || bool_val || ', ' || trim(char_val); + result_text := result_text || ', ' || varchar_val || ', ' || date_val; + result_text := result_text || ', ' || timestamp_val || ', ' || text_val; + + RAISE INFO 'All data types: %', result_text; +END; +$$ LANGUAGE plpgsql; + +-- Redshift-specific data types +CREATE PROCEDURE test_redshift_types_sp( + super_val super, + geom_val geometry, + geog_val geography, + hll_val hllsketch +) AS $$ +BEGIN + RAISE INFO 'Super type length: %', JSON_ARRAY_LENGTH(super_val); + RAISE INFO 'Geometry area: %', ST_AREA(geom_val); + RAISE INFO 'Geography provided: %', CASE WHEN geog_val IS NOT NULL THEN 'Yes' ELSE 'No' END; + RAISE INFO 'HLL cardinality: %', HLL_CARDINALITY(hll_val); +END; +$$ LANGUAGE plpgsql; + +-- Control flow examples + +-- Procedure with IF-ELSIF-ELSE +CREATE PROCEDURE test_control_flow_sp(grade_score int) AS $$ +DECLARE + letter_grade varchar(2); + message varchar(100); +BEGIN + IF grade_score >= 90 THEN + letter_grade := 'A'; + message := 'Excellent'; + ELSIF grade_score >= 80 THEN + letter_grade := 'B'; + message := 'Good'; + ELSIF grade_score >= 70 THEN + letter_grade := 'C'; + message := 'Average'; + ELSIF grade_score >= 60 THEN + letter_grade := 'D'; + message := 'Below Average'; + ELSE + letter_grade := 'F'; + message := 'Failing'; + END IF; + + RAISE INFO 'Score: %, Grade: %, Assessment: %', grade_score, letter_grade, message; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with loops +CREATE PROCEDURE test_loops_sp(max_iterations int) AS $$ +DECLARE + counter int := 1; + factorial bigint := 1; + current_num int; +BEGIN + -- WHILE loop + WHILE counter <= max_iterations LOOP + factorial := factorial * counter; + counter := counter + 1; + END LOOP; + + RAISE INFO 'Factorial of %: %', max_iterations, factorial; + + -- FOR loop with range + FOR current_num IN 1..max_iterations LOOP + IF current_num % 2 = 0 THEN + RAISE INFO 'Even number: %', current_num; + END IF; + END LOOP; + + -- FOR loop with REVERSE + FOR current_num IN REVERSE max_iterations..1 LOOP + IF current_num <= 3 THEN + EXIT; -- Exit the loop early + END IF; + RAISE INFO 'Countdown: %', current_num; + END LOOP; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with labeled loops and EXIT/CONTINUE +CREATE PROCEDURE test_nested_loops_sp(outer_limit int, inner_limit int) AS $$ +DECLARE + i int; + j int; + product int; +BEGIN + <> + FOR i IN 1..outer_limit LOOP + <> + FOR j IN 1..inner_limit LOOP + product := i * j; + + -- Skip even products + IF product % 2 = 0 THEN + CONTINUE inner_loop; + END IF; + + -- Exit outer loop if product > 50 + IF product > 50 THEN + EXIT outer_loop; + END IF; + + RAISE INFO 'Product: % x % = %', i, j, product; + END LOOP inner_loop; + END LOOP outer_loop; +END; +$$ LANGUAGE plpgsql; + +-- Exception handling examples + +-- Procedure with exception handling +CREATE PROCEDURE test_exception_sp(divisor int) AS $$ +DECLARE + result decimal(10,2); + dividend constant int := 100; +BEGIN + BEGIN + result := dividend / divisor; + RAISE INFO 'Result: % / % = %', dividend, divisor, result; + EXCEPTION + WHEN division_by_zero THEN + RAISE WARNING 'Division by zero attempted'; + result := NULL; + WHEN others THEN + RAISE WARNING 'Unexpected error occurred: %', SQLERRM; + result := NULL; + END; + + IF result IS NOT NULL THEN + INSERT INTO calculation_log VALUES (dividend, divisor, result, current_timestamp); + END IF; +END; +$$ LANGUAGE plpgsql; + +-- Custom exception handling +CREATE PROCEDURE test_custom_exception_sp(input_value int) AS $$ +DECLARE + processed_value int; +BEGIN + IF input_value < 0 THEN + RAISE EXCEPTION 'Negative values not allowed' + USING HINT = 'Please provide a positive integer', + ERRCODE = 'P0001'; + END IF; + + IF input_value > 1000 THEN + RAISE EXCEPTION 'Value too large: %', input_value + USING HINT = 'Maximum allowed value is 1000', + ERRCODE = 'P0002'; + END IF; + + processed_value := input_value * 2; + RAISE INFO 'Processed value: %', processed_value; +END; +$$ LANGUAGE plpgsql; + +-- Advanced SQL operations + +-- Procedure with dynamic SQL +CREATE PROCEDURE test_dynamic_sql_sp(table_name varchar(100), column_name varchar(100)) AS $$ +DECLARE + sql_query text; + record_count int; +BEGIN + -- Build dynamic query + sql_query := 'SELECT COUNT(*) FROM ' || quote_ident(table_name) || + ' WHERE ' || quote_ident(column_name) || ' IS NOT NULL'; + + -- Execute dynamic SQL + EXECUTE sql_query INTO record_count; + + RAISE INFO 'Records in %.% with non-null values: %', + table_name, column_name, record_count; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with cursor operations +CREATE PROCEDURE test_cursor_sp(department_id int) AS $$ +DECLARE + emp_cursor CURSOR FOR + SELECT employee_id, first_name, last_name, salary + FROM employees + WHERE dept_id = department_id + ORDER BY salary DESC; + emp_rec RECORD; + total_salary decimal(12,2) := 0; + emp_count int := 0; +BEGIN + FOR emp_rec IN emp_cursor LOOP + total_salary := total_salary + emp_rec.salary; + emp_count := emp_count + 1; + + RAISE INFO 'Employee: % % - Salary: %', + emp_rec.first_name, emp_rec.last_name, emp_rec.salary; + END LOOP; + + IF emp_count > 0 THEN + RAISE INFO 'Department % - Total employees: %, Total salary: %, Average: %', + department_id, emp_count, total_salary, (total_salary / emp_count); + ELSE + RAISE INFO 'No employees found in department %', department_id; + END IF; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with RETURN statements +CREATE PROCEDURE test_return_sp(operation varchar(10), value1 int, value2 int) AS $$ +DECLARE + result int; +BEGIN + CASE operation + WHEN 'add' THEN + result := value1 + value2; + WHEN 'subtract' THEN + result := value1 - value2; + WHEN 'multiply' THEN + result := value1 * value2; + WHEN 'divide' THEN + IF value2 = 0 THEN + RAISE INFO 'Cannot divide by zero'; + RETURN; -- Early return + END IF; + result := value1 / value2; + ELSE + RAISE INFO 'Unknown operation: %', operation; + RETURN; -- Early return + END CASE; + + RAISE INFO 'Operation: % % % = %', value1, operation, value2, result; +END; +$$ LANGUAGE plpgsql; + +-- Complex real-world examples + +-- Data processing procedure +CREATE PROCEDURE process_sales_data_sp(process_date date) AS $$ +DECLARE + processed_count int := 0; + error_count int := 0; + sales_rec RECORD; +BEGIN + -- Process sales records for given date + FOR sales_rec IN + SELECT order_id, customer_id, amount, status + FROM sales_orders + WHERE order_date = process_date AND status = 'pending' + LOOP + BEGIN + -- Validate and process each record + IF sales_rec.amount > 0 AND sales_rec.customer_id IS NOT NULL THEN + UPDATE sales_orders + SET status = 'processed', processed_timestamp = current_timestamp + WHERE order_id = sales_rec.order_id; + + processed_count := processed_count + 1; + ELSE + UPDATE sales_orders + SET status = 'error', error_message = 'Invalid data' + WHERE order_id = sales_rec.order_id; + + error_count := error_count + 1; + END IF; + + EXCEPTION + WHEN OTHERS THEN + error_count := error_count + 1; + RAISE WARNING 'Error processing order %: %', + sales_rec.order_id, SQLERRM; + END; + END LOOP; + + RAISE INFO 'Processing complete for %: % processed, % errors', + process_date, processed_count, error_count; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with transaction management (NONATOMIC) +CREATE PROCEDURE batch_update_sp(batch_size int) NONATOMIC AS $$ +DECLARE + update_count int := 0; + total_updated int := 0; + batch_start_time timestamp; +BEGIN + batch_start_time := current_timestamp; + + LOOP + -- Update a batch of records + UPDATE customer_status + SET last_updated = current_timestamp + WHERE last_updated < current_date - interval '30 days' + AND status = 'active' + LIMIT batch_size; + + GET DIAGNOSTICS update_count = ROW_COUNT; + + IF update_count = 0 THEN + EXIT; -- No more records to update + END IF; + + total_updated := total_updated + update_count; + + -- Commit the batch + COMMIT; + + RAISE INFO 'Updated batch of % records, total: %', + update_count, total_updated; + + -- Small delay between batches + PERFORM pg_sleep(0.1); + END LOOP; + + RAISE INFO 'Batch update completed: % total records updated in %', + total_updated, (current_timestamp - batch_start_time); +END; +$$ LANGUAGE plpgsql; + +-- Procedure with no parameters +CREATE PROCEDURE maintenance_cleanup_sp() AS $$ +DECLARE + cleanup_count int; + start_time timestamp; +BEGIN + start_time := current_timestamp; + + -- Clean up temporary tables + DROP TABLE IF EXISTS temp_processing_table; + DROP TABLE IF EXISTS temp_staging_table; + + -- Clean up old log entries + DELETE FROM procedure_logs + WHERE log_date < current_date - interval '90 days'; + + GET DIAGNOSTICS cleanup_count = ROW_COUNT; + + RAISE INFO 'Maintenance cleanup completed: % old logs removed in %', + cleanup_count, (current_timestamp - start_time); +END; +$$ LANGUAGE plpgsql; + +-- Edge cases and error scenarios + +-- Procedure with maximum input parameters (approaching 32 limit) +CREATE PROCEDURE test_max_params_sp( + p1 int, p2 int, p3 int, p4 int, p5 int, p6 int, p7 int, p8 int, + p9 int, p10 int, p11 int, p12 int, p13 int, p14 int, p15 int, p16 int, + p17 int, p18 int, p19 int, p20 int, p21 int, p22 int, p23 int, p24 int, + p25 int, p26 int, p27 int, p28 int, p29 int, p30 int +) AS $$ +DECLARE + param_sum bigint := 0; + param_array int[] := ARRAY[p1,p2,p3,p4,p5,p6,p7,p8,p9,p10, + p11,p12,p13,p14,p15,p16,p17,p18,p19,p20, + p21,p22,p23,p24,p25,p26,p27,p28,p29,p30]; + param_value int; +BEGIN + FOREACH param_value IN ARRAY param_array LOOP + param_sum := param_sum + COALESCE(param_value, 0); + END LOOP; + + RAISE INFO 'Sum of 30 parameters: %', param_sum; +END; +$$ LANGUAGE plpgsql; + +-- Procedure with mixed IN/OUT/INOUT parameters (max output limit test) +CREATE PROCEDURE test_mixed_params_sp( + in1 IN int, in2 IN varchar(50), in3 IN date, + out1 OUT int, out2 OUT varchar(100), out3 OUT timestamp, + inout1 INOUT decimal(10,2), inout2 INOUT boolean +) AS $$ +BEGIN + -- Process inputs and set outputs + out1 := in1 * 2; + out2 := 'Processed: ' || in2; + out3 := in3::timestamp + interval '1 day'; + + -- Modify INOUT parameters + inout1 := inout1 * 1.1; + inout2 := NOT inout2; + + RAISE INFO 'Mixed parameter processing completed'; +END; +$$ LANGUAGE plpgsql; \ No newline at end of file diff --git a/redshift/examples/redshift/create_rls_policy.sql b/redshift/examples/redshift/create_rls_policy.sql new file mode 100644 index 0000000..6778299 --- /dev/null +++ b/redshift/examples/redshift/create_rls_policy.sql @@ -0,0 +1,123 @@ +-- CREATE RLS POLICY test cases +-- Based on AWS Redshift documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_RLS_POLICY.html + +-- Basic CREATE RLS POLICY with simple predicate +CREATE RLS POLICY policy_concerts +WITH (catgroup VARCHAR(10)) +USING (catgroup = 'Concerts'); + +-- CREATE RLS POLICY with multiple column definitions +CREATE RLS POLICY policy_sales_region +WITH (region VARCHAR(20), year INTEGER) +USING (region = 'US' AND year >= 2020); + +-- CREATE RLS POLICY with relation alias +CREATE RLS POLICY policy_user_access +WITH (user_id INTEGER) AS t +USING (user_id = current_user_id()); + +-- CREATE RLS POLICY with AS keyword explicit +CREATE RLS POLICY policy_department +WITH (dept_id INTEGER, dept_name VARCHAR(50)) AS dept_table +USING (dept_id IN (1, 2, 3)); + +-- CREATE RLS POLICY without WITH clause (minimal syntax) +CREATE RLS POLICY policy_simple +USING (status = 'active'); + +-- CREATE RLS POLICY with complex predicate using OR +CREATE RLS POLICY policy_multi_condition +WITH (category VARCHAR(30), price DECIMAL(10,2)) +USING (category = 'Electronics' OR price < 100.00); + +-- CREATE RLS POLICY with NULL checks +CREATE RLS POLICY policy_null_check +WITH (manager_id INTEGER) +USING (manager_id IS NOT NULL); + +-- CREATE RLS POLICY with LIKE operator +CREATE RLS POLICY policy_name_pattern +WITH (product_name VARCHAR(100)) +USING (product_name LIKE 'Premium%'); + +-- CREATE RLS POLICY with NOT conditions +CREATE RLS POLICY policy_exclude +WITH (status VARCHAR(20)) +USING (status NOT IN ('deleted', 'archived')); + +-- CREATE RLS POLICY with nested conditions +CREATE RLS POLICY policy_complex +WITH (user_role VARCHAR(20), department VARCHAR(30), level INTEGER) +USING ((user_role = 'admin' OR user_role = 'manager') AND department = 'finance' AND level >= 5); + +-- CREATE RLS POLICY with date/timestamp columns +CREATE RLS POLICY policy_temporal +WITH (created_date DATE, updated_timestamp TIMESTAMP) +USING (created_date >= '2023-01-01' AND updated_timestamp IS NOT NULL); + +-- CREATE RLS POLICY with different data types +CREATE RLS POLICY policy_datatypes +WITH ( + id BIGINT, + name VARCHAR(255), + active BOOLEAN, + score REAL, + precise_value DOUBLE PRECISION, + created_time TIMESTAMPTZ +) +USING (active = TRUE AND score > 0.5); + +-- CREATE RLS POLICY with CHAR and CHARACTER types +CREATE RLS POLICY policy_char_types +WITH (code CHAR(5), description CHARACTER(100)) +USING (code = 'ADMIN'); + +-- CREATE RLS POLICY with TIME types +CREATE RLS POLICY policy_time_types +WITH ( + event_time TIME, + event_timetz TIMETZ, + log_timestamp TIMESTAMP WITH TIME ZONE, + backup_time TIMESTAMP WITHOUT TIME ZONE +) +USING (event_time > '09:00:00'); + +-- CREATE RLS POLICY with function calls +CREATE RLS POLICY policy_functions +WITH (user_email VARCHAR(255)) +USING (LOWER(user_email) = current_user()); + +-- CREATE RLS POLICY with quoted identifiers +CREATE RLS POLICY "Policy With Spaces" +WITH ("Column Name" VARCHAR(50), "Another Column" INTEGER) +USING ("Column Name" = 'test'); + +-- CREATE RLS POLICY with numeric literals and comparisons +CREATE RLS POLICY policy_numeric +WITH (quantity INTEGER, price NUMERIC(10,2)) +USING (quantity >= 10 AND price <= 999.99); + +-- CREATE RLS POLICY with boolean literals +CREATE RLS POLICY policy_boolean +WITH (is_active BOOLEAN, is_premium BOOLEAN) +USING (is_active = TRUE AND is_premium = FALSE); + +-- CREATE RLS POLICY with scientific notation +CREATE RLS POLICY policy_scientific +WITH (measurement REAL) +USING (measurement > 1.5e-3); + +-- CREATE RLS POLICY testing edge cases with parentheses +CREATE RLS POLICY policy_parentheses +WITH (a INTEGER, b INTEGER, c INTEGER) +USING ((a > 0 AND b > 0) OR (c IS NULL)); + +-- CREATE RLS POLICY with complex IN clause +CREATE RLS POLICY policy_in_clause +WITH (category VARCHAR(50)) +USING (category IN ('Electronics', 'Books', 'Clothing', 'Home & Garden')); + +-- CREATE RLS POLICY with string concatenation function +CREATE RLS POLICY policy_concat +WITH (first_name VARCHAR(50), last_name VARCHAR(50)) +USING (CONCAT(first_name, ' ', last_name) = 'John Doe'); \ No newline at end of file diff --git a/redshift/examples/redshift/create_role.sql b/redshift/examples/redshift/create_role.sql new file mode 100644 index 0000000..b7c1fd6 --- /dev/null +++ b/redshift/examples/redshift/create_role.sql @@ -0,0 +1,122 @@ +-- CREATE ROLE test cases based on AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_ROLE.html + +-- Basic role creation (from AWS documentation) +CREATE ROLE sample_role1; + +-- Role creation with external ID (from AWS documentation) +CREATE ROLE sample_role1 EXTERNALID "ABC123"; + +-- Additional basic role creation examples +CREATE ROLE analytics_role; +CREATE ROLE data_reader_role; +CREATE ROLE etl_processor_role; +CREATE ROLE bi_analyst_role; +CREATE ROLE temp_role; + +-- Role names with underscores +CREATE ROLE user_management_role; +CREATE ROLE data_warehouse_admin; +CREATE ROLE customer_analytics_reader; +CREATE ROLE reporting_service_account; + +-- Quoted role names for special characters +CREATE ROLE "MyRole"; +CREATE ROLE "role-with-dash"; +CREATE ROLE "role.with.dots"; +CREATE ROLE "role with spaces"; +CREATE ROLE "UPPERCASE_ROLE"; +CREATE ROLE "Role_With_Mixed_Case"; + +-- Numeric role names (quoted) +CREATE ROLE "123role"; +CREATE ROLE "role123"; +CREATE ROLE "role_v2"; + +-- Single character role names +CREATE ROLE a; +CREATE ROLE "A"; +CREATE ROLE z; + +-- External ID variations +CREATE ROLE federated_role EXTERNALID "XYZ456"; +CREATE ROLE sso_role EXTERNALID "SSO_PROVIDER_ID_12345"; +CREATE ROLE aws_role EXTERNALID "arn:aws:iam::123456789012:role/MyRedshiftRole"; +CREATE ROLE azure_role EXTERNALID "azure-ad-group-id-abcd1234"; +CREATE ROLE okta_role EXTERNALID "okta-group-00g1emaKYMLWCQXVHDSN"; + +-- External IDs with special characters +CREATE ROLE special_char_role EXTERNALID "ID_with-special.chars@domain.com"; +CREATE ROLE unicode_role EXTERNALID "üñíçødé_íd"; +CREATE ROLE long_external_id_role EXTERNALID "very_long_external_id_that_contains_many_characters_and_underscores"; + +-- External IDs with spaces and quotes +CREATE ROLE space_role EXTERNALID "external id with spaces"; +CREATE ROLE quote_role EXTERNALID "external 'id' with quotes"; +CREATE ROLE mixed_role EXTERNALID "Mixed Case External ID 123"; + +-- Numeric external IDs +CREATE ROLE numeric_external_role EXTERNALID "123456789"; +CREATE ROLE decimal_external_role EXTERNALID "123.456.789"; + +-- Empty external ID (edge case) +CREATE ROLE empty_external_role EXTERNALID ""; + +-- Real-world use case examples +CREATE ROLE etl_service_role EXTERNALID "arn:aws:iam::987654321098:role/ETLServiceRole"; +CREATE ROLE reporting_dashboard_role EXTERNALID "tableau-service-account-xyz"; +CREATE ROLE data_scientist_role EXTERNALID "data-science-team-okta-group"; +CREATE ROLE readonly_analyst_role EXTERNALID "readonly-analysts-ad-group"; +CREATE ROLE emergency_access_role EXTERNALID "emergency-access-break-glass"; + +-- Service account patterns +CREATE ROLE airflow_dag_role EXTERNALID "airflow-production-service-account"; +CREATE ROLE kubernetes_role EXTERNALID "k8s-redshift-operator-sa"; +CREATE ROLE lambda_function_role EXTERNALID "arn:aws:iam::555666777888:role/LambdaRedshiftAccess"; + +-- Development environment roles +CREATE ROLE dev_readonly_role EXTERNALID "dev-team-readonly-access"; +CREATE ROLE staging_admin_role EXTERNALID "staging-environment-admin"; +CREATE ROLE test_data_role EXTERNALID "test-data-generator-service"; + +-- Compliance and audit roles +CREATE ROLE audit_reader_role EXTERNALID "compliance-audit-team-group"; +CREATE ROLE security_monitor_role EXTERNALID "security-monitoring-service"; +CREATE ROLE compliance_officer_role EXTERNALID "compliance-officer-access-group"; + +-- Regional and department-specific roles +CREATE ROLE north_america_analyst_role EXTERNALID "na-regional-analysts"; +CREATE ROLE europe_reader_role EXTERNALID "eu-regional-readonly"; +CREATE ROLE finance_dept_role EXTERNALID "finance-department-users"; +CREATE ROLE marketing_analytics_role EXTERNALID "marketing-analytics-team"; + +-- Temporary and contractor roles +CREATE ROLE temp_contractor_role EXTERNALID "temporary-contractor-q4-2024"; +CREATE ROLE consultant_access_role EXTERNALID "external-consultant-project-alpha"; +CREATE ROLE vendor_readonly_role EXTERNALID "vendor-readonly-limited-access"; + +-- Machine learning and data science +CREATE ROLE ml_model_role EXTERNALID "ml-model-training-service"; +CREATE ROLE data_pipeline_role EXTERNALID "automated-data-pipeline-v2"; +CREATE ROLE feature_store_role EXTERNALID "feature-store-service-account"; + +-- Case sensitivity tests +CREATE ROLE lowercase_role EXTERNALID "lowercase_external_id"; +CREATE ROLE UPPERCASE_ROLE EXTERNALID "UPPERCASE_EXTERNAL_ID"; +CREATE ROLE "CamelCaseRole" EXTERNALID "CamelCaseExternalId"; + +-- Special AWS IAM patterns +CREATE ROLE cross_account_role EXTERNALID "arn:aws:iam::111222333444:role/CrossAccountAccess"; +CREATE ROLE assume_role_pattern EXTERNALID "arn:aws:iam::123456789012:role/service-role/MyServiceRole"; +CREATE ROLE federated_web_identity EXTERNALID "arn:aws:iam::123456789012:oidc-provider/example.com"; + +-- Edge cases and boundary testing +CREATE ROLE a EXTERNALID "a"; -- Minimal role and external ID +CREATE ROLE longest_possible_role_name_within_identifier_limits EXTERNALID "longest_possible_external_id_string_that_might_be_used"; + +-- Test SQL keywords as quoted identifiers (if supported) +CREATE ROLE "SELECT" EXTERNALID "select-service-account"; +CREATE ROLE "CREATE" EXTERNALID "create-operation-role"; +CREATE ROLE "TABLE" EXTERNALID "table-management-service"; +CREATE ROLE "USER" EXTERNALID "user-management-system"; +CREATE ROLE "ROLE" EXTERNALID "role-management-service"; \ No newline at end of file diff --git a/redshift/examples/redshift/create_schema.sql b/redshift/examples/redshift/create_schema.sql new file mode 100644 index 0000000..cd1f613 --- /dev/null +++ b/redshift/examples/redshift/create_schema.sql @@ -0,0 +1,198 @@ +-- CREATE SCHEMA test cases based on AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA.html + +-- Basic schema creation (from AWS documentation) +CREATE SCHEMA us_sales; + +-- Schema with authorization (from AWS documentation) +CREATE SCHEMA us_sales AUTHORIZATION dwuser; + +-- Schema with quota (from AWS documentation) +CREATE SCHEMA us_sales AUTHORIZATION dwuser QUOTA 50 GB; + +-- Schema with IF NOT EXISTS (from AWS documentation) +CREATE SCHEMA IF NOT EXISTS us_sales; + +-- Basic schema variations +CREATE SCHEMA sales; +CREATE SCHEMA marketing; +CREATE SCHEMA finance; +CREATE SCHEMA hr; +CREATE SCHEMA analytics; +CREATE SCHEMA reporting; +CREATE SCHEMA data_warehouse; +CREATE SCHEMA staging; +CREATE SCHEMA temp; +CREATE SCHEMA archive; + +-- Schema names with underscores +CREATE SCHEMA customer_data; +CREATE SCHEMA product_catalog; +CREATE SCHEMA order_management; +CREATE SCHEMA user_analytics; +CREATE SCHEMA financial_reporting; +CREATE SCHEMA marketing_campaigns; +CREATE SCHEMA supply_chain; +CREATE SCHEMA inventory_management; +CREATE SCHEMA compliance_audit; +CREATE SCHEMA data_science; + +-- Quoted schema names for special characters +CREATE SCHEMA "MySchema"; +CREATE SCHEMA "schema-with-dash"; +CREATE SCHEMA "schema.with.dots"; +CREATE SCHEMA "schema with spaces"; +CREATE SCHEMA "UPPERCASE_SCHEMA"; +CREATE SCHEMA "Schema_With_Mixed_Case"; +CREATE SCHEMA "123schema"; +CREATE SCHEMA "schema123"; +CREATE SCHEMA "schema_v2"; + +-- Single character schema names +CREATE SCHEMA a; +CREATE SCHEMA "A"; +CREATE SCHEMA z; + +-- IF NOT EXISTS variations +CREATE SCHEMA IF NOT EXISTS customer_data; +CREATE SCHEMA IF NOT EXISTS product_catalog; +CREATE SCHEMA IF NOT EXISTS "Special Schema"; +CREATE SCHEMA IF NOT EXISTS analytics AUTHORIZATION admin_user; +CREATE SCHEMA IF NOT EXISTS reporting AUTHORIZATION report_user QUOTA 100 GB; +CREATE SCHEMA IF NOT EXISTS temp_schema QUOTA UNLIMITED; + +-- Authorization variations +CREATE SCHEMA sales_dept AUTHORIZATION sales_manager; +CREATE SCHEMA marketing_dept AUTHORIZATION marketing_lead; +CREATE SCHEMA finance_dept AUTHORIZATION finance_admin; +CREATE SCHEMA analytics_team AUTHORIZATION data_scientist; +CREATE SCHEMA reporting_service AUTHORIZATION service_account; +CREATE SCHEMA external_data AUTHORIZATION external_user; +CREATE SCHEMA vendor_access AUTHORIZATION vendor_account; +CREATE SCHEMA contractor_space AUTHORIZATION temp_contractor; +CREATE SCHEMA audit_logs AUTHORIZATION compliance_officer; +CREATE SCHEMA ml_workspace AUTHORIZATION ml_engineer; + +-- Quoted authorization users +CREATE SCHEMA special_project AUTHORIZATION "User With Spaces"; +CREATE SCHEMA legacy_system AUTHORIZATION "legacy-service-account"; +CREATE SCHEMA cross_region AUTHORIZATION "cross.region.user"; +CREATE SCHEMA federated_access AUTHORIZATION "FEDERATED_USER"; +CREATE SCHEMA service_integration AUTHORIZATION "service_account_123"; + +-- Quota variations with MB +CREATE SCHEMA small_schema QUOTA 100 MB; +CREATE SCHEMA test_schema QUOTA 500 MB; +CREATE SCHEMA temp_data QUOTA 1024 MB; +CREATE SCHEMA cache_schema QUOTA 2048 MB; +CREATE SCHEMA sample_data QUOTA 50 MB; + +-- Quota variations with GB +CREATE SCHEMA medium_schema QUOTA 1 GB; +CREATE SCHEMA user_workspace QUOTA 5 GB; +CREATE SCHEMA project_data QUOTA 10 GB; +CREATE SCHEMA department_analytics QUOTA 25 GB; +CREATE SCHEMA staging_area QUOTA 100 GB; +CREATE SCHEMA historical_data QUOTA 250 GB; +CREATE SCHEMA backup_schema QUOTA 500 GB; +CREATE SCHEMA data_lake QUOTA 1000 GB; + +-- Quota variations with TB +CREATE SCHEMA enterprise_data QUOTA 1 TB; +CREATE SCHEMA big_analytics QUOTA 5 TB; +CREATE SCHEMA data_warehouse_main QUOTA 10 TB; +CREATE SCHEMA historical_archive QUOTA 25 TB; +CREATE SCHEMA raw_data_lake QUOTA 50 TB; +CREATE SCHEMA enterprise_backup QUOTA 100 TB; + +-- Decimal quota values +CREATE SCHEMA fractional_quota_mb QUOTA 100.5 MB; +CREATE SCHEMA fractional_quota_gb QUOTA 1.5 GB; +CREATE SCHEMA fractional_quota_tb QUOTA 2.25 TB; +CREATE SCHEMA precise_allocation QUOTA 10.75 GB; +CREATE SCHEMA micro_allocation QUOTA 0.5 GB; + +-- UNLIMITED quota +CREATE SCHEMA unlimited_schema QUOTA UNLIMITED; +CREATE SCHEMA no_limit_data QUOTA UNLIMITED; +CREATE SCHEMA enterprise_unlimited QUOTA UNLIMITED; + +-- Full syntax combinations +CREATE SCHEMA IF NOT EXISTS sales_analytics AUTHORIZATION sales_analyst QUOTA 50 GB; +CREATE SCHEMA IF NOT EXISTS marketing_data AUTHORIZATION marketing_team QUOTA 25 GB; +CREATE SCHEMA IF NOT EXISTS finance_reports AUTHORIZATION finance_admin QUOTA 100 GB; +CREATE SCHEMA IF NOT EXISTS hr_analytics AUTHORIZATION hr_manager QUOTA 10 GB; +CREATE SCHEMA IF NOT EXISTS customer_insights AUTHORIZATION data_scientist QUOTA 200 GB; +CREATE SCHEMA IF NOT EXISTS product_metrics AUTHORIZATION product_manager QUOTA 75 GB; +CREATE SCHEMA IF NOT EXISTS operational_data AUTHORIZATION ops_team QUOTA 500 GB; +CREATE SCHEMA IF NOT EXISTS compliance_audit AUTHORIZATION compliance_officer QUOTA 50 GB; +CREATE SCHEMA IF NOT EXISTS vendor_data AUTHORIZATION vendor_manager QUOTA 25 GB; +CREATE SCHEMA IF NOT EXISTS research_lab AUTHORIZATION research_lead QUOTA UNLIMITED; + +-- Complex quoted combinations +CREATE SCHEMA IF NOT EXISTS "Complex Schema Name" AUTHORIZATION "Complex User Name" QUOTA 100 GB; +CREATE SCHEMA IF NOT EXISTS "schema-with-special.chars" AUTHORIZATION "user-with-special.chars" QUOTA 50 GB; +CREATE SCHEMA IF NOT EXISTS "2024_Q4_Analysis" AUTHORIZATION "quarterly.analyst" QUOTA 200 GB; +CREATE SCHEMA IF NOT EXISTS "Multi Word Schema" AUTHORIZATION "Multi Word User" QUOTA 150 GB; + +-- Real-world departmental schemas +CREATE SCHEMA customer_360 AUTHORIZATION customer_analytics_team QUOTA 500 GB; +CREATE SCHEMA fraud_detection AUTHORIZATION security_team QUOTA 100 GB; +CREATE SCHEMA recommendation_engine AUTHORIZATION ml_team QUOTA 250 GB; +CREATE SCHEMA supply_chain_optimization AUTHORIZATION operations_team QUOTA 300 GB; +CREATE SCHEMA financial_risk_modeling AUTHORIZATION risk_management QUOTA 200 GB; +CREATE SCHEMA marketing_attribution AUTHORIZATION marketing_analytics QUOTA 150 GB; +CREATE SCHEMA product_performance AUTHORIZATION product_analytics QUOTA 100 GB; +CREATE SCHEMA user_behavior_analysis AUTHORIZATION ux_research_team QUOTA 75 GB; +CREATE SCHEMA competitive_intelligence AUTHORIZATION strategy_team QUOTA 50 GB; +CREATE SCHEMA regulatory_reporting AUTHORIZATION compliance_team QUOTA 25 GB; + +-- Geographic/regional schemas +CREATE SCHEMA north_america_sales AUTHORIZATION na_sales_manager QUOTA 500 GB; +CREATE SCHEMA europe_analytics AUTHORIZATION eu_analyst QUOTA 300 GB; +CREATE SCHEMA asia_pacific_data AUTHORIZATION apac_team QUOTA 400 GB; +CREATE SCHEMA latin_america_metrics AUTHORIZATION latam_manager QUOTA 200 GB; +CREATE SCHEMA global_consolidated AUTHORIZATION global_admin QUOTA 1 TB; + +-- Time-based schemas +CREATE SCHEMA daily_operations AUTHORIZATION daily_ops QUOTA 100 GB; +CREATE SCHEMA weekly_reports AUTHORIZATION weekly_analyst QUOTA 50 GB; +CREATE SCHEMA monthly_analytics AUTHORIZATION monthly_reporter QUOTA 200 GB; +CREATE SCHEMA quarterly_insights AUTHORIZATION quarterly_analyst QUOTA 500 GB; +CREATE SCHEMA annual_archive AUTHORIZATION archive_manager QUOTA 2 TB; + +-- Project-specific schemas +CREATE SCHEMA project_alpha AUTHORIZATION project_lead_alpha QUOTA 100 GB; +CREATE SCHEMA project_beta AUTHORIZATION project_lead_beta QUOTA 150 GB; +CREATE SCHEMA project_gamma AUTHORIZATION project_lead_gamma QUOTA 75 GB; +CREATE SCHEMA migration_workspace AUTHORIZATION migration_team QUOTA 500 GB; +CREATE SCHEMA integration_testing AUTHORIZATION qa_team QUOTA 200 GB; + +-- Service and application schemas +CREATE SCHEMA web_analytics AUTHORIZATION web_team QUOTA 300 GB; +CREATE SCHEMA mobile_analytics AUTHORIZATION mobile_team QUOTA 200 GB; +CREATE SCHEMA api_metrics AUTHORIZATION api_team QUOTA 100 GB; +CREATE SCHEMA etl_staging AUTHORIZATION etl_service QUOTA 500 GB; +CREATE SCHEMA data_quality AUTHORIZATION dq_team QUOTA 50 GB; + +-- Development lifecycle schemas +CREATE SCHEMA dev_sandbox AUTHORIZATION developer QUOTA 10 GB; +CREATE SCHEMA test_environment AUTHORIZATION test_team QUOTA 50 GB; +CREATE SCHEMA staging_validation AUTHORIZATION staging_team QUOTA 100 GB; +CREATE SCHEMA production_replica AUTHORIZATION prod_admin QUOTA 1 TB; +CREATE SCHEMA backup_recovery AUTHORIZATION backup_service QUOTA 2 TB; + +-- Edge cases and boundary testing +CREATE SCHEMA a AUTHORIZATION b QUOTA 1 MB; -- Minimal schema +CREATE SCHEMA longest_possible_schema_name_within_limits AUTHORIZATION longest_possible_user_name_within_limits QUOTA 999999 TB; + +-- Case sensitivity tests +CREATE SCHEMA lowercase_schema AUTHORIZATION lowercase_user QUOTA 10 gb; +CREATE SCHEMA UPPERCASE_SCHEMA AUTHORIZATION UPPERCASE_USER QUOTA 10 GB; +CREATE SCHEMA "CamelCaseSchema" AUTHORIZATION "CamelCaseUser" QUOTA 10 GB; + +-- SQL keywords as quoted identifiers (edge case testing) +CREATE SCHEMA "SELECT" AUTHORIZATION "CREATE" QUOTA 10 GB; +CREATE SCHEMA "TABLE" AUTHORIZATION "USER" QUOTA 5 GB; +CREATE SCHEMA "SCHEMA" AUTHORIZATION "AUTHORIZATION" QUOTA 1 GB; +CREATE SCHEMA "QUOTA" AUTHORIZATION "UNLIMITED" QUOTA UNLIMITED; \ No newline at end of file diff --git a/redshift/examples/redshift/create_table.sql b/redshift/examples/redshift/create_table.sql new file mode 100644 index 0000000..0fe52de --- /dev/null +++ b/redshift/examples/redshift/create_table.sql @@ -0,0 +1,504 @@ +-- CREATE TABLE test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE.html + +-- ==================================== +-- Basic table creation +-- ==================================== + +-- Simple table with basic data types +CREATE TABLE users ( + user_id INTEGER, + username VARCHAR(50), + email VARCHAR(255), + created_date DATE +); + +-- Table with IF NOT EXISTS +CREATE TABLE IF NOT EXISTS products ( + product_id INTEGER, + product_name VARCHAR(100), + price DECIMAL(10,2), + category VARCHAR(50) +); + +-- Table with schema qualification +CREATE TABLE public.orders ( + order_id BIGINT, + user_id INTEGER, + order_date TIMESTAMP, + total_amount DECIMAL(12,2) +); + +-- ==================================== +-- Data types testing +-- ==================================== + +-- All numeric types +CREATE TABLE numeric_types ( + col_smallint SMALLINT, + col_integer INTEGER, + col_int INT, + col_int2 INT2, + col_int4 INT4, + col_int8 INT8, + col_bigint BIGINT, + col_decimal DECIMAL(10,2), + col_numeric NUMERIC(15,4), + col_real REAL, + col_float4 FLOAT4, + col_double DOUBLE PRECISION, + col_float8 FLOAT8, + col_float FLOAT +); + +-- Boolean and character types +CREATE TABLE char_types ( + col_boolean BOOLEAN, + col_bool BOOL, + col_char CHAR(10), + col_character CHARACTER(20), + col_nchar NCHAR(15), + col_bpchar BPCHAR(25), + col_varchar VARCHAR(255), + col_character_varying CHARACTER VARYING(100), + col_nvarchar NVARCHAR(200), + col_text TEXT, + col_string STRING +); + +-- Binary and special types +CREATE TABLE special_types ( + col_varbyte VARBYTE(1024), + col_varbinary VARBINARY(512), + col_binary_varying BINARY VARYING(256), + col_date DATE, + col_timestamp TIMESTAMP, + col_timestamp_tz TIMESTAMP WITH TIME ZONE, + col_timestamptz TIMESTAMPTZ, + col_time TIME, + col_time_tz TIME WITH TIME ZONE, + col_timetz TIMETZ, + col_geometry GEOMETRY, + col_geography GEOGRAPHY, + col_hllsketch HLLSKETCH, + col_super SUPER +); + +-- ==================================== +-- Column constraints +-- ==================================== + +-- NOT NULL and DEFAULT constraints +CREATE TABLE customer_info ( + customer_id INTEGER NOT NULL, + first_name VARCHAR(50) NOT NULL, + last_name VARCHAR(50) NOT NULL, + email VARCHAR(255) UNIQUE NOT NULL, + phone VARCHAR(20), + status VARCHAR(20) DEFAULT 'active', + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP +); + +-- IDENTITY columns +CREATE TABLE products_with_identity ( + product_id INTEGER IDENTITY(1,1), + product_name VARCHAR(100) NOT NULL, + price DECIMAL(10,2) NOT NULL +); + +-- GENERATED IDENTITY columns +CREATE TABLE orders_with_generated_identity ( + order_id BIGINT GENERATED ALWAYS AS IDENTITY, + customer_id INTEGER NOT NULL, + order_date DATE DEFAULT CURRENT_DATE +); + +-- ==================================== +-- Primary and Foreign Keys +-- ==================================== + +-- Primary key constraint +CREATE TABLE categories ( + category_id INTEGER PRIMARY KEY, + category_name VARCHAR(100) NOT NULL, + description TEXT +); + +-- Foreign key constraint +CREATE TABLE product_catalog ( + product_id INTEGER PRIMARY KEY, + product_name VARCHAR(100) NOT NULL, + category_id INTEGER REFERENCES categories(category_id), + price DECIMAL(10,2) NOT NULL +); + +-- Multiple foreign key constraints with referential actions +CREATE TABLE order_items ( + order_item_id INTEGER PRIMARY KEY, + order_id INTEGER REFERENCES orders(order_id), + product_id INTEGER REFERENCES product_catalog(product_id), + quantity INTEGER NOT NULL, + unit_price DECIMAL(10,2) NOT NULL +); + +-- ==================================== +-- Redshift-specific: DISTKEY and SORTKEY +-- ==================================== + +-- Single column DISTKEY +CREATE TABLE user_activity ( + user_id INTEGER DISTKEY, + activity_date DATE SORTKEY, + page_views INTEGER, + session_duration INTERVAL +); + +-- Table-level DISTKEY +CREATE TABLE sales_summary ( + sale_id INTEGER, + customer_id INTEGER, + sale_date DATE, + amount DECIMAL(10,2) +) +DISTKEY(customer_id); + +-- Compound SORTKEY +CREATE TABLE time_series_data ( + timestamp TIMESTAMP, + sensor_id INTEGER, + temperature DECIMAL(5,2), + humidity DECIMAL(5,2) +) +SORTKEY(timestamp, sensor_id); + +-- Interleaved SORTKEY +CREATE TABLE customer_events ( + customer_id INTEGER, + event_date DATE, + event_type VARCHAR(50), + event_data TEXT +) +INTERLEAVED SORTKEY(customer_id, event_date); + +-- ==================================== +-- Redshift-specific: DISTSTYLE +-- ==================================== + +-- DISTSTYLE ALL +CREATE TABLE lookup_table ( + lookup_id INTEGER PRIMARY KEY, + lookup_value VARCHAR(100) +) +DISTSTYLE ALL; + +-- DISTSTYLE EVEN +CREATE TABLE log_data ( + log_id BIGINT, + timestamp TIMESTAMP, + message TEXT +) +DISTSTYLE EVEN; + +-- DISTSTYLE KEY with explicit DISTKEY +CREATE TABLE customer_orders ( + order_id BIGINT, + customer_id INTEGER, + order_date DATE, + total_amount DECIMAL(12,2) +) +DISTSTYLE KEY +DISTKEY(customer_id); + +-- DISTSTYLE AUTO +CREATE TABLE smart_distribution ( + id INTEGER, + data VARCHAR(1000), + created_at TIMESTAMP +) +DISTSTYLE AUTO; + +-- ==================================== +-- Redshift-specific: ENCODE +-- ==================================== + +-- Column-level encoding +CREATE TABLE encoded_data ( + id INTEGER ENCODE RAW, + name VARCHAR(100) ENCODE LZO, + description TEXT ENCODE ZSTD, + amount DECIMAL(10,2) ENCODE AZ64, + category_id INTEGER ENCODE DELTA, + created_date DATE ENCODE DELTA32K +); + +-- Table-level auto encoding +CREATE TABLE auto_encoded ( + id INTEGER, + data VARCHAR(1000), + timestamp TIMESTAMP +) +ENCODE AUTO; + +-- Various encoding types +CREATE TABLE encoding_examples ( + col_raw INTEGER ENCODE RAW, + col_az64 BIGINT ENCODE AZ64, + col_bytedict VARCHAR(50) ENCODE BYTEDICT, + col_delta INTEGER ENCODE DELTA, + col_delta32k INTEGER ENCODE DELTA32K, + col_lzo TEXT ENCODE LZO, + col_mostly8 INTEGER ENCODE MOSTLY8, + col_mostly16 INTEGER ENCODE MOSTLY16, + col_mostly32 INTEGER ENCODE MOSTLY32, + col_runlength VARCHAR(10) ENCODE RUNLENGTH, + col_text255 VARCHAR(255) ENCODE TEXT255, + col_text32k VARCHAR(32000) ENCODE TEXT32K, + col_zstd TEXT ENCODE ZSTD +); + +-- ==================================== +-- Redshift-specific: BACKUP +-- ==================================== + +-- Table with backup enabled +CREATE TABLE important_data ( + id INTEGER PRIMARY KEY, + critical_info TEXT NOT NULL +) +BACKUP YES; + +-- Table with backup disabled +CREATE TABLE temporary_data ( + id INTEGER, + temp_value VARCHAR(100) +) +BACKUP NO; + +-- ==================================== +-- Comprehensive table with all features +-- ==================================== + +-- Complex table combining multiple Redshift features +CREATE TABLE comprehensive_table ( + id BIGINT GENERATED ALWAYS AS IDENTITY, + user_id INTEGER NOT NULL DISTKEY, + transaction_date DATE NOT NULL SORTKEY, + transaction_type VARCHAR(20) NOT NULL ENCODE BYTEDICT, + amount DECIMAL(15,2) NOT NULL ENCODE AZ64, + description TEXT ENCODE LZO, + region VARCHAR(10) DEFAULT 'US' ENCODE RUNLENGTH, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + updated_at TIMESTAMP, + CONSTRAINT pk_comprehensive PRIMARY KEY (id), + CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES users(user_id), + CONSTRAINT chk_transaction_type +) +BACKUP YES +DISTSTYLE KEY; + +-- ==================================== +-- Table constraints (table-level) +-- ==================================== + +-- Table with multiple table-level constraints +CREATE TABLE order_management ( + order_id INTEGER, + customer_id INTEGER, + order_date DATE, + ship_date DATE, + order_status VARCHAR(20), + total_amount DECIMAL(12,2), + PRIMARY KEY (order_id), + FOREIGN KEY (customer_id) REFERENCES customers(customer_id) ON DELETE RESTRICT, + UNIQUE (order_id, customer_id) +); + +-- ==================================== +-- Temporary tables +-- ==================================== + +-- Temporary table +CREATE TEMPORARY TABLE temp_calculations ( + calc_id INTEGER, + input_value DECIMAL(10,2), + result_value DECIMAL(15,4) +); + +-- Local temporary table +CREATE LOCAL TEMPORARY TABLE local_temp_data ( + session_id VARCHAR(50), + data_point DECIMAL(10,2), + timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +-- Temp table (short form) +CREATE TEMP TABLE quick_temp ( + id INTEGER, + value VARCHAR(100) +); + +-- ==================================== +-- CREATE TABLE AS (CTAS) +-- ==================================== + +-- Simple CTAS +CREATE TABLE customer_summary AS +SELECT customer_id, COUNT(*) as order_count, SUM(total_amount) as total_spent +FROM orders +GROUP BY customer_id; + +-- CTAS with table options +CREATE TABLE sales_analysis +DISTSTYLE KEY +DISTKEY(region) +SORTKEY(sale_date) +AS +SELECT region, sale_date, SUM(amount) as daily_sales +FROM sales_data +GROUP BY region, sale_date; + +CREATE TABLE monthly_aggregates AS +SELECT + EXTRACT(YEAR FROM order_date) as order_year, + EXTRACT(MONTH FROM order_date) as order_month, + COUNT(*) as order_count, + AVG(total_amount) as avg_order_value +FROM orders +GROUP BY EXTRACT(YEAR FROM order_date), EXTRACT(MONTH FROM order_date); + +-- ==================================== +-- Complex data type specifications +-- ==================================== + +-- Precision and scale specifications +CREATE TABLE precise_numbers ( + tiny_decimal DECIMAL(3,2), + medium_decimal DECIMAL(10,4), + large_decimal DECIMAL(38,10), + small_numeric NUMERIC(5,2), + large_numeric NUMERIC(38,18) +); + +-- Length specifications for character types +CREATE TABLE string_lengths ( + short_char CHAR(5), + medium_varchar VARCHAR(100), + long_varchar VARCHAR(65535), + tiny_nchar NCHAR(10), + medium_nvarchar NVARCHAR(500) +); + +-- ==================================== +-- Edge cases and boundary testing +-- ==================================== + +-- Maximum length identifiers and minimal table +CREATE TABLE a (a INT); + +-- Mixed case and quoted identifiers +CREATE TABLE "MixedCaseTable" ( + "ColumnWithSpaces And Special-Chars" VARCHAR(100), + "UPPERCASE_COLUMN" INTEGER, + "lowercase_column" DECIMAL(10,2) +); + +-- Table with all constraint types +CREATE TABLE constraint_showcase ( + id INTEGER IDENTITY(1,1) PRIMARY KEY, + code VARCHAR(10) NOT NULL UNIQUE, + name VARCHAR(100) NOT NULL, + parent_id INTEGER REFERENCES constraint_showcase(id), + value DECIMAL(10,2) DEFAULT 0, + status CHAR(1) DEFAULT 'A', + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL +); + +-- Table with complex referential integrity +CREATE TABLE parent_table ( + parent_id INTEGER PRIMARY KEY, + parent_name VARCHAR(100) NOT NULL +); + +CREATE TABLE child_table ( + child_id INTEGER PRIMARY KEY, + parent_id INTEGER NOT NULL, + child_name VARCHAR(100) NOT NULL, + FOREIGN KEY (parent_id) REFERENCES parent_table(parent_id) + ON DELETE CASCADE + ON UPDATE CASCADE +); + +-- ==================================== +-- Real-world examples +-- ==================================== + +-- E-commerce product catalog +CREATE TABLE product_inventory ( + sku VARCHAR(50) PRIMARY KEY, + product_name VARCHAR(200) NOT NULL, + brand VARCHAR(100) ENCODE BYTEDICT, + category VARCHAR(50) ENCODE BYTEDICT, + price DECIMAL(10,2) NOT NULL, + cost DECIMAL(10,2), + quantity_on_hand INTEGER DEFAULT 0, + reorder_level INTEGER DEFAULT 10, + supplier_id INTEGER, + weight_kg DECIMAL(8,3), + dimensions_cm VARCHAR(50), + is_active BOOLEAN DEFAULT TRUE, + created_date DATE DEFAULT CURRENT_DATE, + last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP +) +DISTSTYLE KEY +DISTKEY(category) +SORTKEY(brand, product_name); + +-- Customer relationship management +CREATE TABLE customer_profiles ( + customer_id BIGINT GENERATED ALWAYS AS IDENTITY, + customer_type VARCHAR(20) DEFAULT 'INDIVIDUAL' ENCODE BYTEDICT, + first_name VARCHAR(100), + last_name VARCHAR(100), + company_name VARCHAR(200), + email VARCHAR(255) UNIQUE, + phone VARCHAR(20), + address_line1 VARCHAR(200), + address_line2 VARCHAR(200), + city VARCHAR(100), + state_province VARCHAR(100), + postal_code VARCHAR(20), + country VARCHAR(2) DEFAULT 'US', + registration_date DATE DEFAULT CURRENT_DATE, + last_login TIMESTAMP, + total_orders INTEGER DEFAULT 0, + lifetime_value DECIMAL(12,2) DEFAULT 0, + credit_limit DECIMAL(10,2), + is_vip BOOLEAN DEFAULT FALSE, + notes TEXT, + PRIMARY KEY (customer_id) +) +BACKUP YES +DISTSTYLE AUTO; + + +-- Financial transactions table +CREATE TABLE financial_transactions ( + transaction_id BIGINT IDENTITY(1000000000, 1), + account_id BIGINT NOT NULL DISTKEY, + transaction_date TIMESTAMP NOT NULL SORTKEY, + transaction_type VARCHAR(20) NOT NULL ENCODE BYTEDICT, + amount DECIMAL(15,2) NOT NULL, + currency CHAR(3) DEFAULT 'USD' ENCODE BYTEDICT, + description VARCHAR(500) ENCODE LZO, + reference_number VARCHAR(50), + balance_after DECIMAL(15,2), + fee_amount DECIMAL(8,2) DEFAULT 0, + exchange_rate DECIMAL(10,6), + processed_by VARCHAR(100), + processed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + status VARCHAR(20) DEFAULT 'COMPLETED' ENCODE BYTEDICT, + PRIMARY KEY (transaction_id) +) +BACKUP YES +DISTSTYLE KEY; diff --git a/redshift/examples/redshift/create_table_as.sql b/redshift/examples/redshift/create_table_as.sql new file mode 100644 index 0000000..0ee8505 --- /dev/null +++ b/redshift/examples/redshift/create_table_as.sql @@ -0,0 +1,666 @@ +-- CREATE TABLE AS test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_TABLE_AS.html + +-- ==================================== +-- Basic CREATE TABLE AS (CTAS) +-- ==================================== + +-- Simple CTAS with SELECT statement +CREATE TABLE customer_summary AS +SELECT customer_id, COUNT(*) as order_count, SUM(total_amount) as total_spent +FROM orders +GROUP BY customer_id; + +-- CTAS with column list specification +CREATE TABLE monthly_sales (year_month, total_sales, order_count) AS +SELECT + DATE_TRUNC('month', order_date) as year_month, + SUM(amount) as total_sales, + COUNT(*) as order_count +FROM sales +GROUP BY DATE_TRUNC('month', order_date); + +CREATE TABLE daily_aggregates AS +SELECT + order_date, + COUNT(*) as daily_orders, + AVG(total_amount) as avg_order_value, + SUM(total_amount) as daily_revenue +FROM orders +GROUP BY order_date; + +-- ==================================== +-- Temporary tables with CTAS +-- ==================================== + +-- Temporary table with CTAS +CREATE TEMPORARY TABLE temp_user_stats AS +SELECT + user_id, + COUNT(*) as login_count, + MAX(last_login) as last_activity +FROM user_sessions +GROUP BY user_id; + +-- Local temporary table with CTAS +CREATE LOCAL TEMPORARY TABLE local_temp_analysis AS +SELECT + product_id, + AVG(rating) as avg_rating, + COUNT(review_id) as review_count +FROM product_reviews +WHERE created_date >= CURRENT_DATE - INTERVAL '30 days' +GROUP BY product_id; + +-- Short form temporary table +CREATE TEMP TABLE quick_summary AS +SELECT category, COUNT(*) as product_count +FROM products +WHERE status = 'active' +GROUP BY category; + +-- Table name with # prefix (automatically temporary) +CREATE TABLE #session_data AS +SELECT session_id, user_id, duration_minutes +FROM user_sessions +WHERE session_date = CURRENT_DATE; + +-- ==================================== +-- BACKUP option +-- ==================================== + +-- CTAS with BACKUP YES +CREATE TABLE important_customer_data +BACKUP YES +AS +SELECT + customer_id, + registration_date, + total_purchases, + loyalty_tier +FROM customers +WHERE total_purchases > 1000; + +-- CTAS with BACKUP NO +CREATE TABLE temp_calculations +BACKUP NO +AS +SELECT + product_id, + cost_price * 1.3 as suggested_price, + inventory_count * cost_price as inventory_value +FROM product_inventory; + +-- ==================================== +-- Distribution styles (DISTSTYLE) +-- ==================================== + +-- DISTSTYLE ALL - replicate to all nodes +CREATE TABLE lookup_categories +DISTSTYLE ALL +AS +SELECT category_id, category_name, parent_category +FROM product_categories +WHERE is_active = true; + +-- DISTSTYLE EVEN - distribute evenly +CREATE TABLE log_analysis +DISTSTYLE EVEN +AS +SELECT + DATE_TRUNC('hour', timestamp) as hour_bucket, + COUNT(*) as event_count, + COUNT(DISTINCT user_id) as unique_users +FROM event_logs +GROUP BY DATE_TRUNC('hour', timestamp); + +-- DISTSTYLE KEY with DISTKEY +CREATE TABLE customer_orders +DISTSTYLE KEY +DISTKEY(customer_id) +AS +SELECT + customer_id, + order_id, + order_date, + total_amount, + order_status +FROM orders +WHERE order_date >= '2023-01-01'; + +-- DISTSTYLE AUTO - let Redshift choose +CREATE TABLE smart_distribution +DISTSTYLE AUTO +AS +SELECT + region, + sale_date, + SUM(amount) as regional_sales, + COUNT(*) as transaction_count +FROM sales_transactions +GROUP BY region, sale_date; + +-- ==================================== +-- Sort keys (SORTKEY) +-- ==================================== + +-- COMPOUND SORTKEY (default) +CREATE TABLE time_series_data +SORTKEY(timestamp, sensor_id) +AS +SELECT + timestamp, + sensor_id, + temperature, + humidity, + pressure +FROM sensor_readings +WHERE timestamp >= CURRENT_DATE - INTERVAL '7 days'; + +-- Explicit COMPOUND SORTKEY +CREATE TABLE sales_analysis +COMPOUND SORTKEY(sale_date, region) +AS +SELECT + sale_date, + region, + product_category, + SUM(amount) as daily_sales, + COUNT(*) as transaction_count +FROM sales_data +GROUP BY sale_date, region, product_category; + +-- INTERLEAVED SORTKEY +CREATE TABLE customer_events +INTERLEAVED SORTKEY(customer_id, event_date) +AS +SELECT + customer_id, + event_date, + event_type, + session_id, + page_url +FROM web_events +WHERE event_date >= '2023-01-01'; + +-- ==================================== +-- Multiple table attributes +-- ==================================== + +-- Combining DISTSTYLE, DISTKEY, SORTKEY, and BACKUP +CREATE TABLE comprehensive_sales +BACKUP YES +DISTSTYLE KEY +DISTKEY(customer_id) +SORTKEY(order_date, order_id) +AS +SELECT + customer_id, + order_id, + order_date, + product_id, + quantity, + unit_price, + total_amount, + region +FROM order_details od +JOIN orders o ON od.order_id = o.order_id +WHERE o.order_date >= '2023-01-01'; + +-- Complex table with INTERLEAVED SORTKEY and DISTSTYLE AUTO +CREATE TABLE user_activity_summary +BACKUP NO +DISTSTYLE AUTO +INTERLEAVED SORTKEY(user_id, activity_date) +AS +SELECT + user_id, + activity_date, + page_views, + session_count, + total_time_spent, + purchases_made +FROM ( + SELECT + user_id, + DATE(activity_timestamp) as activity_date, + COUNT(DISTINCT page_id) as page_views, + COUNT(DISTINCT session_id) as session_count, + SUM(time_on_page) as total_time_spent, + COUNT(purchase_id) as purchases_made + FROM user_activity_log + WHERE activity_timestamp >= CURRENT_DATE - INTERVAL '90 days' + GROUP BY user_id, DATE(activity_timestamp) +) subquery; + +-- ==================================== +-- ENCODE AUTO +-- ==================================== + +-- Combining ENCODE AUTO with other attributes +CREATE TABLE optimized_table +BACKUP YES +DISTSTYLE KEY +DISTKEY(region) +SORTKEY(created_date) +AS +SELECT + region, + customer_segment, + created_date, + revenue, + customer_count +FROM regional_summary; + +-- ==================================== +-- Complex SELECT statements +-- ==================================== + +-- CTAS with JOINs +CREATE TABLE customer_order_summary AS +SELECT + c.customer_id, + c.customer_name, + c.email, + COUNT(o.order_id) as total_orders, + SUM(o.total_amount) as lifetime_value, + AVG(o.total_amount) as avg_order_value, + MIN(o.order_date) as first_order, + MAX(o.order_date) as last_order +FROM customers c +LEFT JOIN orders o ON c.customer_id = o.customer_id +GROUP BY c.customer_id, c.customer_name, c.email; + +-- CTAS with multiple JOINs and WHERE clause +CREATE TABLE product_performance AS +SELECT + p.product_id, + p.product_name, + p.category, + COUNT(oi.order_item_id) as times_ordered, + SUM(oi.quantity) as total_quantity_sold, + SUM(oi.quantity * oi.unit_price) as total_revenue, + AVG(pr.rating) as avg_rating, + COUNT(pr.review_id) as review_count +FROM products p +LEFT JOIN order_items oi ON p.product_id = oi.product_id +LEFT JOIN product_reviews pr ON p.product_id = pr.product_id +WHERE p.status = 'active' +GROUP BY p.product_id, p.product_name, p.category +HAVING COUNT(oi.order_item_id) > 0; + +-- CTAS with window functions +CREATE TABLE sales_rankings AS +SELECT + salesperson_id, + sales_month, + monthly_sales, + RANK() OVER (PARTITION BY sales_month ORDER BY monthly_sales DESC) as monthly_rank, + LAG(monthly_sales, 1) OVER (PARTITION BY salesperson_id ORDER BY sales_month) as prev_month_sales, + SUM(monthly_sales) OVER (PARTITION BY salesperson_id ORDER BY sales_month ROWS UNBOUNDED PRECEDING) as running_total +FROM ( + SELECT + salesperson_id, + DATE_TRUNC('month', sale_date) as sales_month, + SUM(amount) as monthly_sales + FROM sales + GROUP BY salesperson_id, DATE_TRUNC('month', sale_date) +) monthly_data; + +-- CTAS with CTE (Common Table Expression) +CREATE TABLE customer_segmentation AS +WITH customer_stats AS ( + SELECT + customer_id, + COUNT(*) as order_count, + SUM(total_amount) as total_spent, + AVG(total_amount) as avg_order_value, + MAX(order_date) as last_order_date, + MIN(order_date) as first_order_date + FROM orders + WHERE order_date >= '2022-01-01' + GROUP BY customer_id +), +customer_segments AS ( + SELECT + customer_id, + order_count, + total_spent, + avg_order_value, + DATEDIFF(day, last_order_date, CURRENT_DATE) as days_since_last_order, + CASE + WHEN total_spent >= 10000 THEN 'VIP' + WHEN total_spent >= 5000 THEN 'Premium' + WHEN total_spent >= 1000 THEN 'Standard' + ELSE 'Basic' + END as spending_tier, + CASE + WHEN days_since_last_order <= 30 THEN 'Active' + WHEN days_since_last_order <= 90 THEN 'At Risk' + ELSE 'Inactive' + END as activity_status + FROM customer_stats +) +SELECT * FROM customer_segments; + +-- ==================================== +-- UNION and set operations +-- ==================================== + +-- CTAS with UNION +CREATE TABLE all_transactions AS +SELECT + transaction_id, + customer_id, + 'PURCHASE' as transaction_type, + amount, + transaction_date +FROM purchases +WHERE transaction_date >= '2023-01-01' +UNION ALL +SELECT + refund_id as transaction_id, + customer_id, + 'REFUND' as transaction_type, + -amount as amount, + refund_date as transaction_date +FROM refunds +WHERE refund_date >= '2023-01-01'; + +-- CTAS with INTERSECT +CREATE TABLE common_customers AS +SELECT customer_id, customer_name +FROM online_customers +INTERSECT +SELECT customer_id, customer_name +FROM store_customers; + +-- ==================================== +-- Subqueries and correlated subqueries +-- ==================================== + +-- CTAS with subquery in SELECT +CREATE TABLE customer_insights AS +SELECT + c.customer_id, + c.customer_name, + (SELECT COUNT(*) FROM orders o WHERE o.customer_id = c.customer_id) as order_count, + (SELECT MAX(order_date) FROM orders o WHERE o.customer_id = c.customer_id) as last_order_date, + (SELECT AVG(total_amount) FROM orders o WHERE o.customer_id = c.customer_id) as avg_order_value +FROM customers c +WHERE c.registration_date >= '2022-01-01'; + +-- CTAS with EXISTS subquery +CREATE TABLE active_products AS +SELECT + product_id, + product_name, + price, + category +FROM products p +WHERE EXISTS ( + SELECT 1 + FROM order_items oi + WHERE oi.product_id = p.product_id + AND oi.order_date >= CURRENT_DATE - INTERVAL '6 months' +); + +-- ==================================== +-- Aggregate functions and grouping +-- ==================================== + +-- CTAS with advanced aggregations +CREATE TABLE sales_metrics AS +SELECT + region, + product_category, + sale_month, + COUNT(*) as transaction_count, + COUNT(DISTINCT customer_id) as unique_customers, + SUM(amount) as total_sales, + AVG(amount) as avg_transaction, + MEDIAN(amount) as median_transaction, + STDDEV(amount) as sales_volatility, + PERCENTILE_CONT(0.75) WITHIN GROUP (ORDER BY amount) as p75_amount, + PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY amount) as p95_amount +FROM sales_data +WHERE sale_date >= '2023-01-01' +GROUP BY region, product_category, DATE_TRUNC('month', sale_date); + +-- CTAS with ROLLUP +CREATE TABLE sales_hierarchy AS +SELECT + region, + state, + city, + SUM(sales_amount) as total_sales, + COUNT(*) as transaction_count +FROM regional_sales +GROUP BY ROLLUP(region, state, city); + +-- CTAS with CUBE +CREATE TABLE multi_dimensional_sales AS +SELECT + product_category, + customer_segment, + sales_channel, + SUM(revenue) as total_revenue, + COUNT(*) as sale_count +FROM sales_fact +GROUP BY CUBE(product_category, customer_segment, sales_channel); + +-- ==================================== +-- Date and time functions +-- ==================================== + +-- CTAS with date manipulation +CREATE TABLE time_based_analysis AS +SELECT + EXTRACT(YEAR FROM order_date) as order_year, + EXTRACT(QUARTER FROM order_date) as order_quarter, + EXTRACT(MONTH FROM order_date) as order_month, + EXTRACT(DAYOFWEEK FROM order_date) as day_of_week, + DATE_TRUNC('week', order_date) as week_start, + COUNT(*) as order_count, + SUM(total_amount) as weekly_revenue +FROM orders +WHERE order_date >= '2022-01-01' +GROUP BY + EXTRACT(YEAR FROM order_date), + EXTRACT(QUARTER FROM order_date), + EXTRACT(MONTH FROM order_date), + EXTRACT(DAYOFWEEK FROM order_date), + DATE_TRUNC('week', order_date); + +-- ==================================== +-- JSON and SUPER data type operations +-- ==================================== + +-- CTAS with JSON operations (Redshift SUPER type) +CREATE TABLE user_preferences AS +SELECT + user_id, + preferences.email_notifications as email_prefs, + preferences.language as preferred_language, + preferences.theme as ui_theme, + JSON_EXTRACT_PATH_TEXT(preferences, 'notification_frequency') as notification_freq +FROM user_profiles +WHERE preferences IS NOT NULL; + +-- ==================================== +-- String and text functions +-- ==================================== + +-- CTAS with string manipulation +CREATE TABLE processed_names AS +SELECT + customer_id, + UPPER(first_name) as first_name_upper, + LOWER(last_name) as last_name_lower, + INITCAP(TRIM(first_name || ' ' || last_name)) as full_name_proper, + LENGTH(email) as email_length, + SPLIT_PART(email, '@', 2) as email_domain, + REGEXP_REPLACE(phone, '[^0-9]', '') as phone_digits_only +FROM customers +WHERE email IS NOT NULL; + +-- ==================================== +-- Mathematical and statistical functions +-- ==================================== + +-- CTAS with mathematical operations +CREATE TABLE financial_calculations AS +SELECT + account_id, + balance, + interest_rate, + ROUND(balance * interest_rate / 100, 2) as annual_interest, + POWER(1 + interest_rate/100, 12) as compound_factor, + LN(balance) as log_balance, + CASE + WHEN balance > 100000 THEN 'High' + WHEN balance > 10000 THEN 'Medium' + ELSE 'Low' + END as balance_tier +FROM account_balances +WHERE balance > 0; + +-- ==================================== +-- Qualified table names +-- ==================================== + +-- CTAS with schema-qualified source tables +CREATE TABLE public.customer_analysis AS +SELECT + customer_id, + order_count, + total_revenue +FROM analytics.customer_metrics +WHERE last_updated >= CURRENT_DATE - INTERVAL '1 day'; + +-- CTAS with database.schema.table naming +CREATE TABLE tickit.public.event_summary AS +SELECT + event_id, + event_name, + venue_name, + event_date, + total_tickets, + tickets_sold +FROM tickit.public.events e +JOIN tickit.public.venues v ON e.venue_id = v.venue_id +WHERE event_date >= CURRENT_DATE; + +-- ==================================== +-- Complex real-world examples +-- ==================================== + +-- E-commerce customer lifetime value calculation +CREATE TABLE customer_ltv_analysis +BACKUP YES +DISTSTYLE KEY +DISTKEY(customer_id) +SORTKEY(registration_date, customer_id) +AS +WITH customer_orders AS ( + SELECT + customer_id, + MIN(order_date) as first_order_date, + MAX(order_date) as last_order_date, + COUNT(*) as total_orders, + SUM(total_amount) as total_spent, + AVG(total_amount) as avg_order_value, + AVG(DATEDIFF(day, LAG(order_date) OVER (PARTITION BY customer_id ORDER BY order_date), order_date)) as avg_days_between_orders + FROM orders + GROUP BY customer_id +), +customer_demographics AS ( + SELECT + customer_id, + registration_date, + age, + gender, + city, + state, + country + FROM customers +) +SELECT + cd.customer_id, + cd.registration_date, + cd.age, + cd.gender, + cd.city, + cd.state, + co.total_orders, + co.total_spent, + co.avg_order_value, + co.avg_days_between_orders, + DATEDIFF(day, co.first_order_date, co.last_order_date) as customer_lifespan_days, + CASE + WHEN co.last_order_date >= CURRENT_DATE - INTERVAL '30 days' THEN 'Active' + WHEN co.last_order_date >= CURRENT_DATE - INTERVAL '90 days' THEN 'At Risk' + ELSE 'Churned' + END as customer_status, + co.total_spent / NULLIF(DATEDIFF(day, co.first_order_date, CURRENT_DATE), 0) * 365 as annualized_ltv +FROM customer_demographics cd +LEFT JOIN customer_orders co ON cd.customer_id = co.customer_id; + +-- Financial risk assessment table +CREATE TABLE risk_assessment +BACKUP YES +DISTSTYLE EVEN +COMPOUND SORTKEY(assessment_date, risk_score) +AS +SELECT + customer_id, + assessment_date, + credit_score, + debt_to_income_ratio, + payment_history_score, + account_age_months, + (credit_score * 0.4 + + payment_history_score * 0.3 + + (100 - debt_to_income_ratio) * 0.2 + + LEAST(account_age_months / 12 * 10, 100) * 0.1) as risk_score, + CASE + WHEN credit_score >= 750 AND debt_to_income_ratio <= 30 THEN 'Low Risk' + WHEN credit_score >= 650 AND debt_to_income_ratio <= 50 THEN 'Medium Risk' + ELSE 'High Risk' + END as risk_category +FROM credit_assessments +WHERE assessment_date >= CURRENT_DATE - INTERVAL '1 year'; + +-- ==================================== +-- Error cases and edge cases +-- ==================================== + +-- CTAS with empty result set (valid but creates empty table) +CREATE TABLE empty_table AS +SELECT customer_id, order_date, total_amount +FROM orders +WHERE 1 = 0; + +-- CTAS with NULL handling +CREATE TABLE null_safe_aggregates AS +SELECT + region, + COUNT(*) as total_records, + COUNT(customer_id) as non_null_customers, + COUNT(revenue) as non_null_revenue, + COALESCE(SUM(revenue), 0) as total_revenue, + COALESCE(AVG(revenue), 0) as avg_revenue, + MAX(order_date) as latest_order +FROM sales_data +GROUP BY region; + +-- CTAS with type casting +CREATE TABLE typed_conversions AS +SELECT + customer_id, + CAST(total_amount AS INTEGER) as amount_int, + CAST(order_date AS VARCHAR(10)) as order_date_str, + order_status::VARCHAR(20) as status_varchar, + CASE WHEN is_premium = 'true' THEN 1 ELSE 0 END as premium_flag +FROM orders +WHERE total_amount IS NOT NULL; \ No newline at end of file diff --git a/redshift/examples/redshift/create_user.sql b/redshift/examples/redshift/create_user.sql new file mode 100644 index 0000000..c6945da --- /dev/null +++ b/redshift/examples/redshift/create_user.sql @@ -0,0 +1,199 @@ +-- CREATE USER test cases based on AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html + +-- Basic user creation (from AWS documentation) +CREATE USER dbuser WITH PASSWORD 'abcD1234'; + +-- User creation without WITH keyword +CREATE USER dbuser PASSWORD 'abcD1234'; + +-- User with connection limits and database creation privileges +CREATE USER dbuser WITH PASSWORD 'abcD1234' CREATEDB CONNECTION LIMIT 30; + +-- User with session timeout +CREATE USER dbuser PASSWORD 'abcD1234' SESSION TIMEOUT 120; + +-- External identity provider user (from AWS documentation) +CREATE USER "myco_aad:bob" EXTERNALID "ABC123" PASSWORD DISABLE; + +-- User with multiple privileges +CREATE USER admin_user WITH PASSWORD 'SecurePass123' CREATEDB CREATEUSER; + +-- User with syslog access +CREATE USER syslog_user WITH PASSWORD 'LogPass456' SYSLOG ACCESS RESTRICTED; +CREATE USER admin_syslog WITH PASSWORD 'AdminLog789' SYSLOG ACCESS UNRESTRICTED; + +-- User added to group +CREATE USER group_user WITH PASSWORD 'GroupPass321' IN GROUP analysts; + +-- User with expiration date +CREATE USER temp_user WITH PASSWORD 'TempPass654' VALID UNTIL '2024-12-31 23:59:59'; + +-- User with unlimited connections +CREATE USER unlimited_user WITH PASSWORD 'UnlimitedPass987' CONNECTION LIMIT UNLIMITED; + +-- MD5 password hash (from AWS documentation example) +CREATE USER md5_user WITH PASSWORD 'md5f6fdffe48c908deb0f4c3bd36c032e72d'; + +-- SHA-256 password hash +CREATE USER sha256_user WITH PASSWORD 'sha256|8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92'; + +-- Password disabled for IAM authentication +CREATE USER iam_user PASSWORD DISABLE; +CREATE USER federated_user EXTERNALID "arn:aws:iam::123456789012:role/RedshiftUser" PASSWORD DISABLE; + +-- Complex user with multiple options +CREATE USER complex_user WITH PASSWORD 'ComplexPass123' + CREATEDB + NOCREATEUSER + SYSLOG ACCESS RESTRICTED + CONNECTION LIMIT 10 + SESSION TIMEOUT 600 + VALID UNTIL '2025-01-01'; + +-- User names with special characters (quoted) +CREATE USER "user-with-dash" WITH PASSWORD 'DashPass123'; +CREATE USER "user.with.dots" WITH PASSWORD 'DotPass456'; +CREATE USER "user with spaces" WITH PASSWORD 'SpacePass789'; +CREATE USER "UPPERCASE_USER" WITH PASSWORD 'UpperPass321'; + +-- External provider format usernames (quoted for special characters) +CREATE USER "okta:john.doe" WITH PASSWORD 'OktaPass123'; +CREATE USER "azure_ad:jane.smith" WITH PASSWORD 'AzurePass456'; +CREATE USER "google:bob.wilson" WITH PASSWORD 'GooglePass789'; + +-- Numeric usernames (quoted) +CREATE USER "123user" WITH PASSWORD 'NumericUser123'; +CREATE USER "user123" WITH PASSWORD 'UserNumeric456'; + +-- Single character usernames +CREATE USER a WITH PASSWORD 'SingleChar123'; +CREATE USER "A" WITH PASSWORD 'SingleCharUpper456'; + +-- Real-world service account patterns +CREATE USER etl_service WITH PASSWORD 'ETLService123' NOCREATEDB NOCREATEUSER CONNECTION LIMIT 5; +CREATE USER reporting_svc WITH PASSWORD 'ReportSvc456' SYSLOG ACCESS RESTRICTED SESSION TIMEOUT 1800; +CREATE USER analytics_user WITH PASSWORD 'Analytics789' IN GROUP data_analysts CREATEDB; + +-- Development environment users +CREATE USER dev_user WITH PASSWORD 'DevPass123' CREATEDB CONNECTION LIMIT 20; +CREATE USER test_user WITH PASSWORD 'TestPass456' VALID UNTIL '2024-06-30'; +CREATE USER staging_user WITH PASSWORD 'StagingPass789' SESSION TIMEOUT 3600; + +-- Administrative users +CREATE USER dba_user WITH PASSWORD 'DBAPass123' CREATEDB CREATEUSER SYSLOG ACCESS UNRESTRICTED; +CREATE USER backup_user WITH PASSWORD 'BackupPass456' NOCREATEDB NOCREATEUSER CONNECTION LIMIT 2; +CREATE USER monitor_user WITH PASSWORD 'MonitorPass789' SYSLOG ACCESS RESTRICTED; + +-- External identity variations +CREATE USER sso_user EXTERNALID "sso-provider-id-12345" PASSWORD DISABLE; +CREATE USER saml_user EXTERNALID "urn:amazon:webservices:govcloud" PASSWORD DISABLE; +CREATE USER oidc_user EXTERNALID "https://example.com/.well-known/openid_configuration" PASSWORD DISABLE; + +-- AWS IAM role patterns +CREATE USER aws_lambda EXTERNALID "arn:aws:iam::123456789012:role/LambdaExecutionRole" PASSWORD DISABLE; +CREATE USER cross_account EXTERNALID "arn:aws:iam::987654321098:role/CrossAccountRole" PASSWORD DISABLE; +CREATE USER service_role EXTERNALID "arn:aws:iam::555666777888:role/service-role/MyServiceRole" PASSWORD DISABLE; + +-- Azure AD patterns +CREATE USER azure_user EXTERNALID "azure-ad-group-12345" PASSWORD DISABLE; +CREATE USER azure_app EXTERNALID "00000000-0000-0000-0000-000000000000" PASSWORD DISABLE; + +-- Google Cloud patterns +CREATE USER gcp_user EXTERNALID "gcp-service-account@project.iam.gserviceaccount.com" PASSWORD DISABLE; + +-- Okta patterns +CREATE USER okta_group EXTERNALID "00g1emaKYMLWCQXVHDSN" PASSWORD DISABLE; +CREATE USER okta_app EXTERNALID "0oa2hm8bXXXXXXXXXX" PASSWORD DISABLE; + +-- Mixed case external IDs +CREATE USER mixed_case EXTERNALID "MixedCaseExternalId123" PASSWORD DISABLE; +CREATE USER special_chars EXTERNALID "external-id_with.special@chars.com" PASSWORD DISABLE; + +-- Empty and minimal values +CREATE USER min_user PASSWORD 'MinPass12'; +CREATE USER "a" PASSWORD 'SingleA12'; + +-- Complex passwords meeting requirements +CREATE USER secure_user1 WITH PASSWORD 'Abcd1234!@#$'; +CREATE USER secure_user2 WITH PASSWORD 'MySecureP@ssw0rd2024'; +CREATE USER secure_user3 WITH PASSWORD 'C0mpl3x&P@ssw0rd!'; + +-- Connection limit variations +CREATE USER limit_1 WITH PASSWORD 'LimitOne123' CONNECTION LIMIT 1; +CREATE USER limit_100 WITH PASSWORD 'LimitHund456' CONNECTION LIMIT 100; +CREATE USER no_limit WITH PASSWORD 'NoLimit789' CONNECTION LIMIT UNLIMITED; + +-- Session timeout variations +CREATE USER timeout_60 WITH PASSWORD 'Timeout60sec' SESSION TIMEOUT 60; +CREATE USER timeout_3600 WITH PASSWORD 'Timeout1hr' SESSION TIMEOUT 3600; +CREATE USER timeout_86400 WITH PASSWORD 'Timeout1day' SESSION TIMEOUT 86400; + +-- Group membership examples +CREATE USER analyst1 WITH PASSWORD 'Analyst123' IN GROUP readonly_users; +CREATE USER analyst2 WITH PASSWORD 'Analyst456' IN GROUP data_scientists; +CREATE USER admin1 WITH PASSWORD 'Admin123' IN GROUP administrators; + +-- Expiration date variations +CREATE USER expire_2024 WITH PASSWORD 'Expire2024' VALID UNTIL '2024-12-31'; +CREATE USER expire_specific WITH PASSWORD 'ExpireSpec' VALID UNTIL '2024-06-15 14:30:00'; +CREATE USER expire_eoy WITH PASSWORD 'ExpireEOY' VALID UNTIL '2024-12-31 23:59:59'; + +-- Multiple options in different orders +CREATE USER ordered1 WITH PASSWORD 'Order123' CREATEDB CONNECTION LIMIT 15 SESSION TIMEOUT 1200; +CREATE USER ordered2 WITH PASSWORD 'Order456' SESSION TIMEOUT 900 CREATEUSER SYSLOG ACCESS RESTRICTED; +CREATE USER ordered3 WITH PASSWORD 'Order789' VALID UNTIL '2025-01-01' IN GROUP power_users NOCREATEDB; + +-- External ID with various quote styles and special characters +CREATE USER quote_test1 EXTERNALID "external-id-with-quotes" PASSWORD DISABLE; +CREATE USER quote_test2 EXTERNALID "external 'id' with internal quotes" PASSWORD DISABLE; +CREATE USER unicode_test EXTERNALID "üñíçødé_éxtérnål_íd" PASSWORD DISABLE; + +-- Realistic scenario combinations +CREATE USER data_engineer WITH PASSWORD 'DataEng123' + CREATEDB + IN GROUP engineers + CONNECTION LIMIT 25 + SESSION TIMEOUT 7200 + SYSLOG ACCESS RESTRICTED; + +CREATE USER readonly_analyst WITH PASSWORD 'ReadOnly456' + NOCREATEDB + NOCREATEUSER + IN GROUP analysts + CONNECTION LIMIT 5 + SESSION TIMEOUT 3600; + +CREATE USER temp_contractor WITH PASSWORD 'TempWork789' + NOCREATEDB + NOCREATEUSER + CONNECTION LIMIT 3 + VALID UNTIL '2024-03-31 23:59:59'; + +CREATE USER service_account WITH PASSWORD 'ServiceAcc321' + NOCREATEDB + NOCREATEUSER + CONNECTION LIMIT 10 + SESSION TIMEOUT 1800; + +-- Edge cases and boundary testing +CREATE USER edge_case1 WITH PASSWORD 'EdgeCase1' CONNECTION LIMIT 0; -- Zero connections +CREATE USER edge_case2 WITH PASSWORD 'EdgeCase2' SESSION TIMEOUT 1; -- One second timeout + +-- SQL keywords as quoted identifiers +CREATE USER "SELECT" WITH PASSWORD 'SelectUser123'; +CREATE USER "CREATE" WITH PASSWORD 'CreateUser456'; +CREATE USER "TABLE" WITH PASSWORD 'TableUser789'; +CREATE USER "DATABASE" WITH PASSWORD 'DatabaseUser321'; +CREATE USER "PASSWORD" WITH PASSWORD 'PasswordUser654'; + +-- Case sensitivity tests for usernames +CREATE USER lowercase_user WITH PASSWORD 'LowerCase123'; +CREATE USER UPPERCASE_USER WITH PASSWORD 'UpperCase456'; +CREATE USER "CamelCaseUser" WITH PASSWORD 'CamelCase789'; + +-- Testing all password options in isolation +CREATE USER clear_pass WITH PASSWORD 'ClearPassword123'; +CREATE USER md5_pass WITH PASSWORD 'md5098f6bcd4621d373cade4e832627b4f6'; +CREATE USER sha256_pass WITH PASSWORD 'sha256|e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'; +CREATE USER disabled_pass PASSWORD DISABLE; \ No newline at end of file diff --git a/redshift/examples/redshift/create_view.sql b/redshift/examples/redshift/create_view.sql new file mode 100644 index 0000000..201e7ed --- /dev/null +++ b/redshift/examples/redshift/create_view.sql @@ -0,0 +1,439 @@ +-- CREATE VIEW test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW.html + +-- Basic view creation (from AWS documentation) +CREATE VIEW myevent AS +SELECT eventname FROM event +WHERE eventname = 'LeAnn Rimes'; + +-- OR REPLACE view (from AWS documentation) +CREATE OR REPLACE VIEW myuser AS +SELECT lastname FROM users; + +-- View with WITH NO SCHEMA BINDING (from AWS documentation) +CREATE VIEW myevent AS +SELECT eventname FROM public.event +WITH NO SCHEMA BINDING; + +-- View with explicit column list +CREATE VIEW event_summary (event_name, venue_name) AS +SELECT eventname, venuename +FROM event +WHERE eventid < 100; + +-- OR REPLACE with column list +CREATE OR REPLACE VIEW user_info (last_name, first_name) AS +SELECT lastname, firstname +FROM users +WHERE userid < 500; + +-- View with column list and WITH NO SCHEMA BINDING +CREATE VIEW sales_summary (product, total_sales, avg_price) AS +SELECT productname, SUM(quantity), AVG(pricepaid) +FROM sales +GROUP BY productname +WITH NO SCHEMA BINDING; + +-- Complex view with JOINs +CREATE VIEW event_sales AS +SELECT + e.eventname, + e.starttime, + v.venuename, + COUNT(*) as tickets_sold, + SUM(s.pricepaid) as total_revenue +FROM event e +JOIN venue v ON e.venueid = v.venueid +JOIN sales s ON e.eventid = s.eventid +GROUP BY e.eventname, e.starttime, v.venuename; + +-- View with WHERE clause and aggregations +CREATE VIEW high_value_sales AS +SELECT + buyerid, + COUNT(*) as purchase_count, + SUM(pricepaid) as total_spent, + AVG(pricepaid) as avg_purchase +FROM sales +WHERE pricepaid > 100 +GROUP BY buyerid +HAVING SUM(pricepaid) > 1000; + +-- View with subquery +CREATE VIEW venue_capacity AS +SELECT + v.venuename, + v.venuecity, + v.venueseats, + avg_sales.avg_tickets_per_event +FROM venue v +JOIN ( + SELECT + venueid, + AVG(tickets_sold) as avg_tickets_per_event + FROM ( + SELECT + e.venueid, + e.eventid, + COUNT(*) as tickets_sold + FROM event e + JOIN sales s ON e.eventid = s.eventid + GROUP BY e.venueid, e.eventid + ) event_sales + GROUP BY venueid +) avg_sales ON v.venueid = avg_sales.venueid; + +-- View with CASE statement +CREATE VIEW user_category AS +SELECT + userid, + firstname, + lastname, + CASE + WHEN total_purchases >= 10 THEN 'VIP' + WHEN total_purchases >= 5 THEN 'Regular' + ELSE 'Occasional' + END as customer_type +FROM ( + SELECT + u.userid, + u.firstname, + u.lastname, + COUNT(s.saleid) as total_purchases + FROM users u + LEFT JOIN sales s ON u.userid = s.buyerid + GROUP BY u.userid, u.firstname, u.lastname +); + +-- View with window functions +CREATE VIEW sales_ranking AS +SELECT + saleid, + buyerid, + eventid, + pricepaid, + RANK() OVER (PARTITION BY eventid ORDER BY pricepaid DESC) as price_rank, + ROW_NUMBER() OVER (ORDER BY pricepaid DESC) as overall_rank +FROM sales; + +-- View with UNION +CREATE VIEW all_names AS +SELECT 'User' as type, firstname as name, lastname +FROM users +UNION ALL +SELECT 'Venue' as type, venuename as name, venuecity +FROM venue; + +-- View with date functions and filtering +CREATE VIEW recent_events AS +SELECT + eventid, + eventname, + starttime, + EXTRACT(YEAR FROM starttime) as event_year, + EXTRACT(MONTH FROM starttime) as event_month +FROM event +WHERE starttime >= '2023-01-01' +ORDER BY starttime; + +-- View with string functions +CREATE VIEW formatted_users AS +SELECT + userid, + UPPER(firstname) as first_name_upper, + LOWER(lastname) as last_name_lower, + firstname || ' ' || lastname as full_name +FROM users +WHERE firstname IS NOT NULL AND lastname IS NOT NULL; + +-- View with NULL handling +CREATE VIEW complete_venues AS +SELECT + venueid, + venuename, + COALESCE(venuecity, 'Unknown City') as city, + COALESCE(venuestate, 'Unknown State') as state, + CASE + WHEN venuecity IS NOT NULL AND venuestate IS NOT NULL THEN 'Complete' + WHEN venuecity IS NOT NULL OR venuestate IS NOT NULL THEN 'Partial' + ELSE 'Incomplete' + END as address_completeness +FROM venue; + +-- View with mathematical operations +CREATE VIEW sales_with_commission AS +SELECT + saleid, + eventid, + pricepaid, + commission * 0.01 as commission_rate, + pricepaid * commission * 0.01 as commission_amount, + pricepaid - (pricepaid * commission * 0.01) as net_amount +FROM sales +WHERE commission > 0; + +-- View with EXISTS clause +CREATE VIEW events_with_sales AS +SELECT + eventid, + eventname, + starttime, + venueid +FROM event e +WHERE EXISTS ( + SELECT 1 + FROM sales s + WHERE s.eventid = e.eventid +); + +-- View with NOT EXISTS clause +CREATE VIEW events_without_sales AS +SELECT + eventid, + eventname, + starttime, + venueid +FROM event e +WHERE NOT EXISTS ( + SELECT 1 + FROM sales s + WHERE s.eventid = e.eventid +); + +-- View with IN clause +CREATE VIEW premium_category_events AS +SELECT + eventid, + eventname, + catid, + starttime +FROM event +WHERE catid IN (1, 2, 3); + +-- View with BETWEEN clause +CREATE VIEW mid_range_sales AS +SELECT + saleid, + buyerid, + eventid, + pricepaid, + saledate +FROM sales +WHERE pricepaid BETWEEN 50 AND 500; + +-- View with LIKE pattern matching +CREATE VIEW rock_events AS +SELECT + eventid, + eventname, + catid, + starttime +FROM event +WHERE eventname LIKE '%Rock%' OR eventname LIKE '%Concert%'; + +-- View with multiple JOINs +CREATE VIEW detailed_sales AS +SELECT + s.saleid, + s.saledate, + s.pricepaid, + u.firstname, + u.lastname, + e.eventname, + e.starttime, + v.venuename, + v.venuecity, + c.catname +FROM sales s +JOIN users u ON s.buyerid = u.userid +JOIN event e ON s.eventid = e.eventid +JOIN venue v ON e.venueid = v.venueid +JOIN category c ON e.catid = c.catid; + +-- View with LEFT JOIN +CREATE VIEW user_sales_summary AS +SELECT + u.userid, + u.firstname, + u.lastname, + COUNT(s.saleid) as total_purchases, + COALESCE(SUM(s.pricepaid), 0) as total_spent +FROM users u +LEFT JOIN sales s ON u.userid = s.buyerid +GROUP BY u.userid, u.firstname, u.lastname; + +-- View with RIGHT JOIN +CREATE VIEW event_sales_summary AS +SELECT + e.eventid, + e.eventname, + COUNT(s.saleid) as tickets_sold, + COALESCE(SUM(s.pricepaid), 0) as revenue +FROM sales s +RIGHT JOIN event e ON s.eventid = e.eventid +GROUP BY e.eventid, e.eventname; + +-- View with FULL OUTER JOIN +CREATE VIEW complete_user_event_matrix AS +SELECT + COALESCE(u.userid, 0) as user_id, + COALESCE(u.firstname, 'Unknown') as first_name, + COALESCE(e.eventid, 0) as event_id, + COALESCE(e.eventname, 'No Event') as event_name, + s.pricepaid +FROM users u +FULL OUTER JOIN sales s ON u.userid = s.buyerid +FULL OUTER JOIN event e ON s.eventid = e.eventid; + +-- View with aggregate functions +CREATE VIEW category_statistics AS +SELECT + c.catid, + c.catname, + COUNT(e.eventid) as total_events, + COUNT(s.saleid) as total_sales, + MIN(s.pricepaid) as min_price, + MAX(s.pricepaid) as max_price, + AVG(s.pricepaid) as avg_price, + SUM(s.pricepaid) as total_revenue +FROM category c +LEFT JOIN event e ON c.catid = e.catid +LEFT JOIN sales s ON e.eventid = s.eventid +GROUP BY c.catid, c.catname; + +-- View with DISTINCT +CREATE VIEW unique_venues_per_city AS +SELECT DISTINCT + venuecity, + venuestate, + COUNT(DISTINCT venueid) as venue_count +FROM venue +WHERE venuecity IS NOT NULL +GROUP BY venuecity, venuestate; + +-- OR REPLACE with complex query and WITH NO SCHEMA BINDING +CREATE OR REPLACE VIEW comprehensive_sales_analysis AS +SELECT + sales_month, + sales_year, + category, + total_events, + total_sales, + total_revenue, + avg_price_per_ticket, + RANK() OVER (PARTITION BY sales_year ORDER BY total_revenue DESC) as monthly_revenue_rank +FROM ( + SELECT + EXTRACT(MONTH FROM e.starttime) as sales_month, + EXTRACT(YEAR FROM e.starttime) as sales_year, + c.catname as category, + COUNT(DISTINCT e.eventid) as total_events, + COUNT(s.saleid) as total_sales, + SUM(s.pricepaid) as total_revenue, + AVG(s.pricepaid) as avg_price_per_ticket + FROM public.event e + JOIN public.category c ON e.catid = c.catid + JOIN public.sales s ON e.eventid = s.eventid + WHERE e.starttime >= '2023-01-01' + GROUP BY + EXTRACT(MONTH FROM e.starttime), + EXTRACT(YEAR FROM e.starttime), + c.catname +) monthly_stats +WITH NO SCHEMA BINDING; + +-- View with nested CASE statements +CREATE VIEW customer_segmentation AS +SELECT + userid, + firstname, + lastname, + total_spent, + purchase_count, + CASE + WHEN total_spent >= 1000 THEN + CASE + WHEN purchase_count >= 10 THEN 'Premium Frequent' + ELSE 'Premium Occasional' + END + WHEN total_spent >= 500 THEN 'Standard' + WHEN total_spent >= 100 THEN 'Basic' + ELSE 'Minimal' + END as customer_segment +FROM ( + SELECT + u.userid, + u.firstname, + u.lastname, + COALESCE(SUM(s.pricepaid), 0) as total_spent, + COUNT(s.saleid) as purchase_count + FROM users u + LEFT JOIN sales s ON u.userid = s.buyerid + GROUP BY u.userid, u.firstname, u.lastname +); + +-- Simple view for basic functionality testing +CREATE VIEW simple_event_list AS +SELECT eventid, eventname +FROM event; + +-- View with schema-qualified table names +CREATE VIEW public_event_details AS +SELECT + public.event.eventid, + public.event.eventname, + public.venue.venuename +FROM public.event +JOIN public.venue ON public.event.venueid = public.venue.venueid; + +-- View with quoted identifiers +CREATE VIEW "Special View Name" AS +SELECT + "eventid" as "Event ID", + "eventname" as "Event Name" +FROM "event" +WHERE "eventid" < 100; + +-- View with column aliases using AS keyword +CREATE VIEW event_venue_info AS +SELECT + e.eventid AS event_identifier, + e.eventname AS event_title, + e.starttime AS event_datetime, + v.venuename AS venue_title, + v.venuecity AS venue_location +FROM event AS e +JOIN venue AS v ON e.venueid = v.venueid; + +-- View with column aliases without AS keyword +CREATE VIEW sales_info AS +SELECT + saleid sale_identifier, + buyerid buyer_identifier, + eventid event_identifier, + pricepaid ticket_price, + saledate purchase_date +FROM sales; + +-- View with ORDER BY +CREATE VIEW top_events_by_revenue AS +SELECT + e.eventid, + e.eventname, + SUM(s.pricepaid) as total_revenue, + COUNT(*) as tickets_sold +FROM event e +JOIN sales s ON e.eventid = s.eventid +GROUP BY e.eventid, e.eventname +ORDER BY total_revenue DESC +LIMIT 10; + +-- View with multiple ORDER BY columns +CREATE VIEW events_by_date_and_name AS +SELECT + eventid, + eventname, + starttime, + venueid +FROM event +ORDER BY starttime ASC, eventname DESC; \ No newline at end of file diff --git a/redshift/examples/redshift/deallocate.sql b/redshift/examples/redshift/deallocate.sql new file mode 100644 index 0000000..1f26546 --- /dev/null +++ b/redshift/examples/redshift/deallocate.sql @@ -0,0 +1,172 @@ +-- DEALLOCATE command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DEALLOCATE.html + +-- Basic DEALLOCATE statements +DEALLOCATE statement1; +deallocate statement1; + +-- DEALLOCATE with PREPARE keyword (optional) +DEALLOCATE PREPARE statement2; +deallocate prepare statement2; + +-- DEALLOCATE ALL to deallocate all prepared statements +DEALLOCATE ALL; +deallocate all; + +-- DEALLOCATE with simple statement names +DEALLOCATE my_statement; +DEALLOCATE stmt_name; +DEALLOCATE test_statement; + +-- DEALLOCATE with underscore in statement names +DEALLOCATE my_statement_name; +DEALLOCATE statement_with_long_name; +DEALLOCATE test_stmt_123; + +-- DEALLOCATE with numeric suffixes +DEALLOCATE stmt1; +DEALLOCATE stmt2; +DEALLOCATE stmt123; +DEALLOCATE my_stmt_1; +DEALLOCATE test_stmt_99; + +-- DEALLOCATE with quoted identifiers +DEALLOCATE "my statement"; +DEALLOCATE "Statement Name"; +DEALLOCATE "statement-with-dashes"; +DEALLOCATE "statement.with.dots"; +DEALLOCATE "statement with spaces"; + +-- DEALLOCATE with mixed case statement names +DEALLOCATE MyStatement; +DEALLOCATE STATEMENT_NAME; +DEALLOCATE TestStatement; +DEALLOCATE myStatement; +DEALLOCATE statementName; + +-- DEALLOCATE with special characters in quoted names +DEALLOCATE "statement@special"; +DEALLOCATE "statement#123"; +DEALLOCATE "statement$name"; +DEALLOCATE "statement%test"; + +-- DEALLOCATE with reserved words as statement names (when quoted) +DEALLOCATE "deallocate"; +DEALLOCATE "prepare"; +DEALLOCATE "transaction"; +DEALLOCATE "work"; +DEALLOCATE "table"; + +-- DEALLOCATE with single character statement names +DEALLOCATE a; +DEALLOCATE b; +DEALLOCATE c; +DEALLOCATE x; +DEALLOCATE y; +DEALLOCATE z; + +-- DEALLOCATE with typical prepared statement naming patterns +DEALLOCATE select_query; +DEALLOCATE insert_stmt; +DEALLOCATE update_stmt; +DEALLOCATE delete_stmt; +DEALLOCATE report_query; + +-- DEALLOCATE with business logic statement names +DEALLOCATE sales_report; +DEALLOCATE customer_lookup; +DEALLOCATE inventory_check; +DEALLOCATE order_summary; +DEALLOCATE revenue_analysis; + +-- DEALLOCATE with procedural statement names +DEALLOCATE proc_stmt; +DEALLOCATE func_stmt; +DEALLOCATE temp_stmt; +DEALLOCATE result_stmt; +DEALLOCATE output_stmt; + +-- DEALLOCATE with database operation naming patterns +DEALLOCATE users_select; +DEALLOCATE orders_insert; +DEALLOCATE items_update; +DEALLOCATE transactions_delete; +DEALLOCATE reports_query; + +-- DEALLOCATE with PREPARE keyword variations +DEALLOCATE PREPARE select_customers; +DEALLOCATE prepare insert_orders; +DEALLOCATE PREPARE update_products; +DEALLOCATE prepare delete_temp_data; + +-- Mixed case variations +Deallocate statement1; +DEALLOCATE statement2; +DeAlLoCaTe statement3; +deallocate STATEMENT4; +DEALLOCATE StatementName; + +-- Complex statement names +DEALLOCATE complex_statement_name_with_underscores; +DEALLOCATE "Complex Statement Name With Spaces"; +DEALLOCATE statement_123_test_abc; +DEALLOCATE "statement-name-with-dashes-123"; + +-- Typical prepared statement lifecycle examples +-- First prepare statements, then deallocate them +DEALLOCATE sales_summary_query; +DEALLOCATE monthly_report_stmt; +DEALLOCATE customer_analysis_prep; +DEALLOCATE inventory_lookup_stmt; + +-- DEALLOCATE ALL variations +DEALLOCATE ALL; +deallocate all; +Deallocate All; +DEALLOCATE all; +deallocate ALL; + +-- DEALLOCATE with PREPARE and ALL +DEALLOCATE PREPARE ALL; +deallocate prepare all; +DEALLOCATE prepare ALL; +deallocate PREPARE all; + +-- Real-world examples based on typical prepared statement usage +DEALLOCATE get_user_by_id; +DEALLOCATE insert_new_order; +DEALLOCATE update_customer_info; +DEALLOCATE delete_expired_sessions; +DEALLOCATE calculate_monthly_revenue; +DEALLOCATE find_top_selling_products; +DEALLOCATE check_inventory_levels; +DEALLOCATE generate_sales_report; +DEALLOCATE validate_user_permissions; +DEALLOCATE process_payment_batch; + +-- Examples with schema-qualified-like names (still just identifiers) +DEALLOCATE analytics_sales_query; +DEALLOCATE reporting_monthly_stmt; +DEALLOCATE etl_data_import_prep; +DEALLOCATE staging_validation_check; + +-- Examples following typical SQL naming conventions +DEALLOCATE sp_get_customer_orders; +DEALLOCATE fn_calculate_discount; +DEALLOCATE vw_active_users_query; +DEALLOCATE tmp_processing_stmt; + +-- Edge cases with valid identifier patterns +DEALLOCATE a1; +DEALLOCATE a1b2c3; +DEALLOCATE _private_stmt; +DEALLOCATE stmt_; +DEALLOCATE "special_name"; +DEALLOCATE statement123abc; + +-- Quoted edge cases +DEALLOCATE "123numeric_start"; +DEALLOCATE "statement with \ttab"; +DEALLOCATE "statement ""with"" quotes"; +DEALLOCATE "CasE SeNsItIvE StAtEmEnT"; +DEALLOCATE "statement@#$%^&*()"; \ No newline at end of file diff --git a/redshift/examples/redshift/declare.sql b/redshift/examples/redshift/declare.sql new file mode 100644 index 0000000..9918d91 --- /dev/null +++ b/redshift/examples/redshift/declare.sql @@ -0,0 +1,227 @@ +-- DECLARE command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DECLARE.html +-- Reference: https://www.postgresql.org/docs/current/sql-declare.html + +-- Basic DECLARE statements +DECLARE my_cursor CURSOR FOR SELECT * FROM sales; +declare my_cursor cursor for select * from sales; + +-- DECLARE with quoted cursor names +DECLARE "my_cursor" CURSOR FOR SELECT * FROM sales; +DECLARE "My Cursor" CURSOR FOR SELECT * FROM sales; + +-- DECLARE with BINARY option +DECLARE my_cursor BINARY CURSOR FOR SELECT * FROM sales; +DECLARE my_cursor BINARY CURSOR FOR SELECT qty, pricepaid FROM sales; + +DECLARE my_cursor INSENSITIVE CURSOR FOR SELECT * FROM sales; + +-- DECLARE with SCROLL options +DECLARE my_cursor SCROLL CURSOR FOR SELECT * FROM sales; +DECLARE my_cursor NO SCROLL CURSOR FOR SELECT * FROM sales; + +-- DECLARE with HOLD options +DECLARE my_cursor CURSOR WITH HOLD FOR SELECT * FROM sales; +DECLARE my_cursor CURSOR WITHOUT HOLD FOR SELECT * FROM sales; + +-- DECLARE with multiple options +DECLARE my_cursor BINARY SCROLL CURSOR FOR SELECT * FROM sales; +DECLARE my_cursor BINARY INSENSITIVE CURSOR FOR SELECT * FROM sales; +DECLARE my_cursor BINARY SCROLL CURSOR WITH HOLD FOR SELECT * FROM sales; +DECLARE my_cursor BINARY INSENSITIVE CURSOR WITHOUT HOLD FOR SELECT * FROM sales; +DECLARE my_cursor SCROLL CURSOR WITH HOLD FOR SELECT * FROM sales; +DECLARE my_cursor NO SCROLL CURSOR WITH HOLD FOR SELECT * FROM sales; +DECLARE my_cursor INSENSITIVE NO SCROLL CURSOR FOR SELECT * FROM sales; + +-- DECLARE with complex SELECT statements +DECLARE sales_cursor CURSOR FOR + SELECT s.salesid, s.listid, s.sellerid, s.buyerid, s.eventid, s.dateid, s.qtysold, s.pricepaid, s.commission + FROM sales s + WHERE s.pricepaid > 100 + ORDER BY s.pricepaid DESC; + +-- DECLARE with JOIN queries +DECLARE event_sales_cursor CURSOR FOR + SELECT e.eventname, s.qtysold, s.pricepaid + FROM event e + JOIN sales s ON e.eventid = s.eventid + WHERE e.catid = 7 + ORDER BY s.pricepaid DESC; + +-- DECLARE with aggregate functions +DECLARE sales_summary_cursor CURSOR FOR + SELECT eventid, COUNT(*) as ticket_count, SUM(pricepaid) as total_sales + FROM sales + GROUP BY eventid + HAVING SUM(pricepaid) > 1000 + ORDER BY total_sales DESC; + +-- DECLARE with subqueries +DECLARE high_value_sales_cursor CURSOR FOR + SELECT * FROM sales + WHERE pricepaid > (SELECT AVG(pricepaid) FROM sales) + ORDER BY pricepaid DESC; + +-- DECLARE with CTE (Common Table Expression) +DECLARE cte_cursor CURSOR FOR + WITH sales_summary AS ( + SELECT eventid, COUNT(*) as ticket_count, SUM(pricepaid) as total_sales + FROM sales + GROUP BY eventid + ) + SELECT ss.eventid, ss.ticket_count, ss.total_sales, e.eventname + FROM sales_summary ss + JOIN event e ON ss.eventid = e.eventid + WHERE ss.total_sales > 1000 + ORDER BY ss.total_sales DESC; + +-- DECLARE with UNION +DECLARE union_cursor CURSOR FOR + SELECT 'High Value' as category, salesid, pricepaid FROM sales WHERE pricepaid > 500 + UNION ALL + SELECT 'Low Value' as category, salesid, pricepaid FROM sales WHERE pricepaid <= 500 + ORDER BY pricepaid DESC; + +-- DECLARE with VALUES statement +DECLARE values_cursor CURSOR FOR VALUES (1, 'First'), (2, 'Second'), (3, 'Third'); + +-- DECLARE with TABLE statement +DECLARE table_cursor CURSOR FOR TABLE sales; + +-- DECLARE with window functions +DECLARE window_cursor CURSOR FOR + SELECT salesid, pricepaid, + ROW_NUMBER() OVER (PARTITION BY eventid ORDER BY pricepaid DESC) as rank_in_event + FROM sales + WHERE qtysold > 1; + +-- DECLARE with CASE statements +DECLARE case_cursor CURSOR FOR + SELECT salesid, + CASE + WHEN pricepaid > 1000 THEN 'Premium' + WHEN pricepaid > 500 THEN 'Standard' + ELSE 'Economy' + END as price_category + FROM sales; + +-- DECLARE with EXISTS subquery +DECLARE exists_cursor CURSOR FOR + SELECT e.eventname + FROM event e + WHERE EXISTS ( + SELECT 1 FROM sales s + WHERE s.eventid = e.eventid AND s.pricepaid > 1000 + ); + +-- DECLARE with IN clause +DECLARE in_cursor CURSOR FOR + SELECT * FROM sales + WHERE eventid IN (SELECT eventid FROM event WHERE catid IN (6, 7, 8)) + ORDER BY pricepaid DESC; + +-- DECLARE with BETWEEN +DECLARE between_cursor CURSOR FOR + SELECT * FROM sales + WHERE pricepaid BETWEEN 100 AND 500 + AND dateid BETWEEN 1900 AND 2000; + +-- DECLARE with LIKE pattern matching +DECLARE like_cursor CURSOR FOR + SELECT e.eventname, s.pricepaid + FROM event e + JOIN sales s ON e.eventid = s.eventid + WHERE e.eventname LIKE '%Concert%' + ORDER BY s.pricepaid DESC; + +-- DECLARE with NULL handling +DECLARE null_cursor CURSOR FOR + SELECT salesid, pricepaid, commission + FROM sales + WHERE commission IS NOT NULL + ORDER BY commission DESC; + +-- DECLARE with LIMIT and OFFSET +DECLARE limited_cursor CURSOR FOR + SELECT * FROM sales + ORDER BY pricepaid DESC + LIMIT 100 OFFSET 50; + +-- DECLARE with mathematical operations +DECLARE math_cursor CURSOR FOR + SELECT salesid, + pricepaid, + commission, + (pricepaid - commission) as net_amount, + (commission / pricepaid * 100) as commission_percentage + FROM sales + WHERE pricepaid > 0 AND commission > 0; + +-- DECLARE with string concatenation +DECLARE concat_cursor CURSOR FOR + SELECT u.firstname || ' ' || u.lastname as full_name, + s.pricepaid + FROM users u + JOIN sales s ON u.userid = s.buyerid + WHERE s.pricepaid > 100; + +-- Complex example with all options +DECLARE complex_cursor BINARY INSENSITIVE SCROLL CURSOR WITH HOLD FOR + WITH high_value_events AS ( + SELECT eventid, AVG(pricepaid) as avg_price + FROM sales + GROUP BY eventid + HAVING AVG(pricepaid) > 200 + ), + event_details AS ( + SELECT e.eventid, e.eventname, e.catid, hve.avg_price + FROM event e + JOIN high_value_events hve ON e.eventid = hve.eventid + ) + SELECT ed.eventname, + ed.avg_price, + c.catname, + COUNT(s.salesid) as total_sales, + SUM(s.pricepaid) as total_revenue, + CASE + WHEN ed.avg_price > 500 THEN 'Premium' + WHEN ed.avg_price > 200 THEN 'Standard' + ELSE 'Economy' + END as event_tier + FROM event_details ed + JOIN category c ON ed.catid = c.catid + JOIN sales s ON ed.eventid = s.eventid + WHERE s.pricepaid IS NOT NULL + GROUP BY ed.eventname, ed.avg_price, c.catname + HAVING COUNT(s.salesid) > 5 + ORDER BY total_revenue DESC, ed.avg_price DESC + LIMIT 50; + +-- Examples from AWS Redshift documentation (if any specific examples exist) +-- Basic cursor for sales analysis +DECLARE sales_analysis_cursor CURSOR FOR + SELECT eventid, SUM(qtysold) as total_quantity, SUM(pricepaid) as total_revenue + FROM sales + GROUP BY eventid + ORDER BY total_revenue DESC; + +-- Cursor for user analysis +DECLARE user_cursor CURSOR FOR + SELECT userid, firstname, lastname, city, state + FROM users + WHERE state IN ('CA', 'NY', 'FL') + ORDER BY lastname, firstname; + +-- Mixed case variations (testing case insensitivity) +Declare My_Cursor Cursor For Select * From Sales; +DECLARE my_cursor CURSOR FOR select * from sales; +declare MY_CURSOR cursor for SELECT * FROM SALES; + +-- Edge cases and boundary conditions +DECLARE edge_cursor CURSOR FOR SELECT 1; +DECLARE edge_cursor CURSOR FOR SELECT NULL; +DECLARE edge_cursor CURSOR FOR SELECT 'test' as col1, 123 as col2; + +-- Cursor with parameter-like syntax (though parameters might not be directly supported in DECLARE) +DECLARE param_cursor CURSOR FOR + SELECT * FROM sales WHERE pricepaid > 100; \ No newline at end of file diff --git a/redshift/examples/redshift/delete.sql b/redshift/examples/redshift/delete.sql new file mode 100644 index 0000000..71449f8 --- /dev/null +++ b/redshift/examples/redshift/delete.sql @@ -0,0 +1,251 @@ +-- DELETE command examples from AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DELETE.html + +-- Example 1: Delete entire table (from AWS docs) +DELETE FROM category; + +-- Example 2: Delete with optional FROM keyword +DELETE category; + +-- Example 3: Delete rows with specific condition (from AWS docs) +DELETE FROM category WHERE catid BETWEEN 0 AND 9; + +-- Example 4: Delete rows based on subquery (from AWS docs) +DELETE FROM listing +WHERE listing.sellerid NOT IN (SELECT sales.sellerid FROM sales); + +-- Example 5: Delete using join condition (from AWS docs) +DELETE FROM category +USING event +WHERE event.catid = category.catid AND category.catid = 9; + +-- Example 6: Delete from materialized view (from AWS docs) +DELETE FROM mv_cities; + +-- Example 7: Delete with simple WHERE clause +DELETE FROM users WHERE age > 65; + +-- Example 8: Delete with multiple conditions +DELETE FROM orders WHERE status = 'cancelled' AND order_date < '2023-01-01'; + +-- Example 9: Delete with USING multiple tables +DELETE FROM inventory +USING products, categories +WHERE inventory.product_id = products.id + AND products.category_id = categories.id + AND categories.name = 'discontinued'; + +-- Example 10: Delete with schema-qualified table names +DELETE FROM sales.orders WHERE customer_id IS NULL; + +-- Example 11: Delete with complex WHERE conditions +DELETE FROM customer_data +WHERE last_login < CURRENT_DATE - INTERVAL '2 years' + AND account_status = 'inactive'; + +-- Example 12: Delete with IN clause +DELETE FROM temp_table WHERE id IN (1, 2, 3, 4, 5); + +-- Example 13: Delete with NOT IN subquery +DELETE FROM products WHERE category_id NOT IN ( + SELECT id FROM active_categories WHERE status = 'active' +); + +-- Example 14: Delete with EXISTS subquery +DELETE FROM users WHERE EXISTS ( + SELECT 1 FROM banned_users WHERE banned_users.user_id = users.id +); + +-- Example 15: Delete with NOT EXISTS +DELETE FROM products WHERE NOT EXISTS ( + SELECT 1 FROM sales WHERE sales.product_id = products.id +); + +-- Example 16: Delete with LIKE pattern matching +DELETE FROM log_entries WHERE message LIKE '%error%' OR message LIKE '%warning%'; + +-- Example 17: Delete with BETWEEN clause +DELETE FROM transactions WHERE amount BETWEEN 0.01 AND 10.00; + +-- Example 18: Delete with IS NULL condition +DELETE FROM customer_profiles WHERE email IS NULL; + +-- Example 19: Delete with IS NOT NULL condition +DELETE FROM temp_data WHERE processed_date IS NOT NULL; + +-- Example 20: Delete with mathematical expressions +DELETE FROM inventory WHERE quantity * unit_price < 100; + +-- Example 21: Delete with function calls in WHERE clause +DELETE FROM users WHERE EXTRACT(YEAR FROM created_date) < 2020; + +-- Example 22: Delete with case-sensitive string comparison +DELETE FROM products WHERE UPPER(name) = 'DISCONTINUED ITEM'; + +-- Example 23: Delete with date comparison +DELETE FROM sessions WHERE session_date < '2023-01-01'::date; + +-- Example 24: Delete with timestamp comparison +DELETE FROM audit_log WHERE created_at < '2023-01-01 00:00:00'::timestamp; + +-- Example 25: Delete with complex join using USING +DELETE FROM order_items +USING orders, customers +WHERE order_items.order_id = orders.id + AND orders.customer_id = customers.id + AND customers.status = 'deleted'; + +-- Example 26: Delete with self-referencing subquery +DELETE FROM employees +WHERE department_id IN ( + SELECT id FROM departments WHERE budget < 50000 +); + +-- Example 27: Delete with nested subqueries +DELETE FROM products +WHERE category_id IN ( + SELECT category_id FROM product_categories + WHERE parent_id IN (SELECT id FROM categories WHERE active = false) +); + +-- Example 28: Delete with OR conditions +DELETE FROM temp_results +WHERE status = 'error' + OR status = 'timeout' + OR created_date < CURRENT_DATE - 7; + +-- Example 29: Delete with AND/OR combination +DELETE FROM user_sessions +WHERE (expired = true OR last_activity < CURRENT_DATE - 1) + AND session_type = 'guest'; + +-- Example 30: Delete with quoted identifiers +DELETE FROM "Special Table" WHERE "Column Name" = 'value'; + +-- Example 31: Delete with table alias in USING +DELETE FROM a +USING products b, categories c +WHERE a.product_id = b.id + AND b.category_id = c.id + AND c.discontinued = true; + +-- Example 32: Delete with ESCAPE clause +DELETE FROM search_terms WHERE term LIKE '%\_%' ESCAPE '\'; + +-- Example 33: Delete with multiple mathematical operations +DELETE FROM financial_data +WHERE (revenue - expenses) / revenue < 0.1; + +-- Example 34: Delete with string concatenation +DELETE FROM logs WHERE CONCAT(level, ': ', message) LIKE '%ERROR:%'; + +-- Example 35: Delete with window function results (using subquery) +DELETE FROM sales +WHERE sale_id IN ( + SELECT sale_id FROM ( + SELECT sale_id, ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY sale_date DESC) as rn + FROM sales + ) ranked + WHERE rn > 10 +); + +-- Example 36: Delete with complex boolean logic +DELETE FROM user_preferences +WHERE NOT ( + (notification_email = true AND email IS NOT NULL) + OR + (notification_sms = true AND phone IS NOT NULL) +); + +-- Example 37: Delete with type casting +DELETE FROM measurements WHERE reading::NUMERIC > 100.5; + +-- Example 38: Delete from schema-qualified materialized view +DELETE FROM analytics.customer_summary WHERE last_updated < '2023-01-01'; + +-- Example 39: Delete with DISTINCT in subquery +DELETE FROM duplicates +WHERE id NOT IN ( + SELECT DISTINCT MIN(id) FROM duplicates GROUP BY email +); + +-- Example 40: Delete with ALL in subquery comparison +DELETE FROM products +WHERE price > ALL ( + SELECT price FROM competitor_products WHERE category = 'electronics' +); + +-- Example 41: Delete with ANY in subquery comparison +DELETE FROM inventory +WHERE quantity < ANY ( + SELECT min_threshold FROM reorder_rules WHERE product_type = 'perishable' +); + +-- Example 42: Delete using CTE (Common Table Expression) +WITH inactive_users AS ( + SELECT user_id FROM user_activity + WHERE last_login < CURRENT_DATE - INTERVAL '1 year' +) +DELETE FROM user_profiles +WHERE user_id IN (SELECT user_id FROM inactive_users); + +-- Example 43: Delete using recursive CTE +WITH RECURSIVE category_tree AS ( + SELECT id, parent_id, name FROM categories WHERE parent_id IS NULL + UNION ALL + SELECT c.id, c.parent_id, c.name + FROM categories c + JOIN category_tree ct ON c.parent_id = ct.id +) +DELETE FROM products +WHERE category_id IN ( + SELECT id FROM category_tree WHERE name = 'obsolete' +); + +-- Example 44: Delete with multiple CTEs +WITH + expired_sessions AS ( + SELECT session_id FROM sessions WHERE expires_at < CURRENT_TIMESTAMP + ), + inactive_users AS ( + SELECT user_id FROM users WHERE last_activity < CURRENT_DATE - 30 + ) +DELETE FROM user_sessions +WHERE session_id IN (SELECT session_id FROM expired_sessions) + OR user_id IN (SELECT user_id FROM inactive_users); + +-- Example 45: Delete with nested parentheses in conditions +DELETE FROM complex_data +WHERE ((status = 'pending' AND priority < 3) OR (status = 'failed' AND retry_count > 5)) + AND (created_date BETWEEN '2023-01-01' AND '2023-12-31'); + +-- Example 46: Delete with function calls and expressions +DELETE FROM metrics +WHERE ABS(value - target_value) > (target_value * 0.2); + +-- Example 47: Delete with CASE-like logic using subqueries +DELETE FROM orders +WHERE status = 'pending' + AND order_date < ( + CASE + WHEN priority = 'high' THEN CURRENT_DATE - 1 + WHEN priority = 'normal' THEN CURRENT_DATE - 7 + ELSE CURRENT_DATE - 30 + END + ); + +-- Example 48: Delete with JSON operations (if supported) +DELETE FROM user_data WHERE preferences::JSON->>'theme' = 'dark'; + +-- Example 49: Delete with array operations +DELETE FROM tags WHERE 'deprecated' = ANY(tag_array); + +-- Example 50: Delete with complex multi-table USING clause +DELETE FROM order_line_items +USING orders o, customers c, products p +WHERE order_line_items.order_id = o.id + AND o.customer_id = c.id + AND order_line_items.product_id = p.id + AND c.status = 'inactive' + AND p.discontinued = true + AND o.order_date < '2022-01-01'; \ No newline at end of file diff --git a/redshift/examples/redshift/desc_datashare.sql b/redshift/examples/redshift/desc_datashare.sql new file mode 100644 index 0000000..a9f90e5 --- /dev/null +++ b/redshift/examples/redshift/desc_datashare.sql @@ -0,0 +1,52 @@ +-- Test cases for DESC DATASHARE command +-- Based on AWS Redshift documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DESC_DATASHARE.html + +-- Basic DESC DATASHARE syntax +DESC DATASHARE salesshare; + +-- DESCRIBE variant (alternative keyword) +DESCRIBE DATASHARE salesshare; + +-- DESC DATASHARE with NAMESPACE (for inbound datashares within same AWS account) +DESC DATASHARE salesshare OF NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d'; + +-- DESC DATASHARE with ACCOUNT and NAMESPACE (for inbound datashares across AWS accounts) +DESC DATASHARE salesshare OF ACCOUNT '123456789012' NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d'; + +-- DESCRIBE variant with ACCOUNT and NAMESPACE +DESCRIBE DATASHARE salesshare OF ACCOUNT '123456789012' NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d'; + +-- Different datashare names +DESC DATASHARE customer_data; +DESC DATASHARE sales_analytics; +DESC DATASHARE marketing_metrics; + +-- Datashare names with underscores and numbers +DESC DATASHARE datashare_001; +DESC DATASHARE test_datashare_v2; + +-- Case variations +desc datashare salesshare; +DESCRIBE datashare salesshare; +Desc DataShare salesshare; + +-- With different account IDs +DESC DATASHARE inventory OF ACCOUNT '999888777666' NAMESPACE 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'; +DESC DATASHARE finance_data OF ACCOUNT '111222333444' NAMESPACE 'ffffffff-eeee-dddd-cccc-bbbbbbbbbbbb'; + +-- Only NAMESPACE specified (without ACCOUNT) +DESC DATASHARE regional_sales OF NAMESPACE '12345678-1234-5678-9012-123456789012'; +DESCRIBE DATASHARE product_catalog OF NAMESPACE 'abcdef12-3456-7890-abcd-ef1234567890'; + +-- Whitespace variations +DESC DATASHARE salesshare; +DESC DATASHARE salesshare OF ACCOUNT '123456789012' NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d'; + +-- Comments +-- This describes an outbound datashare +DESC DATASHARE /* production datashare */ salesshare; + +-- Multi-line example +DESC DATASHARE customer_analytics +OF ACCOUNT '555666777888' +NAMESPACE 'def456ef-789a-bcde-f012-3456789abcde'; \ No newline at end of file diff --git a/redshift/examples/redshift/desc_identity_provider.sql b/redshift/examples/redshift/desc_identity_provider.sql new file mode 100644 index 0000000..227bd91 --- /dev/null +++ b/redshift/examples/redshift/desc_identity_provider.sql @@ -0,0 +1,46 @@ +-- DESC IDENTITY PROVIDER command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DESC_IDENTITY_PROVIDER.html + +-- Basic DESC IDENTITY PROVIDER +DESC IDENTITY PROVIDER azure_idp; + +-- Alternative syntax with DESCRIBE +DESCRIBE IDENTITY PROVIDER azure_idp; + +-- Identity provider with different naming patterns +DESC IDENTITY PROVIDER my_identity_provider; +DESC IDENTITY PROVIDER okta_provider; +DESC IDENTITY PROVIDER saml_idp_001; + +-- Quoted identifier names +DESC IDENTITY PROVIDER "Azure-IDP"; +DESC IDENTITY PROVIDER "My Identity Provider"; +DESC IDENTITY PROVIDER "okta_provider_2023"; + +-- Case variations (should work due to case-insensitive keywords) +desc identity provider test_idp; +Desc Identity Provider test_idp; +DESCRIBE identity provider test_idp; + +-- Names with numbers and underscores +DESC IDENTITY PROVIDER idp_123; +DESC IDENTITY PROVIDER provider_v2; +DESC IDENTITY PROVIDER auth0_provider_prod; + +-- Long identifier names +DESC IDENTITY PROVIDER very_long_identity_provider_name_for_testing; +DESCRIBE IDENTITY PROVIDER corporate_sso_identity_provider_production; + +-- Names that might contain SQL keywords (quoted) +DESC IDENTITY PROVIDER "select"; +DESC IDENTITY PROVIDER "table"; +DESC IDENTITY PROVIDER "identity"; + +-- Realistic identity provider names from different vendors +DESC IDENTITY PROVIDER azure_ad_corp; +DESC IDENTITY PROVIDER okta_enterprise; +DESC IDENTITY PROVIDER auth0_production; +DESC IDENTITY PROVIDER ping_identity; +DESC IDENTITY PROVIDER onelogin_sso; +DESC IDENTITY PROVIDER google_workspace; +DESC IDENTITY PROVIDER microsoft_entra; \ No newline at end of file diff --git a/redshift/examples/redshift/detach_masking_policy.sql b/redshift/examples/redshift/detach_masking_policy.sql new file mode 100644 index 0000000..6e8fd1d --- /dev/null +++ b/redshift/examples/redshift/detach_masking_policy.sql @@ -0,0 +1,215 @@ +-- DETACH MASKING POLICY test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DETACH_MASKING_POLICY.html + +-- Basic detach from a single column for a user +DETACH MASKING POLICY credit_card_mask +ON customer_data +(credit_card_number) +FROM john_doe; + +-- Detach policy from multiple columns for a user +DETACH MASKING POLICY pii_mask +ON employee_table +(ssn, phone_number, email) +FROM alice_smith; + +-- Detach policy from a role +DETACH MASKING POLICY salary_mask +ON hr_data +(salary, bonus) +FROM ROLE finance_team; + +-- Detach policy from PUBLIC (all users) +DETACH MASKING POLICY default_mask +ON sensitive_table +(personal_info) +FROM PUBLIC; + +-- Detach policy from SUPER data type paths +DETACH MASKING POLICY json_mask +ON customer_json +(person.name.first_name, person.name.last_name, person.contact.email) +FROM david_wong; + +-- Detach policy with complex SUPER paths +DETACH MASKING POLICY super_conditional_mask +ON json_data +(sensitive_data.credit_info) +FROM ROLE data_analyst; + +-- Detach policy with mixed column types +DETACH MASKING POLICY mixed_mask +ON hybrid_table +(regular_column, super_data.nested.field) +FROM PUBLIC; + +-- Detach policy with quoted identifiers +DETACH MASKING POLICY "Special-Mask-Policy" +ON "Customer-Table" +("Credit-Card", "SSN-Number") +FROM "user-with-dash"; + +-- Detach policy with quoted identifier and role +DETACH MASKING POLICY policy_123 +ON "sales_2023" +("total_revenue", "customer_id") +FROM ROLE "Sales-Team-Role"; + +-- Complex example with multiple columns and SUPER paths +DETACH MASKING POLICY comprehensive_mask +ON financial_records +(account_balance, routing_number, account_holder.personal.ssn) +FROM ROLE executive_team; + +-- Detach multiple policies from different users on same table +DETACH MASKING POLICY basic_mask +ON employee_records +(salary) +FROM PUBLIC; + +DETACH MASKING POLICY detailed_mask +ON employee_records +(salary, bonus, stock_options) +FROM ROLE hr_manager; + +-- Edge cases with special characters in identifiers +DETACH MASKING POLICY "mask@policy#1" +ON "table$special%chars" +("column&name*1", "column^name!2") +FROM "user@company.com"; + +-- Maximum length identifiers (63 characters) +DETACH MASKING POLICY very_long_policy_name_that_reaches_maximum_allowed_length_12345 +ON table_with_very_long_name_that_also_reaches_maximum_length_123 +(column_with_extremely_long_name_reaching_sixty_three_chars_12345) +FROM user_with_long_name_reaching_maximum_allowed_identifier_length; + +-- Detach from nested SUPER columns with deep paths +DETACH MASKING POLICY deep_nested_mask +ON analytics_data +(user_profile.personal.contact.emergency.phone, user_profile.financial.accounts.primary.number) +FROM ROLE analytics_team; + +-- Detach policy from a single deeply nested column +DETACH MASKING POLICY single_nested_mask +ON order_data +(customer.billing.address.street) +FROM order_processor; + +-- Detach from columns with numeric suffixes +DETACH MASKING POLICY numeric_column_mask +ON data_table_v2 +(column1, column2, column3, column_final) +FROM ROLE data_team; + +-- Detach using case variations (should be case-insensitive) +detach masking policy lowercase_test +on test_table +(test_column) +from test_user; + +DETACH MASKING POLICY UPPERCASE_TEST +ON TEST_TABLE +(TEST_COLUMN) +FROM ROLE TEST_ROLE; + +-- Detach with mixed case +Detach Masking Policy MixedCase_Test +On Mixed_Table +(Mixed_Column) +From Public; + +-- Comments in statements +-- This removes the financial data mask +DETACH MASKING POLICY financial_mask +ON bank_accounts -- Main banking table +(account_number, balance) -- Previously masked columns +FROM ROLE teller; -- Bank teller role + +/* Multi-line comment example + This detaches a comprehensive masking policy + that was used for GDPR compliance */ +DETACH MASKING POLICY gdpr_mask +ON eu_customers +(name, email, phone, address) +FROM PUBLIC; + +-- Real-world scenarios based on AWS documentation patterns + +-- Detaching HR-related masking policies +DETACH MASKING POLICY employee_ssn_mask +ON employees +(social_security_number) +FROM ROLE hr_administrator; + +-- Detaching financial masking policies +DETACH MASKING POLICY account_mask +ON customer_accounts +(account_number, routing_number) +FROM financial_analyst; + +-- Detaching healthcare data masking +DETACH MASKING POLICY patient_data_mask +ON medical_records +(patient_id, diagnosis, treatment_notes) +FROM ROLE healthcare_provider; + +-- Detaching from multiple related columns +DETACH MASKING POLICY contact_info_mask +ON customer_contacts +(phone_home, phone_work, phone_mobile, email_personal, email_work) +FROM customer_service_rep; + +-- Detaching from temporal data +DETACH MASKING POLICY temporal_mask +ON transaction_history +(transaction_date, amount, merchant_info) +FROM ROLE audit_team; + +-- Detaching cross-schema references (if supported) +DETACH MASKING POLICY cross_schema_mask +ON production.customer_data +(sensitive_field) +FROM analytics_user; + +-- Detaching with schema-qualified table names +DETACH MASKING POLICY schema_qualified_mask +ON finance.account_details +(balance, credit_limit) +FROM ROLE finance_viewer; + +-- Edge case: single character identifiers +DETACH MASKING POLICY a +ON b +(c) +FROM d; + +-- Edge case: identifiers with numbers +DETACH MASKING POLICY mask123 +ON table456 +(col789) +FROM user000; + +-- Edge case: underscore variations +DETACH MASKING POLICY _mask_policy_ +ON _table_name_ +(_column_name_) +FROM _user_name_; + +-- Whitespace tolerance test +DETACH MASKING POLICY spaced_policy +ON spaced_table +( spaced_column ) +FROM spaced_user ; + +-- Testing optional semicolon +DETACH MASKING POLICY no_semicolon_policy +ON test_table +(test_column) +FROM test_user + +-- With semicolon for comparison +DETACH MASKING POLICY with_semicolon_policy +ON test_table +(test_column) +FROM test_user; \ No newline at end of file diff --git a/redshift/examples/redshift/detach_rls_policy.sql b/redshift/examples/redshift/detach_rls_policy.sql new file mode 100644 index 0000000..1b197cc --- /dev/null +++ b/redshift/examples/redshift/detach_rls_policy.sql @@ -0,0 +1,266 @@ +-- DETACH RLS POLICY test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DETACH_RLS_POLICY.html + +-- Example from AWS documentation +DETACH RLS POLICY policy_concerts ON tickit_category_redshift +FROM ROLE analyst, ROLE dbadmin; + +-- Basic detach from a single table for a specific user +DETACH RLS POLICY user_access_policy +ON employee_data +FROM john_doe; + +-- Detach policy from multiple users +DETACH RLS POLICY data_filter_policy +ON sales_records +FROM alice_smith, bob_johnson, carol_white; + +-- Detach policy from a single role +DETACH RLS POLICY finance_policy +ON financial_records +FROM ROLE finance_team; + +-- Detach policy from multiple roles +DETACH RLS POLICY audit_policy +ON transaction_logs +FROM ROLE auditor, ROLE compliance_officer, ROLE security_admin; + +-- Detach policy from PUBLIC (all users) +DETACH RLS POLICY public_access_policy +ON public_announcements +FROM PUBLIC; + +-- Detach policy from mixed targets - users, roles, and PUBLIC +DETACH RLS POLICY mixed_access_policy +ON inventory_table +FROM admin_user, ROLE warehouse_manager, PUBLIC; + +-- Detach policy with TABLE keyword +DETACH RLS POLICY regional_policy +ON TABLE customer_orders +FROM ROLE regional_manager; + +-- Detach policy from multiple tables +DETACH RLS POLICY cross_table_policy +ON orders, customers, transactions +FROM ROLE data_analyst, ROLE business_user; + +-- Detach policy from multiple tables with TABLE keyword +DETACH RLS POLICY data_protection_policy +ON TABLE sales_data, customer_profiles, order_history +FROM ROLE marketing_team; + +-- Schema-qualified table names +DETACH RLS POLICY schema_policy +ON sales.orders, sales.customers +FROM ROLE sales_team; + +-- Database.schema.table format +DETACH RLS POLICY cross_schema_policy +ON mydb.public.orders, mydb.sales.customers +FROM ROLE cross_schema_user; + +-- Complex multi-table, multi-target detachment +DETACH RLS POLICY comprehensive_policy +ON TABLE finance.transactions, finance.accounts, finance.budgets +FROM ROLE finance_analyst, ROLE finance_manager, ROLE auditor, finance_admin; + +-- Detach from views and materialized views +DETACH RLS POLICY view_policy +ON customer_view, sales_mv +FROM ROLE view_reader; + +-- Policy with quoted identifiers +DETACH RLS POLICY "Special-Policy-Name" +ON "Customer-Table", "Sales-Data" +FROM "user-with-dashes", ROLE "Role-With-Dashes"; + +-- Policy with numbers in names +DETACH RLS POLICY policy_2024_q1 +ON sales_2024_q1, revenue_2024_q1 +FROM ROLE analyst_2024, quarterly_reviewer; + +-- Single character identifiers (edge case) +DETACH RLS POLICY p +ON t +FROM ROLE r; + +-- Long identifier names +DETACH RLS POLICY very_long_policy_name_for_testing_limits_and_boundaries +ON table_with_a_very_long_name_to_test_parser_capabilities +FROM ROLE role_with_extremely_long_name_for_testing_purposes; + +-- Multiple users without roles +DETACH RLS POLICY user_only_policy +ON products +FROM user1, user2, user3, user4; + +-- Multiple roles without users +DETACH RLS POLICY role_only_policy +ON categories +FROM ROLE role1, ROLE role2, ROLE role3; + +-- Identifiers with underscores +DETACH RLS POLICY _policy_with_underscores_ +ON _table_with_underscores_ +FROM _user_with_underscores_, ROLE _role_with_underscores_; + +-- Identifiers with numbers and mixed case +DETACH RLS POLICY Policy123 +ON Table456, View789 +FROM User000, ROLE Role999; + +-- Case sensitivity variations (should be case-insensitive) +detach rls policy lowercase_test +on test_table +from test_user; + +DETACH RLS POLICY UPPERCASE_TEST +ON TEST_TABLE +FROM ROLE TEST_ROLE; + +Detach Rls Policy MixedCase_Test +On Mixed_Table +From Public; + +-- Healthcare data example +DETACH RLS POLICY patient_privacy_policy +ON medical_records, patient_info +FROM ROLE doctor, ROLE nurse, medical_admin; + +-- Financial services example +DETACH RLS POLICY account_security_policy +ON customer_accounts, transaction_history +FROM ROLE teller, ROLE loan_officer, bank_manager; + +-- E-commerce example +DETACH RLS POLICY order_visibility_policy +ON orders, order_items, shipments +FROM ROLE customer_service, ROLE fulfillment_team; + +-- HR data example +DETACH RLS POLICY employee_confidentiality_policy +ON employee_records, salary_info, performance_reviews +FROM ROLE hr_manager, ROLE payroll_admin; + +-- Multi-tenant application example +DETACH RLS POLICY tenant_isolation_policy +ON tenant_data, tenant_config +FROM ROLE tenant_admin, application_user; + +-- Compliance and audit example +DETACH RLS POLICY gdpr_compliance_policy +ON eu_customer_data, privacy_logs +FROM ROLE compliance_officer, ROLE privacy_officer, PUBLIC; + +-- Development environment example +DETACH RLS POLICY dev_access_policy +ON dev_tables, test_data +FROM ROLE developer, ROLE qa_tester, dev_admin; + +-- Analytics and reporting example +DETACH RLS POLICY reporting_policy +ON analytics_data, business_metrics +FROM ROLE business_analyst, ROLE data_scientist, report_viewer; + +-- Security and monitoring example +DETACH RLS POLICY security_monitoring_policy +ON security_logs, access_logs, audit_trail +FROM ROLE security_admin, ROLE system_monitor; + +-- Data warehouse example +DETACH RLS POLICY warehouse_access_policy +ON fact_sales, dim_customer, dim_product +FROM ROLE data_engineer, ROLE warehouse_admin; + +-- Cross-department access +DETACH RLS POLICY cross_dept_policy +ON shared_resources, common_lookup_tables +FROM ROLE marketing, ROLE sales, ROLE support, shared_user; + +-- Temporal data access +DETACH RLS POLICY temporal_access_policy +ON historical_data, archived_records +FROM ROLE historian, ROLE archive_admin; + +-- Geographic data access +DETACH RLS POLICY geographic_policy +ON location_data, regional_sales +FROM ROLE regional_manager_us, ROLE regional_manager_eu; + +-- Special characters in quoted identifiers +DETACH RLS POLICY "policy@domain.com" +ON "table$special%chars", "view#with&symbols" +FROM "user@company.com", ROLE "role!with*special^chars"; + +-- Maximum complexity example +DETACH RLS POLICY enterprise_master_policy +ON TABLE production.sales.orders, + production.sales.customers, + production.inventory.products, + staging.imports.raw_data, + analytics.reports.daily_summary +FROM enterprise_admin, + data_steward, + business_owner, + ROLE enterprise_viewer, + ROLE data_analyst, + ROLE business_intelligence, + ROLE system_administrator, + PUBLIC; + +-- Edge case: detaching from everything +DETACH RLS POLICY universal_policy +ON all_tables, all_views, all_materialized_views +FROM all_users, ROLE all_roles, PUBLIC; + +-- Whitespace tolerance test +DETACH RLS POLICY spaced_policy +ON spaced_table , another_table +FROM spaced_user , ROLE spaced_role , PUBLIC ; + +-- Comments in statements +-- This removes the customer data access policy +DETACH RLS POLICY customer_data_policy +ON customers -- Customer master table +FROM ROLE customer_service, -- Customer service representatives + ROLE sales_team; -- Sales team members + +/* Multi-line comment example + This detaches a comprehensive data governance policy + that was implemented for regulatory compliance */ +DETACH RLS POLICY regulatory_compliance_policy +ON sensitive_financial_data, customer_pii, transaction_records +FROM ROLE compliance_team, ROLE legal_team, audit_manager; + +-- Real-world enterprise scenarios + +-- Detaching departmental policies +DETACH RLS POLICY hr_department_policy +ON employee_data, payroll_info, benefits_data +FROM ROLE hr_manager, ROLE hr_specialist, hr_admin; + +-- Detaching project-based access +DETACH RLS POLICY project_alpha_policy +ON project_alpha_data, project_alpha_reports +FROM ROLE project_alpha_team, project_alpha_lead; + +-- Detaching time-based access (end of quarter) +DETACH RLS POLICY q4_2024_policy +ON q4_sales_data, q4_financial_reports +FROM ROLE q4_analyst, ROLE quarterly_reviewer; + +-- Detaching contractor access +DETACH RLS POLICY contractor_access_policy +ON limited_project_data, public_documentation +FROM contractor_user1, contractor_user2, ROLE contractor_team; + +-- Emergency access removal +DETACH RLS POLICY emergency_access_policy +ON critical_systems_data, emergency_procedures +FROM ROLE emergency_responder, ROLE incident_manager; + +-- Vendor access removal +DETACH RLS POLICY vendor_integration_policy +ON integration_logs, api_access_data +FROM vendor_integration_user, ROLE vendor_support; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_database.sql b/redshift/examples/redshift/drop_database.sql new file mode 100644 index 0000000..8ddb489 --- /dev/null +++ b/redshift/examples/redshift/drop_database.sql @@ -0,0 +1,5 @@ +-- DROP DATABASE examples for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATABASE.html + +-- Basic DROP DATABASE +DROP DATABASE tickit_test; diff --git a/redshift/examples/redshift/drop_datashare.sql b/redshift/examples/redshift/drop_datashare.sql new file mode 100644 index 0000000..426fce2 --- /dev/null +++ b/redshift/examples/redshift/drop_datashare.sql @@ -0,0 +1,78 @@ +-- DROP DATASHARE command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATASHARE.html + +-- Basic DROP DATASHARE syntax +DROP DATASHARE salesshare; + +-- DROP DATASHARE with IF EXISTS clause +DROP DATASHARE IF EXISTS salesshare; + +-- DROP DATASHARE with various datashare names +DROP DATASHARE myshare; +DROP DATASHARE customer_data; +DROP DATASHARE product_catalog; +DROP DATASHARE analytics_share; + +-- DROP DATASHARE with quoted identifiers +DROP DATASHARE "SalesShare"; +DROP DATASHARE "my-share"; +DROP DATASHARE "Share With Spaces"; + +-- DROP DATASHARE with IF EXISTS and quoted identifiers +DROP DATASHARE IF EXISTS "SalesShare"; +DROP DATASHARE IF EXISTS "my-share"; +DROP DATASHARE IF EXISTS "Share With Spaces"; + +-- DROP DATASHARE with common naming patterns +DROP DATASHARE sales_2023; +DROP DATASHARE customer_360_view; +DROP DATASHARE financial_reporting; +DROP DATASHARE hr_analytics; + +-- DROP DATASHARE with IF EXISTS for common patterns +DROP DATASHARE IF EXISTS sales_2023; +DROP DATASHARE IF EXISTS customer_360_view; +DROP DATASHARE IF EXISTS financial_reporting; +DROP DATASHARE IF EXISTS hr_analytics; + +-- DROP DATASHARE with mixed case names +DROP DATASHARE SalesData; +DROP DATASHARE CustomerInfo; +DROP DATASHARE ProductCatalog; + +-- DROP DATASHARE with underscored names +DROP DATASHARE sales_data_share; +DROP DATASHARE customer_info_share; +DROP DATASHARE product_catalog_share; + +-- DROP DATASHARE with IF EXISTS for mixed case and underscored names +DROP DATASHARE IF EXISTS SalesData; +DROP DATASHARE IF EXISTS sales_data_share; + +-- DROP DATASHARE examples from AWS documentation +-- Note: In practice, AWS Data Exchange datashares require special session variable: +-- SET datashare_break_glass_session_var to '620c871f890c49'; +DROP DATASHARE salesshare; + +-- Additional realistic datashare names +DROP DATASHARE market_data; +DROP DATASHARE financial_metrics; +DROP DATASHARE user_behavior; +DROP DATASHARE inventory_tracking; +DROP DATASHARE compliance_reports; + +-- With IF EXISTS for safety +DROP DATASHARE IF EXISTS market_data; +DROP DATASHARE IF EXISTS financial_metrics; +DROP DATASHARE IF EXISTS user_behavior; +DROP DATASHARE IF EXISTS inventory_tracking; +DROP DATASHARE IF EXISTS compliance_reports; + +-- Edge cases with special characters in quoted names +DROP DATASHARE "share-with-hyphens"; +DROP DATASHARE "share.with.dots"; +DROP DATASHARE "share$with$dollars"; + +-- DROP DATASHARE statements without semicolons (should also be valid) +DROP DATASHARE test_share +DROP DATASHARE IF EXISTS test_share \ No newline at end of file diff --git a/redshift/examples/redshift/drop_external_view.sql b/redshift/examples/redshift/drop_external_view.sql new file mode 100644 index 0000000..1ea2396 --- /dev/null +++ b/redshift/examples/redshift/drop_external_view.sql @@ -0,0 +1,186 @@ +-- DROP EXTERNAL VIEW command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_EXTERNAL_VIEW.html + +-- Basic DROP EXTERNAL VIEW syntax from AWS documentation +DROP EXTERNAL VIEW sample_schema.glue_data_catalog_view; + +-- DROP EXTERNAL VIEW with IF EXISTS clause from AWS documentation +DROP EXTERNAL VIEW IF EXISTS sample_schema.glue_data_catalog_view; + +-- Basic DROP EXTERNAL VIEW without schema qualification +DROP EXTERNAL VIEW simple_view; + +-- DROP EXTERNAL VIEW with IF EXISTS for simple view +DROP EXTERNAL VIEW IF EXISTS simple_view; + +-- DROP EXTERNAL VIEW with two-part names (schema.view) +DROP EXTERNAL VIEW analytics_schema.customer_view; +DROP EXTERNAL VIEW reporting_schema.sales_view; +DROP EXTERNAL VIEW data_warehouse.inventory_view; +DROP EXTERNAL VIEW spectrum_schema.product_view; + +-- DROP EXTERNAL VIEW with IF EXISTS for two-part names +DROP EXTERNAL VIEW IF EXISTS analytics_schema.customer_view; +DROP EXTERNAL VIEW IF EXISTS reporting_schema.sales_view; +DROP EXTERNAL VIEW IF EXISTS data_warehouse.inventory_view; +DROP EXTERNAL VIEW IF EXISTS spectrum_schema.product_view; + +-- DROP EXTERNAL VIEW with three-part names (catalog.schema.view) +DROP EXTERNAL VIEW my_catalog.analytics_schema.sales_view; +DROP EXTERNAL VIEW "data_catalog".reporting.monthly_metrics; +DROP EXTERNAL VIEW external_catalog.public.customer_data; + +-- DROP EXTERNAL VIEW with awsdatacatalog prefix (three-part AWS format) +DROP EXTERNAL VIEW awsdatacatalog.analytics_db.customer_view; +DROP EXTERNAL VIEW awsdatacatalog.sales_database.transaction_view; +DROP EXTERNAL VIEW awsdatacatalog.inventory_db.stock_view; + +-- DROP EXTERNAL VIEW with IF EXISTS for three-part names +DROP EXTERNAL VIEW IF EXISTS my_catalog.analytics_schema.sales_view; +DROP EXTERNAL VIEW IF EXISTS awsdatacatalog.analytics_db.customer_view; +DROP EXTERNAL VIEW IF EXISTS "data_catalog".reporting.monthly_metrics; + +-- DROP EXTERNAL VIEW with quoted identifiers +DROP EXTERNAL VIEW "SampleSchema"."GlueDataCatalogView"; +DROP EXTERNAL VIEW "my-schema"."view-with-hyphens"; +DROP EXTERNAL VIEW "Schema With Spaces"."View With Spaces"; + +-- DROP EXTERNAL VIEW with mixed quoted and unquoted identifiers +DROP EXTERNAL VIEW analytics_schema."Customer View"; +DROP EXTERNAL VIEW "reporting-schema".sales_view; +DROP EXTERNAL VIEW awsdatacatalog."my-database"."special-view"; + +-- DROP EXTERNAL VIEW with IF EXISTS and quoted identifiers +DROP EXTERNAL VIEW IF EXISTS "SampleSchema"."GlueDataCatalogView"; +DROP EXTERNAL VIEW IF EXISTS "my-schema"."view-with-hyphens"; +DROP EXTERNAL VIEW IF EXISTS "Schema With Spaces"."View With Spaces"; + +-- DROP EXTERNAL VIEW with common external schema names +DROP EXTERNAL VIEW spectrum_schema.customer_orders_view; +DROP EXTERNAL VIEW redshift_spectrum.sales_data_view; +DROP EXTERNAL VIEW external_analytics.user_behavior_view; +DROP EXTERNAL VIEW data_lake.financial_metrics_view; + +-- DROP EXTERNAL VIEW with underscored naming patterns +DROP EXTERNAL VIEW customer_analytics.lifetime_value_view; +DROP EXTERNAL VIEW sales_reporting.monthly_summary_view; +DROP EXTERNAL VIEW inventory_management.stock_alerts_view; +DROP EXTERNAL VIEW financial_reporting.quarterly_results_view; + +-- DROP EXTERNAL VIEW with mixed case naming +DROP EXTERNAL VIEW DataLake.CustomerAnalytics; +DROP EXTERNAL VIEW SalesSchema.ProductPerformance; +DROP EXTERNAL VIEW AnalyticsWarehouse.CustomerSegmentation; + +-- DROP EXTERNAL VIEW with IF EXISTS for various naming patterns +DROP EXTERNAL VIEW IF EXISTS spectrum_schema.customer_orders_view; +DROP EXTERNAL VIEW IF EXISTS customer_analytics.lifetime_value_view; +DROP EXTERNAL VIEW IF EXISTS DataLake.CustomerAnalytics; +DROP EXTERNAL VIEW IF EXISTS external_analytics.user_behavior_view; + +-- DROP EXTERNAL VIEW with special characters in quoted names +DROP EXTERNAL VIEW "view-with-hyphens"; +DROP EXTERNAL VIEW "view.with.dots"; +DROP EXTERNAL VIEW "view$with$dollars"; +DROP EXTERNAL VIEW "view@with@symbols"; + +-- DROP EXTERNAL VIEW with three-part quoted names +DROP EXTERNAL VIEW "my-catalog"."analytics-schema"."sales-view"; +DROP EXTERNAL VIEW "data.catalog"."reporting.schema"."monthly.metrics"; +DROP EXTERNAL VIEW awsdatacatalog."database-name"."view-name"; + +-- DROP EXTERNAL VIEW with complex external schema configurations +DROP EXTERNAL VIEW external_s3_data.customer_transactions; +DROP EXTERNAL VIEW glue_catalog_schema.product_inventory; +DROP EXTERNAL VIEW redshift_spectrum_db.order_analytics; +DROP EXTERNAL VIEW cross_platform_data.unified_customer_view; + +-- DROP EXTERNAL VIEW with IF EXISTS for complex configurations +DROP EXTERNAL VIEW IF EXISTS external_s3_data.customer_transactions; +DROP EXTERNAL VIEW IF EXISTS glue_catalog_schema.product_inventory; +DROP EXTERNAL VIEW IF EXISTS redshift_spectrum_db.order_analytics; +DROP EXTERNAL VIEW IF EXISTS cross_platform_data.unified_customer_view; + +-- DROP EXTERNAL VIEW with realistic business scenarios +DROP EXTERNAL VIEW sales_analytics.regional_performance_view; +DROP EXTERNAL VIEW customer_insights.behavior_analysis_view; +DROP EXTERNAL VIEW financial_data.revenue_tracking_view; +DROP EXTERNAL VIEW operations.supply_chain_view; +DROP EXTERNAL VIEW marketing.campaign_effectiveness_view; +DROP EXTERNAL VIEW hr_analytics.employee_performance_view; + +-- DROP EXTERNAL VIEW with database-specific naming +DROP EXTERNAL VIEW awsdatacatalog.ecommerce_db.customer_orders; +DROP EXTERNAL VIEW awsdatacatalog.analytics_warehouse.sales_metrics; +DROP EXTERNAL VIEW awsdatacatalog.operational_data.inventory_levels; +DROP EXTERNAL VIEW awsdatacatalog.financial_reporting.quarterly_summary; + +-- DROP EXTERNAL VIEW with IF EXISTS for business scenarios +DROP EXTERNAL VIEW IF EXISTS sales_analytics.regional_performance_view; +DROP EXTERNAL VIEW IF EXISTS awsdatacatalog.ecommerce_db.customer_orders; +DROP EXTERNAL VIEW IF EXISTS customer_insights.behavior_analysis_view; +DROP EXTERNAL VIEW IF EXISTS financial_data.revenue_tracking_view; + +-- DROP EXTERNAL VIEW with schema names that might be keywords +DROP EXTERNAL VIEW external.view_name; +DROP EXTERNAL VIEW schema.external_view; +DROP EXTERNAL VIEW catalog.schema_view; +DROP EXTERNAL VIEW database.table_view; +DROP EXTERNAL VIEW analytics.data_view; +DROP EXTERNAL VIEW reporting.warehouse_view; + +-- DROP EXTERNAL VIEW with view names that might be keywords +DROP EXTERNAL VIEW sample_schema.external; +DROP EXTERNAL VIEW sample_schema.view; +DROP EXTERNAL VIEW sample_schema.schema; +DROP EXTERNAL VIEW sample_schema.catalog; +DROP EXTERNAL VIEW sample_schema.database; +DROP EXTERNAL VIEW sample_schema.analytics; +DROP EXTERNAL VIEW sample_schema.reporting; +DROP EXTERNAL VIEW sample_schema.warehouse; + +-- DROP EXTERNAL VIEW statements without semicolons (should also be valid) +DROP EXTERNAL VIEW test_schema.test_view +DROP EXTERNAL VIEW IF EXISTS test_schema.conditional_view + +-- DROP EXTERNAL VIEW with various AWS Data Catalog patterns +DROP EXTERNAL VIEW awsdatacatalog.default.customer_data; +DROP EXTERNAL VIEW awsdatacatalog.sampledb.sales_data; +DROP EXTERNAL VIEW awsdatacatalog.analytics.user_events; +DROP EXTERNAL VIEW awsdatacatalog.warehouse.inventory_snapshot; + +-- DROP EXTERNAL VIEW examples that match CREATE EXTERNAL VIEW patterns +-- These should correspond to views that could have been created with CREATE EXTERNAL VIEW +DROP EXTERNAL VIEW sample_schema.glue_data_catalog_view; +DROP EXTERNAL VIEW awsdatacatalog.analytics_db.customer_view; +DROP EXTERNAL VIEW my_catalog.analytics_schema.sales_view; +DROP EXTERNAL VIEW spectrum_schema.aggregated_sales_view; +DROP EXTERNAL VIEW analytics_schema.customer_orders_view; +DROP EXTERNAL VIEW reporting_schema.detailed_order_view; +DROP EXTERNAL VIEW analytics_schema.high_value_customers_view; +DROP EXTERNAL VIEW analytics_schema.customer_segmentation_view; +DROP EXTERNAL VIEW analytics_schema.sales_ranking_view; +DROP EXTERNAL VIEW reporting_schema.monthly_sales_view; +DROP EXTERNAL VIEW analytics_schema.customer_contact_view; +DROP EXTERNAL VIEW reporting_schema.all_transactions_view; +DROP EXTERNAL VIEW analytics_schema.customers_with_orders_view; +DROP EXTERNAL VIEW analytics_schema.customers_without_orders_view; +DROP EXTERNAL VIEW analytics_schema.premium_product_sales_view; +DROP EXTERNAL VIEW reporting_schema.recent_orders_view; +DROP EXTERNAL VIEW analytics_schema.tech_customers_view; +DROP EXTERNAL VIEW analytics_schema.complete_customer_profiles_view; +DROP EXTERNAL VIEW analytics_schema.order_metrics_view; +DROP EXTERNAL VIEW reporting_schema.product_performance_view; +DROP EXTERNAL VIEW external_analytics.regional_sales_summary; +DROP EXTERNAL VIEW data_warehouse.customer_lifetime_value; +DROP EXTERNAL VIEW DataLake.CustomerAnalytics; +DROP EXTERNAL VIEW secure_analytics.financial_summary; +DROP EXTERNAL VIEW cross_platform.unified_customer_data; +DROP EXTERNAL VIEW spectrum_database.public.inventory_status; + +-- DROP EXTERNAL VIEW with IF EXISTS for views that match CREATE patterns +DROP EXTERNAL VIEW IF EXISTS sample_schema.glue_data_catalog_view; +DROP EXTERNAL VIEW IF EXISTS awsdatacatalog.analytics_db.customer_view; +DROP EXTERNAL VIEW IF EXISTS spectrum_schema.aggregated_sales_view; +DROP EXTERNAL VIEW IF EXISTS analytics_schema.customer_segmentation_view; +DROP EXTERNAL VIEW IF EXISTS cross_platform.unified_customer_data; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_function.sql b/redshift/examples/redshift/drop_function.sql new file mode 100644 index 0000000..834d2e9 --- /dev/null +++ b/redshift/examples/redshift/drop_function.sql @@ -0,0 +1,264 @@ +-- DROP FUNCTION test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_FUNCTION.html + +-- Basic DROP FUNCTION examples + +-- Drop function with integer parameter (from AWS docs example) +DROP FUNCTION f_sqrt(int); + +-- Drop function with CASCADE option (from AWS docs example) +DROP FUNCTION f_sqrt(int) CASCADE; + +-- Drop function with RESTRICT option (explicit default behavior) +DROP FUNCTION f_sqrt(int) RESTRICT; + +-- DROP FUNCTION with IF EXISTS + +-- Drop function if it exists (prevents errors) +DROP FUNCTION IF EXISTS f_sqrt(int); + +-- Drop function if exists with CASCADE +DROP FUNCTION IF EXISTS f_sqrt(int) CASCADE; + +-- Drop function if exists with RESTRICT +DROP FUNCTION IF EXISTS f_sqrt(int) RESTRICT; + +-- Schema-qualified function names + +-- Drop function in specific schema +DROP FUNCTION myschema.f_calculate(integer, float); + +-- Drop function in quoted schema +DROP FUNCTION "my_schema".f_process(varchar); + +-- Drop function with quoted function name +DROP FUNCTION "f_special_calc"(decimal); + +-- Drop function with both schema and function name quoted +DROP FUNCTION "my_schema"."f_special_function"(text); + +-- Functions with various data types (matching CREATE FUNCTION examples) + +-- Python UDF examples to drop +DROP FUNCTION f_py_greater(float, float); +DROP FUNCTION f_py_calculator(integer, integer, varchar); +DROP FUNCTION f_py_square(float); +DROP FUNCTION f_py_is_even(integer); +DROP FUNCTION f_py_clean_string(varchar); +DROP FUNCTION f_py_days_between(date, date); + +-- SQL UDF examples to drop +DROP FUNCTION f_sql_greater(float, float); +DROP FUNCTION f_sql_discount_price(decimal, decimal); +DROP FUNCTION f_sql_circle_area(float); +DROP FUNCTION f_sql_full_name(varchar, varchar); +DROP FUNCTION f_sql_grade_letter(integer); + +-- Functions with specific data type variations + +-- Drop function with SMALLINT +DROP FUNCTION f_process_small(smallint); + +-- Drop function with BIGINT +DROP FUNCTION f_process_big(bigint); + +-- Drop function with DECIMAL with precision +DROP FUNCTION f_compound_interest(decimal(10,2), decimal(5,4), integer); + +-- Drop function with NUMERIC with precision and scale +DROP FUNCTION f_financial_calc(numeric(15,2)); + +-- Drop function with REAL +DROP FUNCTION f_real_calc(real); + +-- Drop function with DOUBLE PRECISION +DROP FUNCTION f_precise_calc(double precision); + +-- Drop function with FLOAT with precision +DROP FUNCTION f_float_calc(float(24)); + +-- Drop function with BOOLEAN +DROP FUNCTION f_bool_check(boolean); + +-- Drop function with BOOL (alias) +DROP FUNCTION f_bool_alias(bool); + +-- Drop function with CHAR with length +DROP FUNCTION f_initial(char(50)); + +-- Drop function with CHARACTER with length +DROP FUNCTION f_character_proc(character(10)); + +-- Drop function with VARCHAR with length +DROP FUNCTION f_format_phone(varchar(15)); + +-- Drop function with CHARACTER VARYING +DROP FUNCTION f_varying_text(character varying(100)); + +-- Drop function with DATE +DROP FUNCTION f_date_calc(date); + +-- Drop function with TIMESTAMP +DROP FUNCTION f_timestamp_proc(timestamp); + +-- Drop function with TIMESTAMP with precision +DROP FUNCTION f_timestamp_precise(timestamp(6)); + +-- Drop function with TIMESTAMP WITH TIME ZONE +DROP FUNCTION f_timestamp_tz(timestamp with time zone); + +-- Drop function with TIMESTAMP WITHOUT TIME ZONE +DROP FUNCTION f_timestamp_no_tz(timestamp without time zone); + +-- Drop function with TIMESTAMPTZ +DROP FUNCTION f_timestamptz_proc(timestamptz); + +-- Drop function with TIMESTAMPTZ with precision +DROP FUNCTION f_timestamptz_precise(timestamptz(3)); + +-- Drop function with TIME +DROP FUNCTION f_time_proc(time); + +-- Drop function with TIME with precision +DROP FUNCTION f_time_precise(time(6)); + +-- Drop function with TIME WITH TIME ZONE +DROP FUNCTION f_time_tz(time with time zone); + +-- Drop function with TIME WITHOUT TIME ZONE +DROP FUNCTION f_time_no_tz(time without time zone); + +-- Drop function with TIMETZ +DROP FUNCTION f_timetz_proc(timetz); + +-- Drop function with TIMETZ with precision +DROP FUNCTION f_timetz_precise(timetz(6)); + +-- Drop function with ANYELEMENT +DROP FUNCTION f_first_non_null(anyelement, anyelement); + +-- Drop function with TEXT +DROP FUNCTION f_text_process(text); + +-- Redshift-specific data types + +-- Drop function with SUPER +DROP FUNCTION f_super_length(super); + +-- Drop function with GEOMETRY +DROP FUNCTION f_geometry_area(geometry); + +-- Drop function with GEOGRAPHY +DROP FUNCTION f_geography_distance(geography, geography); + +-- Drop function with HLLSKETCH +DROP FUNCTION f_hll_cardinality(hllsketch); + +-- Functions with multiple parameters + +-- Drop function with two parameters +DROP FUNCTION f_two_params(integer, varchar); + +-- Drop function with three parameters +DROP FUNCTION f_three_params(decimal, float, boolean); + +-- Drop function with many parameters (demonstrating up to 32 limit) +DROP FUNCTION f_sum_many( + integer, integer, integer, integer, integer, + integer, integer, integer, integer, integer +); + +-- Drop function with mixed data types +DROP FUNCTION f_mixed_types( + smallint, bigint, decimal(10,2), varchar(50), + boolean, date, timestamp, geometry +); + +-- Functions with no parameters + +-- Drop function with empty parameter list +DROP FUNCTION f_current_year(); + +-- Drop function with no parameters using IF EXISTS +DROP FUNCTION IF EXISTS f_no_params(); + +-- Functions with argument names (names are ignored during drop) + +-- Drop function where original had argument names (Python UDF style) +DROP FUNCTION f_py_with_names(integer, varchar); + +-- Drop function specifying argument names (optional, ignored) +DROP FUNCTION f_with_arg_names(input_val integer, input_text varchar); + +-- Mixed cases with argument names and without +DROP FUNCTION f_mixed_args(integer, description varchar, active boolean); + +-- Edge cases and special scenarios + +-- Drop function with CASCADE and IF EXISTS combined +DROP FUNCTION IF EXISTS f_cascade_example(integer) CASCADE; + +-- Drop function with RESTRICT and IF EXISTS combined +DROP FUNCTION IF EXISTS f_restrict_example(varchar) RESTRICT; + +-- Drop function with very long name +DROP FUNCTION f_very_long_function_name_that_demonstrates_identifier_length(integer); + +-- Drop function with quoted identifiers containing special characters +DROP FUNCTION "f_special-function"(integer); +DROP FUNCTION "F_UPPER_CASE_FUNCTION"(varchar); + +-- Drop function in system-like schema names +DROP FUNCTION pg_catalog.f_system_function(integer); +DROP FUNCTION information_schema.f_info_function(text); + +-- Drop functions that might have been created with OR REPLACE +DROP FUNCTION f_replaceable_function(float, float); + +-- Complex data type combinations + +-- Drop function with nested precision specifications +DROP FUNCTION f_complex_numeric( + decimal(15,4), + numeric(20,6), + float(53), + timestamp(6) with time zone, + varchar(255) +); + +-- Functions demonstrating all three drop behaviors + +-- Default behavior (RESTRICT implied) +DROP FUNCTION f_default_behavior(integer); + +-- Explicit CASCADE (drops dependent objects) +DROP FUNCTION f_with_cascade(varchar) CASCADE; + +-- Explicit RESTRICT (prevents drop if dependencies exist) +DROP FUNCTION f_with_restrict(boolean) RESTRICT; + +-- Real-world scenario examples + +-- Drop mathematical functions +DROP FUNCTION f_calculate_distance(float, float, float, float); +DROP FUNCTION f_compound_interest_calculator(decimal(12,2), decimal(5,4), integer); + +-- Drop string manipulation functions +DROP FUNCTION f_clean_phone_number(varchar); +DROP FUNCTION f_extract_domain(varchar); + +-- Drop date/time functions +DROP FUNCTION f_business_days_between(date, date); +DROP FUNCTION f_format_timestamp(timestamp); + +-- Drop validation functions +DROP FUNCTION f_is_valid_email(varchar); +DROP FUNCTION f_check_data_quality(super); + +-- Drop aggregation helper functions +DROP FUNCTION f_weighted_average(decimal, decimal); +DROP FUNCTION f_percentile_rank(integer, integer); + +-- Functions with custom type names (identifiers) +DROP FUNCTION f_custom_type_function(my_custom_type); +DROP FUNCTION f_enum_function(status_enum, priority_level); \ No newline at end of file diff --git a/redshift/examples/redshift/drop_group.sql b/redshift/examples/redshift/drop_group.sql new file mode 100644 index 0000000..4f2a0a7 --- /dev/null +++ b/redshift/examples/redshift/drop_group.sql @@ -0,0 +1,17 @@ +-- DROP GROUP examples from AWS Redshift documentation +-- https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_GROUP.html + +-- Basic DROP GROUP +DROP GROUP guests; + +-- Another example +DROP GROUP developers; + +-- Drop a group that might have privileges (need to revoke first) +-- Note: The REVOKE statement must be executed before DROP GROUP if the group has privileges +DROP GROUP sales_team; + +-- Drop groups with various naming conventions +DROP GROUP admin_users; +DROP GROUP readonly_group; +DROP GROUP data_analysts; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_identity_provider.sql b/redshift/examples/redshift/drop_identity_provider.sql new file mode 100644 index 0000000..17c1060 --- /dev/null +++ b/redshift/examples/redshift/drop_identity_provider.sql @@ -0,0 +1,136 @@ +-- DROP IDENTITY PROVIDER command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_IDENTITY_PROVIDER.html + +-- Basic DROP IDENTITY PROVIDER syntax from AWS documentation +DROP IDENTITY PROVIDER oauth_provider; + +-- DROP IDENTITY PROVIDER with CASCADE clause +DROP IDENTITY PROVIDER oauth_provider CASCADE; + +-- DROP IDENTITY PROVIDER with various provider names +DROP IDENTITY PROVIDER azure_ad_provider; +DROP IDENTITY PROVIDER saml_provider; +DROP IDENTITY PROVIDER okta_provider; +DROP IDENTITY PROVIDER google_oauth; +DROP IDENTITY PROVIDER microsoft_provider; + +-- DROP IDENTITY PROVIDER with CASCADE for various providers +DROP IDENTITY PROVIDER azure_ad_provider CASCADE; +DROP IDENTITY PROVIDER saml_provider CASCADE; +DROP IDENTITY PROVIDER okta_provider CASCADE; +DROP IDENTITY PROVIDER google_oauth CASCADE; +DROP IDENTITY PROVIDER microsoft_provider CASCADE; + +-- DROP IDENTITY PROVIDER with quoted identifiers +DROP IDENTITY PROVIDER "OAuth Provider"; +DROP IDENTITY PROVIDER "Azure-AD-Provider"; +DROP IDENTITY PROVIDER "My SAML Provider"; +DROP IDENTITY PROVIDER "Corporate SSO"; + +-- DROP IDENTITY PROVIDER with quoted identifiers and CASCADE +DROP IDENTITY PROVIDER "OAuth Provider" CASCADE; +DROP IDENTITY PROVIDER "Azure-AD-Provider" CASCADE; +DROP IDENTITY PROVIDER "My SAML Provider" CASCADE; +DROP IDENTITY PROVIDER "Corporate SSO" CASCADE; + +-- DROP IDENTITY PROVIDER with common provider naming patterns +DROP IDENTITY PROVIDER company_sso; +DROP IDENTITY PROVIDER corporate_auth; +DROP IDENTITY PROVIDER employee_login; +DROP IDENTITY PROVIDER external_users; +DROP IDENTITY PROVIDER partner_access; +DROP IDENTITY PROVIDER customer_portal; + +-- DROP IDENTITY PROVIDER with common patterns and CASCADE +DROP IDENTITY PROVIDER company_sso CASCADE; +DROP IDENTITY PROVIDER corporate_auth CASCADE; +DROP IDENTITY PROVIDER employee_login CASCADE; +DROP IDENTITY PROVIDER external_users CASCADE; +DROP IDENTITY PROVIDER partner_access CASCADE; +DROP IDENTITY PROVIDER customer_portal CASCADE; + +-- DROP IDENTITY PROVIDER with mixed case names +DROP IDENTITY PROVIDER AzureProvider; +DROP IDENTITY PROVIDER OAuthProvider; +DROP IDENTITY PROVIDER SamlProvider; +DROP IDENTITY PROVIDER GoogleAuth; +DROP IDENTITY PROVIDER MicrosoftSSO; + +-- DROP IDENTITY PROVIDER with mixed case names and CASCADE +DROP IDENTITY PROVIDER AzureProvider CASCADE; +DROP IDENTITY PROVIDER OAuthProvider CASCADE; +DROP IDENTITY PROVIDER SamlProvider CASCADE; +DROP IDENTITY PROVIDER GoogleAuth CASCADE; +DROP IDENTITY PROVIDER MicrosoftSSO CASCADE; + +-- DROP IDENTITY PROVIDER with underscored names +DROP IDENTITY PROVIDER oauth_2_provider; +DROP IDENTITY PROVIDER saml_2_0_provider; +DROP IDENTITY PROVIDER azure_ad_b2c; +DROP IDENTITY PROVIDER google_workspace_sso; +DROP IDENTITY PROVIDER okta_universal_directory; + +-- DROP IDENTITY PROVIDER with underscored names and CASCADE +DROP IDENTITY PROVIDER oauth_2_provider CASCADE; +DROP IDENTITY PROVIDER saml_2_0_provider CASCADE; +DROP IDENTITY PROVIDER azure_ad_b2c CASCADE; +DROP IDENTITY PROVIDER google_workspace_sso CASCADE; +DROP IDENTITY PROVIDER okta_universal_directory CASCADE; + +-- DROP IDENTITY PROVIDER with realistic enterprise provider names +DROP IDENTITY PROVIDER corp_azure_ad; +DROP IDENTITY PROVIDER enterprise_okta; +DROP IDENTITY PROVIDER federated_login; +DROP IDENTITY PROVIDER third_party_auth; +DROP IDENTITY PROVIDER vendor_sso; +DROP IDENTITY PROVIDER client_authentication; + +-- DROP IDENTITY PROVIDER with realistic names and CASCADE +DROP IDENTITY PROVIDER corp_azure_ad CASCADE; +DROP IDENTITY PROVIDER enterprise_okta CASCADE; +DROP IDENTITY PROVIDER federated_login CASCADE; +DROP IDENTITY PROVIDER third_party_auth CASCADE; +DROP IDENTITY PROVIDER vendor_sso CASCADE; +DROP IDENTITY PROVIDER client_authentication CASCADE; + +-- DROP IDENTITY PROVIDER with special characters in quoted names +DROP IDENTITY PROVIDER "provider-with-hyphens"; +DROP IDENTITY PROVIDER "provider.with.dots"; +DROP IDENTITY PROVIDER "provider_with_underscores"; +DROP IDENTITY PROVIDER "Provider With Spaces"; +DROP IDENTITY PROVIDER "provider@company.com"; + +-- DROP IDENTITY PROVIDER with special characters and CASCADE +DROP IDENTITY PROVIDER "provider-with-hyphens" CASCADE; +DROP IDENTITY PROVIDER "provider.with.dots" CASCADE; +DROP IDENTITY PROVIDER "provider_with_underscores" CASCADE; +DROP IDENTITY PROVIDER "Provider With Spaces" CASCADE; +DROP IDENTITY PROVIDER "provider@company.com" CASCADE; + +-- DROP IDENTITY PROVIDER with version numbers in names +DROP IDENTITY PROVIDER oauth2_provider_v1; +DROP IDENTITY PROVIDER saml20_provider; +DROP IDENTITY PROVIDER azure_v2_provider; +DROP IDENTITY PROVIDER openid_connect_v1; + +-- DROP IDENTITY PROVIDER with version numbers and CASCADE +DROP IDENTITY PROVIDER oauth2_provider_v1 CASCADE; +DROP IDENTITY PROVIDER saml20_provider CASCADE; +DROP IDENTITY PROVIDER azure_v2_provider CASCADE; +DROP IDENTITY PROVIDER openid_connect_v1 CASCADE; + +-- DROP IDENTITY PROVIDER with environment-specific names +DROP IDENTITY PROVIDER prod_azure_provider; +DROP IDENTITY PROVIDER staging_oauth_provider; +DROP IDENTITY PROVIDER dev_saml_provider; +DROP IDENTITY PROVIDER test_okta_provider; + +-- DROP IDENTITY PROVIDER with environment-specific names and CASCADE +DROP IDENTITY PROVIDER prod_azure_provider CASCADE; +DROP IDENTITY PROVIDER staging_oauth_provider CASCADE; +DROP IDENTITY PROVIDER dev_saml_provider CASCADE; +DROP IDENTITY PROVIDER test_okta_provider CASCADE; + +-- DROP IDENTITY PROVIDER statements without semicolons (should also be valid) +DROP IDENTITY PROVIDER test_provider +DROP IDENTITY PROVIDER test_provider CASCADE \ No newline at end of file diff --git a/redshift/examples/redshift/drop_library.sql b/redshift/examples/redshift/drop_library.sql new file mode 100644 index 0000000..c50ec3d --- /dev/null +++ b/redshift/examples/redshift/drop_library.sql @@ -0,0 +1,58 @@ +-- DROP LIBRARY test cases for Amazon Redshift +-- Based on AWS documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_LIBRARY.html + +-- Basic DROP LIBRARY statement +DROP LIBRARY my_python_library; + +-- DROP LIBRARY with different identifier formats +DROP LIBRARY MyLibrary; +DROP LIBRARY my_lib_123; +DROP LIBRARY library_with_underscores; +DROP LIBRARY library123; + +-- DROP LIBRARY with quoted identifiers (for case-sensitive or special character names) +DROP LIBRARY "CaseSensitiveLibrary"; +DROP LIBRARY "library-with-dashes"; +DROP LIBRARY "library with spaces"; +DROP LIBRARY "123library"; + +-- DROP LIBRARY with system-generated library names (typical format) +DROP LIBRARY lib_12345; +DROP LIBRARY python_lib_v1; + +-- Real-world examples based on typical Python library names +DROP LIBRARY numpy_custom; +DROP LIBRARY pandas_helper; +DROP LIBRARY sklearn_utils; +DROP LIBRARY custom_ml_lib; + +-- DROP LIBRARY with longer descriptive names +DROP LIBRARY data_processing_utilities; +DROP LIBRARY machine_learning_algorithms; +DROP LIBRARY statistical_functions; + +-- DROP LIBRARY with mixed case (identifiers are case-insensitive unless quoted) +DROP LIBRARY MyCustomLibrary; +DROP LIBRARY UPPERCASE_LIBRARY; +DROP LIBRARY lowercase_library; + +-- Additional test cases for edge cases +DROP LIBRARY a; -- Single character library name +DROP LIBRARY lib_; -- Ending with underscore +DROP LIBRARY _lib; -- Starting with underscore +DROP LIBRARY lib$123; -- With dollar sign (valid in identifiers) + +-- Testing with comments +DROP LIBRARY test_lib; -- This is a comment + +/* Multi-line comment before DROP LIBRARY */ +DROP LIBRARY commented_lib; + +-- Note: Amazon Redshift will discontinue support for creating new Python UDFs +-- after November 1, 2025, though existing Python UDFs will continue to function. + +-- Error cases that would fail (included as comments for documentation): +-- DROP LIBRARY; -- Missing library name +-- DROP LIBRARY IF EXISTS my_lib; -- IF EXISTS not supported for DROP LIBRARY +-- DROP LIBRARY my_lib CASCADE; -- CASCADE not supported for DROP LIBRARY +-- DROP LIBRARY my_lib RESTRICT; -- RESTRICT not supported for DROP LIBRARY \ No newline at end of file diff --git a/redshift/examples/redshift/drop_masking_policy.sql b/redshift/examples/redshift/drop_masking_policy.sql new file mode 100644 index 0000000..8292216 --- /dev/null +++ b/redshift/examples/redshift/drop_masking_policy.sql @@ -0,0 +1,110 @@ +-- DROP MASKING POLICY command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_MASKING_POLICY.html + +-- Basic DROP MASKING POLICY syntax +DROP MASKING POLICY email_mask; + +-- DROP MASKING POLICY with various policy names +DROP MASKING POLICY ssn_mask; +DROP MASKING POLICY credit_card_mask; +DROP MASKING POLICY phone_mask; +DROP MASKING POLICY personal_data_mask; + +-- DROP MASKING POLICY with underscored names +DROP MASKING POLICY customer_email_mask; +DROP MASKING POLICY employee_ssn_mask; +DROP MASKING POLICY payment_card_mask; +DROP MASKING POLICY contact_phone_mask; + +-- DROP MASKING POLICY with quoted identifiers +DROP MASKING POLICY "EmailMask"; +DROP MASKING POLICY "SSN-Mask"; +DROP MASKING POLICY "Credit Card Mask"; +DROP MASKING POLICY "Phone Number Mask"; + +-- DROP MASKING POLICY with mixed case names +DROP MASKING POLICY EmailMaskPolicy; +DROP MASKING POLICY SSNMaskPolicy; +DROP MASKING POLICY CreditCardMaskPolicy; +DROP MASKING POLICY PhoneNumberMaskPolicy; + +-- DROP MASKING POLICY with descriptive names +DROP MASKING POLICY pii_email_protection; +DROP MASKING POLICY sensitive_ssn_mask; +DROP MASKING POLICY financial_card_mask; +DROP MASKING POLICY contact_info_mask; + +-- DROP MASKING POLICY with domain-specific names +DROP MASKING POLICY healthcare_patient_id_mask; +DROP MASKING POLICY finance_account_number_mask; +DROP MASKING POLICY retail_customer_data_mask; +DROP MASKING POLICY hr_employee_info_mask; + +-- DROP MASKING POLICY with security-focused names +DROP MASKING POLICY confidential_data_mask; +DROP MASKING POLICY restricted_info_mask; +DROP MASKING POLICY private_details_mask; +DROP MASKING POLICY secure_field_mask; + +-- DROP MASKING POLICY with functional names +DROP MASKING POLICY partial_email_mask; +DROP MASKING POLICY full_ssn_mask; +DROP MASKING POLICY partial_card_mask; +DROP MASKING POLICY hash_phone_mask; + +-- DROP MASKING POLICY with organizational names +DROP MASKING POLICY sales_team_mask; +DROP MASKING POLICY marketing_data_mask; +DROP MASKING POLICY support_info_mask; +DROP MASKING POLICY analytics_mask; + +-- DROP MASKING POLICY with version indicators +DROP MASKING POLICY email_mask_v1; +DROP MASKING POLICY ssn_mask_v2; +DROP MASKING POLICY card_mask_2023; +DROP MASKING POLICY phone_mask_latest; + +-- DROP MASKING POLICY with environment indicators +DROP MASKING POLICY prod_email_mask; +DROP MASKING POLICY dev_test_mask; +DROP MASKING POLICY staging_data_mask; +DROP MASKING POLICY qa_validation_mask; + +-- Edge cases with special characters in quoted names +DROP MASKING POLICY "mask-with-hyphens"; +DROP MASKING POLICY "mask.with.dots"; +DROP MASKING POLICY "mask$with$dollars"; +DROP MASKING POLICY "mask_with_underscores"; + +-- DROP MASKING POLICY with longer descriptive names +DROP MASKING POLICY customer_personally_identifiable_information_mask; +DROP MASKING POLICY employee_social_security_number_protection_policy; +DROP MASKING POLICY financial_payment_card_data_security_mask; + +-- DROP MASKING POLICY statements without semicolons (should also be valid) +DROP MASKING POLICY test_mask +DROP MASKING POLICY simple_mask + +-- DROP MASKING POLICY with common masking use cases +DROP MASKING POLICY address_partial_mask; +DROP MASKING POLICY salary_range_mask; +DROP MASKING POLICY birth_date_year_mask; +DROP MASKING POLICY ip_address_mask; + +-- DROP MASKING POLICY for compliance scenarios +DROP MASKING POLICY gdpr_compliance_mask; +DROP MASKING POLICY hipaa_patient_mask; +DROP MASKING POLICY pci_payment_mask; +DROP MASKING POLICY sox_financial_mask; + +-- DROP MASKING POLICY for different data types +DROP MASKING POLICY numeric_id_mask; +DROP MASKING POLICY text_content_mask; +DROP MASKING POLICY date_field_mask; +DROP MASKING POLICY json_data_mask; + +-- DROP MASKING POLICY for table-specific masks +DROP MASKING POLICY customers_email_mask; +DROP MASKING POLICY employees_ssn_mask; +DROP MASKING POLICY orders_payment_mask; +DROP MASKING POLICY users_profile_mask; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_materialized_view.sql b/redshift/examples/redshift/drop_materialized_view.sql new file mode 100644 index 0000000..8603716 --- /dev/null +++ b/redshift/examples/redshift/drop_materialized_view.sql @@ -0,0 +1,255 @@ +-- DROP MATERIALIZED VIEW command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-drop-sql-command.html + +-- Basic DROP MATERIALIZED VIEW syntax from AWS documentation +DROP MATERIALIZED VIEW tickets_mv; + +-- DROP MATERIALIZED VIEW with IF EXISTS clause +DROP MATERIALIZED VIEW IF EXISTS tickets_mv; + +-- Basic DROP MATERIALIZED VIEW without schema qualification +DROP MATERIALIZED VIEW simple_mv; +DROP MATERIALIZED VIEW sales_summary; +DROP MATERIALIZED VIEW customer_metrics; +DROP MATERIALIZED VIEW order_analytics; +DROP MATERIALIZED VIEW product_inventory; + +-- DROP MATERIALIZED VIEW with IF EXISTS for simple views +DROP MATERIALIZED VIEW IF EXISTS simple_mv; +DROP MATERIALIZED VIEW IF EXISTS sales_summary; +DROP MATERIALIZED VIEW IF EXISTS customer_metrics; +DROP MATERIALIZED VIEW IF EXISTS order_analytics; +DROP MATERIALIZED VIEW IF EXISTS product_inventory; + +-- DROP MATERIALIZED VIEW with schema qualification +DROP MATERIALIZED VIEW analytics.sales_summary_mv; +DROP MATERIALIZED VIEW reporting.customer_metrics_mv; +DROP MATERIALIZED VIEW warehouse.inventory_snapshot_mv; +DROP MATERIALIZED VIEW finance.quarterly_revenue_mv; +DROP MATERIALIZED VIEW operations.daily_orders_mv; + +-- DROP MATERIALIZED VIEW with IF EXISTS and schema qualification +DROP MATERIALIZED VIEW IF EXISTS analytics.sales_summary_mv; +DROP MATERIALIZED VIEW IF EXISTS reporting.customer_metrics_mv; +DROP MATERIALIZED VIEW IF EXISTS warehouse.inventory_snapshot_mv; +DROP MATERIALIZED VIEW IF EXISTS finance.quarterly_revenue_mv; +DROP MATERIALIZED VIEW IF EXISTS operations.daily_orders_mv; + +-- DROP MATERIALIZED VIEW with CASCADE option +DROP MATERIALIZED VIEW tickets_mv CASCADE; +DROP MATERIALIZED VIEW sales_summary CASCADE; +DROP MATERIALIZED VIEW analytics.customer_metrics_mv CASCADE; +DROP MATERIALIZED VIEW reporting.monthly_sales_mv CASCADE; + +-- DROP MATERIALIZED VIEW with RESTRICT option (explicit default) +DROP MATERIALIZED VIEW tickets_mv RESTRICT; +DROP MATERIALIZED VIEW sales_summary RESTRICT; +DROP MATERIALIZED VIEW analytics.customer_metrics_mv RESTRICT; +DROP MATERIALIZED VIEW reporting.monthly_sales_mv RESTRICT; + +-- DROP MATERIALIZED VIEW with IF EXISTS and CASCADE +DROP MATERIALIZED VIEW IF EXISTS tickets_mv CASCADE; +DROP MATERIALIZED VIEW IF EXISTS sales_summary CASCADE; +DROP MATERIALIZED VIEW IF EXISTS analytics.customer_metrics_mv CASCADE; +DROP MATERIALIZED VIEW IF EXISTS reporting.monthly_sales_mv CASCADE; + +-- DROP MATERIALIZED VIEW with IF EXISTS and RESTRICT +DROP MATERIALIZED VIEW IF EXISTS tickets_mv RESTRICT; +DROP MATERIALIZED VIEW IF EXISTS sales_summary RESTRICT; +DROP MATERIALIZED VIEW IF EXISTS analytics.customer_metrics_mv RESTRICT; +DROP MATERIALIZED VIEW IF EXISTS reporting.monthly_sales_mv RESTRICT; + +-- DROP MATERIALIZED VIEW with multiple views (comma-separated) +DROP MATERIALIZED VIEW view1, view2, view3; +DROP MATERIALIZED VIEW sales_mv, orders_mv, customers_mv; +DROP MATERIALIZED VIEW analytics.sales_summary, analytics.customer_metrics, analytics.product_performance; + +-- DROP MATERIALIZED VIEW with multiple views and IF EXISTS +DROP MATERIALIZED VIEW IF EXISTS view1, view2, view3; +DROP MATERIALIZED VIEW IF EXISTS sales_mv, orders_mv, customers_mv; +DROP MATERIALIZED VIEW IF EXISTS analytics.sales_summary, analytics.customer_metrics, analytics.product_performance; + +-- DROP MATERIALIZED VIEW with multiple views and CASCADE +DROP MATERIALIZED VIEW view1, view2, view3 CASCADE; +DROP MATERIALIZED VIEW sales_mv, orders_mv, customers_mv CASCADE; +DROP MATERIALIZED VIEW analytics.sales_summary, analytics.customer_metrics, analytics.product_performance CASCADE; + +-- DROP MATERIALIZED VIEW with multiple views and RESTRICT +DROP MATERIALIZED VIEW view1, view2, view3 RESTRICT; +DROP MATERIALIZED VIEW sales_mv, orders_mv, customers_mv RESTRICT; +DROP MATERIALIZED VIEW analytics.sales_summary, analytics.customer_metrics, analytics.product_performance RESTRICT; + +-- DROP MATERIALIZED VIEW with multiple views, IF EXISTS, and CASCADE +DROP MATERIALIZED VIEW IF EXISTS view1, view2, view3 CASCADE; +DROP MATERIALIZED VIEW IF EXISTS sales_mv, orders_mv, customers_mv CASCADE; +DROP MATERIALIZED VIEW IF EXISTS analytics.sales_summary, analytics.customer_metrics, analytics.product_performance CASCADE; + +-- DROP MATERIALIZED VIEW with multiple views, IF EXISTS, and RESTRICT +DROP MATERIALIZED VIEW IF EXISTS view1, view2, view3 RESTRICT; +DROP MATERIALIZED VIEW IF EXISTS sales_mv, orders_mv, customers_mv RESTRICT; +DROP MATERIALIZED VIEW IF EXISTS analytics.sales_summary, analytics.customer_metrics, analytics.product_performance RESTRICT; + +-- DROP MATERIALIZED VIEW with quoted identifiers +DROP MATERIALIZED VIEW "SalesAnalytics"."MonthlySummary"; +DROP MATERIALIZED VIEW "my-schema"."view-with-hyphens"; +DROP MATERIALIZED VIEW "Schema With Spaces"."View With Spaces"; +DROP MATERIALIZED VIEW "UPPERCASE_SCHEMA"."UPPERCASE_VIEW"; + +-- DROP MATERIALIZED VIEW with mixed quoted and unquoted identifiers +DROP MATERIALIZED VIEW analytics."Customer Metrics"; +DROP MATERIALIZED VIEW "reporting-schema".sales_view; +DROP MATERIALIZED VIEW "My Analytics"."Daily Reports"; + +-- DROP MATERIALIZED VIEW with IF EXISTS and quoted identifiers +DROP MATERIALIZED VIEW IF EXISTS "SalesAnalytics"."MonthlySummary"; +DROP MATERIALIZED VIEW IF EXISTS "my-schema"."view-with-hyphens"; +DROP MATERIALIZED VIEW IF EXISTS "Schema With Spaces"."View With Spaces"; + +-- DROP MATERIALIZED VIEW with quoted identifiers and CASCADE/RESTRICT +DROP MATERIALIZED VIEW "SalesAnalytics"."MonthlySummary" CASCADE; +DROP MATERIALIZED VIEW "my-schema"."view-with-hyphens" RESTRICT; +DROP MATERIALIZED VIEW IF EXISTS "Schema With Spaces"."View With Spaces" CASCADE; + +-- DROP MATERIALIZED VIEW with business domain naming patterns +DROP MATERIALIZED VIEW sales_analytics.regional_performance_mv; +DROP MATERIALIZED VIEW customer_insights.behavior_analysis_mv; +DROP MATERIALIZED VIEW financial_data.revenue_tracking_mv; +DROP MATERIALIZED VIEW operations.supply_chain_mv; +DROP MATERIALIZED VIEW marketing.campaign_effectiveness_mv; +DROP MATERIALIZED VIEW hr_analytics.employee_performance_mv; + +-- DROP MATERIALIZED VIEW with time-based naming patterns +DROP MATERIALIZED VIEW reporting.daily_sales_summary; +DROP MATERIALIZED VIEW analytics.weekly_customer_metrics; +DROP MATERIALIZED VIEW warehouse.monthly_inventory_snapshot; +DROP MATERIALIZED VIEW finance.quarterly_revenue_analysis; +DROP MATERIALIZED VIEW operations.yearly_performance_review; + +-- DROP MATERIALIZED VIEW with aggregation naming patterns +DROP MATERIALIZED VIEW analytics.customer_order_totals_mv; +DROP MATERIALIZED VIEW reporting.product_sales_aggregates_mv; +DROP MATERIALIZED VIEW warehouse.inventory_level_summaries_mv; +DROP MATERIALIZED VIEW finance.revenue_by_region_mv; +DROP MATERIALIZED VIEW marketing.campaign_conversion_rates_mv; + +-- DROP MATERIALIZED VIEW with common business scenarios +DROP MATERIALIZED VIEW ecommerce.customer_lifetime_value_mv; +DROP MATERIALIZED VIEW retail.product_performance_summary_mv; +DROP MATERIALIZED VIEW logistics.shipping_efficiency_metrics_mv; +DROP MATERIALIZED VIEW banking.transaction_risk_analysis_mv; +DROP MATERIALIZED VIEW healthcare.patient_outcome_metrics_mv; +DROP MATERIALIZED VIEW manufacturing.production_quality_summary_mv; + +-- DROP MATERIALIZED VIEW with IF EXISTS for business scenarios +DROP MATERIALIZED VIEW IF EXISTS ecommerce.customer_lifetime_value_mv; +DROP MATERIALIZED VIEW IF EXISTS retail.product_performance_summary_mv; +DROP MATERIALIZED VIEW IF EXISTS logistics.shipping_efficiency_metrics_mv; +DROP MATERIALIZED VIEW IF EXISTS banking.transaction_risk_analysis_mv; +DROP MATERIALIZED VIEW IF EXISTS healthcare.patient_outcome_metrics_mv; +DROP MATERIALIZED VIEW IF EXISTS manufacturing.production_quality_summary_mv; + +-- DROP MATERIALIZED VIEW with CASCADE for business scenarios +DROP MATERIALIZED VIEW ecommerce.customer_lifetime_value_mv CASCADE; +DROP MATERIALIZED VIEW retail.product_performance_summary_mv CASCADE; +DROP MATERIALIZED VIEW logistics.shipping_efficiency_metrics_mv CASCADE; +DROP MATERIALIZED VIEW banking.transaction_risk_analysis_mv CASCADE; + +-- DROP MATERIALIZED VIEW with schema names that might be keywords +DROP MATERIALIZED VIEW data.sales_summary_mv; +DROP MATERIALIZED VIEW analytics.customer_data_mv; +DROP MATERIALIZED VIEW reporting.warehouse_metrics_mv; +DROP MATERIALIZED VIEW schema.view_analytics_mv; +DROP MATERIALIZED VIEW warehouse.summary_data_mv; + +-- DROP MATERIALIZED VIEW with view names that might be keywords +DROP MATERIALIZED VIEW sales_schema.data; +DROP MATERIALIZED VIEW analytics_schema.view; +DROP MATERIALIZED VIEW reporting_schema.schema; +DROP MATERIALIZED VIEW warehouse_schema.analytics; +DROP MATERIALIZED VIEW finance_schema.reporting; +DROP MATERIALIZED VIEW operations_schema.warehouse; +DROP MATERIALIZED VIEW marketing_schema.summary; +DROP MATERIALIZED VIEW hr_schema.metrics; + +-- DROP MATERIALIZED VIEW statements without semicolons (should also be valid) +DROP MATERIALIZED VIEW test_schema.test_mv +DROP MATERIALIZED VIEW IF EXISTS test_schema.conditional_mv +DROP MATERIALIZED VIEW simple_test_mv CASCADE +DROP MATERIALIZED VIEW IF EXISTS another_test_mv RESTRICT + +-- DROP MATERIALIZED VIEW with complex multiple view combinations +DROP MATERIALIZED VIEW + sales.daily_summary, + sales.weekly_summary, + sales.monthly_summary, + sales.quarterly_summary CASCADE; + +DROP MATERIALIZED VIEW IF EXISTS + analytics.customer_segments, + analytics.product_categories, + analytics.regional_analysis RESTRICT; + +-- DROP MATERIALIZED VIEW with underscored naming conventions +DROP MATERIALIZED VIEW customer_analytics.lifetime_value_mv; +DROP MATERIALIZED VIEW sales_reporting.monthly_summary_mv; +DROP MATERIALIZED VIEW inventory_management.stock_alerts_mv; +DROP MATERIALIZED VIEW financial_reporting.quarterly_results_mv; +DROP MATERIALIZED VIEW operational_metrics.daily_kpi_mv; +DROP MATERIALIZED VIEW marketing_analytics.campaign_roi_mv; + +-- DROP MATERIALIZED VIEW with mixed case naming +DROP MATERIALIZED VIEW DataLake.CustomerAnalyticsMV; +DROP MATERIALIZED VIEW SalesSchema.ProductPerformanceMV; +DROP MATERIALIZED VIEW AnalyticsWarehouse.CustomerSegmentationMV; +DROP MATERIALIZED VIEW ReportingHub.FinancialSummaryMV; + +-- DROP MATERIALIZED VIEW with special characters in quoted names +DROP MATERIALIZED VIEW "view-with-hyphens"; +DROP MATERIALIZED VIEW "view.with.dots"; +DROP MATERIALIZED VIEW "view$with$dollars"; +DROP MATERIALIZED VIEW "view@with@symbols"; +DROP MATERIALIZED VIEW "view_with_underscores"; +DROP MATERIALIZED VIEW "view123with456numbers"; + +-- DROP MATERIALIZED VIEW with comprehensive quoted name combinations +DROP MATERIALIZED VIEW "my-analytics"."sales-summary" CASCADE; +DROP MATERIALIZED VIEW "data.warehouse"."customer.metrics" RESTRICT; +DROP MATERIALIZED VIEW IF EXISTS "schema-name"."view-name" CASCADE; +DROP MATERIALIZED VIEW IF EXISTS "UPPER_CASE_SCHEMA"."UPPER_CASE_VIEW" RESTRICT; + +-- DROP MATERIALIZED VIEW examples that correspond to typical CREATE MATERIALIZED VIEW scenarios +-- These views could have been created with various aggregations and joins +DROP MATERIALIZED VIEW analytics.customer_order_summary_mv; +DROP MATERIALIZED VIEW reporting.sales_performance_by_region_mv; +DROP MATERIALIZED VIEW warehouse.inventory_turnover_analysis_mv; +DROP MATERIALIZED VIEW finance.monthly_revenue_breakdown_mv; +DROP MATERIALIZED VIEW operations.supplier_performance_metrics_mv; +DROP MATERIALIZED VIEW marketing.customer_acquisition_cost_mv; +DROP MATERIALIZED VIEW hr.employee_productivity_summary_mv; +DROP MATERIALIZED VIEW logistics.delivery_performance_tracking_mv; +DROP MATERIALIZED VIEW retail.product_recommendation_matrix_mv; +DROP MATERIALIZED VIEW banking.fraud_detection_summary_mv; + +-- DROP MATERIALIZED VIEW with IF EXISTS for typical scenarios +DROP MATERIALIZED VIEW IF EXISTS analytics.customer_order_summary_mv; +DROP MATERIALIZED VIEW IF EXISTS reporting.sales_performance_by_region_mv; +DROP MATERIALIZED VIEW IF EXISTS warehouse.inventory_turnover_analysis_mv; +DROP MATERIALIZED VIEW IF EXISTS finance.monthly_revenue_breakdown_mv; +DROP MATERIALIZED VIEW IF EXISTS operations.supplier_performance_metrics_mv; + +-- DROP MATERIALIZED VIEW with CASCADE for cleanup scenarios +DROP MATERIALIZED VIEW analytics.customer_order_summary_mv CASCADE; +DROP MATERIALIZED VIEW reporting.sales_performance_by_region_mv CASCADE; +DROP MATERIALIZED VIEW warehouse.inventory_turnover_analysis_mv CASCADE; +DROP MATERIALIZED VIEW finance.monthly_revenue_breakdown_mv CASCADE; + +-- DROP MATERIALIZED VIEW for data warehouse cleanup scenarios +DROP MATERIALIZED VIEW dwh.fact_sales_summary_mv; +DROP MATERIALIZED VIEW dwh.dim_customer_attributes_mv; +DROP MATERIALIZED VIEW dwh.agg_product_performance_mv; +DROP MATERIALIZED VIEW dwh.mart_financial_kpis_mv; +DROP MATERIALIZED VIEW dwh.staging_order_metrics_mv; + +-- DROP MATERIALIZED VIEW with comprehensive combinations +DROP MATERIALIZED VIEW IF EXISTS dwh.fact_sales_summary_mv, dwh.dim_customer_attributes_mv CASCADE; +DROP MATERIALIZED VIEW IF EXISTS analytics.customer_segments, reporting.monthly_metrics RESTRICT; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_model.sql b/redshift/examples/redshift/drop_model.sql new file mode 100644 index 0000000..2ba3f4f --- /dev/null +++ b/redshift/examples/redshift/drop_model.sql @@ -0,0 +1,54 @@ +-- DROP MODEL Test Cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_MODEL.html + +-- Basic DROP MODEL +DROP MODEL customer_churn; + +-- DROP MODEL with schema qualification +DROP MODEL demo_ml.customer_churn; + +-- DROP MODEL with IF EXISTS +DROP MODEL IF EXISTS customer_churn; + +-- DROP MODEL with IF EXISTS and schema qualification +DROP MODEL IF EXISTS demo_ml.customer_churn; + +-- DROP MODEL with quoted identifiers +DROP MODEL "my_schema"."my_model"; + +-- DROP MODEL IF EXISTS with quoted identifiers +DROP MODEL IF EXISTS "my_schema"."my_model"; + +-- DROP MODEL with mixed case identifiers +DROP MODEL MySchema.MyModel; + +-- DROP MODEL IF EXISTS with mixed case +DROP MODEL IF EXISTS MySchema.MyModel; + +-- DROP MODEL with underscore in name +DROP MODEL customer_churn_v1; + +-- DROP MODEL with numbers in name +DROP MODEL model_v2; + +-- DROP MODEL with schema containing underscore +DROP MODEL ml_models.customer_segmentation; + +-- DROP MODEL IF EXISTS with complex name +DROP MODEL IF EXISTS analytics_db.ml_models.sentiment_analysis_v3; + +-- DROP MODEL with keywords as identifiers (quoted) +DROP MODEL "model"."drop"; + +-- DROP MODEL with fully qualified name +DROP MODEL public.my_model; + +-- Multiple DROP MODEL statements +DROP MODEL model1; +DROP MODEL IF EXISTS model2; +DROP MODEL schema1.model3; + +-- DROP MODEL with different casing +drop model test_model; +DROP model if exists test_model2; +Drop Model If Exists schema.model_name; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_procedure.sql b/redshift/examples/redshift/drop_procedure.sql new file mode 100644 index 0000000..fb1d467 --- /dev/null +++ b/redshift/examples/redshift/drop_procedure.sql @@ -0,0 +1,341 @@ +-- DROP PROCEDURE test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_PROCEDURE.html + +-- Basic DROP PROCEDURE examples + +-- Drop procedure with mixed parameters (from AWS docs example) +DROP PROCEDURE quarterly_revenue(volume INOUT bigint, at_price IN numeric, result OUT int); + +-- Drop procedure with simple parameter list +DROP PROCEDURE calculate_total(price IN decimal, tax_rate IN decimal); + +-- Drop procedure with no parameters +DROP PROCEDURE update_statistics(); + +-- DROP PROCEDURE with IF EXISTS + +-- Drop procedure if it exists (prevents errors) +DROP PROCEDURE IF EXISTS quarterly_revenue(volume INOUT bigint, at_price IN numeric, result OUT int); + +-- Drop procedure if exists with single parameter +DROP PROCEDURE IF EXISTS calculate_discount(amount IN decimal); + +-- Drop procedure if exists with no parameters +DROP PROCEDURE IF EXISTS refresh_cache(); + +-- DROP PROCEDURE with CASCADE/RESTRICT options + +-- Drop procedure with CASCADE (removes dependent objects) +DROP PROCEDURE calculate_total(price IN decimal, tax_rate IN decimal) CASCADE; + +-- Drop procedure with RESTRICT (prevents drop if dependencies exist) +DROP PROCEDURE calculate_total(price IN decimal, tax_rate IN decimal) RESTRICT; + +-- Drop procedure with IF EXISTS and CASCADE +DROP PROCEDURE IF EXISTS quarterly_revenue(volume INOUT bigint, at_price IN numeric, result OUT int) CASCADE; + +-- Drop procedure with IF EXISTS and RESTRICT +DROP PROCEDURE IF EXISTS monthly_report(month_id IN integer) RESTRICT; + +-- Schema-qualified procedure names + +-- Drop procedure in specific schema +DROP PROCEDURE finance.calculate_revenue(start_date IN date, end_date IN date); + +-- Drop procedure in quoted schema +DROP PROCEDURE "reporting".monthly_summary(year_val IN integer); + +-- Drop procedure with quoted procedure name +DROP PROCEDURE "complex-procedure-name"(input_data IN text); + +-- Drop procedure with both schema and procedure name quoted +DROP PROCEDURE "finance_schema"."quarterly_analysis"(quarter IN integer, year_val IN integer); + +-- Parameter modes (IN, OUT, INOUT) + +-- Drop procedure with IN parameters only +DROP PROCEDURE process_data(input_val IN integer, description IN varchar); + +-- Drop procedure with OUT parameters only +DROP PROCEDURE get_results(total_count OUT integer, avg_value OUT decimal); + +-- Drop procedure with INOUT parameters only +DROP PROCEDURE transform_data(data INOUT text); + +-- Drop procedure with mixed parameter modes +DROP PROCEDURE complex_calc( + input_amount IN decimal, + multiplier IN float, + result OUT decimal, + status INOUT varchar +); + +-- Different parameter mode orderings + +-- Mode before argument name +DROP PROCEDURE process_order(IN order_id integer, OUT total_amount decimal); + +-- Argument name before mode +DROP PROCEDURE calculate_tax(amount IN decimal, rate IN float, tax_amount OUT decimal); + +-- Mixed ordering within same procedure +DROP PROCEDURE mixed_params(IN input_val integer, result OUT decimal, status INOUT text); + +-- Data type variations + +-- Drop procedure with SMALLINT +DROP PROCEDURE process_small_numbers(count IN smallint); + +-- Drop procedure with INTEGER and INT (aliases) +DROP PROCEDURE process_integers(val1 IN integer, val2 IN int); + +-- Drop procedure with BIGINT +DROP PROCEDURE process_large_numbers(big_num IN bigint); + +-- Drop procedure with DECIMAL with precision +DROP PROCEDURE financial_calc(amount IN decimal(12,2), rate IN decimal(5,4)); + +-- Drop procedure with NUMERIC with precision and scale +DROP PROCEDURE precise_calculation(value IN numeric(15,6)); + +-- Drop procedure with REAL +DROP PROCEDURE real_number_proc(val IN real); + +-- Drop procedure with DOUBLE PRECISION +DROP PROCEDURE high_precision_calc(precise_val IN double precision); + +-- Drop procedure with FLOAT with precision +DROP PROCEDURE float_calculation(float_val IN float(24)); + +-- Drop procedure with BOOLEAN and BOOL +DROP PROCEDURE boolean_check(active IN boolean, enabled IN bool); + +-- Drop procedure with CHAR with length +DROP PROCEDURE char_processing(code IN char(10)); + +-- Drop procedure with CHARACTER with length +DROP PROCEDURE character_handling(name IN character(50)); + +-- Drop procedure with VARCHAR with length +DROP PROCEDURE string_processing(description IN varchar(255)); + +-- Drop procedure with CHARACTER VARYING +DROP PROCEDURE text_manipulation(content IN character varying(1000)); + +-- Drop procedure with DATE +DROP PROCEDURE date_processing(process_date IN date); + +-- Drop procedure with TIMESTAMP variations +DROP PROCEDURE timestamp_proc(ts IN timestamp); +DROP PROCEDURE timestamp_precise(ts IN timestamp(6)); +DROP PROCEDURE timestamp_with_tz(ts IN timestamp with time zone); +DROP PROCEDURE timestamp_without_tz(ts IN timestamp without time zone); + +-- Drop procedure with TIMESTAMPTZ variations +DROP PROCEDURE timestamptz_proc(ts IN timestamptz); +DROP PROCEDURE timestamptz_precise(ts IN timestamptz(3)); + +-- Drop procedure with TIME variations +DROP PROCEDURE time_proc(time_val IN time); +DROP PROCEDURE time_precise(time_val IN time(6)); +DROP PROCEDURE time_with_tz(time_val IN time with time zone); +DROP PROCEDURE time_without_tz(time_val IN time without time zone); + +-- Drop procedure with TIMETZ variations +DROP PROCEDURE timetz_proc(time_val IN timetz); +DROP PROCEDURE timetz_precise(time_val IN timetz(6)); + +-- Drop procedure with TEXT +DROP PROCEDURE text_processing(content IN text); + +-- Redshift-specific data types + +-- Drop procedure with SUPER +DROP PROCEDURE json_processing(data IN super); + +-- Drop procedure with GEOMETRY +DROP PROCEDURE geospatial_calc(shape IN geometry); + +-- Drop procedure with GEOGRAPHY +DROP PROCEDURE geographic_analysis(location IN geography); + +-- Drop procedure with HLLSKETCH +DROP PROCEDURE hyperloglog_processing(sketch IN hllsketch); + +-- Procedures with custom/identifier types +DROP PROCEDURE custom_type_proc(custom_data IN user_defined_type); + +-- Complex parameter combinations + +-- Drop procedure with many parameters (up to 32 limit) +DROP PROCEDURE complex_procedure( + param1 IN integer, + param2 IN varchar(50), + param3 IN decimal(10,2), + param4 OUT boolean, + param5 INOUT text, + param6 IN date, + param7 IN timestamp, + param8 OUT geometry, + param9 IN super, + param10 INOUT float +); + +-- Drop procedure with maximum parameters example +DROP PROCEDURE max_params_example( + p1 IN integer, p2 IN varchar, p3 IN decimal, p4 IN boolean, p5 IN date, + p6 IN timestamp, p7 IN float, p8 IN text, p9 IN bigint, p10 IN smallint, + p11 OUT integer, p12 OUT varchar, p13 OUT decimal, p14 OUT boolean, p15 OUT date, + p16 INOUT timestamp, p17 INOUT float, p18 INOUT text, p19 INOUT bigint, p20 INOUT smallint, + p21 IN geometry, p22 IN geography, p23 IN super, p24 IN hllsketch, p25 IN char(10), + p26 OUT character(20), p27 OUT timestamptz, p28 OUT timetz, p29 INOUT real, p30 INOUT numeric(10,2) +); + +-- Argument names are optional and ignored during drop + +-- Drop procedure where argument names are omitted +DROP PROCEDURE unnamed_params(integer, varchar, OUT decimal); + +-- Drop procedure with some names, some without +DROP PROCEDURE mixed_naming(integer, description varchar, OUT decimal); + +-- Drop procedure with names that don't match original (names ignored) +DROP PROCEDURE name_mismatch(different_name integer, another_name varchar); + +-- Real-world examples based on typical stored procedure use cases + +-- Drop financial calculation procedures +DROP PROCEDURE calculate_compound_interest( + principal IN decimal(15,2), + rate IN decimal(5,4), + periods IN integer, + final_amount OUT decimal(15,2) +); + +DROP PROCEDURE process_monthly_billing( + customer_id IN integer, + billing_month IN integer, + billing_year IN integer, + total_charges OUT decimal(12,2), + status OUT varchar(20) +); + +-- Drop data processing procedures +DROP PROCEDURE etl_transform_customer_data( + source_table IN varchar(100), + target_table IN varchar(100), + transformation_rules IN super, + rows_processed OUT bigint +); + +DROP PROCEDURE validate_data_quality( + table_name IN varchar(100), + validation_rules IN super, + error_count OUT integer, + validation_report OUT text +); + +-- Drop reporting procedures +DROP PROCEDURE generate_sales_report( + start_date IN date, + end_date IN date, + region IN varchar(50), + report_data OUT super +); + +DROP PROCEDURE update_dashboard_metrics( + metric_date IN date, + refresh_cache IN boolean +); + +-- Drop maintenance procedures +DROP PROCEDURE cleanup_temporary_tables( + retention_days IN integer, + tables_dropped OUT integer +); + +DROP PROCEDURE analyze_table_statistics( + schema_name IN varchar(100), + table_pattern IN varchar(100) +); + +-- Edge cases and special scenarios + +-- Drop procedure with very long name +DROP PROCEDURE very_long_procedure_name_that_demonstrates_maximum_identifier_length_support(param IN integer); + +-- Drop procedure with quoted identifiers containing special characters +DROP PROCEDURE "procedure-with-hyphens"(input_val IN integer); +DROP PROCEDURE "UPPERCASE_PROCEDURE"(data IN varchar); +DROP PROCEDURE "procedure with spaces"(value IN decimal); + +-- Drop procedure in system-like schemas +DROP PROCEDURE pg_catalog.system_procedure(config IN text); +DROP PROCEDURE information_schema.info_procedure(metadata IN super); + +-- Multiple procedures with same name but different signatures +DROP PROCEDURE overloaded_proc(param IN integer); +DROP PROCEDURE overloaded_proc(param IN varchar); +DROP PROCEDURE overloaded_proc(param1 IN integer, param2 IN varchar); + +-- Procedures with complex data type specifications +DROP PROCEDURE complex_types_proc( + precise_decimal IN decimal(38,18), + big_varchar IN varchar(65535), + precise_timestamp IN timestamp(6) with time zone, + high_precision_float IN float(53), + long_char IN character(4096) +); + +-- Default behavior demonstrations + +-- Drop procedure with default behavior (RESTRICT implied) +DROP PROCEDURE default_behavior_proc(data IN text); + +-- Drop procedure with explicit CASCADE +DROP PROCEDURE cascade_example_proc(input_val IN integer) CASCADE; + +-- Drop procedure with explicit RESTRICT +DROP PROCEDURE restrict_example_proc(config IN super) RESTRICT; + +-- Combined options testing + +-- All combinations of IF EXISTS with CASCADE/RESTRICT +DROP PROCEDURE IF EXISTS combo_test_cascade(val IN integer) CASCADE; +DROP PROCEDURE IF EXISTS combo_test_restrict(val IN varchar) RESTRICT; + +-- Schema-qualified with IF EXISTS and CASCADE/RESTRICT +DROP PROCEDURE IF EXISTS myschema.qualified_cascade_proc(data IN text) CASCADE; +DROP PROCEDURE IF EXISTS "quoted_schema".qualified_restrict_proc(value IN decimal) RESTRICT; + +-- Complex real-world scenarios + +-- Drop machine learning model procedures +DROP PROCEDURE train_customer_segmentation_model( + training_data_table IN varchar(100), + model_name IN varchar(100), + hyperparameters IN super, + model_accuracy OUT decimal(5,4) +); + +-- Drop data science procedures +DROP PROCEDURE calculate_statistical_summary( + dataset_table IN varchar(100), + columns_list IN super, + summary_stats OUT super +); + +-- Drop integration procedures +DROP PROCEDURE sync_external_data( + source_system IN varchar(50), + sync_timestamp IN timestamp, + records_updated OUT bigint, + sync_status OUT varchar(20) +); + +-- Drop monitoring procedures +DROP PROCEDURE check_system_health( + component_name IN varchar(100), + health_status OUT varchar(20), + metrics OUT super +); \ No newline at end of file diff --git a/redshift/examples/redshift/drop_rls_policy.sql b/redshift/examples/redshift/drop_rls_policy.sql new file mode 100644 index 0000000..8bdf6bc --- /dev/null +++ b/redshift/examples/redshift/drop_rls_policy.sql @@ -0,0 +1,64 @@ +-- DROP RLS POLICY Test Cases +-- Based on AWS Redshift documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_RLS_POLICY.html + +-- Basic DROP RLS POLICY command +DROP RLS POLICY policy_concerts; + +-- DROP RLS POLICY with IF EXISTS clause +DROP RLS POLICY IF EXISTS policy_concerts; + +-- DROP RLS POLICY with CASCADE option +DROP RLS POLICY policy_concerts CASCADE; + +-- DROP RLS POLICY with RESTRICT option (default behavior) +DROP RLS POLICY policy_concerts RESTRICT; + +-- DROP RLS POLICY with IF EXISTS and CASCADE +DROP RLS POLICY IF EXISTS policy_concerts CASCADE; + +-- DROP RLS POLICY with IF EXISTS and RESTRICT +DROP RLS POLICY IF EXISTS policy_concerts RESTRICT; + +-- DROP RLS POLICY with quoted policy name +DROP RLS POLICY "policy_concerts"; + +-- DROP RLS POLICY with quoted policy name and IF EXISTS +DROP RLS POLICY IF EXISTS "policy_concerts"; + +-- DROP RLS POLICY with quoted policy name and CASCADE +DROP RLS POLICY "policy_concerts" CASCADE; + +-- DROP RLS POLICY with quoted policy name and RESTRICT +DROP RLS POLICY "policy_concerts" RESTRICT; + +-- DROP RLS POLICY with complex policy names +DROP RLS POLICY policy_sales_2023; +DROP RLS POLICY policy_customer_data; +DROP RLS POLICY rls_finance_reports; + +-- DROP RLS POLICY with underscores and numbers in policy name +DROP RLS POLICY policy_user_123; +DROP RLS POLICY rls_policy_v2; +DROP RLS POLICY data_access_policy_final; + +-- DROP RLS POLICY with IF EXISTS for non-existent policies (should not error) +DROP RLS POLICY IF EXISTS non_existent_policy; +DROP RLS POLICY IF EXISTS "another_missing_policy"; + +-- Case variations (should work the same) +drop rls policy policy_concerts; +Drop RLS Policy policy_concerts; +DROP rls policy policy_concerts CASCADE; +drop RLS POLICY IF EXISTS policy_concerts restrict; + +-- DROP RLS POLICY with semicolon termination +DROP RLS POLICY policy_concerts; +DROP RLS POLICY IF EXISTS policy_concerts; +DROP RLS POLICY policy_concerts CASCADE; +DROP RLS POLICY policy_concerts RESTRICT; + +-- DROP RLS POLICY without semicolon (should also work) +DROP RLS POLICY policy_concerts +DROP RLS POLICY IF EXISTS policy_concerts +DROP RLS POLICY policy_concerts CASCADE +DROP RLS POLICY policy_concerts RESTRICT \ No newline at end of file diff --git a/redshift/examples/redshift/drop_role.sql b/redshift/examples/redshift/drop_role.sql new file mode 100644 index 0000000..0010193 --- /dev/null +++ b/redshift/examples/redshift/drop_role.sql @@ -0,0 +1,133 @@ +-- DROP ROLE Test Cases +-- Based on AWS Redshift documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_ROLE.html + +-- Basic DROP ROLE command (from AWS documentation example) +DROP ROLE sample_role1; + +-- DROP ROLE with FORCE option (from AWS documentation example) +DROP ROLE sample_role FORCE; + +-- DROP ROLE with RESTRICT option (default behavior) +DROP ROLE sample_role1 RESTRICT; + +-- Basic role names +DROP ROLE analytics_role; +DROP ROLE data_reader_role; +DROP ROLE etl_processor_role; +DROP ROLE bi_analyst_role; +DROP ROLE temp_role; + +-- Role names with underscores +DROP ROLE user_management_role; +DROP ROLE data_warehouse_admin; +DROP ROLE customer_analytics_reader; +DROP ROLE reporting_service_account; + +-- Quoted role names for special characters +DROP ROLE "MyRole"; +DROP ROLE "role-with-dash"; +DROP ROLE "role.with.dots"; +DROP ROLE "role with spaces"; +DROP ROLE "UPPERCASE_ROLE"; +DROP ROLE "Role_With_Mixed_Case"; + +-- Numeric role names (quoted) +DROP ROLE "123role"; +DROP ROLE "role123"; +DROP ROLE "role_v2"; + +-- Single character role names +DROP ROLE a; +DROP ROLE "A"; +DROP ROLE z; + +-- DROP ROLE with FORCE for roles with dependencies +DROP ROLE federated_role FORCE; +DROP ROLE sso_role FORCE; +DROP ROLE aws_role FORCE; +DROP ROLE azure_role FORCE; +DROP ROLE okta_role FORCE; + +-- DROP ROLE with RESTRICT (explicit) +DROP ROLE special_char_role RESTRICT; +DROP ROLE unicode_role RESTRICT; +DROP ROLE long_external_id_role RESTRICT; + +-- Real-world use case examples with FORCE +DROP ROLE etl_service_role FORCE; +DROP ROLE reporting_dashboard_role FORCE; +DROP ROLE data_scientist_role FORCE; +DROP ROLE readonly_analyst_role FORCE; +DROP ROLE emergency_access_role FORCE; + +-- Service account patterns +DROP ROLE airflow_dag_role FORCE; +DROP ROLE kubernetes_role FORCE; +DROP ROLE lambda_function_role FORCE; + +-- Development environment roles +DROP ROLE dev_readonly_role FORCE; +DROP ROLE staging_admin_role FORCE; +DROP ROLE test_data_role FORCE; + +-- Compliance and audit roles +DROP ROLE audit_reader_role FORCE; +DROP ROLE security_monitor_role FORCE; +DROP ROLE compliance_officer_role FORCE; + +-- Regional and department-specific roles +DROP ROLE north_america_analyst_role FORCE; +DROP ROLE europe_reader_role FORCE; +DROP ROLE finance_dept_role FORCE; +DROP ROLE marketing_analytics_role FORCE; + +-- Temporary and contractor roles +DROP ROLE temp_contractor_role FORCE; +DROP ROLE consultant_access_role FORCE; +DROP ROLE vendor_readonly_role FORCE; + +-- Machine learning and data science +DROP ROLE ml_model_role FORCE; +DROP ROLE data_pipeline_role FORCE; +DROP ROLE feature_store_role FORCE; + +-- Case sensitivity tests +DROP ROLE lowercase_role; +DROP ROLE UPPERCASE_ROLE; +DROP ROLE "CamelCaseRole"; + +-- Case variations (should work the same) +drop role sample_role1; +Drop Role sample_role1; +DROP role sample_role1 FORCE; +drop ROLE sample_role1 restrict; + +-- DROP ROLE with semicolon termination +DROP ROLE sample_role1; +DROP ROLE sample_role1 FORCE; +DROP ROLE sample_role1 RESTRICT; + +-- DROP ROLE without semicolon (should also work) +DROP ROLE sample_role1 +DROP ROLE sample_role1 FORCE +DROP ROLE sample_role1 RESTRICT + +-- Edge cases and boundary testing +DROP ROLE a FORCE; -- Minimal role name with FORCE +DROP ROLE longest_possible_role_name_within_identifier_limits FORCE; + +-- Test SQL keywords as quoted identifiers +DROP ROLE "SELECT" FORCE; +DROP ROLE "CREATE" FORCE; +DROP ROLE "TABLE" FORCE; +DROP ROLE "USER" FORCE; +DROP ROLE "ROLE" FORCE; + +-- Complex scenarios based on AWS documentation examples +-- These would be used after creating roles with dependencies +DROP ROLE sample_role1 FORCE; -- Removes all role assignments if any exist +DROP ROLE sample_role2 FORCE; -- For roles granted to other roles + +-- Default RESTRICT behavior (these would fail if role has dependencies) +DROP ROLE independent_role; -- Should work for roles without dependencies +DROP ROLE standalone_role RESTRICT; -- Explicit RESTRICT \ No newline at end of file diff --git a/redshift/examples/redshift/drop_schema.sql b/redshift/examples/redshift/drop_schema.sql new file mode 100644 index 0000000..57dc7ca --- /dev/null +++ b/redshift/examples/redshift/drop_schema.sql @@ -0,0 +1,59 @@ +-- DROP SCHEMA Test Cases for Amazon Redshift +-- Based on AWS documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_SCHEMA.html + +-- Basic DROP SCHEMA with RESTRICT (default behavior) +DROP SCHEMA s_sales RESTRICT; + +-- DROP SCHEMA with CASCADE to drop all objects in schema +DROP SCHEMA s_sales CASCADE; + +-- DROP SCHEMA with IF EXISTS to prevent error if schema doesn't exist +DROP SCHEMA IF EXISTS s_sales; + +-- DROP SCHEMA with external database clause +DROP SCHEMA s_spectrum DROP EXTERNAL DATABASE RESTRICT; + +-- DROP multiple schemas with external database and CASCADE +DROP SCHEMA s_sales, s_profit, s_revenue DROP EXTERNAL DATABASE CASCADE; + +-- Basic DROP SCHEMA without explicit CASCADE/RESTRICT (uses RESTRICT by default) +DROP SCHEMA test_schema; + +-- DROP SCHEMA IF EXISTS with CASCADE +DROP SCHEMA IF EXISTS old_schema CASCADE; + +-- DROP SCHEMA IF EXISTS with RESTRICT +DROP SCHEMA IF EXISTS backup_schema RESTRICT; + +-- DROP multiple schemas with IF EXISTS +DROP SCHEMA IF EXISTS schema1, schema2, schema3; + +-- DROP single external schema +DROP SCHEMA external_data DROP EXTERNAL DATABASE; + +-- DROP SCHEMA with quoted identifier +DROP SCHEMA "Special-Schema"; + +-- DROP multiple schemas with mixed quoted/unquoted identifiers +DROP SCHEMA regular_schema, "quoted-schema", another_schema; + +-- DROP SCHEMA with IF EXISTS and external database +DROP SCHEMA IF EXISTS spectrum_schema DROP EXTERNAL DATABASE CASCADE; + +-- Complex case: multiple schemas with all options +DROP SCHEMA IF EXISTS analytics_schema, reporting_schema DROP EXTERNAL DATABASE CASCADE; + +-- DROP SCHEMA with underscores in name +DROP SCHEMA data_warehouse_schema RESTRICT; + +-- DROP SCHEMA with numbers in name +DROP SCHEMA schema2023 CASCADE; + +-- DROP SCHEMA with mixed case (should be case-insensitive) +drop schema MixedCaseSchema cascade; + +-- DROP SCHEMA with multiple schemas and RESTRICT +DROP SCHEMA temp_schema1, temp_schema2, temp_schema3 RESTRICT; + +-- DROP SCHEMA with IF EXISTS and multiple schemas with external database +DROP SCHEMA IF EXISTS external_schema1, external_schema2 DROP EXTERNAL DATABASE; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_table.sql b/redshift/examples/redshift/drop_table.sql new file mode 100644 index 0000000..60fe64b --- /dev/null +++ b/redshift/examples/redshift/drop_table.sql @@ -0,0 +1,103 @@ +-- DROP TABLE Test Cases for Amazon Redshift +-- Based on AWS documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_TABLE.html + +-- Basic DROP TABLE +DROP TABLE feedback; + +-- DROP TABLE with schema qualification +DROP TABLE public.feedback; +DROP TABLE schema1.table1; + +-- DROP TABLE with IF EXISTS +DROP TABLE IF EXISTS feedback; +DROP TABLE IF EXISTS public.feedback; +DROP TABLE IF EXISTS schema1.table1; + +-- Multiple tables in single statement +DROP TABLE feedback, buyers; +DROP TABLE table1, table2, table3; +DROP TABLE public.feedback, public.buyers; +DROP TABLE schema1.table1, schema2.table2; + +-- DROP TABLE with CASCADE (drops dependent objects) +DROP TABLE feedback CASCADE; +DROP TABLE public.feedback CASCADE; + +-- DROP TABLE with RESTRICT (prevents drop if dependencies exist - default behavior) +DROP TABLE feedback RESTRICT; +DROP TABLE public.feedback RESTRICT; + +-- Combination of IF EXISTS with CASCADE/RESTRICT +DROP TABLE IF EXISTS feedback CASCADE; +DROP TABLE IF EXISTS feedback RESTRICT; +DROP TABLE IF EXISTS public.feedback CASCADE; +DROP TABLE IF EXISTS public.feedback RESTRICT; + +-- Multiple tables with IF EXISTS +DROP TABLE IF EXISTS feedback, buyers; +DROP TABLE IF EXISTS table1, table2, table3; +DROP TABLE IF EXISTS public.feedback, public.buyers; + +-- Multiple tables with CASCADE/RESTRICT +DROP TABLE feedback, buyers CASCADE; +DROP TABLE feedback, buyers RESTRICT; +DROP TABLE table1, table2, table3 CASCADE; +DROP TABLE table1, table2, table3 RESTRICT; + +-- Complex combinations +DROP TABLE IF EXISTS feedback, buyers CASCADE; +DROP TABLE IF EXISTS feedback, buyers RESTRICT; +DROP TABLE IF EXISTS public.feedback, public.buyers CASCADE; +DROP TABLE IF EXISTS schema1.table1, schema2.table2 RESTRICT; + +-- Tables with various identifier patterns +DROP TABLE "quoted_table"; +DROP TABLE public."quoted_table"; +DROP TABLE IF EXISTS "quoted_table"; +DROP TABLE "table with spaces"; +DROP TABLE public."table with spaces"; + +-- Mixed quoted and unquoted identifiers +DROP TABLE feedback, "quoted_table"; +DROP TABLE public.feedback, public."quoted_table"; +DROP TABLE IF EXISTS feedback, "quoted_table" CASCADE; + +-- Real-world examples based on AWS documentation scenarios +-- Example 1: Basic table creation and drop +-- CREATE TABLE feedback(a int); +DROP TABLE feedback; + +-- Example 2: Multiple table drop +-- CREATE TABLE feedback(a int); +-- CREATE TABLE buyers(a int); +DROP TABLE feedback, buyers; + +-- Example 3: Drop with dependencies (CASCADE scenario) +-- CREATE TABLE feedback(a int); +-- CREATE VIEW feedback_view AS SELECT * FROM feedback; +DROP TABLE feedback CASCADE; + +-- Example 4: Conditional drop to avoid errors +DROP TABLE IF EXISTS feedback; +DROP TABLE IF EXISTS nonexistent_table; + +-- Schema-qualified examples +DROP TABLE public.sales_data; +DROP TABLE analytics.user_metrics; +DROP TABLE staging.temp_data; + +-- Complex schema scenarios +DROP TABLE IF EXISTS public.sales_data, analytics.user_metrics CASCADE; +DROP TABLE public.old_table, public.legacy_table, public.archive_table RESTRICT; + +-- Edge cases with identifier names +DROP TABLE table123; +DROP TABLE _private_table; +DROP TABLE table_with_underscores; +DROP TABLE TABLE_UPPERCASE; +DROP TABLE "123_table"; +DROP TABLE "table-with-dashes"; + +-- Multiple schemas in single statement +DROP TABLE schema1.table1, schema2.table2, schema3.table3; +DROP TABLE IF EXISTS dev.temp_table, staging.temp_table, prod.temp_table CASCADE; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_user.sql b/redshift/examples/redshift/drop_user.sql new file mode 100644 index 0000000..5409c3f --- /dev/null +++ b/redshift/examples/redshift/drop_user.sql @@ -0,0 +1,47 @@ +-- Amazon Redshift DROP USER Command Examples +-- Based on AWS documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_USER.html + +-- Basic DROP USER - single user +DROP USER paulo; + +-- DROP USER with multiple users +DROP USER paulo, martha; + +-- DROP USER with IF EXISTS clause (single user) +DROP USER IF EXISTS paulo; + +-- DROP USER with IF EXISTS clause (multiple users) +DROP USER IF EXISTS paulo, martha, john; + +-- DROP USER with quoted identifiers +DROP USER "user with spaces"; +DROP USER "User_With_Mixed_Case"; + +-- DROP USER combining regular and quoted identifiers +DROP USER normaluser, "quoted user", another_user; + +-- DROP USER with IF EXISTS and quoted identifiers +DROP USER IF EXISTS "test_user", regular_user; + +-- DROP USER with various valid identifier formats +DROP USER user1; +DROP USER user_123; +DROP USER user$test; +DROP USER _leading_underscore; + +-- DROP USER with case variations (should be case-insensitive for keywords) +drop user test_user1; +Drop User test_user2; +DROP user test_user3; +drop USER test_user4; + +-- Complex example with IF EXISTS and multiple mixed identifiers +DROP USER IF EXISTS + regular_user1, + "quoted user 2", + user_with_numbers123, + "CaseSensitiveUser", + _underscore_user; + +-- Single line with multiple users +DROP USER user1, user2, user3, user4, user5; \ No newline at end of file diff --git a/redshift/examples/redshift/drop_view.sql b/redshift/examples/redshift/drop_view.sql new file mode 100644 index 0000000..69864d0 --- /dev/null +++ b/redshift/examples/redshift/drop_view.sql @@ -0,0 +1,97 @@ +-- DROP VIEW command test cases +-- Based on AWS Redshift documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_VIEW.html + +-- Basic DROP VIEW +DROP VIEW event; + +-- DROP VIEW with schema qualification +DROP VIEW public.eventview; +DROP VIEW myschema.sales_view; + +-- DROP VIEW with IF EXISTS clause +DROP VIEW IF EXISTS eventview; +DROP VIEW IF EXISTS public.eventview; +DROP VIEW IF EXISTS nonexistent_view; + +-- DROP VIEW with CASCADE option +DROP VIEW eventview CASCADE; +DROP VIEW public.myeventview CASCADE; +DROP VIEW IF EXISTS eventview CASCADE; + +-- DROP VIEW with RESTRICT option (default behavior) +DROP VIEW eventview RESTRICT; +DROP VIEW public.eventview RESTRICT; +DROP VIEW IF EXISTS eventview RESTRICT; + +-- DROP multiple views in single statement +DROP VIEW view1, view2, view3; +DROP VIEW public.view1, schema2.view2, view3; + +-- DROP multiple views with IF EXISTS +DROP VIEW IF EXISTS view1, view2, view3; +DROP VIEW IF EXISTS public.view1, schema2.view2, view3; + +-- DROP multiple views with CASCADE +DROP VIEW view1, view2, view3 CASCADE; +DROP VIEW public.view1, schema2.view2, view3 CASCADE; + +-- DROP multiple views with RESTRICT +DROP VIEW view1, view2, view3 RESTRICT; +DROP VIEW public.view1, schema2.view2, view3 RESTRICT; + +-- Complex combinations +DROP VIEW IF EXISTS public.eventview, myschema.sales_view, customer_view CASCADE; +DROP VIEW IF EXISTS view1, public.view2, schema3.view3 RESTRICT; + +-- Views with reserved keywords as names (quoted identifiers) +DROP VIEW "order"; +DROP VIEW "user"; +DROP VIEW "table"; +DROP VIEW IF EXISTS "select" CASCADE; + +-- Views with special characters in names +DROP VIEW view_with_underscores; +DROP VIEW view123; +DROP VIEW my_schema.view_name_2023; + +-- Case sensitivity tests +DROP VIEW MyView; +DROP VIEW EVENTVIEW; +DROP VIEW eventview; + +-- Additional AWS documentation examples +-- Example from documentation: drop view eventview cascade; +DROP VIEW eventview CASCADE; + +-- Example scenarios from documentation +-- After creating: create view eventview as select dateid, eventname, catid from event where catid = 1; +-- After creating dependent: create view myeventview as select eventname, catid from eventview where eventname <> ' '; +-- This would fail: DROP VIEW eventview; +-- This succeeds: DROP VIEW eventview CASCADE; + +-- Real-world examples +DROP VIEW sales_summary; +DROP VIEW quarterly_report; +DROP VIEW customer_analytics CASCADE; +DROP VIEW IF EXISTS temp_analysis_view; +DROP VIEW regional_sales, monthly_totals, yearly_summary RESTRICT; + +-- Edge cases with whitespace and formatting +DROP VIEW + eventview; + +DROP VIEW IF EXISTS eventview CASCADE; + +DROP VIEW view1, + view2, + view3; + +-- Mixed case keywords +Drop View eventview; +drop view if exists eventview cascade; +DROP view eventview RESTRICT; + +-- Schema names with various formats +DROP VIEW prod.sales_view; +DROP VIEW staging.temp_view; +DROP VIEW analytics.customer_segment_view; \ No newline at end of file diff --git a/redshift/examples/redshift/end.sql b/redshift/examples/redshift/end.sql new file mode 100644 index 0000000..c02fbe7 --- /dev/null +++ b/redshift/examples/redshift/end.sql @@ -0,0 +1,93 @@ +-- END command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_END.html + +-- Basic END statements +END; +end; + +-- END with WORK keyword (optional synonym) +END WORK; +end work; + +-- END with TRANSACTION keyword (optional synonym) +END TRANSACTION; +end transaction; + +-- Examples from AWS documentation +-- The AWS docs show these three variations: +end; +end work; +end transaction; + +-- Mixed case variations +End; +END; +EnD; +end Work; +END WORK; +End Work; +end transaction; +END TRANSACTION; +End Transaction; +END Transaction; + +-- Real-world usage examples in transaction blocks +-- Transaction block with basic end +BEGIN; +INSERT INTO sales VALUES (1001, 'Widget A', 25.50); +END; + +-- Transaction block with end work +BEGIN WORK; +UPDATE inventory SET quantity = quantity - 1 WHERE product_id = 'Widget A'; +END WORK; + +-- Transaction block with end transaction +BEGIN TRANSACTION; +INSERT INTO sales_summary SELECT product_name, SUM(amount) FROM sales GROUP BY product_name; +END TRANSACTION; + +-- Nested transaction example (Redshift processes as single transaction) +BEGIN; +CREATE TEMP TABLE temp_sales AS SELECT * FROM sales WHERE amount > 100; +INSERT INTO high_value_sales SELECT * FROM temp_sales; +DROP TABLE temp_sales; +END; + +-- Complex transaction with multiple operations +BEGIN WORK; +CREATE TABLE test_table (id INTEGER, name VARCHAR(50)); +INSERT INTO test_table VALUES (1, 'Test Item 1'); +INSERT INTO test_table VALUES (2, 'Test Item 2'); +UPDATE test_table SET name = 'Updated Item' WHERE id = 1; +DELETE FROM test_table WHERE id = 2; +END WORK; + +-- Transaction with DDL and DML operations +BEGIN TRANSACTION; +ALTER TABLE products ADD COLUMN description TEXT; +UPDATE products SET description = 'No description available' WHERE description IS NULL; +END TRANSACTION; + +-- Error handling scenarios (these should parse correctly) +-- END after failed operations (would rollback in real usage) +BEGIN; +-- This would normally fail, but syntax should parse +INSERT INTO non_existent_table VALUES (1, 'test'); +END; + +-- Multiple END variations in sequence (each would be separate transactions) +BEGIN; INSERT INTO test VALUES (1); END; +BEGIN WORK; UPDATE test SET col1 = 'a' WHERE id = 1; END WORK; +BEGIN TRANSACTION; DELETE FROM test WHERE id = 1; END TRANSACTION; + +-- Case insensitive parsing verification +begin; select 1; end; +BEGIN; SELECT 2; END; +Begin; Select 3; End; +begin work; select 4; end work; +BEGIN WORK; SELECT 5; END WORK; +Begin Work; Select 6; End Work; +begin transaction; select 7; end transaction; +BEGIN TRANSACTION; SELECT 8; END TRANSACTION; +Begin Transaction; Select 9; End Transaction; \ No newline at end of file diff --git a/redshift/examples/redshift/execute.sql b/redshift/examples/redshift/execute.sql new file mode 100644 index 0000000..bfc3412 --- /dev/null +++ b/redshift/examples/redshift/execute.sql @@ -0,0 +1,76 @@ +-- EXECUTE command test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_EXECUTE.html + +-- Basic EXECUTE without parameters +EXECUTE simple_plan; + +-- EXECUTE with single parameter +EXECUTE prep_select_plan(2); + +-- EXECUTE with multiple parameters (integers) +EXECUTE prep_insert_plan(1, 2); + +-- EXECUTE with mixed parameter types (int, string) +EXECUTE prep_insert_plan(1, 'one'); + +-- EXECUTE with string parameters +EXECUTE prep_update_plan('John', 'Doe'); + +-- EXECUTE with numeric parameters (decimals) +EXECUTE price_query(19.99, 100.50); + +-- EXECUTE with boolean parameters +EXECUTE status_check(true, false); + +-- EXECUTE with NULL parameter +EXECUTE null_test(null); + +-- Examples from AWS documentation: + +-- Example 1: Inserting multiple rows into a temporary table +-- PREPARE prep_insert_plan (int, char) AS insert into prep1 values ($1, $2); +EXECUTE prep_insert_plan(1, 'one'); +EXECUTE prep_insert_plan(2, 'two'); +EXECUTE prep_insert_plan(3, 'three'); + +-- Example 2: Selecting rows with a parameterized condition +-- PREPARE prep_select_plan (int) AS select * from prep1 where c1 = $1; +EXECUTE prep_select_plan(2); +EXECUTE prep_select_plan(3); + +-- Additional test cases: + +-- EXECUTE with complex identifiers +EXECUTE my_complex_plan_name; +EXECUTE plan_with_underscore_123; + +-- EXECUTE with quoted strings containing special characters +EXECUTE text_plan('It''s a test'); +EXECUTE special_chars('Hello, World!'); + +-- EXECUTE with negative numbers +EXECUTE math_plan(-1, -99.99); + +-- EXECUTE with scientific notation +EXECUTE scientific_plan(1.23e-4, 5.67E+10); + +-- EXECUTE with large numbers +EXECUTE big_numbers(999999999, 123456789.987654321); + +-- EXECUTE with multiple mixed parameters +EXECUTE complex_plan(1, 'text', true, null, 3.14, false); + +-- EXECUTE with single quotes in string literals +EXECUTE quote_test('Don''t worry'); +EXECUTE apostrophe_test('That''s correct'); + +-- EXECUTE with empty string +EXECUTE empty_string_test(''); + +-- EXECUTE with zero values +EXECUTE zero_test(0, 0.0); + +-- Case variations (should be case-insensitive) +execute lowercase_plan; +Execute mixed_case_plan; +EXECUTE uppercase_plan; \ No newline at end of file diff --git a/redshift/examples/redshift/explain.sql b/redshift/examples/redshift/explain.sql new file mode 100644 index 0000000..7690ffc --- /dev/null +++ b/redshift/examples/redshift/explain.sql @@ -0,0 +1,391 @@ +-- EXPLAIN command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_EXPLAIN.html + +-- Basic EXPLAIN statements +EXPLAIN SELECT * FROM table1; +explain select * from table1; + +-- EXPLAIN with VERBOSE option +EXPLAIN VERBOSE SELECT * FROM table1; +explain verbose select * from table1; + +-- Example from AWS documentation - basic EXPLAIN +EXPLAIN SELECT eventid, eventname, event.venueid, venuename +FROM event, venue +WHERE event.venueid = venue.venueid; + +-- Example from AWS documentation - VERBOSE EXPLAIN +EXPLAIN VERBOSE SELECT eventid, eventname, event.venueid, venuename +FROM event, venue +WHERE event.venueid = venue.venueid; + +-- EXPLAIN SELECT with various clauses +EXPLAIN SELECT customer_id, customer_name, order_count +FROM customers c +JOIN ( + SELECT customer_id, COUNT(*) as order_count + FROM orders + GROUP BY customer_id +) o ON c.customer_id = o.customer_id +WHERE c.registration_date >= '2023-01-01' +ORDER BY order_count DESC +LIMIT 100; + +-- EXPLAIN VERBOSE with complex SELECT +EXPLAIN VERBOSE +SELECT + category, + AVG(price) as avg_price, + COUNT(*) as product_count +FROM products +WHERE price > 100 +GROUP BY category +HAVING COUNT(*) > 5 +ORDER BY avg_price DESC; + +-- EXPLAIN with window functions +EXPLAIN SELECT + employee_id, + department_id, + salary, + ROW_NUMBER() OVER (PARTITION BY department_id ORDER BY salary DESC) as rank_in_dept +FROM employees +WHERE hire_date > '2020-01-01'; + +-- EXPLAIN with CTE (Common Table Expression) +EXPLAIN WITH sales_summary AS ( + SELECT + product_id, + SUM(quantity) as total_quantity, + SUM(amount) as total_amount + FROM sales + WHERE sale_date >= '2023-01-01' + GROUP BY product_id +) +SELECT p.product_name, s.total_quantity, s.total_amount +FROM sales_summary s +JOIN products p ON s.product_id = p.product_id +ORDER BY s.total_amount DESC; + +-- EXPLAIN VERBOSE with CTE +EXPLAIN VERBOSE WITH regional_sales AS ( + SELECT region, SUM(sales_amount) as total_sales + FROM sales_data + GROUP BY region +), +top_regions AS ( + SELECT region, total_sales + FROM regional_sales + WHERE total_sales > 1000000 +) +SELECT * FROM top_regions ORDER BY total_sales DESC; + +-- EXPLAIN with UNION +EXPLAIN SELECT customer_id, 'current' as status FROM current_customers +UNION ALL +SELECT customer_id, 'former' as status FROM former_customers +ORDER BY customer_id; + +-- EXPLAIN with subqueries +EXPLAIN SELECT * +FROM products p +WHERE p.category_id IN ( + SELECT category_id + FROM categories + WHERE category_name IN ('Electronics', 'Books') +) +AND p.price > ( + SELECT AVG(price) + FROM products + WHERE category_id = p.category_id +); + +-- EXPLAIN CREATE TABLE AS (CTAS) - Example from AWS documentation +EXPLAIN CREATE TABLE venue_nonulls +AS SELECT * FROM venue +WHERE venueseats IS NOT NULL; + +-- EXPLAIN VERBOSE with CREATE TABLE AS +EXPLAIN VERBOSE CREATE TABLE sales_summary_2023 +AS SELECT + product_id, + SUM(quantity) as total_quantity, + SUM(amount) as total_amount, + AVG(amount) as avg_amount +FROM sales +WHERE EXTRACT(YEAR FROM sale_date) = 2023 +GROUP BY product_id; + +-- EXPLAIN CREATE TEMPORARY TABLE AS +EXPLAIN CREATE TEMP TABLE temp_analysis +AS SELECT + customer_id, + COUNT(*) as order_count, + SUM(total_amount) as total_spent +FROM orders +WHERE order_date >= CURRENT_DATE - INTERVAL '30 days' +GROUP BY customer_id; + +-- EXPLAIN CREATE TABLE AS with table attributes +EXPLAIN CREATE TABLE dist_sales +DISTSTYLE KEY +DISTKEY (customer_id) +SORTKEY (sale_date) +AS SELECT customer_id, sale_date, amount, product_id +FROM sales +WHERE sale_date >= '2023-01-01'; + +-- EXPLAIN CREATE TABLE AS with BACKUP option +EXPLAIN CREATE TABLE backup_customers +BACKUP YES +AS SELECT * FROM customers WHERE status = 'active'; + +-- EXPLAIN INSERT statement +EXPLAIN INSERT INTO target_table (col1, col2, col3) +SELECT source_col1, source_col2, source_col3 +FROM source_table +WHERE created_date >= '2023-01-01'; + +-- EXPLAIN INSERT with VALUES +EXPLAIN INSERT INTO products (product_name, price, category_id) +VALUES + ('Product A', 99.99, 1), + ('Product B', 149.99, 2), + ('Product C', 79.99, 1); + +-- EXPLAIN UPDATE statement +EXPLAIN UPDATE customers +SET status = 'inactive', + last_updated = CURRENT_TIMESTAMP +WHERE last_order_date < CURRENT_DATE - INTERVAL '365 days'; + +-- EXPLAIN UPDATE with JOIN +EXPLAIN UPDATE inventory i +SET quantity = i.quantity - o.quantity +FROM order_items o +WHERE i.product_id = o.product_id +AND o.order_date = CURRENT_DATE; + +-- EXPLAIN DELETE statement +EXPLAIN DELETE FROM log_entries +WHERE log_date < CURRENT_DATE - INTERVAL '90 days'; + +-- EXPLAIN DELETE with subquery +EXPLAIN DELETE FROM orders +WHERE customer_id IN ( + SELECT customer_id + FROM customers + WHERE status = 'deleted' +); + +-- EXPLAIN with complex joins +EXPLAIN SELECT + c.customer_name, + o.order_id, + p.product_name, + oi.quantity, + oi.price +FROM customers c +INNER JOIN orders o ON c.customer_id = o.customer_id +INNER JOIN order_items oi ON o.order_id = oi.order_id +INNER JOIN products p ON oi.product_id = p.product_id +LEFT JOIN product_reviews pr ON p.product_id = pr.product_id +WHERE o.order_date >= '2023-01-01' +AND c.country = 'USA'; + +-- EXPLAIN with outer joins +EXPLAIN VERBOSE SELECT + d.department_name, + e.employee_name, + e.salary +FROM departments d +LEFT OUTER JOIN employees e ON d.department_id = e.department_id +RIGHT OUTER JOIN locations l ON d.location_id = l.location_id +FULL OUTER JOIN managers m ON d.department_id = m.department_id; + +-- EXPLAIN with aggregation and grouping +EXPLAIN SELECT + EXTRACT(YEAR FROM order_date) as year, + EXTRACT(MONTH FROM order_date) as month, + COUNT(*) as order_count, + SUM(total_amount) as total_revenue, + AVG(total_amount) as avg_order_value +FROM orders +WHERE order_date >= '2022-01-01' +GROUP BY 1, 2 +ORDER BY 1, 2; + +-- EXPLAIN with HAVING clause +EXPLAIN SELECT + category_id, + COUNT(*) as product_count, + AVG(price) as avg_price +FROM products +GROUP BY category_id +HAVING COUNT(*) > 10 +AND AVG(price) < 500; + +-- EXPLAIN with CASE expressions +EXPLAIN SELECT + customer_id, + CASE + WHEN total_spent >= 10000 THEN 'Premium' + WHEN total_spent >= 5000 THEN 'Gold' + WHEN total_spent >= 1000 THEN 'Silver' + ELSE 'Bronze' + END as customer_tier, + total_spent +FROM ( + SELECT + customer_id, + SUM(order_total) as total_spent + FROM orders + GROUP BY customer_id +) customer_totals; + +-- EXPLAIN with CAST operations +EXPLAIN SELECT + product_id, + CAST(price AS INTEGER) as price_int, + CAST(created_date AS VARCHAR(10)) as created_date_str, + price::DECIMAL(10,2) as price_decimal +FROM products +WHERE CAST(price AS INTEGER) > 100; + +-- EXPLAIN with date/time functions +EXPLAIN SELECT + order_id, + order_date, + EXTRACT(YEAR FROM order_date) as order_year, + EXTRACT(MONTH FROM order_date) as order_month, + EXTRACT(DAY FROM order_date) as order_day, + DATE_PART('dow', order_date) as day_of_week +FROM orders +WHERE order_date >= CURRENT_DATE - INTERVAL '1 year'; + +-- EXPLAIN with string functions and pattern matching +EXPLAIN SELECT + customer_id, + customer_name, + email +FROM customers +WHERE customer_name LIKE 'John%' +AND email LIKE '%@gmail.com' +AND LENGTH(customer_name) > 5; + +-- EXPLAIN with IN and EXISTS clauses +EXPLAIN SELECT * +FROM products p +WHERE p.category_id IN (1, 2, 3, 4, 5) +AND EXISTS ( + SELECT 1 + FROM order_items oi + WHERE oi.product_id = p.product_id + AND oi.order_date >= CURRENT_DATE - INTERVAL '30 days' +); + +-- EXPLAIN with BETWEEN +EXPLAIN SELECT + product_id, + product_name, + price +FROM products +WHERE price BETWEEN 50 AND 200 +AND created_date BETWEEN '2023-01-01' AND '2023-12-31'; + +-- EXPLAIN with NULL handling +EXPLAIN SELECT + customer_id, + customer_name, + COALESCE(phone, 'N/A') as contact_phone, + CASE WHEN email IS NULL THEN 'No Email' ELSE email END as email_status +FROM customers +WHERE phone IS NOT NULL +OR email IS NOT NULL; + +-- EXPLAIN with DISTINCT +EXPLAIN SELECT DISTINCT + category_id, + supplier_id +FROM products +WHERE price > 100; + +-- EXPLAIN with GROUP BY ROLLUP +EXPLAIN SELECT + category_id, + supplier_id, + COUNT(*) as product_count, + AVG(price) as avg_price +FROM products +GROUP BY ROLLUP(category_id, supplier_id); + +-- EXPLAIN with GROUP BY CUBE +EXPLAIN SELECT + EXTRACT(YEAR FROM order_date) as year, + EXTRACT(QUARTER FROM order_date) as quarter, + SUM(total_amount) as revenue +FROM orders +GROUP BY CUBE(1, 2); + +-- EXPLAIN with GROUPING SETS +EXPLAIN SELECT + category_id, + brand_id, + COUNT(*) as product_count +FROM products +GROUP BY GROUPING SETS ( + (category_id), + (brand_id), + (category_id, brand_id), + () +); + +-- EXPLAIN with LIMIT and OFFSET +EXPLAIN SELECT + product_id, + product_name, + price +FROM products +ORDER BY price DESC +LIMIT 50 OFFSET 100; + +-- Mixed case variations +Explain Select * From table1; +EXPLAIN verbose SELECT col1, col2 FROM table2 WHERE col1 > 100; +explain VERBOSE select count(*) from orders group by customer_id; + +-- Complex query with multiple features +EXPLAIN VERBOSE +WITH monthly_sales AS ( + SELECT + DATE_TRUNC('month', order_date) as month, + customer_id, + SUM(total_amount) as monthly_total + FROM orders + WHERE order_date >= '2023-01-01' + GROUP BY 1, 2 +), +customer_metrics AS ( + SELECT + customer_id, + COUNT(DISTINCT month) as active_months, + AVG(monthly_total) as avg_monthly_total, + MAX(monthly_total) as max_monthly_total + FROM monthly_sales + GROUP BY customer_id +) +SELECT + c.customer_name, + cm.active_months, + cm.avg_monthly_total, + cm.max_monthly_total, + CASE + WHEN cm.avg_monthly_total >= 1000 THEN 'High Value' + WHEN cm.avg_monthly_total >= 500 THEN 'Medium Value' + ELSE 'Low Value' + END as customer_segment +FROM customer_metrics cm +JOIN customers c ON cm.customer_id = c.customer_id +WHERE cm.active_months >= 3 +ORDER BY cm.avg_monthly_total DESC +LIMIT 100; \ No newline at end of file diff --git a/redshift/examples/redshift/fetch.sql b/redshift/examples/redshift/fetch.sql new file mode 100644 index 0000000..7131c13 --- /dev/null +++ b/redshift/examples/redshift/fetch.sql @@ -0,0 +1,160 @@ +-- FETCH command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_FETCH.html + +-- Basic FETCH statements (NEXT is default) +FETCH FROM lollapalooza; +fetch from lollapalooza; +FETCH NEXT FROM lollapalooza; +fetch next from lollapalooza; + +-- FETCH with cursor names +FETCH FROM my_cursor; +FETCH FROM cursor_name; +FETCH FROM test_cursor; +FETCH FROM sales_cursor; +FETCH FROM product_cursor; + +-- FETCH NEXT variations +FETCH NEXT FROM cursor1; +FETCH NEXT FROM my_cursor_name; +FETCH NEXT FROM test_cursor_123; + +-- FETCH ALL variations +FETCH ALL FROM cursor1; +FETCH ALL FROM my_cursor; +FETCH ALL FROM sales_report_cursor; +fetch all from customer_cursor; + +-- FETCH FORWARD with count +FETCH FORWARD 1 FROM lollapalooza; +FETCH FORWARD 5 FROM lollapalooza; +FETCH FORWARD 10 FROM my_cursor; +FETCH FORWARD 100 FROM sales_cursor; +FETCH FORWARD 1000 FROM product_cursor; + +-- FETCH FORWARD 0 (current row) +FETCH FORWARD 0 FROM cursor1; +FETCH FORWARD 0 FROM my_cursor; + +-- FETCH FORWARD ALL +FETCH FORWARD ALL FROM cursor1; +FETCH FORWARD ALL FROM my_cursor; +fetch forward all from sales_cursor; + +-- Mixed case variations +Fetch From cursor1; +FETCH from cursor2; +fetch FROM cursor3; +Fetch Next From cursor4; +FETCH ALL from cursor5; +fetch forward 5 from cursor6; + +-- FETCH with quoted cursor names +FETCH FROM "my cursor"; +FETCH FROM "Cursor Name"; +FETCH FROM "cursor-with-dashes"; +FETCH FROM "cursor.with.dots"; +FETCH FROM "cursor with spaces"; +FETCH NEXT FROM "quoted cursor"; +FETCH ALL FROM "Special Cursor Name"; +FETCH FORWARD 10 FROM "cursor@special"; + +-- FETCH with complex cursor names +FETCH FROM cursor_with_long_name; +FETCH FROM complex_cursor_name_with_underscores; +FETCH FROM cursor_123_test_abc; +FETCH NEXT FROM monthly_summary_cursor; +FETCH ALL FROM customer_detail_cursor; +FETCH FORWARD 50 FROM transaction_history_cursor; + +-- Examples from AWS documentation +-- Fetch the first 5 rows in the cursor lollapalooza +FETCH FORWARD 5 FROM lollapalooza; + +-- Fetch the next row +FETCH NEXT FROM lollapalooza; + +-- Common cursor usage patterns +FETCH FROM emp_cursor; +FETCH NEXT FROM dept_cursor; +FETCH ALL FROM sales_cursor; +FETCH FORWARD 20 FROM product_cursor; +FETCH FORWARD ALL FROM customer_cursor; + +-- Procedural cursor patterns +FETCH FROM proc_cursor; +FETCH NEXT FROM func_cursor; +FETCH ALL FROM temp_cursor; +FETCH FORWARD 1 FROM result_cursor; +FETCH FORWARD ALL FROM output_cursor; + +-- Database object cursor patterns +FETCH FROM users_cur; +FETCH NEXT FROM orders_cur; +FETCH ALL FROM items_cur; +FETCH FORWARD 100 FROM transactions_cur; +FETCH FORWARD ALL FROM reports_cur; + +-- Single character cursor names +FETCH FROM a; +FETCH NEXT FROM b; +FETCH ALL FROM c; +FETCH FORWARD 1 FROM x; +FETCH FORWARD 5 FROM y; +FETCH FORWARD ALL FROM z; + +-- Numeric suffixes in cursor names +FETCH FROM cursor1; +FETCH NEXT FROM cursor2; +FETCH ALL FROM cursor123; +FETCH FORWARD 10 FROM my_cursor_1; +FETCH FORWARD ALL FROM test_cursor_99; + +-- Reserved words as quoted cursor names +FETCH FROM "fetch"; +FETCH FROM "next"; +FETCH FROM "all"; +FETCH FROM "forward"; +FETCH FROM "from"; +FETCH FROM "cursor"; +FETCH FROM "table"; +FETCH FROM "select"; + +-- Mixed case cursor names +FETCH FROM MyCursor; +FETCH NEXT FROM CURSOR_NAME; +FETCH ALL FROM TestCursor; +FETCH FORWARD 5 FROM myCursor; +FETCH FORWARD ALL FROM cursorName; + +-- Special characters in quoted cursor names +FETCH FROM "cursor@special"; +FETCH NEXT FROM "cursor#123"; +FETCH ALL FROM "cursor$name"; +FETCH FORWARD 10 FROM "cursor%test"; +FETCH FORWARD ALL FROM "cursor&data"; + +-- Typical business cursor patterns +FETCH FROM customer_orders_cursor; +FETCH NEXT FROM inventory_items_cursor; +FETCH ALL FROM financial_reports_cursor; +FETCH FORWARD 25 FROM employee_details_cursor; +FETCH FORWARD ALL FROM product_sales_cursor; + +-- Time-based cursor patterns +FETCH FROM daily_report_cursor; +FETCH NEXT FROM weekly_summary_cursor; +FETCH ALL FROM monthly_stats_cursor; +FETCH FORWARD 7 FROM quarterly_data_cursor; +FETCH FORWARD ALL FROM yearly_totals_cursor; + +-- Large count values (up to 1000 for single-node clusters) +FETCH FORWARD 999 FROM large_dataset_cursor; +FETCH FORWARD 1000 FROM max_count_cursor; + +-- Edge cases with whitespace and formatting +FETCH FROM cursor1; +FETCH NEXT FROM cursor2; +FETCH ALL FROM cursor3; +FETCH FORWARD 5 FROM cursor4; +FETCH FORWARD ALL FROM cursor5; \ No newline at end of file diff --git a/redshift/examples/redshift/grant.sql b/redshift/examples/redshift/grant.sql new file mode 100644 index 0000000..2b43348 --- /dev/null +++ b/redshift/examples/redshift/grant.sql @@ -0,0 +1,187 @@ +-- GRANT test cases based on AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_GRANT.html + +-- Basic table privileges (from AWS documentation) +GRANT SELECT ON TABLE sales TO dbuser; +GRANT INSERT, UPDATE, DELETE ON TABLE sales TO dbuser; +GRANT ALL ON TABLE sales TO dbuser; +GRANT ALL PRIVILEGES ON TABLE sales TO dbuser; + +-- Table privileges to multiple users +GRANT SELECT ON TABLE sales TO user1, user2, user3; +GRANT INSERT ON sales TO dbuser1, dbuser2; + +-- Table privileges with WITH GRANT OPTION +GRANT SELECT ON TABLE sales TO dbuser WITH GRANT OPTION; +GRANT ALL ON TABLE sales TO dbuser WITH GRANT OPTION; + +-- Column-level privileges (from AWS documentation) +GRANT SELECT (col1) ON TABLE t1 TO PUBLIC; +GRANT UPDATE (col1, col2) ON TABLE t1 TO user1; + +-- Grant to PUBLIC +GRANT SELECT ON TABLE public_data TO PUBLIC; +GRANT USAGE ON SCHEMA public TO PUBLIC; + +-- Grant to ROLE and GROUP +GRANT SELECT ON TABLE sales TO ROLE analyst_role; +GRANT INSERT ON TABLE logs TO GROUP etl_group; +GRANT ALL ON TABLE temp_data TO ROLE temp_role, GROUP admin_group; + +-- All tables in schema (from AWS documentation) +GRANT SELECT ON ALL TABLES IN SCHEMA myschema TO dbuser; +GRANT ALL ON ALL TABLES IN SCHEMA reporting TO ROLE report_role; + +-- Database privileges (from AWS documentation) +GRANT CREATE ON DATABASE mydb TO dbuser; +GRANT USAGE ON DATABASE prod_db TO readonly_user; +GRANT TEMPORARY ON DATABASE session_db TO temp_user; +GRANT TEMP ON DATABASE session_db TO temp_user; +GRANT ALTER ON DATABASE mydb TO admin_user; +GRANT ALL ON DATABASE mydb TO dba_role; +GRANT ALL PRIVILEGES ON DATABASE mydb TO admin_group; + +-- Database privileges with WITH GRANT OPTION +GRANT CREATE ON DATABASE mydb TO dbuser WITH GRANT OPTION; +GRANT ALL ON DATABASE mydb TO admin WITH GRANT OPTION; + +-- Schema privileges (from AWS documentation) +GRANT CREATE ON SCHEMA myschema TO dbuser; +GRANT USAGE ON SCHEMA reporting TO analyst; +GRANT ALTER ON SCHEMA dynamic_schema TO schema_admin; +GRANT DROP ON SCHEMA temp_schema TO cleanup_role; +GRANT ALL ON SCHEMA myschema TO schema_owner; +GRANT ALL PRIVILEGES ON SCHEMA myschema TO schema_admin; + +-- Schema privileges with WITH GRANT OPTION +GRANT USAGE ON SCHEMA reporting TO analyst WITH GRANT OPTION; +GRANT ALL ON SCHEMA myschema TO admin WITH GRANT OPTION; + +-- Function privileges (from AWS documentation) +GRANT EXECUTE ON FUNCTION f1() TO dbuser; +GRANT EXECUTE ON FUNCTION calculate_tax(numeric, numeric) TO tax_calculator; +GRANT ALL ON FUNCTION utility_func() TO utility_user; +GRANT ALL PRIVILEGES ON FUNCTION math_func(integer) TO math_user; + +-- Function privileges with parameters +GRANT EXECUTE ON FUNCTION format_currency(numeric, varchar) TO report_user; +GRANT EXECUTE ON FUNCTION validate_email(varchar(255)) TO validation_service; +GRANT EXECUTE ON FUNCTION calculate_discount(decimal(10,2), integer) TO pricing_engine; + +-- All functions in schema +GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA analytics TO analyst_role; +GRANT ALL ON ALL FUNCTIONS IN SCHEMA utilities TO utility_group; + +-- Procedure privileges +GRANT EXECUTE ON PROCEDURE proc1() TO dbuser; +GRANT EXECUTE ON PROCEDURE update_inventory(integer, varchar) TO inventory_user; +GRANT ALL ON PROCEDURE maintenance_proc() TO admin_role; + +-- All procedures in schema +GRANT EXECUTE ON ALL PROCEDURES IN SCHEMA maintenance TO maintenance_role; +GRANT ALL ON ALL PROCEDURES IN SCHEMA etl TO etl_group; + +-- Function and procedure privileges with WITH GRANT OPTION +GRANT EXECUTE ON FUNCTION f1() TO dbuser WITH GRANT OPTION; +GRANT EXECUTE ON PROCEDURE proc1() TO admin WITH GRANT OPTION; + +-- Datashare privileges (from AWS documentation) +GRANT ALTER ON DATASHARE salesshare TO myuser WITH GRANT OPTION; +GRANT USAGE ON DATASHARE salesshare TO namespace 'a3f3ae8c-14e8-45ba-9eaa-b42b9b7ae635'; + +-- Role privileges (from AWS documentation) +GRANT ROLE sample_role1 TO reguser; +GRANT ROLE admin_role TO user1 WITH ADMIN OPTION; +GRANT ROLE analyst_role TO ROLE senior_analyst; + +-- Multiple role grants +GRANT ROLE read_role TO user1, user2, user3; +GRANT ROLE admin_role TO ROLE super_admin, ROLE department_head; + +-- Model privileges (Amazon Redshift ML) +GRANT EXECUTE ON MODEL customer_churn_model TO ml_user; +GRANT ALL ON MODEL sales_forecast_model TO ml_team; +GRANT ALL PRIVILEGES ON MODEL recommendation_model TO data_scientist; + +-- Model privileges with WITH GRANT OPTION +GRANT EXECUTE ON MODEL fraud_detection_model TO security_analyst WITH GRANT OPTION; +GRANT ALL ON MODEL price_optimization_model TO pricing_team WITH GRANT OPTION; + +-- Complex combinations +GRANT SELECT, INSERT, UPDATE ON TABLE orders TO ROLE order_manager, GROUP sales_team; +GRANT ALL ON TABLE customers TO user1 WITH GRANT OPTION, ROLE customer_admin, GROUP support_team; + +-- Cross-object privileges +GRANT CREATE ON DATABASE prod_db TO schema_creator; +GRANT CREATE ON SCHEMA new_schema TO table_creator; +GRANT SELECT ON TABLE new_schema.products TO product_analyst; + +-- Real-world examples +GRANT SELECT ON TABLE fact_sales TO ROLE analyst_role; +GRANT INSERT, UPDATE ON TABLE staging_orders TO ROLE etl_role; +GRANT ALL ON TABLE dim_customer TO data_engineer WITH GRANT OPTION; +GRANT USAGE ON SCHEMA analytics TO ROLE business_analyst; +GRANT CREATE ON DATABASE warehouse TO ROLE data_architect; + +-- Service account patterns +GRANT SELECT ON ALL TABLES IN SCHEMA reporting TO airflow_service; +GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA utilities TO lambda_function; +GRANT USAGE ON SCHEMA staging TO kubernetes_pod; + +-- Quoted identifiers +GRANT SELECT ON TABLE "Order Details" TO "Sales Manager"; +GRANT USAGE ON SCHEMA "Finance Reports" TO "Finance Team"; +GRANT EXECUTE ON FUNCTION "Calculate Tax"() TO "Tax Service"; + +-- Case variations +grant select on table sales to analyst; +GRANT SELECT ON TABLE SALES TO ANALYST; +Grant Select On Table Sales To Analyst; + +-- Privilege combinations +GRANT SELECT, INSERT ON TABLE logs TO logger_service; +GRANT UPDATE, DELETE, TRUNCATE ON TABLE temp_data TO cleanup_service; +GRANT DROP, ALTER ON TABLE migration_table TO migration_tool; +GRANT REFERENCES, SELECT ON TABLE lookup_table TO referencing_table_owner; + +-- Edge cases +GRANT ALL ON TABLE single_column_table TO single_user; +GRANT SELECT (id) ON TABLE wide_table TO id_reader; +GRANT USAGE ON SCHEMA "" TO edge_case_user; + +-- Multiple grantees with different types +GRANT SELECT ON TABLE mixed_access_table TO user1, ROLE reader_role, GROUP viewer_group, PUBLIC; +GRANT USAGE ON SCHEMA shared_schema TO service_user, ROLE service_role, GROUP service_group; + +-- Nested role grants +GRANT ROLE junior_analyst TO ROLE senior_analyst; +GRANT ROLE team_lead TO ROLE department_manager; +GRANT ROLE read_only_role TO ROLE power_user_role; + +-- Function overloading scenarios +GRANT EXECUTE ON FUNCTION calculate(integer) TO math_user1; +GRANT EXECUTE ON FUNCTION calculate(numeric) TO math_user2; +GRANT EXECUTE ON FUNCTION calculate(integer, integer) TO math_user3; + +-- Data type variations in function parameters +GRANT EXECUTE ON FUNCTION process_string(varchar) TO string_processor; +GRANT EXECUTE ON FUNCTION process_string(text) TO text_processor; +GRANT EXECUTE ON FUNCTION handle_timestamp(timestamp) TO time_handler; +GRANT EXECUTE ON FUNCTION handle_numbers(numeric(10,2)) TO number_handler; + +-- Schema-qualified object names +GRANT SELECT ON TABLE public.users TO public_reader; +GRANT EXECUTE ON FUNCTION analytics.calculate_metrics() TO metrics_user; +GRANT USAGE ON SCHEMA finance TO finance_analyst; + +-- Long identifier names +GRANT SELECT ON TABLE very_long_table_name_for_comprehensive_sales_data TO very_long_user_name_for_sales_analysis; +GRANT EXECUTE ON FUNCTION extremely_long_function_name_for_complex_calculations() TO user_with_very_long_descriptive_name; + +-- Privilege revocation preparation (understanding what can be granted) +GRANT ALL PRIVILEGES ON TABLE revokable_table TO revokable_user WITH GRANT OPTION; +GRANT ALL ON ALL TABLES IN SCHEMA revokable_schema TO revokable_role WITH GRANT OPTION; + +-- Temporary and session-based grants +GRANT TEMPORARY ON DATABASE session_db TO session_user; +GRANT TEMP ON DATABASE temp_workspace TO temp_worker; \ No newline at end of file diff --git a/redshift/examples/redshift/insert.sql b/redshift/examples/redshift/insert.sql new file mode 100644 index 0000000..bfd7e9a --- /dev/null +++ b/redshift/examples/redshift/insert.sql @@ -0,0 +1,293 @@ +-- Amazon Redshift INSERT statement test cases +-- Based on: https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT.html + +-- Basic INSERT with explicit column list +INSERT INTO event (eventid, eventname, starttime, venueid) +VALUES (5000, 'Salome', '2008-01-05 14:00', 3); + +-- INSERT with all columns (implicit column list) +INSERT INTO event +VALUES (5000, 3, 5, 'Salome', '2008-01-05 14:00', 'Opera', 'Strauss'); + +-- Multiple rows INSERT +INSERT INTO event (eventid, eventname, starttime, venueid) +VALUES + (5000, 'Salome', '2008-01-05 14:00', 3), + (5001, 'La Traviata', '2008-01-05 20:00', 4), + (5002, 'Tosca', '2008-01-06 14:00', 5); + +-- INSERT with DEFAULT values +INSERT INTO users (userid, username, firstname, lastname, city, state, email, phone) +VALUES (1001, 'user1001', DEFAULT, DEFAULT, 'New York', 'NY', DEFAULT, DEFAULT); + +-- INSERT with NULL values +INSERT INTO venue (venueid, venuename, venuecity, venuestate, venueseats) +VALUES (500, NULL, 'New York', 'NY', NULL); + +-- INSERT with SELECT statement +INSERT INTO event_backup +SELECT * FROM event WHERE starttime > '2008-01-01'; + +-- INSERT with specific columns from SELECT +INSERT INTO category_stage (catid, catname) +SELECT catid, catname FROM category WHERE catgroup = 'Concerts'; + +-- INSERT with complex SELECT (joins, aggregates) +INSERT INTO sales_summary (salesid, total_price, commission) +SELECT + salesid, + pricepaid * qtysold as total_price, + commission +FROM sales +WHERE saletime >= '2008-01-01' +ORDER BY salesid; + +-- INSERT with SELECT and GROUP BY +INSERT INTO venue_events_count (venueid, event_count) +SELECT + venueid, + COUNT(*) as event_count +FROM event +GROUP BY venueid +HAVING COUNT(*) > 10; + +-- INSERT with SELECT and JOIN +INSERT INTO user_sales (userid, username, total_sales) +SELECT + u.userid, + u.username, + SUM(s.pricepaid) as total_sales +FROM users u +JOIN sales s ON u.userid = s.buyerid +GROUP BY u.userid, u.username; + +-- INSERT with date literals +INSERT INTO date_table (dateid, caldate, day, week, month, qtr, year) +VALUES (20080105, '2008-01-05', 'SA', 1, 'JAN', 1, 2008); + +-- INSERT with timestamp literals +INSERT INTO listing (listid, sellerid, eventid, dateid, numtickets, priceperticket, totalprice, listtime) +VALUES (50000, 1001, 5000, 20080105, 4, 25.00, 100.00, '2008-01-05 07:45:00'); + +-- INSERT with boolean literals +INSERT INTO customer_preferences (customerid, email_opt_in, sms_opt_in, active) +VALUES (1001, TRUE, FALSE, TRUE); + +-- INSERT with numeric literals (integers and decimals) +INSERT INTO product (productid, name, price, quantity, weight) +VALUES (2001, 'Widget Pro', 29.99, 150, 2.5); + +-- INSERT with string literals and special characters +INSERT INTO venue (venueid, venuename, venuecity, venuestate, venueseats) +VALUES (600, 'O''Brien Theater', 'Boston', 'MA', 2500); + +-- INSERT with DEFAULT VALUES clause +INSERT INTO category DEFAULT VALUES; + +-- INSERT with schema-qualified table name +INSERT INTO public.event (eventid, eventname, starttime, venueid) +VALUES (6000, 'Carmen', '2008-02-05 19:00', 8); + +-- INSERT with quoted identifiers +INSERT INTO "Event" ("EventID", "EventName", "StartTime", "VenueID") +VALUES (7000, 'Phantom', '2008-03-05 20:00', 10); + +-- INSERT with subquery in VALUES +INSERT INTO sales (salesid, listid, sellerid, buyerid, eventid, dateid, qtysold, pricepaid, commission, saletime) +VALUES ( + 100000, + (SELECT MAX(listid) FROM listing WHERE eventid = 5000), + 1001, + 2001, + 5000, + 20080105, + 2, + 50.00, + 7.50, + '2008-01-05 09:30:00' +); + +-- INSERT with arithmetic expressions in SELECT +INSERT INTO sales_metrics (metric_date, avg_price, total_revenue, ticket_count) +SELECT + DATE(saletime) as metric_date, + AVG(pricepaid) as avg_price, + SUM(pricepaid * qtysold) as total_revenue, + SUM(qtysold) as ticket_count +FROM sales +WHERE saletime >= '2008-01-01' +GROUP BY DATE(saletime); + +-- INSERT with CASE expression in SELECT +INSERT INTO user_category (userid, username, user_type) +SELECT + userid, + username, + CASE + WHEN likemusicals = TRUE THEN 'Musical Fan' + WHEN likesports = TRUE THEN 'Sports Fan' + ELSE 'General' + END as user_type +FROM users; + +-- INSERT with window functions in SELECT +INSERT INTO sales_ranking (salesid, rank_by_price, total_sales) +SELECT + salesid, + RANK() OVER (ORDER BY pricepaid DESC) as rank_by_price, + SUM(pricepaid) OVER () as total_sales +FROM sales +WHERE saletime >= '2008-01-01'; + +-- INSERT with LIMIT clause in SELECT +INSERT INTO top_venues (venueid, venuename, total_events) +SELECT + v.venueid, + v.venuename, + COUNT(e.eventid) as total_events +FROM venue v +JOIN event e ON v.venueid = e.venueid +GROUP BY v.venueid, v.venuename +ORDER BY total_events DESC +LIMIT 10; + +-- INSERT with CTE (Common Table Expression) +INSERT INTO monthly_sales (month, year, total_sales, event_count) +WITH monthly_data AS ( + SELECT + EXTRACT(MONTH FROM saletime) as month, + EXTRACT(YEAR FROM saletime) as year, + SUM(pricepaid) as total_sales, + COUNT(DISTINCT eventid) as event_count + FROM sales + GROUP BY EXTRACT(MONTH FROM saletime), EXTRACT(YEAR FROM saletime) +) +SELECT month, year, total_sales, event_count +FROM monthly_data +WHERE year = 2008; + +-- INSERT with multiple CTEs +INSERT INTO venue_performance (venueid, venuename, total_sales, avg_price) +WITH venue_sales AS ( + SELECT + v.venueid, + v.venuename, + SUM(s.pricepaid) as total_sales, + AVG(s.pricepaid) as avg_price + FROM venue v + JOIN event e ON v.venueid = e.venueid + JOIN sales s ON e.eventid = s.eventid + GROUP BY v.venueid, v.venuename +), +top_venues AS ( + SELECT * + FROM venue_sales + WHERE total_sales > 10000 +) +SELECT venueid, venuename, total_sales, avg_price +FROM top_venues; + +-- INSERT with UNION in SELECT +INSERT INTO all_names (id, name, type) +SELECT userid as id, username as name, 'user' as type FROM users +UNION ALL +SELECT venueid as id, venuename as name, 'venue' as type FROM venue; + +-- INSERT with very long value lists (testing parser performance) +INSERT INTO large_table (id, value) +VALUES + (1, 'value1'), + (2, 'value2'), + (3, 'value3'), + (4, 'value4'), + (5, 'value5'), + (6, 'value6'), + (7, 'value7'), + (8, 'value8'), + (9, 'value9'), + (10, 'value10'); + +-- INSERT with mixed data types +INSERT INTO mixed_types ( + int_col, + bigint_col, + decimal_col, + real_col, + double_col, + char_col, + varchar_col, + date_col, + timestamp_col, + boolean_col +) VALUES ( + 42, + 9223372036854775807, + 123.45, + 3.14159, + 2.71828182845905, + 'A', + 'Hello, World!', + '2008-01-05', + '2008-01-05 14:30:00', + TRUE +); + +-- INSERT with escape sequences in strings +INSERT INTO text_data (id, content) +VALUES + (1, 'Line 1\nLine 2'), + (2, 'Tab\tseparated'), + (3, 'Quote: ''escaped'''), + (4, 'Backslash: \\'); + +-- INSERT with unicode characters +INSERT INTO international (id, city, greeting) +VALUES + (1, 'Tokyo', '東京'), + (2, 'Paris', 'Bonjour'), + (3, 'Moscow', 'Москва'); + +-- INSERT with computed columns in SELECT +INSERT INTO calculated_values (id, base_value, computed_value) +SELECT + id, + value, + value * 1.1 + 10 as computed_value +FROM source_table +WHERE value > 0; + +-- INSERT with correlated subquery +INSERT INTO user_first_sale (userid, username, first_sale_date) +SELECT + u.userid, + u.username, + (SELECT MIN(saletime) FROM sales s WHERE s.buyerid = u.userid) as first_sale_date +FROM users u +WHERE EXISTS (SELECT 1 FROM sales s WHERE s.buyerid = u.userid); + +-- INSERT with SELECT DISTINCT +INSERT INTO unique_cities (city, state) +SELECT DISTINCT venuecity, venuestate +FROM venue +WHERE venuestate IS NOT NULL +ORDER BY venuecity, venuestate; + +-- INSERT with outer join +INSERT INTO user_sales_summary (userid, username, total_spent, purchase_count) +SELECT + u.userid, + u.username, + COALESCE(SUM(s.pricepaid), 0) as total_spent, + COUNT(s.salesid) as purchase_count +FROM users u +LEFT JOIN sales s ON u.userid = s.buyerid +GROUP BY u.userid, u.username; + +-- INSERT with full outer join +INSERT INTO venue_event_matrix (venueid, eventid, has_event) +SELECT + COALESCE(v.venueid, e.venueid) as venueid, + e.eventid, + CASE WHEN e.eventid IS NOT NULL THEN TRUE ELSE FALSE END as has_event +FROM venue v +FULL OUTER JOIN event e ON v.venueid = e.venueid; \ No newline at end of file diff --git a/redshift/examples/redshift/insert_external_table.sql b/redshift/examples/redshift/insert_external_table.sql new file mode 100644 index 0000000..a73e080 --- /dev/null +++ b/redshift/examples/redshift/insert_external_table.sql @@ -0,0 +1,161 @@ +-- Redshift INSERT into external tables test cases +-- Based on https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_external_table.html + +-- Basic INSERT with SELECT from local table +INSERT INTO spectrum.lineitem SELECT * FROM local_lineitem; + +-- INSERT into non-partitioned external table +INSERT INTO spectrum.customers +SELECT customer_id, customer_name, customer_email, signup_date +FROM staging.new_customers; + +-- INSERT with WHERE clause filtering +INSERT INTO spectrum.orders +SELECT order_id, customer_id, order_date, total_amount +FROM local_orders +WHERE order_date >= '2024-01-01'; + +-- INSERT with JOIN between local tables +INSERT INTO spectrum.order_details +SELECT od.order_id, od.product_id, p.product_name, od.quantity, od.price +FROM local_order_details od +JOIN local_products p ON od.product_id = p.product_id; + +-- Static partitioning - adding specific partition values +INSERT INTO spectrum.customer +SELECT name, age, gender, 'May', 28 +FROM local_customer; + +-- Static partitioning with multiple partition columns +INSERT INTO spectrum.sales_data +SELECT product_id, quantity, price, customer_id, '2024', '05', '15' +FROM daily_sales +WHERE sale_date = '2024-05-15'; + +-- Dynamic partitioning - partition values from source data +INSERT INTO spectrum.customer +SELECT name, age, gender, month, day +FROM local_customer; + +-- Dynamic partitioning with computed partition values +INSERT INTO spectrum.web_logs +SELECT request_id, user_id, page_url, response_time, + YEAR(log_timestamp), MONTH(log_timestamp), DAY(log_timestamp) +FROM raw_web_logs; + +-- INSERT with aggregation +INSERT INTO spectrum.daily_summaries +SELECT product_category, + COUNT(*) as total_orders, + SUM(quantity) as total_quantity, + AVG(price) as avg_price, + '2024-05-15' +FROM local_orders +WHERE order_date = '2024-05-15' +GROUP BY product_category; + +-- INSERT with complex SELECT including CTEs (Common Table Expressions) +INSERT INTO spectrum.customer_metrics +WITH customer_totals AS ( + SELECT customer_id, + COUNT(DISTINCT order_id) as order_count, + SUM(total_amount) as lifetime_value + FROM orders + GROUP BY customer_id +) +SELECT c.customer_id, c.customer_name, ct.order_count, ct.lifetime_value, CURRENT_DATE +FROM customers c +JOIN customer_totals ct ON c.customer_id = ct.customer_id; + +-- INSERT with CASE expressions for partition columns +INSERT INTO spectrum.customer_segments +SELECT customer_id, + customer_name, + total_purchases, + CASE + WHEN total_purchases >= 1000 THEN 'premium' + WHEN total_purchases >= 100 THEN 'regular' + ELSE 'basic' + END, + YEAR(CURRENT_DATE), + MONTH(CURRENT_DATE) +FROM customer_purchase_summary; + +-- INSERT with multiple JOINs +INSERT INTO spectrum.product_performance +SELECT p.product_id, + p.product_name, + p.category, + COUNT(DISTINCT o.order_id) as order_count, + SUM(od.quantity) as total_quantity, + SUM(od.quantity * od.unit_price) as total_revenue +FROM products p +JOIN order_details od ON p.product_id = od.product_id +JOIN orders o ON od.order_id = o.order_id +WHERE o.order_date >= DATEADD(month, -3, CURRENT_DATE) +GROUP BY p.product_id, p.product_name, p.category; + +-- INSERT with window functions +INSERT INTO spectrum.customer_rankings +SELECT customer_id, + customer_name, + total_purchases, + RANK() OVER (ORDER BY total_purchases DESC) as purchase_rank, + NTILE(10) OVER (ORDER BY total_purchases DESC) as decile, + CURRENT_DATE +FROM customer_summary; + +-- INSERT with UNION ALL +INSERT INTO spectrum.all_events +SELECT event_id, 'order' as event_type, customer_id, event_timestamp +FROM order_events +UNION ALL +SELECT event_id, 'return' as event_type, customer_id, event_timestamp +FROM return_events; + +-- INSERT with subquery in SELECT list +INSERT INTO spectrum.product_comparisons +SELECT p1.product_id, + p1.product_name, + p1.price, + (SELECT AVG(price) FROM products p2 WHERE p2.category = p1.category) as category_avg_price, + p1.category +FROM products p1; + +-- INSERT with EXISTS clause +INSERT INTO spectrum.active_customers +SELECT c.customer_id, c.customer_name, c.email, CURRENT_DATE +FROM customers c +WHERE EXISTS ( + SELECT 1 + FROM orders o + WHERE o.customer_id = c.customer_id + AND o.order_date >= DATEADD(day, -30, CURRENT_DATE) +); + +-- INSERT with NOT IN clause +INSERT INTO spectrum.inactive_products +SELECT product_id, product_name, category, last_modified_date +FROM products +WHERE product_id NOT IN ( + SELECT DISTINCT product_id + FROM order_details + WHERE order_date >= DATEADD(month, -6, CURRENT_DATE) +); + +-- INSERT with multiple partition columns and complex expressions +INSERT INTO spectrum.hourly_metrics +SELECT server_id, + COUNT(*) as request_count, + AVG(response_time) as avg_response_time, + MAX(response_time) as max_response_time, + DATE_PART(year, request_timestamp), + DATE_PART(month, request_timestamp), + DATE_PART(day, request_timestamp), + DATE_PART(hour, request_timestamp) +FROM server_logs +GROUP BY server_id, + DATE_PART(year, request_timestamp), + DATE_PART(month, request_timestamp), + DATE_PART(day, request_timestamp), + DATE_PART(hour, request_timestamp); \ No newline at end of file diff --git a/redshift/examples/redshift/lock.sql b/redshift/examples/redshift/lock.sql new file mode 100644 index 0000000..19f38be --- /dev/null +++ b/redshift/examples/redshift/lock.sql @@ -0,0 +1,119 @@ +-- LOCK command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_LOCK.html + +-- Basic LOCK statement (defaults to ACCESS EXCLUSIVE mode) +LOCK event; +LOCK table1; +lock users; + +-- LOCK with TABLE keyword +LOCK TABLE event; +LOCK TABLE sales; +lock table customers; + +-- Multiple tables (from AWS documentation example) +LOCK event, sales; +LOCK TABLE event, sales; +lock table users, orders, products; + +-- Schema-qualified table names +LOCK public.event; +LOCK TABLE schema1.table1; +LOCK myschema.users, public.orders; + +-- LOCK with explicit lock modes +-- ACCESS SHARE (least restrictive) +LOCK event IN ACCESS SHARE MODE; +LOCK TABLE sales IN ACCESS SHARE MODE; +lock table users in access share mode; + +-- ROW SHARE +LOCK event IN ROW SHARE MODE; +LOCK TABLE sales IN ROW SHARE MODE; +lock table users in row share mode; + +-- ROW EXCLUSIVE +LOCK event IN ROW EXCLUSIVE MODE; +LOCK TABLE sales IN ROW EXCLUSIVE MODE; +lock table users in row exclusive mode; + +-- SHARE UPDATE EXCLUSIVE +LOCK event IN SHARE UPDATE EXCLUSIVE MODE; +LOCK TABLE sales IN SHARE UPDATE EXCLUSIVE MODE; +lock table users in share update exclusive mode; + +-- SHARE +LOCK event IN SHARE MODE; +LOCK TABLE sales IN SHARE MODE; +lock table users in share mode; + +-- SHARE ROW EXCLUSIVE +LOCK event IN SHARE ROW EXCLUSIVE MODE; +LOCK TABLE sales IN SHARE ROW EXCLUSIVE MODE; +lock table users in share row exclusive mode; + +-- EXCLUSIVE +LOCK event IN EXCLUSIVE MODE; +LOCK TABLE sales IN EXCLUSIVE MODE; +lock table users in exclusive mode; + +-- ACCESS EXCLUSIVE (most restrictive, default mode) +LOCK event IN ACCESS EXCLUSIVE MODE; +LOCK TABLE sales IN ACCESS EXCLUSIVE MODE; +lock table users in access exclusive mode; + +-- LOCK with NOWAIT option +LOCK event NOWAIT; +LOCK TABLE sales NOWAIT; +lock table users nowait; + +-- LOCK with explicit mode and NOWAIT +LOCK event IN ACCESS SHARE MODE NOWAIT; +LOCK TABLE sales IN ROW EXCLUSIVE MODE NOWAIT; +LOCK users IN EXCLUSIVE MODE NOWAIT; +lock table orders in share mode nowait; + +-- Multiple tables with lock mode +LOCK event, sales IN ACCESS SHARE MODE; +LOCK TABLE users, orders IN ROW EXCLUSIVE MODE; +lock products, categories in exclusive mode; + +-- Multiple tables with lock mode and NOWAIT +LOCK event, sales IN ACCESS SHARE MODE NOWAIT; +LOCK TABLE users, orders IN ROW EXCLUSIVE MODE NOWAIT; +lock products, categories in exclusive mode nowait; + +-- Schema-qualified tables with modes +LOCK public.event IN SHARE MODE; +LOCK TABLE schema1.users, schema2.orders IN ROW EXCLUSIVE MODE; +LOCK mydb.public.sales IN ACCESS EXCLUSIVE MODE NOWAIT; + +-- Mixed case variations +Lock Event; +LOCK table Sales; +lock TABLE Users in ACCESS share MODE; +Lock Table orders IN row EXCLUSIVE mode NOWAIT; + +-- Real-world examples from AWS documentation context +-- Lock tables before performing operations that need consistency +LOCK event, sales; +LOCK TABLE venue IN ACCESS EXCLUSIVE MODE; + +-- Lock with different modes for different scenarios +-- For SELECT operations that need consistent view +LOCK reporting_table IN ACCESS SHARE MODE; + +-- For UPDATE/INSERT/DELETE operations +LOCK transactional_table IN ROW EXCLUSIVE MODE; + +-- For schema changes +LOCK target_table IN ACCESS EXCLUSIVE MODE; + +-- Complex scenarios with multiple schema-qualified tables +LOCK public.fact_sales, staging.temp_data IN SHARE MODE NOWAIT; +LOCK TABLE analytics.user_metrics, public.session_data IN ROW EXCLUSIVE MODE; + +-- Edge cases with identifier names +LOCK "table with spaces"; +LOCK TABLE "Mixed_Case_Table" IN ACCESS SHARE MODE; +LOCK "schema"."table" IN EXCLUSIVE MODE NOWAIT; \ No newline at end of file diff --git a/redshift/examples/redshift/merge.sql b/redshift/examples/redshift/merge.sql new file mode 100644 index 0000000..3fc7497 --- /dev/null +++ b/redshift/examples/redshift/merge.sql @@ -0,0 +1,634 @@ +-- MERGE command examples from AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_MERGE.html + +-- Example 1: Basic MERGE with UPDATE and INSERT (from AWS docs) +MERGE INTO target_table +USING source_table +ON target_table.id = source_table.id +WHEN MATCHED THEN UPDATE SET name = source_table.name, value = source_table.value +WHEN NOT MATCHED THEN INSERT VALUES (source_table.id, source_table.name, source_table.value); + +-- Example 2: MERGE with DELETE action (from AWS docs) +MERGE INTO customer_table +USING temp_customer_data +ON customer_table.customer_id = temp_customer_data.customer_id +WHEN MATCHED THEN DELETE +WHEN NOT MATCHED THEN INSERT VALUES (temp_customer_data.customer_id, temp_customer_data.name, temp_customer_data.email); + +-- Example 3: MERGE with REMOVE DUPLICATES (from AWS docs) +MERGE INTO sales_data +USING new_sales_data +ON sales_data.sale_id = new_sales_data.sale_id +REMOVE DUPLICATES; + +-- Example 4: MERGE with table aliases +MERGE INTO inventory i +USING product_updates p +ON i.product_id = p.product_id +WHEN MATCHED THEN UPDATE SET quantity = p.quantity, price = p.price +WHEN NOT MATCHED THEN INSERT VALUES (p.product_id, p.quantity, p.price); + +-- Example 5: MERGE with schema-qualified table names +MERGE INTO sales.customer_data +USING staging.new_customers +ON sales.customer_data.customer_id = staging.new_customers.customer_id +WHEN MATCHED THEN UPDATE SET + name = staging.new_customers.name, + email = staging.new_customers.email, + last_updated = CURRENT_TIMESTAMP +WHEN NOT MATCHED THEN INSERT VALUES ( + staging.new_customers.customer_id, + staging.new_customers.name, + staging.new_customers.email, + CURRENT_TIMESTAMP +); + +-- Example 6: MERGE with subquery as source +MERGE INTO product_summary +USING ( + SELECT product_id, SUM(quantity) as total_qty, AVG(price) as avg_price + FROM product_transactions + WHERE transaction_date >= '2023-01-01' + GROUP BY product_id +) t +ON product_summary.product_id = t.product_id +WHEN MATCHED THEN UPDATE SET total_quantity = t.total_qty, average_price = t.avg_price +WHEN NOT MATCHED THEN INSERT VALUES (t.product_id, t.total_qty, t.avg_price); + +-- Example 7: MERGE with complex match condition +MERGE INTO employee_data +USING hr_updates +ON employee_data.emp_id = hr_updates.emp_id AND employee_data.department = hr_updates.department +WHEN MATCHED THEN UPDATE SET + salary = hr_updates.salary, + title = hr_updates.title, + manager_id = hr_updates.manager_id +WHEN NOT MATCHED THEN INSERT VALUES ( + hr_updates.emp_id, + hr_updates.department, + hr_updates.salary, + hr_updates.title, + hr_updates.manager_id +); + +-- Example 8: MERGE with multiple SET clauses +MERGE INTO user_profile +USING user_updates +ON user_profile.user_id = user_updates.user_id +WHEN MATCHED THEN UPDATE SET + first_name = user_updates.first_name, + last_name = user_updates.last_name, + email = user_updates.email, + phone = user_updates.phone, + address = user_updates.address, + last_modified = CURRENT_TIMESTAMP +WHEN NOT MATCHED THEN INSERT VALUES ( + user_updates.user_id, + user_updates.first_name, + user_updates.last_name, + user_updates.email, + user_updates.phone, + user_updates.address, + CURRENT_TIMESTAMP +); + +-- Example 9: MERGE with WHERE clause in subquery source +MERGE INTO active_customers +USING ( + SELECT customer_id, name, email, phone + FROM customer_staging + WHERE status = 'active' AND created_date >= '2023-01-01' +) active_data +ON active_customers.customer_id = active_data.customer_id +WHEN MATCHED THEN UPDATE SET + name = active_data.name, + email = active_data.email, + phone = active_data.phone +WHEN NOT MATCHED THEN INSERT VALUES ( + active_data.customer_id, + active_data.name, + active_data.email, + active_data.phone +); + +-- Example 10: MERGE with functions in expressions +MERGE INTO customer_metrics +USING daily_activity +ON customer_metrics.customer_id = daily_activity.customer_id +WHEN MATCHED THEN UPDATE SET + total_orders = customer_metrics.total_orders + daily_activity.order_count, + last_activity = GREATEST(customer_metrics.last_activity, daily_activity.activity_date), + average_order_value = (customer_metrics.total_revenue + daily_activity.revenue) / + (customer_metrics.total_orders + daily_activity.order_count) +WHEN NOT MATCHED THEN INSERT VALUES ( + daily_activity.customer_id, + daily_activity.order_count, + daily_activity.activity_date, + daily_activity.revenue / daily_activity.order_count +); + +-- Example 11: MERGE with quoted identifiers +MERGE INTO "Customer Data" +USING "New Customer Info" AS nci +ON "Customer Data"."Customer ID" = nci."Customer ID" +WHEN MATCHED THEN UPDATE SET + "Customer Name" = nci."Customer Name", + "Email Address" = nci."Email Address" +WHEN NOT MATCHED THEN INSERT VALUES ( + nci."Customer ID", + nci."Customer Name", + nci."Email Address" +); + +-- Example 12: MERGE with CASE expressions +MERGE INTO product_pricing +USING market_data +ON product_pricing.product_id = market_data.product_id +WHEN MATCHED THEN UPDATE SET + price = CASE + WHEN market_data.competitor_price > product_pricing.price THEN market_data.competitor_price * 0.95 + WHEN market_data.competitor_price < product_pricing.price THEN market_data.competitor_price * 1.05 + ELSE product_pricing.price + END, + last_updated = CURRENT_DATE +WHEN NOT MATCHED THEN INSERT VALUES ( + market_data.product_id, + market_data.competitor_price, + CURRENT_DATE +); + +-- Example 13: MERGE with NULL handling +MERGE INTO contact_info +USING contact_updates +ON contact_info.contact_id = contact_updates.contact_id +WHEN MATCHED THEN UPDATE SET + email = COALESCE(contact_updates.email, contact_info.email), + phone = COALESCE(contact_updates.phone, contact_info.phone), + address = COALESCE(contact_updates.address, contact_info.address) +WHEN NOT MATCHED THEN INSERT VALUES ( + contact_updates.contact_id, + contact_updates.email, + contact_updates.phone, + contact_updates.address +); + +-- Example 14: MERGE with string functions +MERGE INTO user_accounts +USING user_imports +ON UPPER(user_accounts.username) = UPPER(user_imports.username) +WHEN MATCHED THEN UPDATE SET + email = LOWER(user_imports.email), + full_name = INITCAP(user_imports.full_name), + last_login = user_imports.last_login +WHEN NOT MATCHED THEN INSERT VALUES ( + LOWER(user_imports.username), + LOWER(user_imports.email), + INITCAP(user_imports.full_name), + user_imports.last_login +); + +-- Example 15: MERGE with date/time functions +MERGE INTO sales_summary +USING daily_sales +ON sales_summary.sale_date = daily_sales.sale_date AND + sales_summary.region = daily_sales.region +WHEN MATCHED THEN UPDATE SET + total_amount = sales_summary.total_amount + daily_sales.amount, + transaction_count = sales_summary.transaction_count + daily_sales.count, + last_updated = CURRENT_TIMESTAMP +WHEN NOT MATCHED THEN INSERT VALUES ( + daily_sales.sale_date, + daily_sales.region, + daily_sales.amount, + daily_sales.count, + CURRENT_TIMESTAMP +); + +-- Example 16: MERGE with mathematical operations +MERGE INTO inventory_levels +USING inventory_adjustments +ON inventory_levels.item_id = inventory_adjustments.item_id +WHEN MATCHED THEN UPDATE SET + quantity = inventory_levels.quantity + inventory_adjustments.adjustment, + value = (inventory_levels.quantity + inventory_adjustments.adjustment) * inventory_levels.unit_cost, + last_adjustment = CURRENT_DATE +WHEN NOT MATCHED THEN INSERT VALUES ( + inventory_adjustments.item_id, + inventory_adjustments.adjustment, + inventory_adjustments.adjustment * inventory_adjustments.unit_cost, + inventory_adjustments.unit_cost, + CURRENT_DATE +); + +-- Example 17: MERGE with subquery in match condition +MERGE INTO premium_customers +USING customer_analysis +ON premium_customers.customer_id = customer_analysis.customer_id +WHEN MATCHED THEN UPDATE SET + tier_level = customer_analysis.calculated_tier, + annual_revenue = customer_analysis.total_revenue +WHEN NOT MATCHED AND customer_analysis.total_revenue > ( + SELECT AVG(total_revenue) * 2 FROM customer_analysis +) THEN INSERT VALUES ( + customer_analysis.customer_id, + customer_analysis.calculated_tier, + customer_analysis.total_revenue +); + +-- Example 18: MERGE with aggregate functions in source +MERGE INTO department_stats +USING ( + SELECT + department_id, + COUNT(*) as employee_count, + AVG(salary) as avg_salary, + MAX(hire_date) as latest_hire, + MIN(hire_date) as earliest_hire + FROM employees + GROUP BY department_id +) dept_agg +ON department_stats.department_id = dept_agg.department_id +WHEN MATCHED THEN UPDATE SET + total_employees = dept_agg.employee_count, + average_salary = dept_agg.avg_salary, + newest_hire = dept_agg.latest_hire, + oldest_hire = dept_agg.earliest_hire +WHEN NOT MATCHED THEN INSERT VALUES ( + dept_agg.department_id, + dept_agg.employee_count, + dept_agg.avg_salary, + dept_agg.latest_hire, + dept_agg.earliest_hire +); + +-- Example 19: MERGE with JOIN in source subquery +MERGE INTO customer_orders_summary +USING ( + SELECT + c.customer_id, + c.customer_name, + COUNT(o.order_id) as order_count, + SUM(o.total_amount) as total_spent, + MAX(o.order_date) as last_order_date + FROM customers c + LEFT JOIN orders o ON c.customer_id = o.customer_id + WHERE c.status = 'active' + GROUP BY c.customer_id, c.customer_name +) summary_data +ON customer_orders_summary.customer_id = summary_data.customer_id +WHEN MATCHED THEN UPDATE SET + customer_name = summary_data.customer_name, + total_orders = summary_data.order_count, + lifetime_value = summary_data.total_spent, + last_purchase = summary_data.last_order_date +WHEN NOT MATCHED THEN INSERT VALUES ( + summary_data.customer_id, + summary_data.customer_name, + summary_data.order_count, + summary_data.total_spent, + summary_data.last_order_date +); + +-- Example 20: MERGE with complex boolean expressions +MERGE INTO product_alerts +USING inventory_check +ON product_alerts.product_id = inventory_check.product_id +WHEN MATCHED AND (inventory_check.current_stock < inventory_check.reorder_point + OR inventory_check.days_until_expiry < 30) THEN UPDATE SET + alert_type = CASE + WHEN inventory_check.current_stock < inventory_check.reorder_point AND inventory_check.days_until_expiry < 30 + THEN 'LOW_STOCK_AND_EXPIRING' + WHEN inventory_check.current_stock < inventory_check.reorder_point + THEN 'LOW_STOCK' + ELSE 'EXPIRING_SOON' + END, + alert_date = CURRENT_DATE, + current_quantity = inventory_check.current_stock +WHEN NOT MATCHED AND (inventory_check.current_stock < inventory_check.reorder_point + OR inventory_check.days_until_expiry < 30) THEN INSERT VALUES ( + inventory_check.product_id, + CASE + WHEN inventory_check.current_stock < inventory_check.reorder_point AND inventory_check.days_until_expiry < 30 + THEN 'LOW_STOCK_AND_EXPIRING' + WHEN inventory_check.current_stock < inventory_check.reorder_point + THEN 'LOW_STOCK' + ELSE 'EXPIRING_SOON' + END, + CURRENT_DATE, + inventory_check.current_stock +); + +-- Example 21: MERGE with window functions in source (via subquery) +MERGE INTO sales_rankings +USING ( + SELECT + salesperson_id, + sales_amount, + RANK() OVER (ORDER BY sales_amount DESC) as sales_rank, + PERCENT_RANK() OVER (ORDER BY sales_amount DESC) as percentile_rank + FROM ( + SELECT salesperson_id, SUM(amount) as sales_amount + FROM sales_transactions + WHERE transaction_date >= DATE_TRUNC('month', CURRENT_DATE) + GROUP BY salesperson_id + ) monthly_sales +) rankings +ON sales_rankings.salesperson_id = rankings.salesperson_id +WHEN MATCHED THEN UPDATE SET + monthly_sales = rankings.sales_amount, + rank_position = rankings.sales_rank, + performance_percentile = rankings.percentile_rank, + last_updated = CURRENT_DATE +WHEN NOT MATCHED THEN INSERT VALUES ( + rankings.salesperson_id, + rankings.sales_amount, + rankings.sales_rank, + rankings.performance_percentile, + CURRENT_DATE +); + +-- Example 22: MERGE with type casting +MERGE INTO financial_metrics +USING raw_financial_data +ON financial_metrics.account_id = raw_financial_data.account_id::INTEGER +WHEN MATCHED THEN UPDATE SET + balance = raw_financial_data.balance_text::DECIMAL(15,2), + interest_rate = raw_financial_data.rate_text::NUMERIC(5,4), + last_transaction = raw_financial_data.transaction_date::DATE +WHEN NOT MATCHED THEN INSERT VALUES ( + raw_financial_data.account_id::INTEGER, + raw_financial_data.balance_text::DECIMAL(15,2), + raw_financial_data.rate_text::NUMERIC(5,4), + raw_financial_data.transaction_date::DATE +); + +-- Example 23: MERGE with BETWEEN conditions +MERGE INTO age_demographics +USING customer_ages +ON age_demographics.age_group = + CASE + WHEN customer_ages.age BETWEEN 18 AND 25 THEN '18-25' + WHEN customer_ages.age BETWEEN 26 AND 35 THEN '26-35' + WHEN customer_ages.age BETWEEN 36 AND 50 THEN '36-50' + WHEN customer_ages.age BETWEEN 51 AND 65 THEN '51-65' + ELSE '65+' + END +WHEN MATCHED THEN UPDATE SET + customer_count = age_demographics.customer_count + 1, + total_revenue = age_demographics.total_revenue + customer_ages.annual_spending +WHEN NOT MATCHED THEN INSERT VALUES ( + CASE + WHEN customer_ages.age BETWEEN 18 AND 25 THEN '18-25' + WHEN customer_ages.age BETWEEN 26 AND 35 THEN '26-35' + WHEN customer_ages.age BETWEEN 36 AND 50 THEN '36-50' + WHEN customer_ages.age BETWEEN 51 AND 65 THEN '51-65' + ELSE '65+' + END, + 1, + customer_ages.annual_spending +); + +-- Example 24: MERGE with IN clause +MERGE INTO priority_customers +USING customer_data +ON priority_customers.customer_id = customer_data.customer_id +WHEN MATCHED AND customer_data.tier IN ('gold', 'platinum', 'diamond') THEN UPDATE SET + tier_level = customer_data.tier, + priority_score = CASE customer_data.tier + WHEN 'diamond' THEN 100 + WHEN 'platinum' THEN 75 + WHEN 'gold' THEN 50 + ELSE 25 + END, + last_updated = CURRENT_TIMESTAMP +WHEN NOT MATCHED AND customer_data.tier IN ('gold', 'platinum', 'diamond') THEN INSERT VALUES ( + customer_data.customer_id, + customer_data.tier, + CASE customer_data.tier + WHEN 'diamond' THEN 100 + WHEN 'platinum' THEN 75 + WHEN 'gold' THEN 50 + ELSE 25 + END, + CURRENT_TIMESTAMP +); + +-- Example 25: MERGE with LIKE pattern matching +MERGE INTO email_domains +USING ( + SELECT DISTINCT + SUBSTRING(email FROM '@(.+)$') as domain, + COUNT(*) as user_count + FROM user_registrations + WHERE email LIKE '%@%' + GROUP BY SUBSTRING(email FROM '@(.+)$') +) domain_stats +ON email_domains.domain_name = domain_stats.domain +WHEN MATCHED THEN UPDATE SET + registration_count = email_domains.registration_count + domain_stats.user_count, + last_updated = CURRENT_DATE +WHEN NOT MATCHED THEN INSERT VALUES ( + domain_stats.domain, + domain_stats.user_count, + CURRENT_DATE +); + +-- Example 26: MERGE with EXISTS subquery +MERGE INTO active_products +USING product_catalog +ON active_products.product_id = product_catalog.product_id +WHEN MATCHED AND EXISTS ( + SELECT 1 FROM recent_sales + WHERE recent_sales.product_id = product_catalog.product_id + AND sale_date >= CURRENT_DATE - 90 +) THEN UPDATE SET + status = 'active', + last_sale_date = ( + SELECT MAX(sale_date) FROM recent_sales + WHERE recent_sales.product_id = product_catalog.product_id + ), + total_sales = ( + SELECT COUNT(*) FROM recent_sales + WHERE recent_sales.product_id = product_catalog.product_id + AND sale_date >= CURRENT_DATE - 90 + ) +WHEN NOT MATCHED AND EXISTS ( + SELECT 1 FROM recent_sales + WHERE recent_sales.product_id = product_catalog.product_id + AND sale_date >= CURRENT_DATE - 90 +) THEN INSERT VALUES ( + product_catalog.product_id, + 'active', + (SELECT MAX(sale_date) FROM recent_sales + WHERE recent_sales.product_id = product_catalog.product_id), + (SELECT COUNT(*) FROM recent_sales + WHERE recent_sales.product_id = product_catalog.product_id + AND sale_date >= CURRENT_DATE - 90) +); + +-- Example 27: MERGE with NOT EXISTS +MERGE INTO inactive_customers +USING all_customers +ON inactive_customers.customer_id = all_customers.customer_id +WHEN MATCHED AND NOT EXISTS ( + SELECT 1 FROM recent_orders + WHERE recent_orders.customer_id = all_customers.customer_id + AND order_date >= CURRENT_DATE - 365 +) THEN UPDATE SET + days_inactive = CURRENT_DATE - ( + SELECT MAX(order_date) FROM customer_orders + WHERE customer_orders.customer_id = all_customers.customer_id + ), + status = 'inactive' +WHEN NOT MATCHED AND NOT EXISTS ( + SELECT 1 FROM recent_orders + WHERE recent_orders.customer_id = all_customers.customer_id + AND order_date >= CURRENT_DATE - 365 +) THEN INSERT VALUES ( + all_customers.customer_id, + all_customers.customer_name, + CURRENT_DATE - ( + SELECT MAX(order_date) FROM customer_orders + WHERE customer_orders.customer_id = all_customers.customer_id + ), + 'inactive' +); + +-- Example 28: MERGE with IS NULL conditions +MERGE INTO customer_contacts +USING customer_updates +ON customer_contacts.customer_id = customer_updates.customer_id +WHEN MATCHED THEN UPDATE SET + email = CASE WHEN customer_updates.email IS NOT NULL THEN customer_updates.email ELSE customer_contacts.email END, + phone = CASE WHEN customer_updates.phone IS NOT NULL THEN customer_updates.phone ELSE customer_contacts.phone END, + address = CASE WHEN customer_updates.address IS NOT NULL THEN customer_updates.address ELSE customer_contacts.address END, + updated_fields = ( + CASE WHEN customer_updates.email IS NOT NULL THEN 'email,' ELSE '' END || + CASE WHEN customer_updates.phone IS NOT NULL THEN 'phone,' ELSE '' END || + CASE WHEN customer_updates.address IS NOT NULL THEN 'address,' ELSE '' END + ) +WHEN NOT MATCHED THEN INSERT VALUES ( + customer_updates.customer_id, + customer_updates.email, + customer_updates.phone, + customer_updates.address, + 'new_record' +); + +-- Example 29: MERGE with complex JOIN in source +MERGE INTO order_fulfillment_stats +USING ( + SELECT + o.order_id, + o.customer_id, + o.order_date, + s.shipment_date, + COALESCE(s.shipment_date - o.order_date, 0) as processing_days, + CASE WHEN s.shipment_date IS NULL THEN 'pending' ELSE 'shipped' END as status + FROM orders o + LEFT JOIN shipments s ON o.order_id = s.order_id + WHERE o.order_date >= CURRENT_DATE - 30 +) order_data +ON order_fulfillment_stats.order_id = order_data.order_id +WHEN MATCHED THEN UPDATE SET + shipment_date = order_data.shipment_date, + processing_time = order_data.processing_days, + fulfillment_status = order_data.status, + last_updated = CURRENT_TIMESTAMP +WHEN NOT MATCHED THEN INSERT VALUES ( + order_data.order_id, + order_data.customer_id, + order_data.order_date, + order_data.shipment_date, + order_data.processing_days, + order_data.status, + CURRENT_TIMESTAMP +); + +-- Example 30: MERGE with only DELETE action (cleanup operation) +MERGE INTO temp_processing_data +USING cleanup_list +ON temp_processing_data.record_id = cleanup_list.record_id +WHEN MATCHED THEN DELETE; + +-- Example 31: MERGE with only INSERT action (new records only) +MERGE INTO new_user_queue +USING user_registrations +ON new_user_queue.user_id = user_registrations.user_id +WHEN NOT MATCHED THEN INSERT VALUES ( + user_registrations.user_id, + user_registrations.email, + user_registrations.registration_date, + 'pending_verification' +); + +-- Example 32: Simple REMOVE DUPLICATES with minimal syntax +MERGE INTO sales_transactions +USING sales_staging +ON sales_transactions.transaction_id = sales_staging.transaction_id +REMOVE DUPLICATES; + +-- Example 33: MERGE with all three actions (UPDATE, DELETE, INSERT) +MERGE INTO product_inventory +USING product_updates +ON product_inventory.product_id = product_updates.product_id +WHEN MATCHED AND product_updates.action_type = 'delete' THEN DELETE +WHEN MATCHED AND product_updates.action_type = 'update' THEN UPDATE SET + quantity = product_updates.quantity, + price = product_updates.price, + last_updated = CURRENT_TIMESTAMP +WHEN NOT MATCHED AND product_updates.action_type = 'insert' THEN INSERT VALUES ( + product_updates.product_id, + product_updates.quantity, + product_updates.price, + CURRENT_TIMESTAMP +); + +-- Example 34: MERGE with complex expressions in VALUES +MERGE INTO calculated_metrics +USING base_data +ON calculated_metrics.metric_id = base_data.metric_id +WHEN MATCHED THEN UPDATE SET + calculated_value = base_data.raw_value * base_data.multiplier + base_data.offset, + confidence_score = CASE + WHEN base_data.sample_size >= 1000 THEN 0.95 + WHEN base_data.sample_size >= 100 THEN 0.85 + ELSE 0.70 + END +WHEN NOT MATCHED THEN INSERT VALUES ( + base_data.metric_id, + base_data.raw_value * base_data.multiplier + base_data.offset, + CASE + WHEN base_data.sample_size >= 1000 THEN 0.95 + WHEN base_data.sample_size >= 100 THEN 0.85 + ELSE 0.70 + END, + CURRENT_DATE +); + +-- Example 35: MERGE with ORDER BY in source subquery +MERGE INTO top_performers +USING ( + SELECT employee_id, performance_score, performance_rank + FROM ( + SELECT + employee_id, + performance_score, + ROW_NUMBER() OVER (ORDER BY performance_score DESC) as performance_rank + FROM employee_evaluations + WHERE evaluation_date >= DATE_TRUNC('quarter', CURRENT_DATE) + ) ranked_employees + WHERE performance_rank <= 10 + ORDER BY performance_rank +) top_10 +ON top_performers.employee_id = top_10.employee_id +WHEN MATCHED THEN UPDATE SET + quarterly_score = top_10.performance_score, + rank_position = top_10.performance_rank, + quarter_year = DATE_TRUNC('quarter', CURRENT_DATE) +WHEN NOT MATCHED THEN INSERT VALUES ( + top_10.employee_id, + top_10.performance_score, + top_10.performance_rank, + DATE_TRUNC('quarter', CURRENT_DATE) +); \ No newline at end of file diff --git a/redshift/examples/redshift/prepare.sql b/redshift/examples/redshift/prepare.sql new file mode 100644 index 0000000..d14f98e --- /dev/null +++ b/redshift/examples/redshift/prepare.sql @@ -0,0 +1,290 @@ +-- PREPARE command test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_PREPARE.html + +-- Basic PREPARE statement without parameter types +PREPARE simple_plan AS SELECT * FROM users; + +-- PREPARE with single parameter type +PREPARE prep_select_plan (int) AS SELECT * FROM prep1 WHERE c1 = $1; + +-- PREPARE with multiple parameter types +PREPARE prep_insert_plan (int, char) AS INSERT INTO prep1 VALUES ($1, $2); + +-- Examples from AWS documentation: + +-- Example 1: Create a table and prepare an insert statement +PREPARE prep_insert_plan (int, char) AS INSERT INTO prep1 VALUES ($1, $2); + +-- Example 2: Prepare a select statement with parameter +PREPARE prep_select_plan (int) AS SELECT * FROM prep1 WHERE c1 = $1; + +-- Data type variations: + +-- Character data types +PREPARE char_plan (char) AS INSERT INTO test VALUES ($1); +PREPARE char_precision (char(10)) AS INSERT INTO test VALUES ($1); +PREPARE varchar_plan (varchar) AS INSERT INTO test VALUES ($1); +PREPARE varchar_precision (varchar(255)) AS INSERT INTO test VALUES ($1); +PREPARE text_plan (text) AS INSERT INTO test VALUES ($1); + +-- Numeric data types +PREPARE smallint_plan (smallint) AS INSERT INTO test VALUES ($1); +PREPARE integer_plan (integer) AS INSERT INTO test VALUES ($1); +PREPARE int_plan (int) AS INSERT INTO test VALUES ($1); +PREPARE bigint_plan (bigint) AS INSERT INTO test VALUES ($1); +PREPARE decimal_plan (decimal) AS INSERT INTO test VALUES ($1); +PREPARE decimal_precision (decimal(10,2)) AS INSERT INTO test VALUES ($1); +PREPARE numeric_plan (numeric) AS INSERT INTO test VALUES ($1); +PREPARE numeric_precision (numeric(18,4)) AS INSERT INTO test VALUES ($1); +PREPARE real_plan (real) AS INSERT INTO test VALUES ($1); +PREPARE double_precision_plan (double precision) AS INSERT INTO test VALUES ($1); +PREPARE float_plan (float) AS INSERT INTO test VALUES ($1); +PREPARE float_precision (float(24)) AS INSERT INTO test VALUES ($1); + +-- Date/time data types +PREPARE date_plan (date) AS INSERT INTO test VALUES ($1); +PREPARE time_plan (time) AS INSERT INTO test VALUES ($1); +PREPARE time_precision (time(6)) AS INSERT INTO test VALUES ($1); +PREPARE timestamp_plan (timestamp) AS INSERT INTO test VALUES ($1); +PREPARE timestamp_precision (timestamp(6)) AS INSERT INTO test VALUES ($1); +PREPARE timestamptz_plan (timestamptz) AS INSERT INTO test VALUES ($1); + +-- Boolean data type +PREPARE boolean_plan (boolean) AS INSERT INTO test VALUES ($1); +PREPARE bool_plan (bool) AS INSERT INTO test VALUES ($1); + +-- Multiple parameter types +PREPARE multi_type_plan (int, varchar(50), date) AS + INSERT INTO users (id, name, created_date) VALUES ($1, $2, $3); + +PREPARE complex_types (bigint, decimal(15,2), timestamp, boolean, text) AS + INSERT INTO orders (order_id, amount, order_date, is_active, notes) + VALUES ($1, $2, $3, $4, $5); + +-- SELECT statement variations: + +-- Basic SELECT with WHERE clause +PREPARE select_by_id (int) AS SELECT * FROM customers WHERE customer_id = $1; + +-- SELECT with multiple conditions +PREPARE select_by_criteria (varchar(50), date, boolean) AS + SELECT * FROM orders WHERE status = $1 AND order_date >= $2 AND is_processed = $3; + +-- SELECT with JOIN +PREPARE select_with_join (int) AS + SELECT c.name, o.total FROM customers c JOIN orders o ON c.id = o.customer_id + WHERE c.id = $1; + +-- SELECT with GROUP BY +PREPARE select_aggregated (date) AS + SELECT customer_id, COUNT(*), SUM(total) FROM orders + WHERE order_date >= $1 GROUP BY customer_id; + +-- SELECT with ORDER BY and LIMIT +PREPARE select_top_customers (int) AS + SELECT customer_id, SUM(total) as total_spent FROM orders + GROUP BY customer_id ORDER BY total_spent DESC LIMIT $1; + +-- INSERT statement variations: + +-- Basic INSERT with VALUES +PREPARE insert_customer (varchar(100), varchar(50)) AS + INSERT INTO customers (name, email) VALUES ($1, $2); + +-- INSERT with multiple value sets (using single parameter per value) +PREPARE insert_multiple_products (varchar(50), decimal(10,2)) AS + INSERT INTO products (product_name, price) VALUES ($1, $2); + +-- INSERT with SELECT +PREPARE insert_from_select (date) AS + INSERT INTO monthly_summary (customer_id, total_orders, total_amount) + SELECT customer_id, COUNT(*), SUM(amount) FROM orders + WHERE order_date >= $1 GROUP BY customer_id; + +-- UPDATE statement variations: + +-- Basic UPDATE +PREPARE update_customer_email (varchar(100), int) AS + UPDATE customers SET email = $1 WHERE customer_id = $2; + +-- UPDATE with multiple columns +PREPARE update_order_status (varchar(20), timestamp, int) AS + UPDATE orders SET status = $1, updated_at = $2 WHERE order_id = $3; + +-- UPDATE with condition using multiple parameters +PREPARE update_product_price (decimal(10,2), varchar(50), boolean) AS + UPDATE products SET price = $1 WHERE category = $2 AND is_active = $3; + +-- DELETE statement variations: + +-- Basic DELETE +PREPARE delete_customer (int) AS DELETE FROM customers WHERE customer_id = $1; + +-- DELETE with multiple conditions +PREPARE delete_old_orders (date, varchar(20)) AS + DELETE FROM orders WHERE order_date < $1 AND status = $2; + +-- DELETE with subquery condition +PREPARE delete_inactive_customers (date) AS + DELETE FROM customers WHERE customer_id NOT IN + (SELECT DISTINCT customer_id FROM orders WHERE order_date >= $1); + +-- Complex query examples: + +-- Window function query +PREPARE sales_ranking (date, date) AS + SELECT salesperson, SUM(amount) as total_sales, + RANK() OVER (ORDER BY SUM(amount) DESC) as rank + FROM sales WHERE sale_date BETWEEN $1 AND $2 + GROUP BY salesperson; + +-- CTE (Common Table Expression) query +PREPARE monthly_report (date) AS + WITH monthly_sales AS ( + SELECT customer_id, SUM(amount) as total + FROM orders WHERE order_date >= $1 + GROUP BY customer_id + ) + SELECT c.name, ms.total FROM customers c + JOIN monthly_sales ms ON c.id = ms.customer_id + ORDER BY ms.total DESC; + +-- Subquery examples +PREPARE customers_above_average (date) AS + SELECT * FROM customers WHERE customer_id IN ( + SELECT customer_id FROM orders + WHERE order_date >= $1 + GROUP BY customer_id + HAVING SUM(amount) > (SELECT AVG(total_amount) FROM ( + SELECT customer_id, SUM(amount) as total_amount + FROM orders GROUP BY customer_id + ) avg_calc) + ); + +-- Parameter placeholder variations (up to the documented limit): + +-- Multiple parameters in different positions +PREPARE param_positions (int, varchar(50), date, decimal(10,2), boolean) AS + SELECT * FROM transactions + WHERE user_id = $1 AND description LIKE $2 AND trans_date >= $3 + AND amount >= $4 AND is_verified = $5; + +-- Parameters in different clauses +PREPARE multi_clause_params (varchar(50), int, decimal(10,2)) AS + SELECT category, COUNT(*) as count, AVG(price) as avg_price + FROM products + WHERE category = $1 + GROUP BY category + HAVING COUNT(*) >= $2 AND AVG(price) <= $3; + +-- Case sensitivity tests: +prepare lowercase_plan (int) as select * from test where id = $1; +PREPARE uppercase_plan (INT) AS SELECT * FROM TEST WHERE ID = $1; +Prepare mixed_case_plan (Integer) As Select * From test Where id = $1; + +-- Plan name variations: +PREPARE simple_name (int) AS SELECT $1; +PREPARE plan_with_underscore (int) AS SELECT $1; +PREPARE plan123 (int) AS SELECT $1; +PREPARE very_long_plan_name_with_many_words (int) AS SELECT $1; +PREPARE a (int) AS SELECT $1; +PREPARE z (int) AS SELECT $1; +PREPARE plan_1 (int) AS SELECT $1; +PREPARE my_plan_v2 (int) AS SELECT $1; + +-- Real-world business logic examples: + +-- Customer management +PREPARE get_customer_orders (int, date) AS + SELECT o.order_id, o.order_date, o.total, o.status + FROM orders o WHERE o.customer_id = $1 AND o.order_date >= $2 + ORDER BY o.order_date DESC; + +-- Inventory management +PREPARE update_stock_level (int, int) AS + UPDATE products SET stock_quantity = stock_quantity - $2 WHERE product_id = $1; + +-- Financial reporting +PREPARE revenue_by_period (date, date) AS + SELECT DATE_TRUNC('month', order_date) as month, SUM(total) as revenue + FROM orders WHERE order_date BETWEEN $1 AND $2 + GROUP BY DATE_TRUNC('month', order_date) + ORDER BY month; + +-- User authentication +PREPARE validate_user (varchar(100), varchar(255)) AS + SELECT user_id, role, last_login FROM users + WHERE email = $1 AND password_hash = $2 AND is_active = true; + +-- Analytics queries +PREPARE top_selling_products (int, date) AS + SELECT p.product_name, SUM(oi.quantity) as total_sold, SUM(oi.quantity * oi.price) as revenue + FROM products p + JOIN order_items oi ON p.product_id = oi.product_id + JOIN orders o ON oi.order_id = o.order_id + WHERE o.order_date >= $2 + GROUP BY p.product_id, p.product_name + ORDER BY total_sold DESC + LIMIT $1; + +-- Data cleanup operations +PREPARE archive_old_data (date) AS + INSERT INTO archived_orders SELECT * FROM orders WHERE order_date < $1; + +PREPARE cleanup_temp_data (timestamp) AS + DELETE FROM temp_processing_log WHERE created_at < $1; + +-- Redshift-specific features in prepared statements: + +-- UNLOAD command preparation (simplified representation) +PREPARE export_customer_data (date) AS + SELECT customer_id, name, email FROM customers WHERE created_date >= $1; + +-- Advanced analytics with window functions +PREPARE customer_lifetime_value (int) AS + SELECT customer_id, + SUM(total) OVER (PARTITION BY customer_id ORDER BY order_date + ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as running_total, + LAG(order_date, 1) OVER (PARTITION BY customer_id ORDER BY order_date) as prev_order_date + FROM orders WHERE customer_id = $1 ORDER BY order_date; + +-- JSON operations (if supported) +PREPARE json_extract_query (varchar(100)) AS + SELECT customer_id, JSON_EXTRACT_PATH_TEXT(profile_data, $1) as extracted_value + FROM customer_profiles WHERE profile_data IS NOT NULL; + +-- Working with arrays (if supported) +PREPARE array_operations (int) AS + SELECT order_id, item_ids[1:$1] as first_n_items + FROM order_summary WHERE ARRAY_LENGTH(item_ids, 1) >= $1; + +-- Error handling scenarios (these should still parse correctly): + +-- Minimum parameters (1 parameter) +PREPARE single_param (int) AS SELECT $1; + +-- Edge case with parameter at end +PREPARE param_at_end (varchar(50)) AS + SELECT * FROM logs WHERE message LIKE '%error%' ORDER BY timestamp DESC LIMIT $1; + +-- Multiple tables with parameters +PREPARE cross_table_query (int, varchar(50), date) AS + SELECT u.name, p.title, o.order_date + FROM users u + JOIN profiles p ON u.id = p.user_id + JOIN orders o ON u.id = o.customer_id + WHERE u.id = $1 AND p.department = $2 AND o.order_date >= $3; + +-- Nested function calls with parameters +PREPARE nested_functions (varchar(50), int) AS + SELECT UPPER(SUBSTRING($1, 1, $2)) as formatted_text; + +-- Mathematical operations with parameters +PREPARE math_operations (decimal(10,2), decimal(10,2), int) AS + SELECT $1 * $2 as product, POWER($1, $3) as power_result; + +-- String operations with parameters +PREPARE string_operations (varchar(100), varchar(10)) AS + SELECT CONCAT($1, ' - ', $2) as combined, + LENGTH($1) as text_length, + POSITION($2 IN $1) as substring_position; \ No newline at end of file diff --git a/redshift/examples/redshift/refresh_materialized_view.sql b/redshift/examples/redshift/refresh_materialized_view.sql new file mode 100644 index 0000000..fc0b882 --- /dev/null +++ b/redshift/examples/redshift/refresh_materialized_view.sql @@ -0,0 +1,80 @@ +-- REFRESH MATERIALIZED VIEW command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-refresh-sql-command.html + +-- Basic REFRESH MATERIALIZED VIEW statements +REFRESH MATERIALIZED VIEW tickets_mv; +refresh materialized view tickets_mv; + +-- With schema qualification +REFRESH MATERIALIZED VIEW myschema.products_mv; +refresh materialized view sales_schema.monthly_sales_mv; + +-- With quoted identifiers +REFRESH MATERIALIZED VIEW "MyMaterializedView"; +REFRESH MATERIALIZED VIEW "my schema"."my view"; + +-- REFRESH with RESTRICT option (default behavior) +REFRESH MATERIALIZED VIEW tickets_mv RESTRICT; +refresh materialized view products_mv restrict; +REFRESH MATERIALIZED VIEW myschema.sales_mv RESTRICT; + +-- REFRESH with CASCADE option +REFRESH MATERIALIZED VIEW products_mv CASCADE; +refresh materialized view tickets_mv cascade; +REFRESH MATERIALIZED VIEW sales_schema.base_mv CASCADE; + +-- Mixed case variations +Refresh Materialized View my_mv; +REFRESH materialized VIEW my_mv; +refresh MATERIALIZED view my_mv; +REFRESH MATERIALIZED VIEW My_Mv; + +-- Examples from AWS documentation +-- Basic refresh for a tickets materialized view +REFRESH MATERIALIZED VIEW tickets_mv; + +-- Cascading refresh for dependent materialized views +REFRESH MATERIALIZED VIEW products_mv CASCADE; + +-- Real-world scenarios +-- Refresh a materialized view that aggregates sales data +REFRESH MATERIALIZED VIEW daily_sales_summary; + +-- Refresh with cascade for nested materialized views +-- where sales_summary_mv depends on other MVs +REFRESH MATERIALIZED VIEW sales_summary_mv CASCADE; + +-- Refresh materialized views in different schemas +REFRESH MATERIALIZED VIEW analytics.customer_metrics; +REFRESH MATERIALIZED VIEW reporting.revenue_summary; +REFRESH MATERIALIZED VIEW dwh.fact_sales_mv; + +-- Refresh with RESTRICT to avoid refreshing dependent views +REFRESH MATERIALIZED VIEW base_customers_mv RESTRICT; +REFRESH MATERIALIZED VIEW raw_data.source_mv RESTRICT; + +-- Complex schema and view names +REFRESH MATERIALIZED VIEW "2024_sales"."Q1_summary"; +REFRESH MATERIALIZED VIEW "sales-data"."monthly_metrics_v2"; +REFRESH MATERIALIZED VIEW prod_schema."USER_ACTIVITY_MV"; + +-- Edge cases with special characters in names +REFRESH MATERIALIZED VIEW "my-mv-with-dashes"; +REFRESH MATERIALIZED VIEW "MV_With_Mixed_Case"; +REFRESH MATERIALIZED VIEW "mv with spaces"; + +-- Multiple refresh statements in sequence +REFRESH MATERIALIZED VIEW base_table_mv RESTRICT; +REFRESH MATERIALIZED VIEW dependent_mv_1 RESTRICT; +REFRESH MATERIALIZED VIEW dependent_mv_2 RESTRICT; +REFRESH MATERIALIZED VIEW top_level_mv CASCADE; + +-- Refresh materialized views for data lake integrations +REFRESH MATERIALIZED VIEW lake_house.external_data_mv; +REFRESH MATERIALIZED VIEW zero_etl.integration_mv CASCADE; + +-- Refresh materialized views for different use cases +REFRESH MATERIALIZED VIEW inventory.stock_levels; +REFRESH MATERIALIZED VIEW marketing.campaign_performance; +REFRESH MATERIALIZED VIEW finance.quarterly_reports CASCADE; +REFRESH MATERIALIZED VIEW operations.kpi_dashboard RESTRICT; \ No newline at end of file diff --git a/redshift/examples/redshift/reset.sql b/redshift/examples/redshift/reset.sql new file mode 100644 index 0000000..e2ecedd --- /dev/null +++ b/redshift/examples/redshift/reset.sql @@ -0,0 +1,53 @@ +-- Test cases for RESET command +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_RESET.html + +-- Basic RESET with specific parameter +RESET query_group; +RESET search_path; +RESET datestyle; +RESET timezone; +RESET statement_timeout; + +-- RESET ALL - resets all runtime parameters and session context variables +RESET ALL; + +-- Reset context variables (session context variables) +RESET app_context.user_id; +RESET app_context.tenant_id; +RESET session_context.application_name; +RESET custom_context.department; + +-- Common configuration parameters that can be reset +RESET enable_result_cache_for_session; +RESET wlm_json_configuration; +RESET max_concurrency_scaling_clusters; +RESET spectrum_enable_pseudo_columns; + +-- Case variations +reset query_group; +Reset ALL; +RESET all; + +-- Multiple RESET statements in sequence +RESET query_group; +RESET search_path; +RESET ALL; + +-- RESET after SET operations (common usage pattern) +SET query_group TO 'high_priority'; +-- ... execute queries ... +RESET query_group; + +SET search_path TO myschema, public; +-- ... execute queries ... +RESET search_path; + +-- Session variables reset +SET app_context.user_id TO 12345; +-- ... execute queries ... +RESET app_context.user_id; + +-- Error cases that should be tested (parser should handle gracefully) +-- RESET; -- Missing parameter +-- RESET query_group search_path; -- Multiple parameters not allowed +-- RESET (query_group); -- Invalid syntax with parentheses \ No newline at end of file diff --git a/redshift/examples/redshift/revoke.sql b/redshift/examples/redshift/revoke.sql new file mode 100644 index 0000000..09e0b88 --- /dev/null +++ b/redshift/examples/redshift/revoke.sql @@ -0,0 +1,307 @@ +-- REVOKE test cases based on AWS Redshift documentation +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_REVOKE.html + +-- Basic table privileges +REVOKE SELECT ON TABLE sales FROM dbuser; +REVOKE INSERT, UPDATE, DELETE ON TABLE sales FROM dbuser; +REVOKE ALL ON TABLE sales FROM dbuser; +REVOKE ALL PRIVILEGES ON TABLE sales FROM dbuser; +REVOKE ALTER, DROP, TRUNCATE, REFERENCES ON TABLE sales FROM admin_user; + +-- Table privileges from multiple users +REVOKE SELECT ON TABLE sales FROM user1, user2, user3; +REVOKE INSERT ON sales FROM dbuser1, dbuser2; + +-- Revoke GRANT OPTION only (users keep the privilege but can't grant it) +REVOKE GRANT OPTION FOR SELECT ON TABLE sales FROM dbuser; +REVOKE GRANT OPTION FOR ALL ON TABLE sales FROM dbuser; + +-- Column-level privileges +REVOKE SELECT (col1) ON TABLE t1 FROM PUBLIC; +REVOKE UPDATE (col1, col2) ON TABLE t1 FROM user1; +REVOKE SELECT (customer_id, customer_name) ON TABLE customers FROM analyst; +REVOKE ALL (order_id, order_date, order_total) ON orders FROM report_user; + +-- Revoke from PUBLIC +REVOKE SELECT ON TABLE public_data FROM PUBLIC; +REVOKE USAGE ON SCHEMA public FROM PUBLIC; + +-- Revoke from ROLE and GROUP +REVOKE SELECT ON TABLE sales FROM ROLE analyst_role; +REVOKE INSERT ON TABLE logs FROM GROUP etl_group; +REVOKE ALL ON TABLE temp_data FROM ROLE temp_role, GROUP admin_group; + +-- All tables in schema +REVOKE SELECT ON ALL TABLES IN SCHEMA myschema FROM dbuser; +REVOKE ALL ON ALL TABLES IN SCHEMA reporting FROM ROLE report_role; + +-- Database privileges +REVOKE CREATE ON DATABASE mydb FROM dbuser; +REVOKE USAGE ON DATABASE prod_db FROM readonly_user; +REVOKE TEMPORARY ON DATABASE session_db FROM temp_user; +REVOKE TEMP ON DATABASE session_db FROM temp_user; +REVOKE ALTER ON DATABASE mydb FROM admin_user; +REVOKE ALL ON DATABASE mydb FROM dba_role; +REVOKE ALL PRIVILEGES ON DATABASE mydb FROM admin_group; + +-- Database privileges with CASCADE/RESTRICT +REVOKE CREATE ON DATABASE mydb FROM dbuser CASCADE; +REVOKE ALL ON DATABASE mydb FROM admin RESTRICT; + +-- Schema privileges +REVOKE CREATE ON SCHEMA myschema FROM dbuser; +REVOKE USAGE ON SCHEMA reporting FROM analyst; +REVOKE ALTER ON SCHEMA dynamic_schema FROM schema_admin; +REVOKE DROP ON SCHEMA temp_schema FROM cleanup_role; +REVOKE ALL ON SCHEMA myschema FROM schema_owner; +REVOKE ALL PRIVILEGES ON SCHEMA myschema FROM schema_admin; + +-- Schema privileges with CASCADE/RESTRICT +REVOKE USAGE ON SCHEMA reporting FROM analyst CASCADE; +REVOKE ALL ON SCHEMA myschema FROM admin RESTRICT; + +-- Function privileges +REVOKE EXECUTE ON FUNCTION f1() FROM dbuser; +REVOKE EXECUTE ON FUNCTION calculate_tax(numeric, numeric) FROM tax_calculator; +REVOKE ALL ON FUNCTION utility_func() FROM utility_user; +REVOKE ALL PRIVILEGES ON FUNCTION math_func(integer) FROM math_user; + +-- Function privileges with parameters +REVOKE EXECUTE ON FUNCTION format_currency(numeric, varchar) FROM report_user; +REVOKE EXECUTE ON FUNCTION validate_email(varchar(255)) FROM validation_service; +REVOKE EXECUTE ON FUNCTION calculate_discount(decimal(10,2), integer) FROM pricing_engine; + +-- All functions in schema +REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA analytics FROM analyst_role; +REVOKE ALL ON ALL FUNCTIONS IN SCHEMA utilities FROM utility_group; + +-- Procedure privileges +REVOKE EXECUTE ON PROCEDURE proc1() FROM dbuser; +REVOKE EXECUTE ON PROCEDURE update_inventory(integer, varchar) FROM inventory_user; +REVOKE ALL ON PROCEDURE maintenance_proc() FROM admin_role; + +-- All procedures in schema +REVOKE EXECUTE ON ALL PROCEDURES IN SCHEMA maintenance FROM maintenance_role; +REVOKE ALL ON ALL PROCEDURES IN SCHEMA etl FROM etl_group; + +-- Language privileges +REVOKE USAGE ON LANGUAGE plpythonu FROM untrusted_user; +REVOKE USAGE ON LANGUAGE plpythonu FROM PUBLIC; + +-- Datashare privileges +REVOKE ALTER ON DATASHARE salesshare FROM myuser; +REVOKE SHARE ON DATASHARE marketingshare FROM marketing_admin; +REVOKE USAGE ON DATASHARE salesshare FROM namespace 'a3f3ae8c-14e8-45ba-9eaa-b42b9b7ae635'; +REVOKE USAGE ON DATASHARE customerdata FROM ACCOUNT '123456789012'; +REVOKE USAGE ON DATASHARE productdata FROM ACCOUNT '987654321098' VIA DATA_CATALOG; + +-- Datashare database and schema usage +REVOKE USAGE ON DATABASE shared_db FROM consumer_user; +REVOKE USAGE ON SCHEMA shared_schema FROM consumer_role; + +-- Role privileges +REVOKE ROLE sample_role1 FROM reguser; +REVOKE ROLE admin_role FROM user1; +REVOKE ROLE analyst_role FROM ROLE senior_analyst; +REVOKE ADMIN OPTION FOR ROLE admin_role FROM user1; + +-- Multiple role revocations +REVOKE ROLE read_role FROM user1, user2, user3; +REVOKE ROLE admin_role FROM ROLE super_admin, ROLE department_head; +REVOKE ROLE junior_analyst, ROLE data_entry FROM new_hire; + +-- System permissions from roles +REVOKE CREATE USER FROM ROLE user_admin; +REVOKE DROP USER FROM ROLE user_admin; +REVOKE ALTER USER FROM ROLE limited_admin; +REVOKE CREATE SCHEMA FROM ROLE schema_creator; +REVOKE DROP SCHEMA FROM ROLE schema_admin; +REVOKE ALTER DEFAULT PRIVILEGES FROM ROLE privilege_admin; +REVOKE ACCESS CATALOG FROM ROLE catalog_user; +REVOKE CREATE TABLE FROM ROLE table_creator; +REVOKE DROP TABLE FROM ROLE table_admin; +REVOKE ALTER TABLE FROM ROLE table_modifier; +REVOKE CREATE OR REPLACE FUNCTION FROM ROLE function_developer; +REVOKE CREATE OR REPLACE EXTERNAL FUNCTION FROM ROLE external_developer; +REVOKE DROP FUNCTION FROM ROLE function_admin; +REVOKE CREATE OR REPLACE PROCEDURE FROM ROLE procedure_developer; +REVOKE DROP PROCEDURE FROM ROLE procedure_admin; +REVOKE CREATE OR REPLACE VIEW FROM ROLE view_developer; +REVOKE DROP VIEW FROM ROLE view_admin; +REVOKE CREATE MODEL FROM ROLE ml_developer; +REVOKE DROP MODEL FROM ROLE ml_admin; +REVOKE CREATE DATASHARE FROM ROLE datashare_creator; +REVOKE ALTER DATASHARE FROM ROLE datashare_admin; +REVOKE DROP DATASHARE FROM ROLE datashare_owner; +REVOKE CREATE LIBRARY FROM ROLE library_manager; +REVOKE DROP LIBRARY FROM ROLE library_admin; +REVOKE CREATE ROLE FROM ROLE role_admin; +REVOKE DROP ROLE FROM ROLE role_manager; +REVOKE TRUNCATE TABLE FROM ROLE data_manager; +REVOKE VACUUM FROM ROLE maintenance_user; +REVOKE ANALYZE FROM ROLE maintenance_user; +REVOKE CANCEL FROM ROLE operations_user; +REVOKE IGNORE RLS FROM ROLE bypass_user; +REVOKE EXPLAIN RLS FROM ROLE security_analyst; +REVOKE EXPLAIN MASKING FROM ROLE compliance_officer; +REVOKE ALL FROM ROLE super_admin; +REVOKE ALL PRIVILEGES FROM ROLE restricted_user; + +-- Model privileges (Amazon Redshift ML) +REVOKE EXECUTE ON MODEL customer_churn_model FROM ml_user; +REVOKE ALL ON MODEL sales_forecast_model FROM ml_team; +REVOKE ALL PRIVILEGES ON MODEL recommendation_model FROM data_scientist; +REVOKE CREATE MODEL FROM untrusted_user; + +-- Row-level security permissions +REVOKE EXPLAIN RLS FROM ROLE analyst; +REVOKE IGNORE RLS FROM ROLE privileged_user; +REVOKE SELECT ON TABLE sensitive_data FROM RLS POLICY high_security_policy; + +-- Assume role permissions +REVOKE ASSUMEROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' FROM sales_user FOR COPY; +REVOKE ASSUMEROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' FROM etl_user FOR UNLOAD; +REVOKE ASSUMEROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' FROM ml_user FOR CREATE MODEL; +REVOKE ASSUMEROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' FROM lambda_user FOR EXTERNAL FUNCTION; +REVOKE ASSUMEROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' FROM analytics_team FOR ALL; +REVOKE ASSUMEROLE DEFAULT FROM legacy_user FOR COPY; +REVOKE ASSUMEROLE ALL FROM untrusted_user FOR ALL; + +-- Multiple IAM roles +REVOKE ASSUMEROLE 'arn:aws:iam::123456789012:role/Role1', 'arn:aws:iam::123456789012:role/Role2' FROM multi_role_user FOR COPY; + +-- External schema permissions (Spectrum integration) +REVOKE CREATE ON EXTERNAL SCHEMA spectrum_schema FROM IAM_ROLE 'spectrum_user'; +REVOKE ALTER ON EXTERNAL SCHEMA spectrum_schema FROM IAM_ROLE 'schema_modifier'; +REVOKE DROP ON EXTERNAL SCHEMA spectrum_schema FROM IAM_ROLE 'schema_admin'; +REVOKE ALL ON EXTERNAL SCHEMA spectrum_schema FROM IAM_ROLE 'spectrum_admin'; +REVOKE CREATE, ALTER, DROP ON EXTERNAL SCHEMA glue_schema FROM IAM_ROLE 'glue_user'; + +-- IAM role permissions for external objects +REVOKE SELECT ON EXTERNAL TABLE spectrum_schema.data FROM IAM_ROLE 'arn:aws:iam::123456789012:role/SpectrumRole'; +REVOKE ALL ON EXTERNAL SCHEMA glue_schema FROM IAM_ROLE 'arn:aws:iam::123456789012:role/GlueRole'; + +-- Copy job permissions +REVOKE ALTER ON COPY JOB my_copy_job FROM job_modifier; +REVOKE DROP ON COPY JOB old_copy_job FROM job_cleaner; +REVOKE ALL ON COPY JOB critical_job FROM PUBLIC; +REVOKE ALTER, DROP ON COPY JOB job1, job2, job3 FROM job_admin; + +-- Scoped permissions (for future objects) +REVOKE CREATE FOR SCHEMAS IN DATABASE mydb FROM schema_creator; +REVOKE SELECT FOR TABLES IN SCHEMA reporting FROM analyst_role; +REVOKE SELECT FOR TABLES IN SCHEMA finance DATABASE prod_db FROM finance_reader; +REVOKE EXECUTE FOR FUNCTIONS IN SCHEMA utilities FROM function_user; +REVOKE EXECUTE FOR FUNCTIONS IN SCHEMA math_lib DATABASE analytics_db FROM calculator_app; +REVOKE EXECUTE FOR PROCEDURES IN SCHEMA etl FROM etl_runner; +REVOKE EXECUTE FOR PROCEDURES IN SCHEMA maintenance DATABASE ops_db FROM maintenance_bot; +REVOKE USAGE FOR LANGUAGES IN DATABASE dev_db FROM developer; +REVOKE ALTER FOR COPY JOBS IN SCHEMA data_import FROM job_modifier; +REVOKE DROP FOR COPY JOBS IN SCHEMA data_import DATABASE warehouse FROM job_admin; + +-- Complex combinations +REVOKE SELECT, INSERT, UPDATE ON TABLE orders FROM ROLE order_manager, GROUP sales_team; +REVOKE ALL ON TABLE customers FROM user1, ROLE customer_admin, GROUP support_team CASCADE; + +-- Cross-object privileges +REVOKE CREATE ON DATABASE prod_db FROM schema_creator; +REVOKE CREATE ON SCHEMA new_schema FROM table_creator; +REVOKE SELECT ON TABLE new_schema.products FROM product_analyst; + +-- Real-world examples +REVOKE SELECT ON TABLE fact_sales FROM ROLE analyst_role CASCADE; +REVOKE INSERT, UPDATE ON TABLE staging_orders FROM ROLE etl_role RESTRICT; +REVOKE ALL ON TABLE dim_customer FROM data_engineer CASCADE; +REVOKE USAGE ON SCHEMA analytics FROM ROLE business_analyst RESTRICT; +REVOKE CREATE ON DATABASE warehouse FROM ROLE data_architect CASCADE; + +-- Service account patterns +REVOKE SELECT ON ALL TABLES IN SCHEMA reporting FROM airflow_service; +REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA utilities FROM lambda_function; +REVOKE USAGE ON SCHEMA staging FROM kubernetes_pod; + +-- Quoted identifiers +REVOKE SELECT ON TABLE "Order Details" FROM "Sales Manager"; +REVOKE USAGE ON SCHEMA "Finance Reports" FROM "Finance Team"; +REVOKE EXECUTE ON FUNCTION "Calculate Tax"() FROM "Tax Service"; + +-- Case variations +revoke select on table sales from analyst; +REVOKE SELECT ON TABLE SALES FROM ANALYST; +Revoke Select On Table Sales From Analyst; + +-- Privilege combinations +REVOKE SELECT, INSERT ON TABLE logs FROM logger_service; +REVOKE UPDATE, DELETE, TRUNCATE ON TABLE temp_data FROM cleanup_service; +REVOKE DROP, ALTER ON TABLE migration_table FROM migration_tool; +REVOKE REFERENCES, SELECT ON TABLE lookup_table FROM referencing_table_owner; + +-- Edge cases +REVOKE ALL ON TABLE single_column_table FROM single_user CASCADE; +REVOKE SELECT (id) ON TABLE wide_table FROM id_reader RESTRICT; +REVOKE USAGE ON SCHEMA "" FROM edge_case_user; + +-- Multiple grantees with different types +REVOKE SELECT ON TABLE mixed_access_table FROM user1, ROLE reader_role, GROUP viewer_group, PUBLIC; +REVOKE USAGE ON SCHEMA shared_schema FROM service_user, ROLE service_role, GROUP service_group; + +-- Nested role revocations +REVOKE ROLE junior_analyst FROM ROLE senior_analyst; +REVOKE ROLE team_lead FROM ROLE department_manager; +REVOKE ROLE read_only_role FROM ROLE power_user_role; + +-- Function overloading scenarios +REVOKE EXECUTE ON FUNCTION calculate(integer) FROM math_user1; +REVOKE EXECUTE ON FUNCTION calculate(numeric) FROM math_user2; +REVOKE EXECUTE ON FUNCTION calculate(integer, integer) FROM math_user3; + +-- Data type variations in function parameters +REVOKE EXECUTE ON FUNCTION process_string(varchar) FROM string_processor; +REVOKE EXECUTE ON FUNCTION process_string(text) FROM text_processor; +REVOKE EXECUTE ON FUNCTION handle_timestamp(timestamp) FROM time_handler; +REVOKE EXECUTE ON FUNCTION handle_numbers(numeric(10,2)) FROM number_handler; + +-- Schema-qualified object names +REVOKE SELECT ON TABLE public.users FROM public_reader; +REVOKE EXECUTE ON FUNCTION analytics.calculate_metrics() FROM metrics_user; +REVOKE USAGE ON SCHEMA finance FROM finance_analyst; + +-- Long identifier names +REVOKE SELECT ON TABLE very_long_table_name_for_comprehensive_sales_data FROM very_long_user_name_for_sales_analysis; +REVOKE EXECUTE ON FUNCTION extremely_long_function_name_for_complex_calculations() FROM user_with_very_long_descriptive_name; + +-- Cleanup after grants with GRANT OPTION +REVOKE ALL PRIVILEGES ON TABLE revokable_table FROM revokable_user CASCADE; +REVOKE ALL ON ALL TABLES IN SCHEMA revokable_schema FROM revokable_role CASCADE; + +-- Temporary and session-based revocations +REVOKE TEMPORARY ON DATABASE session_db FROM session_user; +REVOKE TEMP ON DATABASE temp_workspace FROM temp_worker; + +-- GRANT OPTION revocations (keep privilege but remove ability to grant) +REVOKE GRANT OPTION FOR SELECT ON TABLE sensitive_data FROM trusted_user; +REVOKE GRANT OPTION FOR ALL ON DATABASE prod_db FROM admin_user; +REVOKE GRANT OPTION FOR USAGE ON SCHEMA reporting FROM lead_analyst; +REVOKE GRANT OPTION FOR EXECUTE ON FUNCTION calc() FROM senior_developer; +REVOKE GRANT OPTION FOR ALTER ON DATASHARE salesshare FROM share_admin; + +-- Multiple privileges in one statement +REVOKE SELECT, INSERT, UPDATE, DELETE, TRUNCATE ON TABLE transactions FROM transaction_processor; +REVOKE CREATE, USAGE, ALTER, DROP ON SCHEMA dynamic_schema FROM schema_manager; +REVOKE CREATE, TEMPORARY, ALTER ON DATABASE test_db FROM test_user; + +-- Revoke from users that were granted through groups/roles +REVOKE SELECT ON TABLE inherited_access FROM user_via_group CASCADE; +REVOKE USAGE ON SCHEMA inherited_schema FROM user_via_role RESTRICT; + +-- Special cases with system tables and catalog access +REVOKE ACCESS CATALOG FROM ROLE limited_viewer; + +-- Revoking combinations of column and table privileges +REVOKE SELECT ON TABLE orders FROM order_viewer; +REVOKE UPDATE (status, modified_date) ON TABLE orders FROM order_updater; +REVOKE ALL (sensitive_col1, sensitive_col2) ON TABLE secure_table FROM PUBLIC; + +-- Conditional revocations based on object existence +REVOKE SELECT ON TABLE IF EXISTS optional_table FROM optional_user; +REVOKE USAGE ON SCHEMA IF EXISTS optional_schema FROM optional_role; \ No newline at end of file diff --git a/redshift/examples/redshift/rollback.sql b/redshift/examples/redshift/rollback.sql new file mode 100644 index 0000000..88d0012 --- /dev/null +++ b/redshift/examples/redshift/rollback.sql @@ -0,0 +1,82 @@ +-- rollback.sql +-- Test cases for ROLLBACK command in Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_ROLLBACK.html + +-- Basic ROLLBACK +ROLLBACK; + +-- ROLLBACK with WORK keyword +ROLLBACK WORK; + +-- ROLLBACK with TRANSACTION keyword +ROLLBACK TRANSACTION; + +-- Case variations +rollback; +Rollback; +ROLLBACK; + +rollback work; +Rollback Work; +ROLLBACK WORK; + +rollback transaction; +Rollback Transaction; +ROLLBACK TRANSACTION; + +-- Full example from AWS documentation +-- Create a table +create table movie_gross( name varchar(30), gross bigint ); + +-- Start a transaction +begin; + +-- Insert data +insert into movie_gross values ( 'Raiders of the Lost Ark', 23400000); +insert into movie_gross values ( 'Star Wars', 10000000 ); + +-- Roll back the transaction (discards all updates) +rollback; + +-- Another example with WORK keyword +begin; +insert into movie_gross values ( 'The Empire Strikes Back', 20000000); +insert into movie_gross values ( 'Return of the Jedi', 15000000 ); +rollback work; + +-- Example with TRANSACTION keyword +begin; +insert into movie_gross values ( 'Indiana Jones and the Temple of Doom', 25000000); +insert into movie_gross values ( 'Indiana Jones and the Last Crusade', 19700000 ); +rollback transaction; + +-- ROLLBACK in a more complex transaction +begin; + +-- Multiple operations +create table temp_sales (id int, amount decimal(10,2)); +insert into temp_sales values (1, 100.50); +insert into temp_sales values (2, 250.75); +update temp_sales set amount = amount * 1.1 where id = 1; +delete from temp_sales where amount < 200; + +-- Roll back all changes +rollback; + +-- ROLLBACK after DDL operations +begin; +create table test_rollback (col1 int, col2 varchar(50)); +alter table test_rollback add column col3 date; +rollback; + +-- Note: ROLLBACK is functionally equivalent to ABORT +-- Both commands stop the current transaction and discard all updates + +-- Test with explicit transaction blocks +BEGIN TRANSACTION; +-- Some operations would go here +ROLLBACK TRANSACTION; + +BEGIN WORK; +-- Some operations would go here +ROLLBACK WORK; \ No newline at end of file diff --git a/redshift/examples/redshift/select.sql b/redshift/examples/redshift/select.sql new file mode 100644 index 0000000..59d7368 --- /dev/null +++ b/redshift/examples/redshift/select.sql @@ -0,0 +1,386 @@ +-- Basic SELECT statements +-- Select all columns +SELECT * FROM users; + +-- Select specific columns +SELECT username, email, created_date FROM users; + +-- Select with column aliases +SELECT + username AS user_name, + email AS user_email, + created_date AS signup_date +FROM users; + +-- Select with expressions +SELECT + first_name || ' ' || last_name AS full_name, + age * 12 AS age_in_months, + salary / 12 AS monthly_salary +FROM employees; + +-- TOP clause +SELECT TOP 10 * FROM sales ORDER BY sale_amount DESC; +SELECT TOP 100 product_id, SUM(quantity) FROM sales GROUP BY product_id; + +-- DISTINCT +SELECT DISTINCT category FROM products; +SELECT DISTINCT department, location FROM offices; + +-- WHERE clause +SELECT * FROM orders WHERE order_date >= '2025-01-01'; +SELECT * FROM products WHERE price BETWEEN 10 AND 100; +SELECT * FROM customers WHERE country IN ('US', 'CA', 'MX'); +SELECT * FROM users WHERE email LIKE '%@example.com'; +SELECT * FROM employees WHERE manager_id IS NOT NULL; + +-- Joins +-- INNER JOIN +SELECT o.order_id, o.order_date, c.customer_name +FROM orders o +INNER JOIN customers c ON o.customer_id = c.customer_id; + +-- LEFT JOIN +SELECT c.customer_name, o.order_id +FROM customers c +LEFT JOIN orders o ON c.customer_id = o.customer_id; + +-- RIGHT JOIN +SELECT o.order_id, c.customer_name +FROM orders o +RIGHT JOIN customers c ON o.customer_id = c.customer_id; + +-- FULL OUTER JOIN +SELECT c.customer_name, o.order_id +FROM customers c +FULL OUTER JOIN orders o ON c.customer_id = o.customer_id; + +-- CROSS JOIN +SELECT p.product_name, c.category_name +FROM products p +CROSS JOIN categories c; + +-- Multiple joins +SELECT + o.order_id, + c.customer_name, + p.product_name, + oi.quantity, + oi.unit_price +FROM orders o +JOIN customers c ON o.customer_id = c.customer_id +JOIN order_items oi ON o.order_id = oi.order_id +JOIN products p ON oi.product_id = p.product_id; + +-- Self join +SELECT + e1.employee_name AS employee, + e2.employee_name AS manager +FROM employees e1 +LEFT JOIN employees e2 ON e1.manager_id = e2.employee_id; + +-- GROUP BY and aggregates +SELECT category, COUNT(*) AS product_count +FROM products +GROUP BY category; + +SELECT + department, + AVG(salary) AS avg_salary, + MIN(salary) AS min_salary, + MAX(salary) AS max_salary, + SUM(salary) AS total_salary, + COUNT(*) AS employee_count +FROM employees +GROUP BY department; + +-- GROUP BY with HAVING +SELECT category, COUNT(*) AS product_count +FROM products +GROUP BY category +HAVING COUNT(*) > 10; + +SELECT department, AVG(salary) AS avg_salary +FROM employees +GROUP BY department +HAVING AVG(salary) > 50000; + +-- ROLLUP +SELECT + region, + country, + SUM(sales_amount) AS total_sales +FROM sales_data +GROUP BY ROLLUP(region, country); + +-- CUBE +SELECT + product_category, + store_location, + SUM(quantity) AS total_quantity +FROM inventory +GROUP BY CUBE(product_category, store_location); + +-- GROUPING SETS +SELECT + department, + job_title, + COUNT(*) AS employee_count +FROM employees +GROUP BY GROUPING SETS ( + (department), + (job_title), + (department, job_title), + () +); + +-- Common Table Expressions (WITH clause) +WITH regional_sales AS ( + SELECT region, SUM(sales_amount) AS total_sales + FROM orders + GROUP BY region +) +SELECT * FROM regional_sales WHERE total_sales > 1000000; + +-- Multiple CTEs +WITH +customer_orders AS ( + SELECT customer_id, COUNT(*) AS order_count + FROM orders + GROUP BY customer_id +), +high_value_customers AS ( + SELECT customer_id + FROM customer_orders + WHERE order_count > 10 +) +SELECT c.* +FROM customers c +JOIN high_value_customers hvc ON c.customer_id = hvc.customer_id; + +-- Recursive CTE +WITH RECURSIVE employee_hierarchy AS ( + -- Base case: top-level employees + SELECT + employee_id, + employee_name, + manager_id, + 1 AS level + FROM employees + WHERE manager_id IS NULL + + UNION ALL + + -- Recursive case: employees with managers + SELECT + e.employee_id, + e.employee_name, + e.manager_id, + eh.level + 1 + FROM employees e + JOIN employee_hierarchy eh ON e.manager_id = eh.employee_id + WHERE eh.level < 5 +) +SELECT * FROM employee_hierarchy ORDER BY level, employee_name; + +-- Window functions +SELECT + employee_name, + department, + salary, + AVG(salary) OVER (PARTITION BY department) AS dept_avg_salary, + salary - AVG(salary) OVER (PARTITION BY department) AS salary_diff +FROM employees; + +SELECT + order_date, + order_amount, + SUM(order_amount) OVER (ORDER BY order_date) AS running_total, + ROW_NUMBER() OVER (ORDER BY order_amount DESC) AS order_rank +FROM orders; + +-- Window function with frame +SELECT + sale_date, + sale_amount, + AVG(sale_amount) OVER ( + ORDER BY sale_date + ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING + ) AS moving_avg +FROM daily_sales; + +-- QUALIFY clause +SELECT + product_id, + sale_date, + sale_amount, + ROW_NUMBER() OVER (PARTITION BY product_id ORDER BY sale_amount DESC) AS rn +FROM sales +QUALIFY rn <= 3; + +-- Set operations +-- UNION +SELECT customer_id, customer_name FROM customers_us +UNION +SELECT customer_id, customer_name FROM customers_ca; + +-- UNION ALL +SELECT product_id FROM orders_2024 +UNION ALL +SELECT product_id FROM orders_2025; + +-- INTERSECT +SELECT customer_id FROM customers +INTERSECT +SELECT customer_id FROM orders; + +-- EXCEPT +SELECT customer_id FROM customers +EXCEPT +SELECT customer_id FROM orders; + +-- MINUS (synonym for EXCEPT) +SELECT product_id FROM all_products +MINUS +SELECT product_id FROM discontinued_products; + +-- ORDER BY +SELECT * FROM products ORDER BY price DESC; +SELECT * FROM employees ORDER BY department, salary DESC; +SELECT * FROM orders ORDER BY order_date DESC NULLS LAST; + +-- LIMIT and OFFSET +SELECT * FROM products LIMIT 10; +SELECT * FROM products LIMIT 10 OFFSET 20; +SELECT * FROM products ORDER BY price DESC LIMIT ALL; + +-- Subqueries +-- Scalar subquery +SELECT + product_name, + price, + (SELECT AVG(price) FROM products) AS avg_price +FROM products; + +-- IN subquery +SELECT * FROM customers +WHERE customer_id IN ( + SELECT DISTINCT customer_id + FROM orders + WHERE order_date >= '2025-01-01' +); + +-- EXISTS subquery +SELECT c.* FROM customers c +WHERE EXISTS ( + SELECT 1 + FROM orders o + WHERE o.customer_id = c.customer_id + AND o.order_amount > 1000 +); + +-- Correlated subquery +SELECT + e1.employee_name, + e1.salary, + e1.department +FROM employees e1 +WHERE e1.salary > ( + SELECT AVG(e2.salary) + FROM employees e2 + WHERE e2.department = e1.department +); + +-- CASE expressions +SELECT + order_id, + order_amount, + CASE + WHEN order_amount >= 1000 THEN 'High' + WHEN order_amount >= 500 THEN 'Medium' + ELSE 'Low' + END AS order_category +FROM orders; + +SELECT + product_name, + CASE product_category + WHEN 'Electronics' THEN price * 0.9 + WHEN 'Clothing' THEN price * 0.8 + ELSE price + END AS discounted_price +FROM products; + +-- LISTAGG +SELECT + department, + LISTAGG(employee_name, ', ') WITHIN GROUP (ORDER BY employee_name) AS employees +FROM employees +GROUP BY department; + +SELECT + customer_id, + LISTAGG(DISTINCT product_category, ' | ') AS purchased_categories +FROM customer_purchases +GROUP BY customer_id; + +-- Complex query with multiple features +WITH monthly_sales AS ( + SELECT + DATE_TRUNC('month', sale_date) AS month, + product_category, + SUM(sale_amount) AS total_sales, + COUNT(*) AS transaction_count + FROM sales + WHERE sale_date >= '2024-01-01' + GROUP BY DATE_TRUNC('month', sale_date), product_category +), +category_ranks AS ( + SELECT + month, + product_category, + total_sales, + transaction_count, + RANK() OVER (PARTITION BY month ORDER BY total_sales DESC) AS sales_rank, + total_sales / SUM(total_sales) OVER (PARTITION BY month) * 100 AS pct_of_month + FROM monthly_sales +) +SELECT + TO_CHAR(month, 'YYYY-MM') AS month_str, + product_category, + total_sales, + transaction_count, + sales_rank, + ROUND(pct_of_month, 2) AS pct_of_month +FROM category_ranks +WHERE sales_rank <= 5 +ORDER BY month, sales_rank; + +-- EXCLUDE clause (Redshift specific) +SELECT * EXCLUDE (password, ssn) FROM users; +SELECT * EXCLUDE (internal_notes, debug_info) FROM orders; + +-- TABLESAMPLE +SELECT * FROM large_table TABLESAMPLE BERNOULLI (10); +SELECT * FROM huge_table TABLESAMPLE SYSTEM (1) WHERE created_date >= '2025-01-01'; + +-- FOR UPDATE +SELECT * FROM inventory WHERE product_id = 123 FOR UPDATE; +SELECT * FROM accounts WHERE status = 'pending' FOR UPDATE SKIP LOCKED; + +-- -- CONNECT BY (hierarchical queries) +-- SELECT employee_id, employee_name, manager_id, LEVEL +-- FROM employees +-- START WITH manager_id IS NULL +-- CONNECT BY PRIOR employee_id = manager_id; +-- +-- -- Complex hierarchical query with CONNECT BY +-- SELECT +-- LPAD(' ', (LEVEL - 1) * 2) || employee_name AS org_chart, +-- employee_id, +-- manager_id, +-- LEVEL AS hierarchy_level +-- FROM employees +-- START WITH employee_id = 1 +-- CONNECT BY PRIOR employee_id = manager_id +-- ORDER BY employee_name; \ No newline at end of file diff --git a/redshift/examples/redshift/select_into.sql b/redshift/examples/redshift/select_into.sql new file mode 100644 index 0000000..5039123 --- /dev/null +++ b/redshift/examples/redshift/select_into.sql @@ -0,0 +1,359 @@ +-- SELECT INTO Examples for Amazon Redshift +-- Based on AWS documentation: https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_INTO.html + +-- Basic SELECT INTO - Create a new table from an existing table +SELECT * INTO newevent FROM event; + +-- SELECT INTO with specific columns +SELECT eventid, eventname, venueid +INTO event_backup +FROM event; + +-- SELECT INTO with WHERE clause +SELECT * +INTO recent_events +FROM event +WHERE starttime > '2023-01-01'; + +-- SELECT INTO with temporary table +SELECT * +INTO TEMP TABLE temp_events +FROM event; + +-- SELECT INTO with TEMPORARY keyword (alternative syntax) +SELECT * +INTO TEMPORARY TABLE temp_events2 +FROM event; + +-- SELECT INTO with TABLE keyword (optional) +SELECT * +INTO TABLE event_copy +FROM event; + +-- SELECT INTO TEMP TABLE with TABLE keyword +SELECT * +INTO TEMP TABLE temp_events3 +FROM event; + +-- SELECT INTO with aggregation +SELECT username, lastname, SUM(pricepaid - commission) AS profit +INTO TEMP TABLE profits +FROM sales, users +WHERE sales.sellerid = users.userid +GROUP BY 1, 2 +ORDER BY 3 DESC; + +-- SELECT INTO with JOIN +SELECT e.eventid, e.eventname, v.venuename, v.venuecity +INTO venue_events +FROM event e + JOIN venue v ON e.venueid = v.venueid; + +-- SELECT INTO with multiple JOINs +SELECT u.username, e.eventname, s.pricepaid +INTO user_event_sales +FROM users u + JOIN sales s ON u.userid = s.buyerid + JOIN event e ON s.eventid = e.eventid; + +-- SELECT INTO with LEFT JOIN +SELECT c.catname, COUNT(e.eventid) as event_count +INTO category_counts +FROM category c + LEFT JOIN event e ON c.catid = e.catid +GROUP BY c.catname; + +-- SELECT INTO with subquery in FROM clause +SELECT * +INTO high_price_sales +FROM ( + SELECT * FROM sales WHERE pricepaid > 100 + ) AS expensive_sales; + +-- SELECT INTO with CTE (Common Table Expression) +WITH high_commission_sales AS ( + SELECT * FROM sales WHERE commission > 50 +) +SELECT * +INTO temp_high_commission +FROM high_commission_sales; + +-- SELECT INTO with multiple CTEs +WITH + venue_stats AS ( + SELECT venueid, COUNT(*) as event_count + FROM event + GROUP BY venueid + ), + popular_venues AS ( + SELECT * FROM venue_stats WHERE event_count > 10 + ) +SELECT v.venuename, vs.event_count +INTO popular_venue_report +FROM popular_venues vs + JOIN venue v ON vs.venueid = v.venueid; + +-- SELECT INTO with UNION +SELECT eventid, 'event' as source +INTO combined_ids +FROM event +UNION +SELECT listid, 'listing' as source +FROM listing; + +-- SELECT INTO with UNION ALL +SELECT userid, username, 'buyer' as role +INTO temp_all_users +FROM users +WHERE userid IN (SELECT buyerid FROM sales) +UNION ALL +SELECT userid, username, 'seller' as role +FROM users +WHERE userid IN (SELECT sellerid FROM sales); + +-- SELECT INTO with DISTINCT +SELECT DISTINCT venuecity, venuestate +INTO unique_locations +FROM venue; + +-- SELECT INTO with TOP clause +SELECT TOP 100 * +INTO top_sales +FROM sales +ORDER BY pricepaid DESC; + +-- SELECT INTO with window functions +SELECT + salesid, + pricepaid, + ROW_NUMBER() OVER (ORDER BY pricepaid DESC) as price_rank, + RANK() OVER (PARTITION BY eventid ORDER BY pricepaid DESC) as event_price_rank +INTO sales_rankings +FROM sales; + +-- SELECT INTO with CASE expressions +SELECT + eventid, + eventname, + CASE + WHEN starttime < '2023-01-01' THEN 'past' + WHEN starttime >= '2023-01-01' AND starttime < '2024-01-01' THEN 'current' + ELSE 'future' + END as event_period +INTO event_periods +FROM event; + +-- SELECT INTO with calculated columns +SELECT + salesid, + pricepaid, + commission, + pricepaid - commission as net_price, + (commission / NULLIF(pricepaid, 0)) * 100 as commission_percentage +INTO sales_analysis +FROM sales; + +-- SELECT INTO with GROUP BY and HAVING +SELECT + eventid, + COUNT(*) as sale_count, + SUM(pricepaid) as total_revenue +INTO event_revenue +FROM sales +GROUP BY eventid +HAVING COUNT(*) > 5; + +-- SELECT INTO with LIMIT and OFFSET +SELECT * +INTO recent_subset +FROM event +ORDER BY starttime DESC + LIMIT 1000 +OFFSET 100; + +-- SELECT INTO with schema qualification +SELECT * +INTO myschema.event_backup +FROM public.event; + +-- SELECT INTO with complex expressions +SELECT + DATE_TRUNC('month', saletime) as sale_month, + COUNT(*) as sale_count, + AVG(pricepaid) as avg_price, + MIN(pricepaid) as min_price, + MAX(pricepaid) as max_price +INTO monthly_sales_stats +FROM sales +GROUP BY 1 +ORDER BY 1; + +-- SELECT INTO with EXCLUDE (if supported) +SELECT * EXCLUDE (commission, saletime) +INTO sales_simplified +FROM sales; + +-- SELECT INTO with LISTAGG +SELECT + venueid, + LISTAGG(eventname, ', ') WITHIN GROUP (ORDER BY eventname) as events_list +INTO venue_event_list +FROM event +GROUP BY venueid; + +-- SELECT INTO with GROUPING SETS +SELECT + venuecity, + venuestate, + COUNT(*) as venue_count +INTO venue_grouping_stats +FROM venue +GROUP BY GROUPING SETS ((venuecity), (venuestate), (venuecity, venuestate)); + +-- SELECT INTO with ROLLUP +SELECT + DATE_PART('year', saletime) as sale_year, + DATE_PART('month', saletime) as sale_month, + SUM(pricepaid) as total_sales +INTO sales_rollup +FROM sales +GROUP BY ROLLUP(1, 2); + +-- SELECT INTO with CUBE +SELECT + venuecity, + venuestate, + COUNT(*) as venue_count +INTO venue_cube_stats +FROM venue +GROUP BY CUBE(venuecity, venuestate); + +-- SELECT INTO with EXISTS subquery +SELECT * +INTO venues_with_events +FROM venue v +WHERE EXISTS ( + SELECT 1 FROM event e WHERE e.venueid = v.venueid +); + +-- SELECT INTO with NOT IN subquery +SELECT * +INTO users_without_sales +FROM users +WHERE userid NOT IN ( + SELECT DISTINCT buyerid FROM sales + UNION + SELECT DISTINCT sellerid FROM sales +); + +-- SELECT INTO with correlated subquery +SELECT + u.userid, + u.username, + (SELECT COUNT(*) FROM sales s WHERE s.buyerid = u.userid) as purchase_count +INTO user_purchase_counts +FROM users u; + +-- SELECT INTO with INTERSECT +SELECT venueid +INTO venues_with_both +FROM event +WHERE catid = 1 +INTERSECT +SELECT venueid +FROM event +WHERE catid = 2; + +-- SELECT INTO with EXCEPT +SELECT userid +INTO buyers_not_sellers +FROM users +WHERE userid IN (SELECT DISTINCT buyerid FROM sales) +EXCEPT +SELECT userid +FROM users +WHERE userid IN (SELECT DISTINCT sellerid FROM sales); + +-- SELECT INTO with complex date operations +SELECT + eventid, + eventname, + starttime, + DATEADD(hour, 3, starttime) as endtime_estimate, + DATEDIFF(day, CURRENT_DATE, starttime) as days_until_event +INTO event_schedule +FROM event +WHERE starttime > CURRENT_DATE; + +-- SELECT INTO with string operations +SELECT + userid, + username, + UPPER(firstname) as firstname_upper, + LOWER(lastname) as lastname_lower, + firstname || ' ' || lastname as full_name, + LENGTH(email) as email_length +INTO user_details +FROM users; + +-- SELECT INTO with QUALIFY clause (if supported in Redshift) +SELECT + salesid, + eventid, + pricepaid, + ROW_NUMBER() OVER (PARTITION BY eventid ORDER BY pricepaid DESC) as rn +INTO top_sales_per_event +FROM sales + QUALIFY rn <= 3; + +-- SELECT INTO with recursive CTE (if supported) +WITH RECURSIVE event_hierarchy AS ( + SELECT eventid, eventname, 1 as level + FROM event + WHERE eventid = 1 + UNION ALL + SELECT e.eventid, e.eventname, eh.level + 1 + FROM event e + JOIN event_hierarchy eh ON e.eventid = eh.eventid + 1 +) +SELECT * +INTO event_tree +FROM event_hierarchy; + +-- Complex real-world example: Sales performance analysis +WITH monthly_sales AS ( + SELECT + DATE_TRUNC('month', saletime) as month, + sellerid, + COUNT(*) as sale_count, + SUM(pricepaid) as total_revenue, + AVG(commission) as avg_commission +FROM sales +GROUP BY 1, 2 + ), + seller_ranks AS ( +SELECT + month, + sellerid, + sale_count, + total_revenue, + avg_commission, + RANK() OVER (PARTITION BY month ORDER BY total_revenue DESC) as revenue_rank, + PERCENT_RANK() OVER (PARTITION BY month ORDER BY sale_count DESC) as sale_count_percentile +FROM monthly_sales + ) +SELECT + sr.*, + u.username, + u.firstname, + u.lastname, + CASE + WHEN revenue_rank <= 10 THEN 'Top Performer' + WHEN sale_count_percentile <= 0.25 THEN 'High Volume' + ELSE 'Standard' + END as seller_category +INTO TEMP TABLE seller_performance_report +FROM seller_ranks sr + JOIN users u ON sr.sellerid = u.userid +WHERE sr.month >= DATE_TRUNC('month', DATEADD(month, -12, CURRENT_DATE)) +ORDER BY sr.month DESC, sr.revenue_rank; \ No newline at end of file diff --git a/redshift/examples/redshift/set.sql b/redshift/examples/redshift/set.sql new file mode 100644 index 0000000..bfbd84b --- /dev/null +++ b/redshift/examples/redshift/set.sql @@ -0,0 +1,131 @@ +-- Test cases for SET command +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SET.html + +-- Basic SET with TO syntax +SET datestyle TO 'SQL,DMY'; +SET search_path TO myschema, public; +SET statement_timeout TO 30000; +SET timezone TO 'America/New_York'; + +-- Basic SET with = syntax +SET datestyle = 'ISO,MDY'; +SET search_path = '$user', public; +SET statement_timeout = 60000; +SET timezone = 'UTC'; + +-- SET with SESSION scope (explicit) +SET SESSION datestyle TO 'German,DMY'; +SET SESSION search_path TO myschema; +SET SESSION statement_timeout TO 0; +SET SESSION enable_result_cache_for_session TO off; + +-- SET with LOCAL scope (transaction-specific) +SET LOCAL datestyle TO 'Postgres,MDY'; +SET LOCAL search_path TO tempschema; +SET LOCAL statement_timeout TO 10000; +SET LOCAL timezone TO 'PST8PDT'; + +-- SET SEED for random number generation +SET SEED TO .25; +SET SEED TO 0.5; +SET SEED TO 0.99; +SET SESSION SEED TO 0.1; +SET LOCAL SEED TO 0.75; + +-- SET context variables (custom application context) +SET app_context.user_id TO 123; +SET app_context.user_id TO 'sample_variable_value'; +SET app_context.tenant_id TO 'company_123'; +SET custom_context.department TO 'engineering'; +SET session_context.application_name TO 'myapp'; + +-- SET with quoted values +SET datestyle TO 'SQL,DMY'; +SET search_path TO 'myschema', 'public'; +SET query_group TO 'priority'; +SET app_context.user_name TO 'John Doe'; + +-- SET identity namespace +SET SESSION default_identity_namespace = 'MYCO'; +SET default_identity_namespace TO 'COMPANY_ABC'; +SET LOCAL default_identity_namespace = 'TEST_NAMESPACE'; + +-- SET with DEFAULT keyword +SET datestyle TO DEFAULT; +SET search_path TO DEFAULT; +SET timezone TO DEFAULT; +SET SESSION statement_timeout TO DEFAULT; + +-- SET workload management parameters +SET query_group TO 'high_priority'; +SET query_group = 'reporting'; +SET wlm_json_configuration TO '{"queue_name":"etl"}'; + +-- SET result cache parameters +SET enable_result_cache_for_session TO on; +SET enable_result_cache_for_session = off; +SET enable_result_cache_for_session TO true; +SET enable_result_cache_for_session = false; + +-- SET concurrency scaling +SET max_concurrency_scaling_clusters TO 10; +SET max_concurrency_scaling_clusters = 5; + +-- SET spectrum parameters +SET spectrum_enable_pseudo_columns TO true; +SET spectrum_enable_pseudo_columns = false; + +-- SET SESSION CHARACTERISTICS (transaction isolation) +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL REPEATABLE READ; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE; + +-- Case variations +set datestyle to 'SQL,DMY'; +Set Search_Path To myschema; +SET DATESTYLE TO 'ISO,MDY'; + +-- Multiple SET statements in sequence (common usage pattern) +SET query_group TO 'etl_jobs'; +SET statement_timeout TO 3600000; +SET enable_result_cache_for_session TO off; + +-- SET before operations (typical usage) +SET query_group TO 'priority'; +-- SELECT tbl, count(*) FROM stv_blocklist; +-- RESET query_group; + +SET app_context.user_id TO 456; +-- SELECT * FROM user_data WHERE user_id = current_setting('app_context.user_id'); +-- RESET app_context.user_id; + +-- Boolean values +SET enable_result_cache_for_session TO TRUE; +SET enable_result_cache_for_session TO FALSE; +SET spectrum_enable_pseudo_columns TO true; +SET spectrum_enable_pseudo_columns TO false; + +-- Numeric values +SET statement_timeout TO 0; +SET statement_timeout TO 1000; +SET statement_timeout TO 3600000; +SET max_concurrency_scaling_clusters TO 1; + +-- Additional context variable examples (simplified) +SET app_context.config TO '30'; +SET session_context.data TO '2024-01-01'; +SET custom_context.setting TO '1000'; + +-- Mixed case identifiers +SET "MixedCase_Param" TO 'value'; +SET app_context."UserID" TO '789'; +SET "CUSTOM_CONTEXT"."DEPT_CODE" TO 'FIN'; + +-- Error cases that should be tested (parser should handle gracefully) +-- SET; -- Missing parameter and value +-- SET datestyle; -- Missing TO/= and value +-- SET datestyle TO; -- Missing value +-- SET TO 'value'; -- Missing parameter +-- SET LOCAL; -- Missing parameter and value +-- SET SESSION LOCAL datestyle TO 'SQL,DMY'; -- Both SESSION and LOCAL \ No newline at end of file diff --git a/redshift/examples/redshift/set_session_authorization.sql b/redshift/examples/redshift/set_session_authorization.sql new file mode 100644 index 0000000..36ecc2e --- /dev/null +++ b/redshift/examples/redshift/set_session_authorization.sql @@ -0,0 +1,53 @@ +-- SET SESSION AUTHORIZATION examples +-- https://docs.aws.amazon.com/redshift/latest/dg/r_SET_SESSION_AUTHORIZATION.html + +-- Basic usage: Set session user to 'dwuser' (string literal) +SET SESSION AUTHORIZATION 'dwuser'; + +-- Set session user using identifier (without quotes) +SET SESSION AUTHORIZATION dwuser; + +-- Set session user with mixed case identifier +SET SESSION AUTHORIZATION TestUser; + +-- Set transaction-local user (only valid for current transaction) +SET LOCAL SESSION AUTHORIZATION 'dwuser'; + +-- Set transaction-local user using identifier +SET LOCAL SESSION AUTHORIZATION dwuser; + +-- Reset session authorization to default user +SET SESSION AUTHORIZATION DEFAULT; + +-- Reset transaction-local authorization to default +SET LOCAL SESSION AUTHORIZATION DEFAULT; + +-- Various user name formats +SET SESSION AUTHORIZATION 'test_user'; +SET SESSION AUTHORIZATION 'user123'; +SET SESSION AUTHORIZATION 'admin@example.com'; + +-- Edge cases with special characters in user names +SET SESSION AUTHORIZATION 'user-with-dash'; +SET SESSION AUTHORIZATION 'user.with.dots'; +SET SESSION AUTHORIZATION 'user_with_underscore'; + +-- Combined with transaction blocks (typical usage pattern) +BEGIN; +SET LOCAL SESSION AUTHORIZATION 'unprivileged_user'; +-- Test database operations as unprivileged_user +SELECT * FROM sensitive_table; -- This would be tested with reduced privileges +COMMIT; -- Session authorization reverts after transaction + +-- Multiple authorization changes in one session +SET SESSION AUTHORIZATION 'analyst'; +-- Do some work as analyst +SET SESSION AUTHORIZATION 'developer'; +-- Do some work as developer +SET SESSION AUTHORIZATION DEFAULT; +-- Back to original user + +-- Case sensitivity tests +SET SESSION AUTHORIZATION 'UserName'; +SET SESSION AUTHORIZATION 'USERNAME'; +SET SESSION AUTHORIZATION 'username'; \ No newline at end of file diff --git a/redshift/examples/redshift/set_session_characteristics.sql b/redshift/examples/redshift/set_session_characteristics.sql new file mode 100644 index 0000000..ff8ec7e --- /dev/null +++ b/redshift/examples/redshift/set_session_characteristics.sql @@ -0,0 +1,108 @@ +-- Test cases for SET SESSION CHARACTERISTICS command +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SET_SESSION_CHARACTERISTICS.html +-- Note: This command is deprecated in Amazon Redshift + +-- Basic isolation level settings +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL REPEATABLE READ; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE; + +-- Access mode settings (READ WRITE | READ ONLY) +SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE; +SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY; + +-- Deferrable mode settings +SET SESSION CHARACTERISTICS AS TRANSACTION DEFERRABLE; +SET SESSION CHARACTERISTICS AS TRANSACTION NOT DEFERRABLE; + +-- Combined transaction characteristics (isolation level + access mode) +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED, READ WRITE; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY; +SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY, ISOLATION LEVEL REPEATABLE READ; +SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE, ISOLATION LEVEL READ UNCOMMITTED; + +-- Combined with deferrable mode +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED, READ WRITE, NOT DEFERRABLE; +SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE, DEFERRABLE, ISOLATION LEVEL REPEATABLE READ; + +-- All three characteristics combined +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED, READ WRITE, NOT DEFERRABLE; +SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY, ISOLATION LEVEL REPEATABLE READ, DEFERRABLE; +SET SESSION CHARACTERISTICS AS TRANSACTION NOT DEFERRABLE, READ WRITE, ISOLATION LEVEL READ UNCOMMITTED; + +-- Case variations (SQL keywords are case-insensitive) +set session characteristics as transaction isolation level read committed; +Set Session Characteristics As Transaction Read Write; +SET SESSION CHARACTERISTICS as TRANSACTION isolation LEVEL serializable; +SET session CHARACTERISTICS AS transaction READ only; + +-- Multiple characteristics in different orders +SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE, NOT DEFERRABLE, ISOLATION LEVEL READ COMMITTED; +SET SESSION CHARACTERISTICS AS TRANSACTION DEFERRABLE, ISOLATION LEVEL SERIALIZABLE, READ ONLY; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL REPEATABLE READ, DEFERRABLE, READ WRITE; + +-- Typical use cases + +-- Setting up a read-only session for reporting +SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY, ISOLATION LEVEL READ COMMITTED; + +-- Setting up a session for ETL operations +SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE, ISOLATION LEVEL READ UNCOMMITTED; + +-- Setting up a session for critical financial transactions +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE; + +-- Setting up a session for data analysis with consistent reads +SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY, ISOLATION LEVEL REPEATABLE READ; + +-- PostgreSQL compatibility examples +-- (Redshift may not support all PostgreSQL features, but these are standard SQL) +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED; +SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE; + +-- Edge cases with spacing +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED; +SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE ; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE,READ ONLY,DEFERRABLE; + +-- Multiple characteristics with newlines (for readability in scripts) +SET SESSION CHARACTERISTICS AS TRANSACTION + ISOLATION LEVEL SERIALIZABLE, + READ ONLY, + DEFERRABLE; + +SET SESSION CHARACTERISTICS AS TRANSACTION + READ WRITE, + ISOLATION LEVEL READ COMMITTED, + NOT DEFERRABLE; + +-- Comments within statements +SET SESSION CHARACTERISTICS AS TRANSACTION -- Setting transaction defaults + ISOLATION LEVEL SERIALIZABLE, -- Highest isolation level + READ ONLY; -- Prevent accidental writes + +-- Practical application scenarios + +-- 1. Before running reports on production data +SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY, ISOLATION LEVEL READ COMMITTED; +-- SELECT * FROM sales_data WHERE date >= '2024-01-01'; + +-- 2. Before ETL processes that need to see uncommitted changes +SET SESSION CHARACTERISTICS AS TRANSACTION READ WRITE, ISOLATION LEVEL READ UNCOMMITTED; +-- INSERT INTO staging_table SELECT * FROM source_table; + +-- 3. For applications requiring serializable isolation +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE; +-- BEGIN; +-- UPDATE accounts SET balance = balance - 100 WHERE account_id = 1; +-- UPDATE accounts SET balance = balance + 100 WHERE account_id = 2; +-- COMMIT; + +-- Note: In Amazon Redshift, this command is deprecated. +-- The recommended approach is to use SET commands for individual settings: +-- SET default_transaction_isolation TO 'serializable'; +-- SET default_transaction_read_only TO true; \ No newline at end of file diff --git a/redshift/examples/redshift/show.sql b/redshift/examples/redshift/show.sql new file mode 100644 index 0000000..ccff865 --- /dev/null +++ b/redshift/examples/redshift/show.sql @@ -0,0 +1,99 @@ +-- SHOW command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW.html + +-- Basic SHOW commands for specific parameters +SHOW query_group; +SHOW datestyle; +SHOW extra_float_digits; +SHOW search_path; +SHOW statement_timeout; +SHOW enable_case_sensitive_identifier; +SHOW enable_result_cache_for_session; +SHOW json_configuration_file; +SHOW max_concurrency_scaling_clusters; +SHOW mv_enable_aqmv_for_session; +SHOW use_fips_ssl; +SHOW wlm_json_configuration; + +-- SHOW ALL command +SHOW ALL; + +-- Session context variables +SHOW app_context.user_id; +SHOW app_context.client_id; +SHOW app_context.tenant_id; +SHOW application_context.user_name; +SHOW session_context.request_id; + +-- Common parameter names from AWS documentation +SHOW analyze_threshold_percent; +SHOW datashare_database_mode; +SHOW default_geometry_encoding; +SHOW describe_field_name_in_uppercase; +SHOW downcase_delimited_identifier; +SHOW enable_hll; +SHOW enable_vacuum_boost; +SHOW explain_returntargetlist; +SHOW ignore_session_isolation_level_for_datashares; +SHOW json_serialization_enable; +SHOW json_serialization_parse_nested_strings; +SHOW max_cursor_result_set_size; +SHOW preserved_statements_count; +SHOW query_planning_improvement; +SHOW reader_endpoint_validated_clusters; +SHOW spectrum_enable_pseudo_columns; +SHOW timezone; + +-- Additional common parameters +SHOW client_encoding; +SHOW IntervalStyle; +SHOW standard_conforming_strings; +SHOW transaction_isolation; +SHOW transaction_read_only; +SHOW transaction_deferrable; + +-- Mixed case parameter names +SHOW TimeZone; +SHOW DateStyle; +SHOW IntervalStyle; + +-- Parameter names with underscores +SHOW enable_interleaved_sort_key; +SHOW max_query_queue_time; +SHOW query_timeout; +SHOW idle_in_transaction_session_timeout; +SHOW lock_timeout; + +-- System information parameters +SHOW server_version; +SHOW server_encoding; +SHOW application_name; + +-- WLM related parameters +SHOW wlm_query_slot_count; +SHOW wlm_query_group; +SHOW wlm_memory_percent_to_use; + +-- Spectrum related parameters +SHOW spectrum_query_maxerror; +SHOW spectrum_iam_role; + +-- Encoding related parameters +SHOW client_encoding; +SHOW server_encoding; + +-- Session parameters (using valid Redshift SHOW syntax) +SHOW current_user; +SHOW current_database; + +-- Database connection parameters +SHOW current_database; +SHOW current_user; +SHOW session_user; + +-- Additional context variable examples with different naming patterns +SHOW app.user_id; +SHOW application.session_id; +SHOW context.request_id; +SHOW custom_context.department_id; +SHOW my_app_context.organization_id; \ No newline at end of file diff --git a/redshift/examples/redshift/show_columns.sql b/redshift/examples/redshift/show_columns.sql new file mode 100644 index 0000000..a25c622 --- /dev/null +++ b/redshift/examples/redshift/show_columns.sql @@ -0,0 +1,101 @@ +-- SHOW COLUMNS command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_COLUMNS.html + +-- Basic syntax with fully qualified table name +SHOW COLUMNS FROM TABLE sample_data_dev.tickit.event; + +-- AWS Glue Data Catalog example with row limit +SHOW COLUMNS FROM TABLE awsdatacatalog.batman.nation LIMIT 2; + +-- Basic table reference (single name) +SHOW COLUMNS FROM TABLE event; +SHOW COLUMNS FROM TABLE sales; +SHOW COLUMNS FROM TABLE venue; +SHOW COLUMNS FROM TABLE listing; +SHOW COLUMNS FROM TABLE category; +SHOW COLUMNS FROM TABLE date; +SHOW COLUMNS FROM TABLE users; + +-- Database and table name (two-part name) +SHOW COLUMNS FROM TABLE tickit.event; +SHOW COLUMNS FROM TABLE tickit.sales; +SHOW COLUMNS FROM TABLE tickit.venue; +SHOW COLUMNS FROM TABLE public.listing; +SHOW COLUMNS FROM TABLE public.category; + +-- Full three-part names (database.schema.table) +SHOW COLUMNS FROM TABLE mydb.public.sales; +SHOW COLUMNS FROM TABLE mydb.public.venue; +SHOW COLUMNS FROM TABLE sample_data_dev.public.users; +SHOW COLUMNS FROM TABLE sample_data_dev.tickit.event; +SHOW COLUMNS FROM TABLE sample_data_dev.tickit.listing; + +-- With LIKE pattern matching +SHOW COLUMNS FROM TABLE event LIKE 'event%'; +SHOW COLUMNS FROM TABLE sales LIKE '%id'; +SHOW COLUMNS FROM TABLE venue LIKE 'venue_%'; +SHOW COLUMNS FROM TABLE users LIKE 'user%'; +SHOW COLUMNS FROM TABLE listing LIKE '%price%'; +SHOW COLUMNS FROM TABLE category LIKE 'cat%'; + +-- With LIKE pattern on fully qualified tables +SHOW COLUMNS FROM TABLE tickit.event LIKE '%date%'; +SHOW COLUMNS FROM TABLE tickit.sales LIKE 'sale%'; +SHOW COLUMNS FROM TABLE sample_data_dev.tickit.venue LIKE '%name%'; + +-- With LIMIT clause +SHOW COLUMNS FROM TABLE event LIMIT 5; +SHOW COLUMNS FROM TABLE sales LIMIT 10; +SHOW COLUMNS FROM TABLE venue LIMIT 3; +SHOW COLUMNS FROM TABLE listing LIMIT 100; +SHOW COLUMNS FROM TABLE category LIMIT 1000; + +-- With LIMIT on fully qualified tables +SHOW COLUMNS FROM TABLE tickit.event LIMIT 5; +SHOW COLUMNS FROM TABLE tickit.sales LIMIT 10; +SHOW COLUMNS FROM TABLE sample_data_dev.tickit.venue LIMIT 20; + +-- Combining LIKE and LIMIT +SHOW COLUMNS FROM TABLE event LIKE 'event%' LIMIT 5; +SHOW COLUMNS FROM TABLE sales LIKE '%id' LIMIT 10; +SHOW COLUMNS FROM TABLE venue LIKE 'venue_%' LIMIT 3; +SHOW COLUMNS FROM TABLE tickit.listing LIKE '%price%' LIMIT 100; +SHOW COLUMNS FROM TABLE sample_data_dev.tickit.category LIKE 'cat%' LIMIT 50; + +-- Edge cases and special patterns +SHOW COLUMNS FROM TABLE sales LIKE '_id'; -- Single character wildcard +SHOW COLUMNS FROM TABLE sales LIKE '%_id'; -- Ends with _id +SHOW COLUMNS FROM TABLE sales LIKE 'sale_'; +SHOW COLUMNS FROM TABLE event LIKE '%time%'; +SHOW COLUMNS FROM TABLE users LIKE 'user_%_%'; -- Multiple wildcards + +-- Maximum limit value (10000) +SHOW COLUMNS FROM TABLE event LIMIT 10000; +SHOW COLUMNS FROM TABLE tickit.sales LIMIT 10000; + +-- Zero limit (should return no rows) +SHOW COLUMNS FROM TABLE event LIMIT 0; + +-- External tables (if supported) +SHOW COLUMNS FROM TABLE external_schema.external_table; +SHOW COLUMNS FROM TABLE awsdatacatalog.external_db.external_table; + +-- Mixed case identifiers +SHOW COLUMNS FROM TABLE MyDatabase.MySchema.MyTable; +SHOW COLUMNS FROM TABLE "MixedCase"."Table"; + +-- Special characters in identifiers (quoted) +SHOW COLUMNS FROM TABLE "special-db"."special-schema"."special-table"; +SHOW COLUMNS FROM TABLE "db.with.dots"."schema"."table"; + +-- Complex LIKE patterns +SHOW COLUMNS FROM TABLE sales LIKE 's%s'; +SHOW COLUMNS FROM TABLE sales LIKE '%a%e%'; +SHOW COLUMNS FROM TABLE venue LIKE 'v____e%'; -- Four underscores +SHOW COLUMNS FROM TABLE listing LIKE 'l%ing%'; + +-- AWS Glue Data Catalog patterns +SHOW COLUMNS FROM TABLE awsdatacatalog.mydb.mytable; +SHOW COLUMNS FROM TABLE awsdatacatalog.mydb.mytable LIKE 'col%'; +SHOW COLUMNS FROM TABLE awsdatacatalog.mydb.mytable LIMIT 5; +SHOW COLUMNS FROM TABLE awsdatacatalog.mydb.mytable LIKE '%id' LIMIT 10; \ No newline at end of file diff --git a/redshift/examples/redshift/show_databases.sql b/redshift/examples/redshift/show_databases.sql new file mode 100644 index 0000000..60327c2 --- /dev/null +++ b/redshift/examples/redshift/show_databases.sql @@ -0,0 +1,129 @@ +-- SHOW DATABASES test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_DATABASES.html + +-- Basic Usage + +-- Show all databases in the current data warehouse +SHOW DATABASES; + +-- Show databases with a specific limit +SHOW DATABASES LIMIT 10; + +-- Show databases with a smaller limit +SHOW DATABASES LIMIT 5; + +-- Pattern Matching with LIKE + +-- Show databases that start with 'dev' +SHOW DATABASES LIKE 'dev%'; + +-- Show databases that contain 'test' +SHOW DATABASES LIKE '%test%'; + +-- Show databases that end with '_db' +SHOW DATABASES LIKE '%_db'; + +-- Show databases with single character wildcard +SHOW DATABASES LIKE 'db_'; + +-- Show databases matching complex pattern +SHOW DATABASES LIKE 'prod_%_2023'; + +-- Combine LIKE with LIMIT +SHOW DATABASES LIKE 'dev%' LIMIT 5; + +-- Data Catalog Usage + +-- Show databases from data catalog with default settings +SHOW DATABASES FROM DATA CATALOG; + +-- Show databases from data catalog with specific account +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012'; + +-- Show databases from multiple accounts +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012', '234567890123', '345678901234'; + +-- Show databases from data catalog with pattern matching +SHOW DATABASES FROM DATA CATALOG LIKE 'analytics%'; + +-- Show databases from data catalog with limit +SHOW DATABASES FROM DATA CATALOG LIMIT 20; + +-- IAM Role Options + +-- Use default IAM role +SHOW DATABASES FROM DATA CATALOG IAM_ROLE DEFAULT; + +-- Use session credentials +SHOW DATABASES FROM DATA CATALOG IAM_ROLE SESSION; + +-- Use specific IAM role ARN +SHOW DATABASES FROM DATA CATALOG IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftDataCatalogRole'; + +-- Complex Combinations + +-- Data catalog with account and IAM role +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012' IAM_ROLE DEFAULT; + +-- Data catalog with account, pattern, and limit +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012' LIKE 'prod%' LIMIT 10; + +-- Data catalog with multiple accounts and pattern +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012', '234567890123' LIKE 'staging_%'; + +-- Full syntax with all options +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012', '234567890123' LIKE 'analytics%' IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftRole' LIMIT 50; + +-- Edge Cases and Special Patterns + +-- Show databases with exact name match (no wildcards) +SHOW DATABASES LIKE 'mydb'; + +-- Show all databases (equivalent to no LIKE clause) +SHOW DATABASES LIKE '%'; + +-- Empty result scenarios +SHOW DATABASES LIKE 'nonexistent%'; + +-- Maximum limit +SHOW DATABASES LIMIT 10000; + +-- Minimum limit +SHOW DATABASES LIMIT 1; + +-- Zero limit (should return no results) +SHOW DATABASES LIMIT 0; + +-- Pattern with underscores (literal underscore in database name) +SHOW DATABASES LIKE 'my\_database'; + +-- Pattern with percentage sign (literal % in database name) +SHOW DATABASES LIKE 'db\%prod'; + +-- Multiple wildcards in pattern +SHOW DATABASES LIKE '%dev%test%'; + +-- Case sensitivity tests (Redshift is case-insensitive by default) +SHOW DATABASES LIKE 'DEV%'; +SHOW DATABASES LIKE 'Dev%'; +SHOW DATABASES LIKE 'dev%'; + +-- Quoted identifiers in LIKE patterns +SHOW DATABASES LIKE '"MyDatabase"'; + +-- Special characters in patterns +SHOW DATABASES LIKE 'db-prod-%'; +SHOW DATABASES LIKE 'db.test.%'; +SHOW DATABASES LIKE 'db$prod%'; + +-- IAM Role variations +SHOW DATABASES FROM DATA CATALOG IAM_ROLE 'SESSION'; +SHOW DATABASES FROM DATA CATALOG IAM_ROLE 'default'; +SHOW DATABASES FROM DATA CATALOG IAM_ROLE 'arn:aws:iam::123456789012:role/service-role/AmazonRedshift-CommandsAccessRole-20231201'; + +-- Multiple account IDs with different formats +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012', '000000000000', '999999999999'; + +-- All options combined in different orders +SHOW DATABASES FROM DATA CATALOG IAM_ROLE DEFAULT ACCOUNT '123456789012' LIKE 'prod%' LIMIT 25; +SHOW DATABASES FROM DATA CATALOG ACCOUNT '123456789012' IAM_ROLE 'arn:aws:iam::123456789012:role/RedshiftRole' LIKE 'test%' LIMIT 15; \ No newline at end of file diff --git a/redshift/examples/redshift/show_datashares.sql b/redshift/examples/redshift/show_datashares.sql new file mode 100644 index 0000000..18f3f45 --- /dev/null +++ b/redshift/examples/redshift/show_datashares.sql @@ -0,0 +1,112 @@ +-- SHOW DATASHARES test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_DATASHARES.html + +-- Basic SHOW DATASHARES command +-- Shows all datashares in the cluster +SHOW DATASHARES; + +-- With LIKE pattern - exact match +SHOW DATASHARES LIKE 'salesshare'; + +-- With LIKE pattern - wildcard at end +-- Shows all datashares starting with 'sales' +SHOW DATASHARES LIKE 'sales%'; + +-- With LIKE pattern - wildcard at beginning +-- Shows all datashares ending with 'share' +SHOW DATASHARES LIKE '%share'; + +-- With LIKE pattern - wildcard in middle +-- Shows all datashares containing 'data' +SHOW DATASHARES LIKE '%data%'; + +-- With LIKE pattern - single character wildcard +-- Shows datashares matching pattern like 'share1', 'share2', etc. +SHOW DATASHARES LIKE 'share_'; + +-- Complex LIKE patterns +SHOW DATASHARES LIKE 'prod_%_share'; +SHOW DATASHARES LIKE 'test_datashare_%'; +SHOW DATASHARES LIKE '_____share'; -- Exactly 5 characters before 'share' + +-- Case variations (SQL keywords are case-insensitive) +show datashares; +Show Datashares; +SHOW datashares; +show DATASHARES; + +-- With LIKE in different cases +show datashares like 'myshare%'; +SHOW DATASHARES Like 'test%'; +Show Datashares LIKE 'prod%'; + +-- Edge cases with special characters in patterns +SHOW DATASHARES LIKE 'share$%'; +SHOW DATASHARES LIKE 'share@test%'; +SHOW DATASHARES LIKE 'share-prod%'; +SHOW DATASHARES LIKE 'share.dev%'; + +-- Empty pattern +SHOW DATASHARES LIKE ''; + +-- Pattern with only wildcards +SHOW DATASHARES LIKE '%'; +SHOW DATASHARES LIKE '%%'; +SHOW DATASHARES LIKE '_%'; + +-- Patterns with escaped characters +SHOW DATASHARES LIKE 'share\_prod%'; -- Looking for literal underscore +SHOW DATASHARES LIKE 'share\%test'; -- Looking for literal percent + +-- Multi-line formatting +SHOW + DATASHARES; + +SHOW DATASHARES + LIKE 'sales%'; + +SHOW + DATASHARES + LIKE + 'prod%'; + +-- With comments +SHOW DATASHARES; -- Show all datashares +SHOW DATASHARES LIKE 'test%'; -- Show test datashares +/* Show production datashares */ SHOW DATASHARES LIKE 'prod%'; + +-- Common naming patterns +SHOW DATASHARES LIKE 'dev_%'; +SHOW DATASHARES LIKE 'staging_%'; +SHOW DATASHARES LIKE 'prod_%'; +SHOW DATASHARES LIKE '%_backup'; +SHOW DATASHARES LIKE '%_archive'; +SHOW DATASHARES LIKE '%_replica'; + +-- Date-based patterns +SHOW DATASHARES LIKE '%2024%'; +SHOW DATASHARES LIKE '%202401%'; +SHOW DATASHARES LIKE '%20240115%'; + +-- Department/team patterns +SHOW DATASHARES LIKE 'finance_%'; +SHOW DATASHARES LIKE 'marketing_%'; +SHOW DATASHARES LIKE 'analytics_%'; +SHOW DATASHARES LIKE 'engineering_%'; + +-- Region-based patterns +SHOW DATASHARES LIKE '%_us_east_%'; +SHOW DATASHARES LIKE '%_eu_west_%'; +SHOW DATASHARES LIKE '%_ap_south_%'; + +-- Version patterns +SHOW DATASHARES LIKE '%_v1'; +SHOW DATASHARES LIKE '%_v2'; +SHOW DATASHARES LIKE '%_v1.0'; +SHOW DATASHARES LIKE '%_v2.1'; + +-- Complex real-world examples +SHOW DATASHARES LIKE 'sales_prod_us_east_%'; +SHOW DATASHARES LIKE 'analytics_staging_v2_%'; +SHOW DATASHARES LIKE 'finance_archive_2024%'; +SHOW DATASHARES LIKE 'marketing_dev_%_backup'; \ No newline at end of file diff --git a/redshift/examples/redshift/show_external_table.sql b/redshift/examples/redshift/show_external_table.sql new file mode 100644 index 0000000..2939ad6 --- /dev/null +++ b/redshift/examples/redshift/show_external_table.sql @@ -0,0 +1,65 @@ +-- SHOW EXTERNAL TABLE command test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_EXTERNAL_TABLE.html + +-- Basic SHOW EXTERNAL TABLE command +SHOW EXTERNAL TABLE spectrum.sales; + +-- With schema and table name +SHOW EXTERNAL TABLE my_schema.alldatatypes_parquet_test_partitioned; + +-- With database, schema, and table name +SHOW EXTERNAL TABLE my_database.my_schema.alldatatypes_parquet_test_partitioned; + +-- With PARTITION option +SHOW EXTERNAL TABLE my_schema.alldatatypes_parquet_test_partitioned PARTITION; + +-- With database and PARTITION option +SHOW EXTERNAL TABLE my_database.my_schema.sales_data PARTITION; + +-- Various external table names +SHOW EXTERNAL TABLE spectrum.customer_data; +SHOW EXTERNAL TABLE external_schema.transactions; +SHOW EXTERNAL TABLE analytics_db.external_schema.user_events; + +-- With quoted identifiers +SHOW EXTERNAL TABLE "My_Schema"."My_Table"; +SHOW EXTERNAL TABLE my_db."External_Schema"."Table_Name"; + +-- Mixed case without quotes +SHOW EXTERNAL TABLE MyDatabase.MySchema.MyTable; + +-- With underscores and numbers in names +SHOW EXTERNAL TABLE db_2024.schema_01.table_v2; +SHOW EXTERNAL TABLE external_db.ext_schema.sales_2024_q1; + +-- Test with PARTITION keyword +SHOW EXTERNAL TABLE spectrum.sales_partitioned PARTITION; +SHOW EXTERNAL TABLE analytics.external_data.events_partitioned PARTITION; + +-- Real-world examples from documentation +SHOW EXTERNAL TABLE spectrum.alldatatypes_parquet_test_partitioned; +SHOW EXTERNAL TABLE spectrum.alldatatypes_parquet_test_partitioned PARTITION; + +-- Edge cases with special naming +SHOW EXTERNAL TABLE "database-name"."schema-name"."table-name"; +SHOW EXTERNAL TABLE db123.schema456.table789; + +-- Multiple levels of qualification +SHOW EXTERNAL TABLE prod_db.spectrum_schema.fact_sales; +SHOW EXTERNAL TABLE test_db.external_s3.dim_customer PARTITION; + +-- Various partition table examples +SHOW EXTERNAL TABLE sales_db.spectrum.sales_by_region PARTITION; +SHOW EXTERNAL TABLE marketing.external_s3.campaigns_by_date PARTITION; +SHOW EXTERNAL TABLE finance.spectrum_tables.transactions_by_month PARTITION; + +-- Comments to test parser's comment handling +-- This is a comment +SHOW EXTERNAL TABLE my_schema.my_table; -- inline comment + +/* Block comment test */ +SHOW EXTERNAL TABLE db.schema.table_name; + +/* Multi-line + block comment */ +SHOW EXTERNAL TABLE external_database.external_schema.external_table PARTITION; \ No newline at end of file diff --git a/redshift/examples/redshift/show_grants.sql b/redshift/examples/redshift/show_grants.sql new file mode 100644 index 0000000..ea1a1e3 --- /dev/null +++ b/redshift/examples/redshift/show_grants.sql @@ -0,0 +1,168 @@ +-- SHOW GRANTS test cases based on AWS Redshift documentation +-- https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_GRANTS.html + +-- ============================================== +-- 1. Show grants on database objects +-- ============================================== + +-- Show grants on a database +SHOW GRANTS ON DATABASE dev; +SHOW GRANTS ON DATABASE mydb; +SHOW GRANTS ON DATABASE sales_db; + +-- Show grants on a database for a specific user +SHOW GRANTS ON DATABASE dev FOR alice; +SHOW GRANTS ON DATABASE mydb FOR bob; +SHOW GRANTS ON DATABASE sales_db FOR ROLE analyst_role; +SHOW GRANTS ON DATABASE test_db FOR PUBLIC; + +-- Show grants on a database with limit +SHOW GRANTS ON DATABASE dev LIMIT 10; +SHOW GRANTS ON DATABASE mydb FOR alice LIMIT 100; +SHOW GRANTS ON DATABASE sales_db FOR ROLE admin_role LIMIT 5000; + +-- ============================================== +-- 2. Show grants on schemas +-- ============================================== + +-- Show grants on a schema (simple name) +SHOW GRANTS ON SCHEMA demo; +SHOW GRANTS ON SCHEMA public; +SHOW GRANTS ON SCHEMA sales; + +-- Show grants on a schema (qualified with database) +SHOW GRANTS ON SCHEMA mydb.sales; +SHOW GRANTS ON SCHEMA dev.analytics; +SHOW GRANTS ON SCHEMA prod_db.reporting; + +-- Show grants on a schema for specific principals +SHOW GRANTS ON SCHEMA demo FOR alice; +SHOW GRANTS ON SCHEMA public FOR ROLE reader_role; +SHOW GRANTS ON SCHEMA mydb.sales FOR bob; +SHOW GRANTS ON SCHEMA dev.analytics FOR PUBLIC; + +-- Show grants on a schema with limit +SHOW GRANTS ON SCHEMA demo LIMIT 50; +SHOW GRANTS ON SCHEMA mydb.sales FOR alice LIMIT 1000; + +-- ============================================== +-- 3. Show grants on tables +-- ============================================== + +-- Show grants on a table (simple name) +SHOW GRANTS ON t4; +SHOW GRANTS ON customers; +SHOW GRANTS ON orders; + +-- Show grants on a table with TABLE keyword +SHOW GRANTS ON TABLE t4; +SHOW GRANTS ON TABLE public.t4; +SHOW GRANTS ON TABLE customers; + +-- Show grants on a table (two-part notation) +SHOW GRANTS ON TABLE demo_schema.t3; +SHOW GRANTS ON TABLE sales.customers; +SHOW GRANTS ON TABLE analytics.events; +SHOW GRANTS ON demo_schema.t3 FOR alice; +SHOW GRANTS ON sales.customers FOR ROLE sales_role; + +-- Show grants on a table (three-part notation) +SHOW GRANTS ON TABLE demo_db.demo_schema.t3 FOR alice; +SHOW GRANTS ON TABLE mydb.sales.orders FOR bob; +SHOW GRANTS ON TABLE prod_db.analytics.metrics FOR ROLE analyst_role; +SHOW GRANTS ON demo_db.demo_schema.t3 FOR PUBLIC; + +-- Show grants on a table with limit +SHOW GRANTS ON TABLE customers LIMIT 20; +SHOW GRANTS ON TABLE sales.orders FOR alice LIMIT 100; +SHOW GRANTS ON TABLE mydb.sales.products FOR ROLE viewer_role LIMIT 500; + +-- ============================================== +-- 4. Show grants on functions +-- ============================================== + +-- Show grants on a function (without parameters) +SHOW GRANTS ON FUNCTION calculate_total; +SHOW GRANTS ON FUNCTION public.get_user_count; +SHOW GRANTS ON FUNCTION sales.compute_revenue; +SHOW GRANTS ON FUNCTION mydb.analytics.process_data; + +-- Show grants on a function (with empty parameter list) +SHOW GRANTS ON FUNCTION calculate_total(); +SHOW GRANTS ON FUNCTION public.get_user_count(); +SHOW GRANTS ON FUNCTION sales.compute_revenue(); + +-- Show grants on a function (with parameters) +SHOW GRANTS ON FUNCTION add_numbers(integer, integer); +SHOW GRANTS ON FUNCTION public.concat_strings(text, text); +SHOW GRANTS ON FUNCTION sales.calculate_discount(numeric, numeric); +SHOW GRANTS ON FUNCTION mydb.util.format_date(date); + +-- Show grants on a function with named parameters +SHOW GRANTS ON FUNCTION calculate_tax(amount numeric, rate numeric); +SHOW GRANTS ON FUNCTION public.process_order(order_id integer, user_id integer); +SHOW GRANTS ON FUNCTION analytics.aggregate_metrics(start_date date, end_date date, metric_type varchar); + +-- Show grants on a function for specific principals +SHOW GRANTS ON FUNCTION calculate_total FOR alice; +SHOW GRANTS ON FUNCTION public.get_user_count() FOR ROLE app_role; +SHOW GRANTS ON FUNCTION sales.compute_revenue(date, date) FOR bob; +SHOW GRANTS ON FUNCTION mydb.analytics.process_data FOR PUBLIC; + +-- Show grants on a function with limit +SHOW GRANTS ON FUNCTION calculate_total LIMIT 10; +SHOW GRANTS ON FUNCTION public.get_user_count() FOR alice LIMIT 50; + +-- ============================================== +-- 5. Show grants for users and roles +-- ============================================== + +-- Show grants for a user +SHOW GRANTS FOR alice; +SHOW GRANTS FOR bob; +SHOW GRANTS FOR admin_user; +SHOW GRANTS FOR app_service_account; + +-- Show grants for a role +SHOW GRANTS FOR ROLE analyst_role; +SHOW GRANTS FOR ROLE admin_role; +SHOW GRANTS FOR ROLE reader_role; +SHOW GRANTS FOR ROLE developer_role; + +-- Show grants with limit +SHOW GRANTS FOR alice LIMIT 100; +SHOW GRANTS FOR bob LIMIT 500; +SHOW GRANTS FOR ROLE analyst_role LIMIT 1000; +SHOW GRANTS FOR ROLE admin_role LIMIT 10000; + +-- ============================================== +-- 6. Edge cases and complex examples +-- ============================================== + +-- Maximum limit value +SHOW GRANTS ON DATABASE dev LIMIT 10000; +SHOW GRANTS FOR alice LIMIT 10000; + +-- Minimum limit value +SHOW GRANTS ON SCHEMA public LIMIT 0; +SHOW GRANTS FOR ROLE test_role LIMIT 1; + +-- Mixed case identifiers +SHOW GRANTS ON DATABASE Dev; +SHOW GRANTS ON SCHEMA Public; +SHOW GRANTS ON TABLE Customers; +SHOW GRANTS FOR Alice; +SHOW GRANTS FOR ROLE Admin_Role; + +-- Identifiers with underscores and numbers +SHOW GRANTS ON DATABASE test_db_2023; +SHOW GRANTS ON SCHEMA schema_v2; +SHOW GRANTS ON TABLE orders_2023_q4; +SHOW GRANTS ON FUNCTION calc_metrics_v3(integer, date); +SHOW GRANTS FOR user_123; +SHOW GRANTS FOR ROLE role_test_456; + +-- Complex function signatures +SHOW GRANTS ON FUNCTION mydb.analytics.complex_calc(p1 integer, p2 numeric, p3 varchar, p4 date, p5 timestamp); +SHOW GRANTS ON FUNCTION process_array(arr integer[], delimiter text); +SHOW GRANTS ON FUNCTION validate_json(data json, schema text); \ No newline at end of file diff --git a/redshift/examples/redshift/show_model.sql b/redshift/examples/redshift/show_model.sql new file mode 100644 index 0000000..a36140a --- /dev/null +++ b/redshift/examples/redshift/show_model.sql @@ -0,0 +1,42 @@ +-- SHOW MODEL test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_MODEL.html + +-- Test Case 1: Show all models +-- This command shows all models the user has access to +SHOW MODEL ALL; + +-- Test Case 2: Show specific model details +-- This displays detailed information about the customer_churn model +SHOW MODEL customer_churn; + +-- Test Case 3: Show model with schema-qualified name +-- Testing with a fully qualified model name +SHOW MODEL public.customer_churn; + +-- Test Case 4: Show model with quoted identifier +-- Testing with a quoted model name that may contain special characters +SHOW MODEL "my-model-2023"; + +-- Test Case 5: Show model with mixed case identifier +-- Testing with a mixed case model name (case-insensitive in Redshift) +SHOW MODEL CustomerSegmentation; + +-- Test Case 6: Show model with underscore in name +-- Common naming convention for ML models +SHOW MODEL sales_forecast_model; + +-- Test Case 7: Show model with numeric suffix +-- Testing model names with version numbers +SHOW MODEL churn_model_v2; + +-- Test Case 8: Show all models (lowercase) +-- Testing case insensitivity of the ALL keyword +show model all; + +-- Test Case 9: Show specific model (mixed case command) +-- Testing case insensitivity of the SHOW MODEL command +Show Model product_recommendation; + +-- Test Case 10: Show model with long name +-- Testing longer model names +SHOW MODEL customer_lifetime_value_prediction_model_2023; \ No newline at end of file diff --git a/redshift/examples/redshift/show_procedure.sql b/redshift/examples/redshift/show_procedure.sql new file mode 100644 index 0000000..128d18f --- /dev/null +++ b/redshift/examples/redshift/show_procedure.sql @@ -0,0 +1,104 @@ +-- SHOW PROCEDURE Examples +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_PROCEDURE.html + +-- Basic usage: Show procedure with argument types +SHOW PROCEDURE test_sp2(int, varchar); + +-- Show procedure with no arguments +SHOW PROCEDURE simple_proc(); + +-- Show procedure without parentheses (when unique) +SHOW PROCEDURE unique_procedure_name; + +-- Show procedure with multiple arguments +SHOW PROCEDURE calculate_totals(integer, decimal(10,2), varchar(100)); + +-- Show procedure with named arguments and modes +SHOW PROCEDURE process_order(IN order_id integer, INOUT status varchar, OUT result decimal); + +-- Show procedure with complex argument types +SHOW PROCEDURE data_transform( + bigint, + timestamp, + numeric(18,4), + boolean, + char(10), + date +); + +-- Show overloaded procedure with specific signature +SHOW PROCEDURE update_inventory(smallint); +SHOW PROCEDURE update_inventory(integer, varchar); +SHOW PROCEDURE update_inventory(bigint, text, timestamp); + +-- Show procedure with array types +SHOW PROCEDURE array_processor(integer[]); + +-- Show procedure with mixed argument modes +SHOW PROCEDURE complex_proc( + IN input_val integer, + OUT output_val varchar, + INOUT bidirectional_val numeric +); + +-- Show procedure with optional argument names +SHOW PROCEDURE named_args_proc( + customer_id integer, + order_date date, + amount decimal(10,2) +); + +-- Show procedure in specific schema (using qualified name) +SHOW PROCEDURE myschema.special_procedure(integer); + +-- Show procedure with no arguments (both syntaxes) +SHOW PROCEDURE no_args_proc; +SHOW PROCEDURE no_args_proc(); + +-- Show procedure with text/varchar variations +SHOW PROCEDURE string_processor(text); +SHOW PROCEDURE string_processor(varchar); +SHOW PROCEDURE string_processor(varchar(255)); +SHOW PROCEDURE string_processor(character varying(100)); + +-- Show procedure with numeric variations +SHOW PROCEDURE calc_proc(numeric); +SHOW PROCEDURE calc_proc(decimal); +SHOW PROCEDURE calc_proc(numeric(10,2)); +SHOW PROCEDURE calc_proc(decimal(18,4)); + +-- Show procedure with real/double precision +SHOW PROCEDURE float_calc(real); +SHOW PROCEDURE float_calc(double precision); +SHOW PROCEDURE float_calc(float4); +SHOW PROCEDURE float_calc(float8); + +-- Show procedure with timestamp variations +SHOW PROCEDURE time_proc(timestamp); +SHOW PROCEDURE time_proc(timestamp without time zone); +SHOW PROCEDURE time_proc(timestamp with time zone); +SHOW PROCEDURE time_proc(timestamptz); + +-- Show procedure with interval type +SHOW PROCEDURE interval_calc(interval); + +-- Show procedure with boolean type +SHOW PROCEDURE flag_processor(boolean); + +-- Mixed case procedure names +SHOW PROCEDURE "MixedCaseProcedure"(integer); +SHOW PROCEDURE "UPPERCASE_PROC"(varchar); + +-- Procedure with underscore and numbers in name +SHOW PROCEDURE proc_v2_final(integer, varchar); +SHOW PROCEDURE _private_proc(text); +SHOW PROCEDURE proc123(numeric); + +-- Show procedure with all argument modes specified +SHOW PROCEDURE full_spec_proc( + IN param1 integer, + IN param2 varchar(100), + OUT result1 decimal, + OUT result2 text, + INOUT status_flag boolean +); \ No newline at end of file diff --git a/redshift/examples/redshift/show_schemas.sql b/redshift/examples/redshift/show_schemas.sql new file mode 100644 index 0000000..ec3e388 --- /dev/null +++ b/redshift/examples/redshift/show_schemas.sql @@ -0,0 +1,116 @@ +-- SHOW SCHEMAS test cases for Amazon Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_SCHEMAS.html + +-- Basic Usage + +-- Show all schemas from a specific database +SHOW SCHEMAS FROM DATABASE dev; + +-- Show schemas from the default database +SHOW SCHEMAS FROM DATABASE mydb; + +-- Show schemas from a test database +SHOW SCHEMAS FROM DATABASE test_db; + +-- AWS Data Catalog Usage + +-- Show schemas from AWS Glue Data Catalog +SHOW SCHEMAS FROM DATABASE awsdatacatalog; + +-- Show schemas from AWS Glue Data Catalog with limit +SHOW SCHEMAS FROM DATABASE awsdatacatalog LIMIT 5; + +-- Show schemas from AWS Glue Data Catalog with larger limit +SHOW SCHEMAS FROM DATABASE awsdatacatalog LIMIT 100; + +-- Pattern Matching with LIKE + +-- Show schemas that start with 'public' +SHOW SCHEMAS FROM DATABASE dev LIKE 'public%'; + +-- Show schemas that contain 'test' +SHOW SCHEMAS FROM DATABASE mydb LIKE '%test%'; + +-- Show schemas that end with '_schema' +SHOW SCHEMAS FROM DATABASE dev LIKE '%_schema'; + +-- Show schemas with single character wildcard +SHOW SCHEMAS FROM DATABASE test_db LIKE 'schema_'; + +-- Show schemas matching complex pattern +SHOW SCHEMAS FROM DATABASE dev LIKE 'app_%_v2'; + +-- Show schemas that start with 'pg_' +SHOW SCHEMAS FROM DATABASE dev LIKE 'pg_%'; + +-- Combining LIKE and LIMIT + +-- Show up to 10 schemas that start with 'dev' +SHOW SCHEMAS FROM DATABASE mydb LIKE 'dev%' LIMIT 10; + +-- Show up to 5 schemas containing 'analytics' +SHOW SCHEMAS FROM DATABASE awsdatacatalog LIKE '%analytics%' LIMIT 5; + +-- Show up to 20 schemas ending with '_staging' +SHOW SCHEMAS FROM DATABASE dev LIKE '%_staging' LIMIT 20; + +-- Edge Cases and Special Scenarios + +-- Limit with zero rows (should return no results) +SHOW SCHEMAS FROM DATABASE dev LIMIT 0; + +-- Maximum limit value +SHOW SCHEMAS FROM DATABASE dev LIMIT 10000; + +-- Pattern with no wildcards (exact match) +SHOW SCHEMAS FROM DATABASE dev LIKE 'public'; + +-- Pattern with multiple wildcards +SHOW SCHEMAS FROM DATABASE dev LIKE '%test%schema%'; + +-- Pattern with underscore wildcard for single character +SHOW SCHEMAS FROM DATABASE dev LIKE 'schema_1'; + +-- Database names with special characters (quoted identifiers) +SHOW SCHEMAS FROM DATABASE "my-database"; + +-- Database names with mixed case (quoted identifiers) +SHOW SCHEMAS FROM DATABASE "MyDatabase"; + +-- Comments in queries + +-- Show schemas with inline comment +SHOW SCHEMAS FROM DATABASE dev; -- This shows all schemas in dev + +-- Show schemas with multi-line comment +/* + * This query shows schemas from the AWS Data Catalog + * with a limit of 10 rows + */ +SHOW SCHEMAS FROM DATABASE awsdatacatalog LIMIT 10; + +-- Complex pattern matching examples + +-- Show schemas with pattern containing both wildcards +SHOW SCHEMAS FROM DATABASE dev LIKE 'pg_%_temp'; + +-- Show schemas with escaped characters in pattern +SHOW SCHEMAS FROM DATABASE dev LIKE 'schema\_with\_underscores'; + +-- Show schemas with case-sensitive pattern matching +SHOW SCHEMAS FROM DATABASE dev LIKE 'Schema%'; -- Won't match 'schema...' + +-- Additional test cases + +-- Show schemas from catalog with specific patterns +SHOW SCHEMAS FROM DATABASE awsdatacatalog LIKE 'glue_%'; + +-- Show schemas with numeric patterns +SHOW SCHEMAS FROM DATABASE dev LIKE '%2023%'; + +-- Show schemas with very specific pattern +SHOW SCHEMAS FROM DATABASE dev LIKE 'app_v2_%_prod'; + +-- Limit edge cases +SHOW SCHEMAS FROM DATABASE dev LIMIT 1; +SHOW SCHEMAS FROM DATABASE dev LIMIT 9999; \ No newline at end of file diff --git a/redshift/examples/redshift/show_table.sql b/redshift/examples/redshift/show_table.sql new file mode 100644 index 0000000..7d92289 --- /dev/null +++ b/redshift/examples/redshift/show_table.sql @@ -0,0 +1,32 @@ +-- SHOW TABLE Examples +-- https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_TABLE.html + +-- Example 1: Show table definition for sales table +SHOW TABLE sales; + +-- Example 2: Show table definition with schema qualification +SHOW TABLE public.category; + +-- Example 3: Show table after creating with primary key +-- First create a table +CREATE TABLE foo(a INT PRIMARY KEY, b INT); +-- Then show its definition +SHOW TABLE foo; + +-- Example 4: Show table in specific schema +SHOW TABLE myschema.mytable; + +-- Example 5: Simple table name without schema +SHOW TABLE customer; + +-- Example 6: Table with mixed case name (requires quotes in actual usage) +SHOW TABLE "MixedCaseTable"; + +-- Note: SHOW TABLE displays the complete CREATE TABLE statement including: +-- - Column definitions with data types +-- - Column constraints (NOT NULL, DEFAULT, etc.) +-- - Table constraints (PRIMARY KEY, FOREIGN KEY, etc.) +-- - Encoding specifications +-- - Distribution style (DISTKEY) +-- - Sort keys (SORTKEY) +-- - Table properties \ No newline at end of file diff --git a/redshift/examples/redshift/show_tables.sql b/redshift/examples/redshift/show_tables.sql new file mode 100644 index 0000000..f550e79 --- /dev/null +++ b/redshift/examples/redshift/show_tables.sql @@ -0,0 +1,79 @@ +-- SHOW TABLES test cases based on AWS documentation +-- https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_TABLES.html + +-- Basic syntax: Show all tables in a schema +SHOW TABLES FROM SCHEMA dev.public; + +-- Show tables in different schemas +SHOW TABLES FROM SCHEMA mydb.myschema; +SHOW TABLES FROM SCHEMA production.sales; +SHOW TABLES FROM SCHEMA analytics.reports; + +-- Show tables in AWS Glue Data Catalog +SHOW TABLES FROM SCHEMA awsdatacatalog.batman; +SHOW TABLES FROM SCHEMA awsdatacatalog.customer_data; +SHOW TABLES FROM SCHEMA awsdatacatalog.product_catalog; + +-- Using LIKE pattern matching with wildcards +-- % matches zero or more characters +SHOW TABLES FROM SCHEMA dev.public LIKE 'user%'; +SHOW TABLES FROM SCHEMA dev.public LIKE '%_temp'; +SHOW TABLES FROM SCHEMA dev.public LIKE 'log_%'; +SHOW TABLES FROM SCHEMA dev.public LIKE '%customer%'; + +-- Using LIKE with underscore wildcard +-- _ matches exactly one character +SHOW TABLES FROM SCHEMA dev.public LIKE 'user_'; +SHOW TABLES FROM SCHEMA dev.public LIKE 't_mp'; +SHOW TABLES FROM SCHEMA dev.public LIKE '___data'; + +-- Complex LIKE patterns +SHOW TABLES FROM SCHEMA dev.public LIKE 'fact_%_2024'; +SHOW TABLES FROM SCHEMA dev.public LIKE 'dim_%_v%'; +SHOW TABLES FROM SCHEMA dev.public LIKE '%_backup_%'; + +-- Using LIMIT clause +SHOW TABLES FROM SCHEMA dev.public LIMIT 10; +SHOW TABLES FROM SCHEMA dev.public LIMIT 100; +SHOW TABLES FROM SCHEMA dev.public LIMIT 1000; +SHOW TABLES FROM SCHEMA dev.public LIMIT 10000; + +-- Combining LIKE and LIMIT +SHOW TABLES FROM SCHEMA dev.public LIKE 'user%' LIMIT 50; +SHOW TABLES FROM SCHEMA dev.public LIKE '%_temp' LIMIT 20; +SHOW TABLES FROM SCHEMA dev.public LIKE 'fact_%' LIMIT 100; + +-- AWS Glue Data Catalog with filters +SHOW TABLES FROM SCHEMA awsdatacatalog.sales_db LIKE 'orders%' LIMIT 25; +SHOW TABLES FROM SCHEMA awsdatacatalog.analytics LIKE '%_daily' LIMIT 50; + +-- Edge cases with special characters in identifiers +SHOW TABLES FROM SCHEMA "my-db"."my-schema"; +SHOW TABLES FROM SCHEMA "DB_2024"."SCHEMA_PROD"; + +-- Mixed case identifiers +SHOW TABLES FROM SCHEMA MyDatabase.MySchema; +SHOW TABLES FROM SCHEMA MYDB.MYSCHEMA; + +-- Pattern matching edge cases +SHOW TABLES FROM SCHEMA dev.public LIKE ''; -- Empty pattern +SHOW TABLES FROM SCHEMA dev.public LIKE '%'; -- Match all +SHOW TABLES FROM SCHEMA dev.public LIKE '_%'; -- At least one character +SHOW TABLES FROM SCHEMA dev.public LIKE '%_%'; -- Contains at least one character + +-- Numeric limits +SHOW TABLES FROM SCHEMA dev.public LIMIT 0; -- Minimum limit +SHOW TABLES FROM SCHEMA dev.public LIMIT 1; -- Single result + +-- Complex real-world examples +SHOW TABLES FROM SCHEMA production.analytics LIKE 'fact_%_daily' LIMIT 100; +SHOW TABLES FROM SCHEMA staging.etl LIKE 'tmp_%_2024%' LIMIT 50; +SHOW TABLES FROM SCHEMA warehouse.reporting LIKE 'rpt_%_v%' LIMIT 200; + +-- Comments in queries +-- Show user tables +SHOW TABLES FROM SCHEMA dev.public LIKE 'user%'; -- User-related tables + +/* Multi-line comment + Showing temporary tables */ +SHOW TABLES FROM SCHEMA dev.public LIKE '%_temp' LIMIT 10; \ No newline at end of file diff --git a/redshift/examples/redshift/show_view.sql b/redshift/examples/redshift/show_view.sql new file mode 100644 index 0000000..e0d3118 --- /dev/null +++ b/redshift/examples/redshift/show_view.sql @@ -0,0 +1,63 @@ +-- SHOW VIEW command tests +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_SHOW_VIEW.html + +-- Basic usage: show view without schema +SHOW VIEW LA_Venues_v; + +-- Show view with schema name +SHOW VIEW public.Sports_v; + +-- Show view with quoted identifiers +SHOW VIEW "my_view"; +SHOW VIEW "my_schema"."my_view"; + +-- Show views with mixed case names +SHOW VIEW MyView; +SHOW VIEW MySchema.MyView; + +-- Show view with underscores in names +SHOW VIEW sales_summary_view; +SHOW VIEW reporting.monthly_sales_view; + +-- Show view with numbers in names +SHOW VIEW view1; +SHOW VIEW schema1.view2; + +-- Show view for materialized views (mentioned in documentation) +SHOW VIEW materialized_sales_view; +SHOW VIEW analytics.materialized_customer_view; + +-- Show view for late-binding views (mentioned in documentation) +SHOW VIEW late_binding_external_view; +SHOW VIEW external_schema.late_binding_view; + +-- Edge cases with special naming +SHOW VIEW "_view"; +SHOW VIEW "123view"; +SHOW VIEW "view-with-dash"; +SHOW VIEW "schema-name"."view-name"; + +-- Real-world example based on documentation +-- First create a view (commented out as this is just testing SHOW VIEW) +-- CREATE VIEW LA_Venues_v AS SELECT * FROM venue WHERE venuecity='Los Angeles'; +SHOW VIEW LA_Venues_v; + +-- Another real-world example from documentation +-- CREATE VIEW public.Sports_v AS SELECT * FROM category WHERE catgroup='Sports'; +SHOW VIEW public.Sports_v; + +-- Common view patterns +SHOW VIEW customer_summary; +SHOW VIEW sales.revenue_by_region; +SHOW VIEW analytics.user_activity_daily; +SHOW VIEW reporting.quarterly_metrics; + +-- Views with longer names +SHOW VIEW very_long_view_name_that_describes_complex_business_logic; +SHOW VIEW long_schema_name.another_long_view_name_for_testing; + +-- Common abbreviations in view names +SHOW VIEW vw_customers; +SHOW VIEW v_sales; +SHOW VIEW dw.dim_product_v; +SHOW VIEW etl.stg_orders_vw; \ No newline at end of file diff --git a/redshift/examples/redshift/start_transaction.sql b/redshift/examples/redshift/start_transaction.sql new file mode 100644 index 0000000..3ec1770 --- /dev/null +++ b/redshift/examples/redshift/start_transaction.sql @@ -0,0 +1,82 @@ +-- START TRANSACTION test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_START_TRANSACTION.html +-- START TRANSACTION is a synonym of BEGIN + +-- Basic START TRANSACTION +START TRANSACTION; + +-- START TRANSACTION with isolation levels +-- Note: All isolation levels map to SERIALIZABLE in Redshift +START TRANSACTION ISOLATION LEVEL SERIALIZABLE; +START TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; +START TRANSACTION ISOLATION LEVEL READ COMMITTED; +START TRANSACTION ISOLATION LEVEL REPEATABLE READ; + +-- START TRANSACTION with read/write modes +START TRANSACTION READ WRITE; +START TRANSACTION READ ONLY; + +-- START TRANSACTION with both isolation level and read/write mode +START TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE; +START TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY; +START TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE; +START TRANSACTION ISOLATION LEVEL READ COMMITTED READ ONLY; +START TRANSACTION ISOLATION LEVEL READ UNCOMMITTED READ WRITE; +START TRANSACTION ISOLATION LEVEL READ UNCOMMITTED READ ONLY; +START TRANSACTION ISOLATION LEVEL REPEATABLE READ READ WRITE; +START TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY; + +-- Order variations (read/write mode before isolation level) +START TRANSACTION READ WRITE ISOLATION LEVEL SERIALIZABLE; +START TRANSACTION READ ONLY ISOLATION LEVEL READ COMMITTED; + +-- Case variations (SQL is case-insensitive) +start transaction; +Start Transaction; +START transaction; +start TRANSACTION; + +-- With isolation level case variations +start transaction isolation level serializable; +START TRANSACTION ISOLATION level READ UNCOMMITTED; +Start Transaction Isolation Level Read Committed; + +-- With read/write mode case variations +start transaction read write; +START TRANSACTION READ only; +Start Transaction Read Write; + +-- Complex case variations +start transaction isolation level serializable read write; +START TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY; +Start Transaction Read Only Isolation Level Read Uncommitted; + +-- Example usage in a transaction block +START TRANSACTION; +-- Insert some data +-- UPDATE operations +-- SELECT queries +COMMIT; + +-- Example with read only mode +START TRANSACTION READ ONLY; +-- SELECT queries only +-- No INSERT/UPDATE/DELETE allowed +COMMIT; + +-- Example with explicit isolation level +START TRANSACTION ISOLATION LEVEL SERIALIZABLE; +-- Operations with serializable isolation +-- This is the default in Redshift +END; + +-- Example combining with other transaction control +START TRANSACTION READ WRITE; +-- Some operations +ROLLBACK; + +-- Note: These are equivalent in Redshift: +-- START TRANSACTION; +-- BEGIN; +-- BEGIN TRANSACTION; +-- BEGIN WORK; \ No newline at end of file diff --git a/redshift/examples/redshift/truncate.sql b/redshift/examples/redshift/truncate.sql new file mode 100644 index 0000000..e76002b --- /dev/null +++ b/redshift/examples/redshift/truncate.sql @@ -0,0 +1,113 @@ +-- TRUNCATE command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_TRUNCATE.html + +-- Basic TRUNCATE statements +TRUNCATE category; +truncate category; + +-- TRUNCATE with TABLE keyword (optional) +TRUNCATE TABLE category; +truncate table category; + +-- TRUNCATE materialized view +TRUNCATE my_materialized_view; +truncate my_materialized_view; + +-- Examples from AWS documentation +-- Example 1: Truncate a table (CATEGORY table is empty after this command) +TRUNCATE category; + +-- Example 2: Truncate a materialized view +TRUNCATE my_materialized_view; + +-- Example 3: Demonstrating automatic commit behavior +-- The following transaction is automatically committed, and the rollback has no effect +BEGIN; +TRUNCATE date; +ROLLBACK; +-- DATE table remains empty after ROLLBACK + +-- Mixed case variations +Truncate category; +TRUNCATE CATEGORY; +TrUnCaTe TaBlE category; +Truncate Table Category; + +-- Quoted identifiers +TRUNCATE "category"; +TRUNCATE TABLE "category"; +TRUNCATE "my_table"; +truncate table "my_table"; + +-- Tables with schema qualifiers +TRUNCATE public.category; +TRUNCATE TABLE public.category; +truncate sales.fact_sales; +TRUNCATE TABLE marketing.campaign_data; + +-- Quoted schema and table names +TRUNCATE "public"."category"; +TRUNCATE TABLE "public"."category"; +truncate "sales"."fact_sales"; + +-- Mixed quoted and unquoted identifiers +TRUNCATE public."category"; +TRUNCATE "public".category; +truncate table sales."fact_sales"; + +-- Special characters in quoted names +TRUNCATE "table-with-hyphens"; +TRUNCATE TABLE "table.with.dots"; +truncate "table with spaces"; +TRUNCATE TABLE "CaseSensitiveTable"; + +-- Materialized views with various naming patterns +TRUNCATE mv_sales_summary; +TRUNCATE materialized_view_1; +truncate "mv_complex-name"; +TRUNCATE public.mv_aggregated_data; +TRUNCATE "schema"."mv_quoted"; + +-- Real-world usage examples +-- Example: Truncating staging tables +TRUNCATE staging.raw_events; +TRUNCATE TABLE staging.temp_users; + +-- Example: Truncating temporary tables +TRUNCATE temp_analysis; +TRUNCATE TABLE temp_calculations; + +-- Example: Truncating fact tables for reload +TRUNCATE fact_sales; +TRUNCATE TABLE fact_inventory; + +-- Example: Truncating dimension tables +TRUNCATE dim_product; +TRUNCATE TABLE dim_customer; + +-- Example: Truncating error or log tables +TRUNCATE etl_errors; +TRUNCATE TABLE process_log; + +-- Example: Transaction blocks showing automatic commit +BEGIN; +TRUNCATE staging_table; +-- Any subsequent commands in this transaction will see empty staging_table +SELECT COUNT(*) FROM staging_table; -- Returns 0 +COMMIT; -- This COMMIT is effectively a no-op since TRUNCATE already committed + +BEGIN TRANSACTION; +TRUNCATE audit_log; +-- Even if we try to rollback, the TRUNCATE has already committed +ROLLBACK; -- This has no effect on the TRUNCATE operation + +-- Example: Using TRUNCATE in ETL processes +-- Step 1: Truncate staging +TRUNCATE staging.customer_data; + +-- Step 2: Truncate target before reload +TRUNCATE fact_customer_transactions; + +-- Example: Maintenance operations +TRUNCATE old_backup_table; +TRUNCATE TABLE archived_data_2020; \ No newline at end of file diff --git a/redshift/examples/redshift/unload.sql b/redshift/examples/redshift/unload.sql new file mode 100644 index 0000000..d963158 --- /dev/null +++ b/redshift/examples/redshift/unload.sql @@ -0,0 +1,286 @@ +-- UNLOAD command test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_UNLOAD.html + +-- Basic UNLOAD with minimal options +UNLOAD ('SELECT * FROM sales') +TO 's3://mybucket/myprefix' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole'; + +-- UNLOAD with DEFAULT IAM role +UNLOAD ('SELECT * FROM customers') +TO 's3://mybucket/customers/' +IAM_ROLE default; + +-- UNLOAD with CSV format +UNLOAD ('SELECT * FROM products') +TO 's3://mybucket/products/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT CSV; + +-- UNLOAD with PARQUET format +UNLOAD ('SELECT * FROM orders') +TO 's3://mybucket/orders/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT PARQUET; + +-- UNLOAD with JSON format +UNLOAD ('SELECT * FROM events') +TO 's3://mybucket/events/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT JSON; + +-- UNLOAD with PARTITION BY +UNLOAD ('SELECT * FROM sales_data') +TO 's3://mybucket/partitioned/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +PARTITION BY (year, month); + +-- UNLOAD with PARTITION BY and INCLUDE +UNLOAD ('SELECT * FROM sales_data') +TO 's3://mybucket/partitioned_include/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +PARTITION BY (region, category) INCLUDE; + +-- UNLOAD with MANIFEST +UNLOAD ('SELECT * FROM inventory') +TO 's3://mybucket/inventory/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +MANIFEST; + +-- UNLOAD with MANIFEST VERBOSE +UNLOAD ('SELECT * FROM inventory') +TO 's3://mybucket/inventory_verbose/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +MANIFEST VERBOSE; + +-- UNLOAD with HEADER (for CSV) +UNLOAD ('SELECT * FROM employees') +TO 's3://mybucket/employees/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT CSV +HEADER; + +-- UNLOAD with custom DELIMITER +UNLOAD ('SELECT * FROM data') +TO 's3://mybucket/data/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER AS '|'; + +-- UNLOAD with DELIMITER without AS +UNLOAD ('SELECT * FROM data') +TO 's3://mybucket/data_tab/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +DELIMITER '\t'; + +-- UNLOAD with FIXEDWIDTH +UNLOAD ('SELECT * FROM fixed_data') +TO 's3://mybucket/fixed/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FIXEDWIDTH 'name:30,age:3,city:20'; + +-- UNLOAD with ENCRYPTED +UNLOAD ('SELECT * FROM sensitive_data') +TO 's3://mybucket/encrypted/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ENCRYPTED; + +-- UNLOAD with ENCRYPTED AUTO +UNLOAD ('SELECT * FROM sensitive_data') +TO 's3://mybucket/encrypted_auto/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ENCRYPTED AUTO; + +-- UNLOAD with KMS_KEY_ID +UNLOAD ('SELECT * FROM confidential') +TO 's3://mybucket/kms_encrypted/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ENCRYPTED +KMS_KEY_ID '1234abcd-12ab-34cd-56ef-1234567890ab'; + +-- UNLOAD with BZIP2 compression +UNLOAD ('SELECT * FROM large_table') +TO 's3://mybucket/compressed/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +BZIP2; + +-- UNLOAD with GZIP compression +UNLOAD ('SELECT * FROM large_table') +TO 's3://mybucket/gzipped/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +GZIP; + +-- UNLOAD with ZSTD compression +UNLOAD ('SELECT * FROM large_table') +TO 's3://mybucket/zstd_compressed/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ZSTD; + +-- UNLOAD with ADDQUOTES +UNLOAD ('SELECT * FROM text_data') +TO 's3://mybucket/quoted/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ADDQUOTES; + +-- UNLOAD with NULL AS +UNLOAD ('SELECT * FROM nullable_data') +TO 's3://mybucket/nulls/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +NULL AS '\\N'; + +-- UNLOAD with ESCAPE +UNLOAD ('SELECT * FROM special_chars') +TO 's3://mybucket/escaped/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ESCAPE; + +-- UNLOAD with ALLOWOVERWRITE +UNLOAD ('SELECT * FROM daily_data') +TO 's3://mybucket/daily/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +ALLOWOVERWRITE; + +-- UNLOAD with CLEANPATH +UNLOAD ('SELECT * FROM temp_data') +TO 's3://mybucket/clean/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +CLEANPATH; + +-- UNLOAD with PARALLEL ON +UNLOAD ('SELECT * FROM large_dataset') +TO 's3://mybucket/parallel/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +PARALLEL ON; + +-- UNLOAD with PARALLEL OFF +UNLOAD ('SELECT * FROM small_dataset') +TO 's3://mybucket/sequential/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +PARALLEL OFF; + +-- UNLOAD with MAXFILESIZE in MB +UNLOAD ('SELECT * FROM huge_table') +TO 's3://mybucket/sized/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +MAXFILESIZE 100 MB; + +-- UNLOAD with MAXFILESIZE AS and GB +UNLOAD ('SELECT * FROM huge_table') +TO 's3://mybucket/sized_gb/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +MAXFILESIZE AS 1 GB; + +-- UNLOAD with MAXFILESIZE without unit (defaults to MB) +UNLOAD ('SELECT * FROM huge_table') +TO 's3://mybucket/sized_default/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +MAXFILESIZE 500; + +-- UNLOAD with ROWGROUPSIZE for Parquet +UNLOAD ('SELECT * FROM parquet_data') +TO 's3://mybucket/parquet_rg/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT PARQUET +ROWGROUPSIZE 128 MB; + +-- UNLOAD with ROWGROUPSIZE AS +UNLOAD ('SELECT * FROM parquet_data') +TO 's3://mybucket/parquet_rg_as/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT PARQUET +ROWGROUPSIZE AS 256 MB; + +-- UNLOAD with REGION +UNLOAD ('SELECT * FROM regional_data') +TO 's3://mybucket/regional/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +REGION 'us-west-2'; + +-- UNLOAD with REGION AS +UNLOAD ('SELECT * FROM regional_data') +TO 's3://mybucket/regional_as/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +REGION AS 'eu-west-1'; + +-- UNLOAD with EXTENSION +UNLOAD ('SELECT * FROM custom_data') +TO 's3://mybucket/custom/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +EXTENSION 'txt'; + +-- Complex UNLOAD with multiple options +UNLOAD ('SELECT customer_id, order_date, total_amount FROM orders WHERE order_date >= ''2023-01-01''') +TO 's3://mybucket/orders/2023/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT CSV +HEADER +DELIMITER AS ',' +ADDQUOTES +NULL AS '' +ESCAPE +PARALLEL ON +MAXFILESIZE 100 MB +GZIP +MANIFEST +ALLOWOVERWRITE; + +-- UNLOAD with Parquet format and multiple options +UNLOAD ('SELECT * FROM fact_sales') +TO 's3://mybucket/fact_sales/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT PARQUET +PARTITION BY (year, month, day) INCLUDE +ROWGROUPSIZE 512 MB +MAXFILESIZE 1 GB +ENCRYPTED AUTO +MANIFEST VERBOSE +CLEANPATH; + +-- UNLOAD with JSON format and options +UNLOAD ('SELECT event_id, event_type, event_data, timestamp FROM events') +TO 's3://mybucket/events/json/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT JSON +MAXFILESIZE 250 MB +ZSTD +MANIFEST +REGION 'ap-southeast-1' +EXTENSION 'json.zst'; + +-- UNLOAD with complex SELECT statement +UNLOAD (' + WITH monthly_sales AS ( + SELECT + DATE_TRUNC(''month'', order_date) as month, + SUM(total_amount) as total_sales, + COUNT(*) as order_count + FROM orders + WHERE order_date >= ''2023-01-01'' + GROUP BY 1 + ) + SELECT * FROM monthly_sales + ORDER BY month +') +TO 's3://mybucket/monthly_reports/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT CSV +HEADER +PARALLEL OFF; + +-- UNLOAD with JOIN query +UNLOAD (' + SELECT + c.customer_id, + c.customer_name, + o.order_id, + o.order_date, + o.total_amount + FROM customers c + JOIN orders o ON c.customer_id = o.customer_id + WHERE o.order_date >= DATEADD(month, -3, CURRENT_DATE) +') +TO 's3://mybucket/customer_orders/' +IAM_ROLE 'arn:aws:iam::123456789012:role/MyRedshiftRole' +FORMAT PARQUET +PARTITION BY (order_date) +MAXFILESIZE 500 MB +MANIFEST VERBOSE; \ No newline at end of file diff --git a/redshift/examples/redshift/update.sql b/redshift/examples/redshift/update.sql new file mode 100644 index 0000000..b48ad98 --- /dev/null +++ b/redshift/examples/redshift/update.sql @@ -0,0 +1,331 @@ +-- UPDATE command test cases for Redshift +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_UPDATE.html + +-- ===================================== +-- Basic UPDATE statements +-- ===================================== + +-- Simple UPDATE with single column +UPDATE users SET email = 'newemail@example.com' WHERE userid = 1; + +-- UPDATE with schema-qualified table name +UPDATE public.users SET email = 'newemail@example.com' WHERE userid = 1; + +-- UPDATE multiple columns +UPDATE category +SET catgroup = 'Theatre', + catname = 'Broadway', + catdesc = 'All Broadway shows' +WHERE catid = 10; + +-- UPDATE with expression +UPDATE sales +SET commission = salesamt * 0.05 +WHERE salesamt > 10000; + +-- UPDATE with DEFAULT value +UPDATE product +SET discount = DEFAULT +WHERE category = 'discontinued'; + +-- UPDATE with NULL value +UPDATE customer +SET middle_name = NULL +WHERE middle_name = ''; + +-- ===================================== +-- UPDATE with subqueries +-- ===================================== + +-- UPDATE with scalar subquery +UPDATE event +SET starttime = (SELECT min(starttime) FROM event WHERE venueid = 40) +WHERE eventid = 5; + +-- UPDATE with correlated subquery +UPDATE sales s +SET pricepaid = ( + SELECT e.price + FROM event e + WHERE e.eventid = s.eventid +) +WHERE s.eventid IN (SELECT eventid FROM event WHERE catid = 7); + +-- UPDATE with subquery in WHERE clause +UPDATE users +SET state = 'CA' +WHERE userid IN ( + SELECT DISTINCT userid + FROM sales + WHERE salesdate > '2023-01-01' +); + +-- ===================================== +-- UPDATE with FROM clause +-- ===================================== + +-- Simple UPDATE with FROM +UPDATE sales +SET pricepaid = e.price +FROM event e +WHERE sales.eventid = e.eventid +AND sales.salesdate = e.starttime; + +-- UPDATE with multiple tables in FROM +UPDATE inventory i +SET quantity = i.quantity - s.quantity_sold +FROM ( + SELECT product_id, SUM(quantity) as quantity_sold + FROM sales_detail + WHERE sale_date = CURRENT_DATE + GROUP BY product_id +) s +WHERE i.product_id = s.product_id; + +-- UPDATE with table alias +UPDATE users u +SET email = lower(u.email) +WHERE u.email LIKE '%@EXAMPLE.COM'; + +-- UPDATE with self-join +UPDATE category c1 +SET catdesc = c2.catdesc +FROM category c2 +WHERE c1.catid = c2.catid + 100 +AND c2.catgroup = 'Sports'; + +-- ===================================== +-- UPDATE with CTEs (Common Table Expressions) +-- ===================================== + +-- UPDATE with simple CTE +WITH high_commission_sales AS ( + SELECT salesid + FROM sales + WHERE commission > 100 +) +UPDATE sales +SET commission = commission * 1.1 +WHERE salesid IN (SELECT salesid FROM high_commission_sales); + +-- UPDATE with multiple CTEs +WITH +active_users AS ( + SELECT DISTINCT userid + FROM sales + WHERE salesdate >= CURRENT_DATE - INTERVAL '30 days' +), +high_value_users AS ( + SELECT userid, SUM(pricepaid) as total_spent + FROM sales + GROUP BY userid + HAVING SUM(pricepaid) > 1000 +) +UPDATE users +SET status = 'VIP' +WHERE userid IN ( + SELECT userid FROM active_users + INTERSECT + SELECT userid FROM high_value_users +); + +-- UPDATE with recursive CTE +WITH RECURSIVE category_tree AS ( + SELECT catid, catname, parent_catid, 0 as level + FROM category + WHERE parent_catid IS NULL + + UNION ALL + + SELECT c.catid, c.catname, c.parent_catid, ct.level + 1 + FROM category c + JOIN category_tree ct ON c.parent_catid = ct.catid +) +UPDATE category +SET hierarchy_level = ct.level +FROM category_tree ct +WHERE category.catid = ct.catid; + +-- ===================================== +-- UPDATE with complex expressions +-- ===================================== + +-- UPDATE with CASE expression +UPDATE orders +SET status = CASE + WHEN shipped_date IS NOT NULL THEN 'Shipped' + WHEN cancelled_date IS NOT NULL THEN 'Cancelled' + WHEN payment_date IS NOT NULL THEN 'Paid' + ELSE 'Pending' +END +WHERE order_date >= '2023-01-01'; + +-- UPDATE with multiple CASE expressions +UPDATE product_inventory +SET + stock_status = CASE + WHEN quantity = 0 THEN 'Out of Stock' + WHEN quantity < reorder_level THEN 'Low Stock' + ELSE 'In Stock' + END, + reorder_flag = CASE + WHEN quantity <= reorder_level THEN TRUE + ELSE FALSE + END +WHERE last_updated < CURRENT_DATE; + +-- UPDATE with mathematical expressions +UPDATE sales_forecast +SET + adjusted_forecast = base_forecast * (1 + growth_rate), + confidence_interval = base_forecast * margin_of_error * 2, + last_calculated = CURRENT_TIMESTAMP +WHERE forecast_date > CURRENT_DATE; + +-- UPDATE with string operations +UPDATE customer +SET + full_name = first_name || ' ' || COALESCE(middle_name || ' ', '') || last_name, + search_name = UPPER(last_name || ', ' || first_name) +WHERE full_name IS NULL; + +-- ===================================== +-- UPDATE IDENTITY columns +-- ===================================== + +-- UPDATE GENERATED BY DEFAULT AS IDENTITY column +UPDATE product_catalog +SET product_id = 99999 +WHERE product_name = 'Special Item'; + +-- ===================================== +-- UPDATE with date/time functions +-- ===================================== + +-- UPDATE with date arithmetic +UPDATE subscription +SET + expiry_date = start_date + INTERVAL '1 year', + renewal_reminder_date = expiry_date - INTERVAL '30 days' +WHERE subscription_type = 'Annual'; + +-- UPDATE with current timestamp +UPDATE user_activity +SET + last_login = CURRENT_TIMESTAMP, + login_count = login_count + 1 +WHERE user_id = 12345; + +-- ===================================== +-- UPDATE with window functions (via subquery) +-- ===================================== + +-- UPDATE with row_number +UPDATE sales s +SET rank_in_category = sub.rn +FROM ( + SELECT salesid, + ROW_NUMBER() OVER (PARTITION BY catid ORDER BY pricepaid DESC) as rn + FROM sales +) sub +WHERE s.salesid = sub.salesid; + +-- ===================================== +-- UPDATE with EXISTS +-- ===================================== + +-- UPDATE with EXISTS condition +UPDATE venue +SET active = TRUE +WHERE EXISTS ( + SELECT 1 + FROM event + WHERE event.venueid = venue.venueid + AND event.starttime > CURRENT_DATE +); + +-- UPDATE with NOT EXISTS +UPDATE customer +SET status = 'Inactive' +WHERE NOT EXISTS ( + SELECT 1 + FROM orders + WHERE orders.customer_id = customer.customer_id + AND order_date > CURRENT_DATE - INTERVAL '6 months' +); + +-- ===================================== +-- UPDATE with complex WHERE conditions +-- ===================================== + +-- UPDATE with multiple conditions +UPDATE sales +SET discount_applied = TRUE +WHERE salesdate BETWEEN '2023-01-01' AND '2023-12-31' +AND pricepaid > 100 +AND eventid IN (SELECT eventid FROM event WHERE catid = 7) +AND commission IS NOT NULL; + +-- UPDATE with LIKE pattern +UPDATE users +SET email_domain = 'company.com' +WHERE email LIKE '%@oldcompany.com'; + +-- UPDATE with ILIKE (case-insensitive) +UPDATE product +SET category = 'Electronics' +WHERE product_name ILIKE '%laptop%' + OR product_name ILIKE '%computer%'; + +-- ===================================== +-- UPDATE materialized views (if supported) +-- ===================================== + +-- UPDATE on materialized view +UPDATE sales_summary_mv +SET last_refresh = CURRENT_TIMESTAMP +WHERE summary_date = CURRENT_DATE; + +-- ===================================== +-- Multi-column UPDATE patterns +-- ===================================== + +-- UPDATE multiple columns from subquery +UPDATE order_summary os +SET (total_amount, order_count, last_order_date) = ( + SELECT SUM(amount), COUNT(*), MAX(order_date) + FROM orders o + WHERE o.customer_id = os.customer_id + AND o.order_date >= DATE_TRUNC('month', CURRENT_DATE) +) +WHERE os.summary_month = DATE_TRUNC('month', CURRENT_DATE); + +-- UPDATE with column list syntax +UPDATE sales +SET (pricepaid, commission) = (100.00, 10.00) +WHERE salesid = 12345; + +-- ===================================== +-- Performance considerations +-- ===================================== + +-- UPDATE with proper join conditions to avoid cartesian product +UPDATE large_table lt +SET status = 'Processed' +FROM processing_queue pq +WHERE lt.id = pq.record_id +AND pq.status = 'Ready' +AND pq.process_date = CURRENT_DATE; + +-- UPDATE with limiting conditions for large tables +UPDATE events_archive +SET archived = TRUE +WHERE event_date < CURRENT_DATE - INTERVAL '2 years' +AND archived = FALSE +AND eventid IN ( + SELECT eventid + FROM events_archive + WHERE event_date < CURRENT_DATE - INTERVAL '2 years' + AND archived = FALSE + LIMIT 10000 +); \ No newline at end of file diff --git a/redshift/examples/redshift/use.sql b/redshift/examples/redshift/use.sql new file mode 100644 index 0000000..618fe2c --- /dev/null +++ b/redshift/examples/redshift/use.sql @@ -0,0 +1,61 @@ +-- USE command test cases +-- Changes the current database +-- https://docs.aws.amazon.com/redshift/latest/dg/r_USE.html + +-- Basic USE command +USE mydb; +USE database1; +USE dev; +USE prod; +USE test; + +-- Database names with underscores +USE my_database; +USE test_db; +USE dev_environment; +USE prod_environment; + +-- Database names with numbers +USE db1; +USE database123; +USE test_2023; +USE dev_v2; + +-- Mixed case database names (Redshift is case-insensitive by default) +USE MyDatabase; +USE TestDB; +USE DevEnvironment; + +-- Longer database names +USE production_analytics_database; +USE development_testing_environment; +USE staging_application_database; + +-- Common database naming patterns +USE dwh; +USE data_warehouse; +USE analytics; +USE reporting; +USE staging; +USE sandbox; + +-- Database names that follow common conventions +USE raw_data; +USE processed_data; +USE curated_data; +USE mart_sales; +USE mart_finance; +USE mart_marketing; + +-- Edge cases with valid identifiers +USE db; +USE d; +USE database_with_very_long_name_but_still_valid; + +-- Real-world examples +USE ecommerce; +USE customer_360; +USE revenue_analytics; +USE user_behavior; +USE product_catalog; +USE inventory_management; \ No newline at end of file diff --git a/redshift/examples/redshift/vacuum.sql b/redshift/examples/redshift/vacuum.sql new file mode 100644 index 0000000..029c2f2 --- /dev/null +++ b/redshift/examples/redshift/vacuum.sql @@ -0,0 +1,103 @@ +-- VACUUM command test cases +-- Reference: https://docs.aws.amazon.com/redshift/latest/dg/r_VACUUM_command.html + +-- Basic VACUUM commands +VACUUM; +vacuum; +VACUUM sales; +vacuum "sales_table"; +vacuum public.sales; + +-- VACUUM FULL (default option) +VACUUM FULL; +VACUUM FULL sales; +vacuum full customer_table; +VACUUM FULL sales TO 75 PERCENT; +vacuum full sales to 90 percent; +VACUUM FULL sales BOOST; +vacuum full sales to 80 percent boost; + +-- VACUUM SORT ONLY +VACUUM SORT ONLY; +vacuum sort only; +VACUUM SORT ONLY sales; +vacuum sort only customer_table; +VACUUM SORT ONLY sales TO 75 PERCENT; +vacuum sort only sales to 50 percent; +VACUUM SORT ONLY sales BOOST; +vacuum sort only sales to 95 percent boost; + +-- VACUUM DELETE ONLY +VACUUM DELETE ONLY; +vacuum delete only; +VACUUM DELETE ONLY sales; +vacuum delete only inventory_table; +VACUUM DELETE ONLY sales TO 75 PERCENT; +vacuum delete only sales to 60 percent; +VACUUM DELETE ONLY sales BOOST; +vacuum delete only sales to 85 percent boost; + +-- VACUUM REINDEX (requires table name) +VACUUM REINDEX listing; +vacuum reindex customer_table; +VACUUM REINDEX listing TO 80 PERCENT; +vacuum reindex listing to 90 percent; +VACUUM REINDEX listing BOOST; +vacuum reindex listing to 75 percent boost; + +-- VACUUM RECLUSTER (requires table name) +VACUUM RECLUSTER listing; +vacuum recluster sales_fact; +VACUUM RECLUSTER listing TO 80 PERCENT; +vacuum recluster listing to 95 percent; +VACUUM RECLUSTER listing BOOST; +vacuum recluster listing to 70 percent boost; + +-- Edge cases and variations +VACUUM TO 100 PERCENT; +vacuum to 0 percent; +VACUUM BOOST; +vacuum boost; + +-- Mixed case and quoted identifiers +VACUUM "MixedCase_Table"; +vacuum "table with spaces"; +VACUUM FULL "schema"."table"; +vacuum sort only "MyTable" to 75 percent boost; + +-- Real-world examples from AWS documentation +-- Example 1: Run VACUUM on the entire database +VACUUM; + +-- Example 2: Run VACUUM on specific table with default threshold +VACUUM sales; + +-- Example 3: Run VACUUM with custom threshold +VACUUM sales TO 75 PERCENT; + +-- Example 4: Sort only operation +VACUUM SORT ONLY sales TO 75 PERCENT; + +-- Example 5: Delete only operation +VACUUM DELETE ONLY sales TO 75 PERCENT; + +-- Example 6: Reindex interleaved table +VACUUM REINDEX listing; + +-- Example 7: Recluster table with boost +VACUUM RECLUSTER listing BOOST; + +-- Comments and formatting tests +VACUUM; -- Basic vacuum +VACUUM /* inline comment */ sales; +VACUUM + FULL + sales + TO + 80 + PERCENT; + +-- Multiple VACUUM commands +VACUUM sales; +VACUUM customer_table; +VACUUM inventory TO 90 PERCENT BOOST; \ No newline at end of file diff --git a/redshift/keywords.go b/redshift/keywords.go new file mode 100644 index 0000000..feb3890 --- /dev/null +++ b/redshift/keywords.go @@ -0,0 +1,855 @@ +package redshift + +// Keyword represents a SQL keyword with its reserved status. +type Keyword struct { + Keyword string + Reserved bool +} + +// Retrieved from https://www.postgresql.org/docs/current/sql-keywords-appendix.html#KEYWORDS-TABLE +// Reserved is true if it's label is in ["reserved", "reserved, requires as", "reserved (can be function or type)"] +var Keywords = map[string]Keyword{ + "A": {Keyword: "A", Reserved: false}, + "ABORT": {Keyword: "ABORT", Reserved: false}, + "ABS": {Keyword: "ABS", Reserved: false}, + "ABSENT": {Keyword: "ABSENT", Reserved: false}, + "ABSOLUTE": {Keyword: "ABSOLUTE", Reserved: false}, + "ACCESS": {Keyword: "ACCESS", Reserved: false}, + "ACCORDING": {Keyword: "ACCORDING", Reserved: false}, + "ACOS": {Keyword: "ACOS", Reserved: false}, + "ACTION": {Keyword: "ACTION", Reserved: false}, + "ADA": {Keyword: "ADA", Reserved: false}, + "ADD": {Keyword: "ADD", Reserved: false}, + "ADMIN": {Keyword: "ADMIN", Reserved: false}, + "AFTER": {Keyword: "AFTER", Reserved: false}, + "AGGREGATE": {Keyword: "AGGREGATE", Reserved: false}, + "ALL": {Keyword: "ALL", Reserved: true}, + "ALLOCATE": {Keyword: "ALLOCATE", Reserved: false}, + "ALSO": {Keyword: "ALSO", Reserved: false}, + "ALTER": {Keyword: "ALTER", Reserved: false}, + "ALWAYS": {Keyword: "ALWAYS", Reserved: false}, + "ANALYSE": {Keyword: "ANALYSE", Reserved: true}, + "ANALYZE": {Keyword: "ANALYZE", Reserved: true}, + "AND": {Keyword: "AND", Reserved: true}, + "ANY": {Keyword: "ANY", Reserved: true}, + "ANY_VALUE": {Keyword: "ANY_VALUE", Reserved: false}, + "ARE": {Keyword: "ARE", Reserved: false}, + "ARRAY": {Keyword: "ARRAY", Reserved: true}, + "ARRAY_AGG": {Keyword: "ARRAY_AGG", Reserved: false}, + "ARRAY_MAX_CARDINALITY": {Keyword: "ARRAY_MAX_CARDINALITY", Reserved: false}, + "AS": {Keyword: "AS", Reserved: true}, + "ASC": {Keyword: "ASC", Reserved: true}, + "ASENSITIVE": {Keyword: "ASENSITIVE", Reserved: false}, + "ASIN": {Keyword: "ASIN", Reserved: false}, + "ASSERTION": {Keyword: "ASSERTION", Reserved: false}, + "ASSIGNMENT": {Keyword: "ASSIGNMENT", Reserved: false}, + "ASYMMETRIC": {Keyword: "ASYMMETRIC", Reserved: true}, + "AT": {Keyword: "AT", Reserved: false}, + "ATAN": {Keyword: "ATAN", Reserved: false}, + "ATOMIC": {Keyword: "ATOMIC", Reserved: false}, + "ATTACH": {Keyword: "ATTACH", Reserved: false}, + "ATTRIBUTE": {Keyword: "ATTRIBUTE", Reserved: false}, + "ATTRIBUTES": {Keyword: "ATTRIBUTES", Reserved: false}, + "AUTHORIZATION": {Keyword: "AUTHORIZATION", Reserved: true}, + "AVG": {Keyword: "AVG", Reserved: false}, + "BACKWARD": {Keyword: "BACKWARD", Reserved: false}, + "BASE64": {Keyword: "BASE64", Reserved: false}, + "BEFORE": {Keyword: "BEFORE", Reserved: false}, + "BEGIN": {Keyword: "BEGIN", Reserved: false}, + "BEGIN_FRAME": {Keyword: "BEGIN_FRAME", Reserved: false}, + "BEGIN_PARTITION": {Keyword: "BEGIN_PARTITION", Reserved: false}, + "BERNOULLI": {Keyword: "BERNOULLI", Reserved: false}, + "BETWEEN": {Keyword: "BETWEEN", Reserved: false}, + "BIGINT": {Keyword: "BIGINT", Reserved: false}, + "BINARY": {Keyword: "BINARY", Reserved: true}, + "BIT": {Keyword: "BIT", Reserved: false}, + "BIT_LENGTH": {Keyword: "BIT_LENGTH", Reserved: false}, + "BLOB": {Keyword: "BLOB", Reserved: false}, + "BLOCKED": {Keyword: "BLOCKED", Reserved: false}, + "BOM": {Keyword: "BOM", Reserved: false}, + "BOOLEAN": {Keyword: "BOOLEAN", Reserved: false}, + "BOTH": {Keyword: "BOTH", Reserved: true}, + "BREADTH": {Keyword: "BREADTH", Reserved: false}, + "BTRIM": {Keyword: "BTRIM", Reserved: false}, + "BY": {Keyword: "BY", Reserved: false}, + "C": {Keyword: "C", Reserved: false}, + "CACHE": {Keyword: "CACHE", Reserved: false}, + "CALL": {Keyword: "CALL", Reserved: false}, + "CALLED": {Keyword: "CALLED", Reserved: false}, + "CARDINALITY": {Keyword: "CARDINALITY", Reserved: false}, + "CASCADE": {Keyword: "CASCADE", Reserved: false}, + "CASCADED": {Keyword: "CASCADED", Reserved: false}, + "CASE": {Keyword: "CASE", Reserved: true}, + "CAST": {Keyword: "CAST", Reserved: true}, + "CATALOG": {Keyword: "CATALOG", Reserved: false}, + "CATALOG_NAME": {Keyword: "CATALOG_NAME", Reserved: false}, + "CEIL": {Keyword: "CEIL", Reserved: false}, + "CEILING": {Keyword: "CEILING", Reserved: false}, + "CHAIN": {Keyword: "CHAIN", Reserved: false}, + "CHAINING": {Keyword: "CHAINING", Reserved: false}, + "CHAR": {Keyword: "CHAR", Reserved: false}, + "CHARACTER": {Keyword: "CHARACTER", Reserved: false}, + "CHARACTERISTICS": {Keyword: "CHARACTERISTICS", Reserved: false}, + "CHARACTERS": {Keyword: "CHARACTERS", Reserved: false}, + "CHARACTER_LENGTH": {Keyword: "CHARACTER_LENGTH", Reserved: false}, + "CHARACTER_SET_CATALOG": {Keyword: "CHARACTER_SET_CATALOG", Reserved: false}, + "CHARACTER_SET_NAME": {Keyword: "CHARACTER_SET_NAME", Reserved: false}, + "CHARACTER_SET_SCHEMA": {Keyword: "CHARACTER_SET_SCHEMA", Reserved: false}, + "CHAR_LENGTH": {Keyword: "CHAR_LENGTH", Reserved: false}, + "CHECK": {Keyword: "CHECK", Reserved: true}, + "CHECKPOINT": {Keyword: "CHECKPOINT", Reserved: false}, + "CLASS": {Keyword: "CLASS", Reserved: false}, + "CLASSIFIER": {Keyword: "CLASSIFIER", Reserved: false}, + "CLASS_ORIGIN": {Keyword: "CLASS_ORIGIN", Reserved: false}, + "CLOB": {Keyword: "CLOB", Reserved: false}, + "CLOSE": {Keyword: "CLOSE", Reserved: false}, + "CLUSTER": {Keyword: "CLUSTER", Reserved: false}, + "COALESCE": {Keyword: "COALESCE", Reserved: false}, + "COBOL": {Keyword: "COBOL", Reserved: false}, + "COLLATE": {Keyword: "COLLATE", Reserved: true}, + "COLLATION": {Keyword: "COLLATION", Reserved: true}, + "COLLATION_CATALOG": {Keyword: "COLLATION_CATALOG", Reserved: false}, + "COLLATION_NAME": {Keyword: "COLLATION_NAME", Reserved: false}, + "COLLATION_SCHEMA": {Keyword: "COLLATION_SCHEMA", Reserved: false}, + "COLLECT": {Keyword: "COLLECT", Reserved: false}, + "COLUMN": {Keyword: "COLUMN", Reserved: true}, + "COLUMNS": {Keyword: "COLUMNS", Reserved: false}, + "COLUMN_NAME": {Keyword: "COLUMN_NAME", Reserved: false}, + "COMMAND_FUNCTION": {Keyword: "COMMAND_FUNCTION", Reserved: false}, + "COMMAND_FUNCTION_CODE": {Keyword: "COMMAND_FUNCTION_CODE", Reserved: false}, + "COMMENT": {Keyword: "COMMENT", Reserved: false}, + "COMMENTS": {Keyword: "COMMENTS", Reserved: false}, + "COMMIT": {Keyword: "COMMIT", Reserved: false}, + "COMMITTED": {Keyword: "COMMITTED", Reserved: false}, + "COMPRESSION": {Keyword: "COMPRESSION", Reserved: false}, + "CONCURRENTLY": {Keyword: "CONCURRENTLY", Reserved: true}, + "CONDITION": {Keyword: "CONDITION", Reserved: false}, + "CONDITIONAL": {Keyword: "CONDITIONAL", Reserved: false}, + "CONDITION_NUMBER": {Keyword: "CONDITION_NUMBER", Reserved: false}, + "CONFIGURATION": {Keyword: "CONFIGURATION", Reserved: false}, + "CONFLICT": {Keyword: "CONFLICT", Reserved: false}, + "CONNECT": {Keyword: "CONNECT", Reserved: false}, + "CONNECTION": {Keyword: "CONNECTION", Reserved: false}, + "CONNECTION_NAME": {Keyword: "CONNECTION_NAME", Reserved: false}, + "CONSTRAINT": {Keyword: "CONSTRAINT", Reserved: true}, + "CONSTRAINTS": {Keyword: "CONSTRAINTS", Reserved: false}, + "CONSTRAINT_CATALOG": {Keyword: "CONSTRAINT_CATALOG", Reserved: false}, + "CONSTRAINT_NAME": {Keyword: "CONSTRAINT_NAME", Reserved: false}, + "CONSTRAINT_SCHEMA": {Keyword: "CONSTRAINT_SCHEMA", Reserved: false}, + "CONSTRUCTOR": {Keyword: "CONSTRUCTOR", Reserved: false}, + "CONTAINS": {Keyword: "CONTAINS", Reserved: false}, + "CONTENT": {Keyword: "CONTENT", Reserved: false}, + "CONTINUE": {Keyword: "CONTINUE", Reserved: false}, + "CONTROL": {Keyword: "CONTROL", Reserved: false}, + "CONVERSION": {Keyword: "CONVERSION", Reserved: false}, + "CONVERT": {Keyword: "CONVERT", Reserved: false}, + "COPARTITION": {Keyword: "COPARTITION", Reserved: false}, + "COPY": {Keyword: "COPY", Reserved: false}, + "CORR": {Keyword: "CORR", Reserved: false}, + "CORRESPONDING": {Keyword: "CORRESPONDING", Reserved: false}, + "COS": {Keyword: "COS", Reserved: false}, + "COSH": {Keyword: "COSH", Reserved: false}, + "COST": {Keyword: "COST", Reserved: false}, + "COUNT": {Keyword: "COUNT", Reserved: false}, + "COVAR_POP": {Keyword: "COVAR_POP", Reserved: false}, + "COVAR_SAMP": {Keyword: "COVAR_SAMP", Reserved: false}, + "CREATE": {Keyword: "CREATE", Reserved: true}, + "CROSS": {Keyword: "CROSS", Reserved: true}, + "CSV": {Keyword: "CSV", Reserved: false}, + "CUBE": {Keyword: "CUBE", Reserved: false}, + "CUME_DIST": {Keyword: "CUME_DIST", Reserved: false}, + "CURRENT": {Keyword: "CURRENT", Reserved: false}, + "CURRENT_CATALOG": {Keyword: "CURRENT_CATALOG", Reserved: true}, + "CURRENT_DATE": {Keyword: "CURRENT_DATE", Reserved: true}, + "CURRENT_DEFAULT_TRANSFORM_GROUP": {Keyword: "CURRENT_DEFAULT_TRANSFORM_GROUP", Reserved: false}, + "CURRENT_PATH": {Keyword: "CURRENT_PATH", Reserved: false}, + "CURRENT_ROLE": {Keyword: "CURRENT_ROLE", Reserved: true}, + "CURRENT_ROW": {Keyword: "CURRENT_ROW", Reserved: false}, + "CURRENT_SCHEMA": {Keyword: "CURRENT_SCHEMA", Reserved: true}, + "CURRENT_TIME": {Keyword: "CURRENT_TIME", Reserved: true}, + "CURRENT_TIMESTAMP": {Keyword: "CURRENT_TIMESTAMP", Reserved: true}, + "CURRENT_TRANSFORM_GROUP_FOR_TYPE": {Keyword: "CURRENT_TRANSFORM_GROUP_FOR_TYPE", Reserved: false}, + "CURRENT_USER": {Keyword: "CURRENT_USER", Reserved: true}, + "CURSOR": {Keyword: "CURSOR", Reserved: false}, + "CURSOR_NAME": {Keyword: "CURSOR_NAME", Reserved: false}, + "CYCLE": {Keyword: "CYCLE", Reserved: false}, + "DATA": {Keyword: "DATA", Reserved: false}, + "DATABASE": {Keyword: "DATABASE", Reserved: false}, + "DATALINK": {Keyword: "DATALINK", Reserved: false}, + "DATE": {Keyword: "DATE", Reserved: false}, + "DATETIME_INTERVAL_CODE": {Keyword: "DATETIME_INTERVAL_CODE", Reserved: false}, + "DATETIME_INTERVAL_PRECISION": {Keyword: "DATETIME_INTERVAL_PRECISION", Reserved: false}, + "DAY": {Keyword: "DAY", Reserved: false}, + "DB": {Keyword: "DB", Reserved: false}, + "DEALLOCATE": {Keyword: "DEALLOCATE", Reserved: false}, + "DEC": {Keyword: "DEC", Reserved: false}, + "DECFLOAT": {Keyword: "DECFLOAT", Reserved: false}, + "DECIMAL": {Keyword: "DECIMAL", Reserved: false}, + "DECLARE": {Keyword: "DECLARE", Reserved: false}, + "DEFAULT": {Keyword: "DEFAULT", Reserved: true}, + "DEFAULTS": {Keyword: "DEFAULTS", Reserved: false}, + "DEFERRABLE": {Keyword: "DEFERRABLE", Reserved: true}, + "DEFERRED": {Keyword: "DEFERRED", Reserved: false}, + "DEFINE": {Keyword: "DEFINE", Reserved: false}, + "DEFINED": {Keyword: "DEFINED", Reserved: false}, + "DEFINER": {Keyword: "DEFINER", Reserved: false}, + "DEGREE": {Keyword: "DEGREE", Reserved: false}, + "DELETE": {Keyword: "DELETE", Reserved: false}, + "DELIMITER": {Keyword: "DELIMITER", Reserved: false}, + "DELIMITERS": {Keyword: "DELIMITERS", Reserved: false}, + "DENSE_RANK": {Keyword: "DENSE_RANK", Reserved: false}, + "DEPENDS": {Keyword: "DEPENDS", Reserved: false}, + "DEPTH": {Keyword: "DEPTH", Reserved: false}, + "DEREF": {Keyword: "DEREF", Reserved: false}, + "DERIVED": {Keyword: "DERIVED", Reserved: false}, + "DESC": {Keyword: "DESC", Reserved: true}, + "DESCRIBE": {Keyword: "DESCRIBE", Reserved: false}, + "DESCRIPTOR": {Keyword: "DESCRIPTOR", Reserved: false}, + "DETACH": {Keyword: "DETACH", Reserved: false}, + "DETERMINISTIC": {Keyword: "DETERMINISTIC", Reserved: false}, + "DIAGNOSTICS": {Keyword: "DIAGNOSTICS", Reserved: false}, + "DICTIONARY": {Keyword: "DICTIONARY", Reserved: false}, + "DISABLE": {Keyword: "DISABLE", Reserved: false}, + "DISCARD": {Keyword: "DISCARD", Reserved: false}, + "DISCONNECT": {Keyword: "DISCONNECT", Reserved: false}, + "DISPATCH": {Keyword: "DISPATCH", Reserved: false}, + "DISTINCT": {Keyword: "DISTINCT", Reserved: true}, + "DLNEWCOPY": {Keyword: "DLNEWCOPY", Reserved: false}, + "DLPREVIOUSCOPY": {Keyword: "DLPREVIOUSCOPY", Reserved: false}, + "DLURLCOMPLETE": {Keyword: "DLURLCOMPLETE", Reserved: false}, + "DLURLCOMPLETEONLY": {Keyword: "DLURLCOMPLETEONLY", Reserved: false}, + "DLURLCOMPLETEWRITE": {Keyword: "DLURLCOMPLETEWRITE", Reserved: false}, + "DLURLPATH": {Keyword: "DLURLPATH", Reserved: false}, + "DLURLPATHONLY": {Keyword: "DLURLPATHONLY", Reserved: false}, + "DLURLPATHWRITE": {Keyword: "DLURLPATHWRITE", Reserved: false}, + "DLURLSCHEME": {Keyword: "DLURLSCHEME", Reserved: false}, + "DLURLSERVER": {Keyword: "DLURLSERVER", Reserved: false}, + "DLVALUE": {Keyword: "DLVALUE", Reserved: false}, + "DO": {Keyword: "DO", Reserved: true}, + "DOCUMENT": {Keyword: "DOCUMENT", Reserved: false}, + "DOMAIN": {Keyword: "DOMAIN", Reserved: false}, + "DOUBLE": {Keyword: "DOUBLE", Reserved: false}, + "DROP": {Keyword: "DROP", Reserved: false}, + "DYNAMIC": {Keyword: "DYNAMIC", Reserved: false}, + "DYNAMIC_FUNCTION": {Keyword: "DYNAMIC_FUNCTION", Reserved: false}, + "DYNAMIC_FUNCTION_CODE": {Keyword: "DYNAMIC_FUNCTION_CODE", Reserved: false}, + "EACH": {Keyword: "EACH", Reserved: false}, + "ELEMENT": {Keyword: "ELEMENT", Reserved: false}, + "ELSE": {Keyword: "ELSE", Reserved: true}, + "EMPTY": {Keyword: "EMPTY", Reserved: false}, + "ENABLE": {Keyword: "ENABLE", Reserved: false}, + "ENCODING": {Keyword: "ENCODING", Reserved: false}, + "ENCRYPTED": {Keyword: "ENCRYPTED", Reserved: false}, + "END": {Keyword: "END", Reserved: true}, + "END-EXEC": {Keyword: "END-EXEC", Reserved: false}, + "END_FRAME": {Keyword: "END_FRAME", Reserved: false}, + "END_PARTITION": {Keyword: "END_PARTITION", Reserved: false}, + "ENFORCED": {Keyword: "ENFORCED", Reserved: false}, + "ENUM": {Keyword: "ENUM", Reserved: false}, + "EQUALS": {Keyword: "EQUALS", Reserved: false}, + "ERROR": {Keyword: "ERROR", Reserved: false}, + "ESCAPE": {Keyword: "ESCAPE", Reserved: false}, + "EVENT": {Keyword: "EVENT", Reserved: false}, + "EVERY": {Keyword: "EVERY", Reserved: false}, + "EXCEPT": {Keyword: "EXCEPT", Reserved: true}, + "EXCEPTION": {Keyword: "EXCEPTION", Reserved: false}, + "EXCLUDE": {Keyword: "EXCLUDE", Reserved: false}, + "EXCLUDING": {Keyword: "EXCLUDING", Reserved: false}, + "EXCLUSIVE": {Keyword: "EXCLUSIVE", Reserved: false}, + "EXEC": {Keyword: "EXEC", Reserved: false}, + "EXECUTE": {Keyword: "EXECUTE", Reserved: false}, + "EXISTS": {Keyword: "EXISTS", Reserved: false}, + "EXP": {Keyword: "EXP", Reserved: false}, + "EXPLAIN": {Keyword: "EXPLAIN", Reserved: false}, + "EXPRESSION": {Keyword: "EXPRESSION", Reserved: false}, + "EXTENSION": {Keyword: "EXTENSION", Reserved: false}, + "EXTERNAL": {Keyword: "EXTERNAL", Reserved: false}, + "EXTRACT": {Keyword: "EXTRACT", Reserved: false}, + "FALSE": {Keyword: "FALSE", Reserved: true}, + "FAMILY": {Keyword: "FAMILY", Reserved: false}, + "FETCH": {Keyword: "FETCH", Reserved: true}, + "FILE": {Keyword: "FILE", Reserved: false}, + "FILTER": {Keyword: "FILTER", Reserved: false}, + "FINAL": {Keyword: "FINAL", Reserved: false}, + "FINALIZE": {Keyword: "FINALIZE", Reserved: false}, + "FINISH": {Keyword: "FINISH", Reserved: false}, + "FIRST": {Keyword: "FIRST", Reserved: false}, + "FIRST_VALUE": {Keyword: "FIRST_VALUE", Reserved: false}, + "FLAG": {Keyword: "FLAG", Reserved: false}, + "FLOAT": {Keyword: "FLOAT", Reserved: false}, + "FLOOR": {Keyword: "FLOOR", Reserved: false}, + "FOLLOWING": {Keyword: "FOLLOWING", Reserved: false}, + "FOR": {Keyword: "FOR", Reserved: true}, + "FORCE": {Keyword: "FORCE", Reserved: false}, + "FOREIGN": {Keyword: "FOREIGN", Reserved: true}, + "FORMAT": {Keyword: "FORMAT", Reserved: false}, + "FORTRAN": {Keyword: "FORTRAN", Reserved: false}, + "FORWARD": {Keyword: "FORWARD", Reserved: false}, + "FOUND": {Keyword: "FOUND", Reserved: false}, + "FRAME_ROW": {Keyword: "FRAME_ROW", Reserved: false}, + "FREE": {Keyword: "FREE", Reserved: false}, + "FREEZE": {Keyword: "FREEZE", Reserved: true}, + "FROM": {Keyword: "FROM", Reserved: true}, + "FS": {Keyword: "FS", Reserved: false}, + "FULFILL": {Keyword: "FULFILL", Reserved: false}, + "FULL": {Keyword: "FULL", Reserved: true}, + "FUNCTION": {Keyword: "FUNCTION", Reserved: false}, + "FUNCTIONS": {Keyword: "FUNCTIONS", Reserved: false}, + "FUSION": {Keyword: "FUSION", Reserved: false}, + "G": {Keyword: "G", Reserved: false}, + "GENERAL": {Keyword: "GENERAL", Reserved: false}, + "GENERATED": {Keyword: "GENERATED", Reserved: false}, + "GET": {Keyword: "GET", Reserved: false}, + "GLOBAL": {Keyword: "GLOBAL", Reserved: false}, + "GO": {Keyword: "GO", Reserved: false}, + "GOTO": {Keyword: "GOTO", Reserved: false}, + "GRANT": {Keyword: "GRANT", Reserved: true}, + "GRANTED": {Keyword: "GRANTED", Reserved: false}, + "GREATEST": {Keyword: "GREATEST", Reserved: false}, + "GROUP": {Keyword: "GROUP", Reserved: true}, + "GROUPING": {Keyword: "GROUPING", Reserved: false}, + "GROUPS": {Keyword: "GROUPS", Reserved: false}, + "HANDLER": {Keyword: "HANDLER", Reserved: false}, + "HAVING": {Keyword: "HAVING", Reserved: true}, + "HEADER": {Keyword: "HEADER", Reserved: false}, + "HEX": {Keyword: "HEX", Reserved: false}, + "HIERARCHY": {Keyword: "HIERARCHY", Reserved: false}, + "HOLD": {Keyword: "HOLD", Reserved: false}, + "HOUR": {Keyword: "HOUR", Reserved: false}, + "ID": {Keyword: "ID", Reserved: false}, + "IDENTITY": {Keyword: "IDENTITY", Reserved: false}, + "IF": {Keyword: "IF", Reserved: false}, + "IGNORE": {Keyword: "IGNORE", Reserved: false}, + "ILIKE": {Keyword: "ILIKE", Reserved: true}, + "IMMEDIATE": {Keyword: "IMMEDIATE", Reserved: false}, + "IMMEDIATELY": {Keyword: "IMMEDIATELY", Reserved: false}, + "IMMUTABLE": {Keyword: "IMMUTABLE", Reserved: false}, + "IMPLEMENTATION": {Keyword: "IMPLEMENTATION", Reserved: false}, + "IMPLICIT": {Keyword: "IMPLICIT", Reserved: false}, + "IMPORT": {Keyword: "IMPORT", Reserved: false}, + "IN": {Keyword: "IN", Reserved: true}, + "INCLUDE": {Keyword: "INCLUDE", Reserved: false}, + "INCLUDING": {Keyword: "INCLUDING", Reserved: false}, + "INCREMENT": {Keyword: "INCREMENT", Reserved: false}, + "INDENT": {Keyword: "INDENT", Reserved: false}, + "INDEX": {Keyword: "INDEX", Reserved: false}, + "INDEXES": {Keyword: "INDEXES", Reserved: false}, + "INDICATOR": {Keyword: "INDICATOR", Reserved: false}, + "INHERIT": {Keyword: "INHERIT", Reserved: false}, + "INHERITS": {Keyword: "INHERITS", Reserved: false}, + "INITIAL": {Keyword: "INITIAL", Reserved: false}, + "INITIALLY": {Keyword: "INITIALLY", Reserved: true}, + "INLINE": {Keyword: "INLINE", Reserved: false}, + "INNER": {Keyword: "INNER", Reserved: true}, + "INOUT": {Keyword: "INOUT", Reserved: false}, + "INPUT": {Keyword: "INPUT", Reserved: false}, + "INSENSITIVE": {Keyword: "INSENSITIVE", Reserved: false}, + "INSERT": {Keyword: "INSERT", Reserved: false}, + "INSTANCE": {Keyword: "INSTANCE", Reserved: false}, + "INSTANTIABLE": {Keyword: "INSTANTIABLE", Reserved: false}, + "INSTEAD": {Keyword: "INSTEAD", Reserved: false}, + "INT": {Keyword: "INT", Reserved: false}, + "INTEGER": {Keyword: "INTEGER", Reserved: false}, + "INTEGRITY": {Keyword: "INTEGRITY", Reserved: false}, + "INTERSECT": {Keyword: "INTERSECT", Reserved: true}, + "INTERSECTION": {Keyword: "INTERSECTION", Reserved: false}, + "INTERVAL": {Keyword: "INTERVAL", Reserved: false}, + "INTO": {Keyword: "INTO", Reserved: true}, + "INVOKER": {Keyword: "INVOKER", Reserved: false}, + "IS": {Keyword: "IS", Reserved: true}, + "ISNULL": {Keyword: "ISNULL", Reserved: false}, + "ISOLATION": {Keyword: "ISOLATION", Reserved: false}, + "JOIN": {Keyword: "JOIN", Reserved: true}, + "JSON": {Keyword: "JSON", Reserved: false}, + "JSON_ARRAY": {Keyword: "JSON_ARRAY", Reserved: false}, + "JSON_ARRAYAGG": {Keyword: "JSON_ARRAYAGG", Reserved: false}, + "JSON_EXISTS": {Keyword: "JSON_EXISTS", Reserved: false}, + "JSON_OBJECT": {Keyword: "JSON_OBJECT", Reserved: false}, + "JSON_OBJECTAGG": {Keyword: "JSON_OBJECTAGG", Reserved: false}, + "JSON_QUERY": {Keyword: "JSON_QUERY", Reserved: false}, + "JSON_SCALAR": {Keyword: "JSON_SCALAR", Reserved: false}, + "JSON_SERIALIZE": {Keyword: "JSON_SERIALIZE", Reserved: false}, + "JSON_TABLE": {Keyword: "JSON_TABLE", Reserved: false}, + "JSON_TABLE_PRIMITIVE": {Keyword: "JSON_TABLE_PRIMITIVE", Reserved: false}, + "JSON_VALUE": {Keyword: "JSON_VALUE", Reserved: false}, + "K": {Keyword: "K", Reserved: false}, + "KEEP": {Keyword: "KEEP", Reserved: false}, + "KEY": {Keyword: "KEY", Reserved: false}, + "KEYS": {Keyword: "KEYS", Reserved: false}, + "KEY_MEMBER": {Keyword: "KEY_MEMBER", Reserved: false}, + "KEY_TYPE": {Keyword: "KEY_TYPE", Reserved: false}, + "LABEL": {Keyword: "LABEL", Reserved: false}, + "LAG": {Keyword: "LAG", Reserved: false}, + "LANGUAGE": {Keyword: "LANGUAGE", Reserved: false}, + "LARGE": {Keyword: "LARGE", Reserved: false}, + "LAST": {Keyword: "LAST", Reserved: false}, + "LAST_VALUE": {Keyword: "LAST_VALUE", Reserved: false}, + "LATERAL": {Keyword: "LATERAL", Reserved: true}, + "LEAD": {Keyword: "LEAD", Reserved: false}, + "LEADING": {Keyword: "LEADING", Reserved: true}, + "LEAKPROOF": {Keyword: "LEAKPROOF", Reserved: false}, + "LEAST": {Keyword: "LEAST", Reserved: false}, + "LEFT": {Keyword: "LEFT", Reserved: true}, + "LENGTH": {Keyword: "LENGTH", Reserved: false}, + "LEVEL": {Keyword: "LEVEL", Reserved: false}, + "LIBRARY": {Keyword: "LIBRARY", Reserved: false}, + "LIKE": {Keyword: "LIKE", Reserved: true}, + "LIKE_REGEX": {Keyword: "LIKE_REGEX", Reserved: false}, + "LIMIT": {Keyword: "LIMIT", Reserved: true}, + "LINK": {Keyword: "LINK", Reserved: false}, + "LISTAGG": {Keyword: "LISTAGG", Reserved: false}, + "LISTEN": {Keyword: "LISTEN", Reserved: false}, + "LN": {Keyword: "LN", Reserved: false}, + "LOAD": {Keyword: "LOAD", Reserved: false}, + "LOCAL": {Keyword: "LOCAL", Reserved: false}, + "LOCALTIME": {Keyword: "LOCALTIME", Reserved: true}, + "LOCALTIMESTAMP": {Keyword: "LOCALTIMESTAMP", Reserved: true}, + "LOCATION": {Keyword: "LOCATION", Reserved: false}, + "LOCATOR": {Keyword: "LOCATOR", Reserved: false}, + "LOCK": {Keyword: "LOCK", Reserved: false}, + "LOCKED": {Keyword: "LOCKED", Reserved: false}, + "LOG": {Keyword: "LOG", Reserved: false}, + "LOG10": {Keyword: "LOG10", Reserved: false}, + "LOGGED": {Keyword: "LOGGED", Reserved: false}, + "LOWER": {Keyword: "LOWER", Reserved: false}, + "LPAD": {Keyword: "LPAD", Reserved: false}, + "LTRIM": {Keyword: "LTRIM", Reserved: false}, + "M": {Keyword: "M", Reserved: false}, + "MAP": {Keyword: "MAP", Reserved: false}, + "MAPPING": {Keyword: "MAPPING", Reserved: false}, + "MATCH": {Keyword: "MATCH", Reserved: false}, + "MATCHED": {Keyword: "MATCHED", Reserved: false}, + "MATCHES": {Keyword: "MATCHES", Reserved: false}, + "MATCH_NUMBER": {Keyword: "MATCH_NUMBER", Reserved: false}, + "MATCH_RECOGNIZE": {Keyword: "MATCH_RECOGNIZE", Reserved: false}, + "MATERIALIZED": {Keyword: "MATERIALIZED", Reserved: false}, + "MAX": {Keyword: "MAX", Reserved: false}, + "MAXVALUE": {Keyword: "MAXVALUE", Reserved: false}, + "MEASURES": {Keyword: "MEASURES", Reserved: false}, + "MEMBER": {Keyword: "MEMBER", Reserved: false}, + "MERGE": {Keyword: "MERGE", Reserved: false}, + "MERGE_ACTION": {Keyword: "MERGE_ACTION", Reserved: false}, + "MESSAGE_LENGTH": {Keyword: "MESSAGE_LENGTH", Reserved: false}, + "MESSAGE_OCTET_LENGTH": {Keyword: "MESSAGE_OCTET_LENGTH", Reserved: false}, + "MESSAGE_TEXT": {Keyword: "MESSAGE_TEXT", Reserved: false}, + "METHOD": {Keyword: "METHOD", Reserved: false}, + "MIN": {Keyword: "MIN", Reserved: false}, + "MINUTE": {Keyword: "MINUTE", Reserved: false}, + "MINVALUE": {Keyword: "MINVALUE", Reserved: false}, + "MOD": {Keyword: "MOD", Reserved: false}, + "MODE": {Keyword: "MODE", Reserved: false}, + "MODIFIES": {Keyword: "MODIFIES", Reserved: false}, + "MODULE": {Keyword: "MODULE", Reserved: false}, + "MONTH": {Keyword: "MONTH", Reserved: false}, + "MORE": {Keyword: "MORE", Reserved: false}, + "MOVE": {Keyword: "MOVE", Reserved: false}, + "MULTISET": {Keyword: "MULTISET", Reserved: false}, + "MUMPS": {Keyword: "MUMPS", Reserved: false}, + "NAME": {Keyword: "NAME", Reserved: false}, + "NAMES": {Keyword: "NAMES", Reserved: false}, + "NAMESPACE": {Keyword: "NAMESPACE", Reserved: false}, + "NATIONAL": {Keyword: "NATIONAL", Reserved: false}, + "NATURAL": {Keyword: "NATURAL", Reserved: true}, + "NCHAR": {Keyword: "NCHAR", Reserved: false}, + "NCLOB": {Keyword: "NCLOB", Reserved: false}, + "NESTED": {Keyword: "NESTED", Reserved: false}, + "NESTING": {Keyword: "NESTING", Reserved: false}, + "NEW": {Keyword: "NEW", Reserved: false}, + "NEXT": {Keyword: "NEXT", Reserved: false}, + "NFC": {Keyword: "NFC", Reserved: false}, + "NFD": {Keyword: "NFD", Reserved: false}, + "NFKC": {Keyword: "NFKC", Reserved: false}, + "NFKD": {Keyword: "NFKD", Reserved: false}, + "NIL": {Keyword: "NIL", Reserved: false}, + "NO": {Keyword: "NO", Reserved: false}, + "NONE": {Keyword: "NONE", Reserved: false}, + "NORMALIZE": {Keyword: "NORMALIZE", Reserved: false}, + "NORMALIZED": {Keyword: "NORMALIZED", Reserved: false}, + "NOT": {Keyword: "NOT", Reserved: true}, + "NOTHING": {Keyword: "NOTHING", Reserved: false}, + "NOTIFY": {Keyword: "NOTIFY", Reserved: false}, + "NOTNULL": {Keyword: "NOTNULL", Reserved: false}, + "NOWAIT": {Keyword: "NOWAIT", Reserved: false}, + "NTH_VALUE": {Keyword: "NTH_VALUE", Reserved: false}, + "NTILE": {Keyword: "NTILE", Reserved: false}, + "NULL": {Keyword: "NULL", Reserved: true}, + "NULLABLE": {Keyword: "NULLABLE", Reserved: false}, + "NULLIF": {Keyword: "NULLIF", Reserved: false}, + "NULLS": {Keyword: "NULLS", Reserved: false}, + "NULL_ORDERING": {Keyword: "NULL_ORDERING", Reserved: false}, + "NUMBER": {Keyword: "NUMBER", Reserved: false}, + "NUMERIC": {Keyword: "NUMERIC", Reserved: false}, + "OBJECT": {Keyword: "OBJECT", Reserved: false}, + "OCCURRENCE": {Keyword: "OCCURRENCE", Reserved: false}, + "OCCURRENCES_REGEX": {Keyword: "OCCURRENCES_REGEX", Reserved: false}, + "OCTETS": {Keyword: "OCTETS", Reserved: false}, + "OCTET_LENGTH": {Keyword: "OCTET_LENGTH", Reserved: false}, + "OF": {Keyword: "OF", Reserved: false}, + "OFF": {Keyword: "OFF", Reserved: false}, + "OFFSET": {Keyword: "OFFSET", Reserved: true}, + "OIDS": {Keyword: "OIDS", Reserved: false}, + "OLD": {Keyword: "OLD", Reserved: false}, + "OMIT": {Keyword: "OMIT", Reserved: false}, + "ON": {Keyword: "ON", Reserved: true}, + "ONE": {Keyword: "ONE", Reserved: false}, + "ONLY": {Keyword: "ONLY", Reserved: true}, + "OPEN": {Keyword: "OPEN", Reserved: false}, + "OPERATOR": {Keyword: "OPERATOR", Reserved: false}, + "OPTION": {Keyword: "OPTION", Reserved: false}, + "OPTIONS": {Keyword: "OPTIONS", Reserved: false}, + "OR": {Keyword: "OR", Reserved: true}, + "ORDER": {Keyword: "ORDER", Reserved: true}, + "ORDERING": {Keyword: "ORDERING", Reserved: false}, + "ORDINALITY": {Keyword: "ORDINALITY", Reserved: false}, + "OTHERS": {Keyword: "OTHERS", Reserved: false}, + "OUT": {Keyword: "OUT", Reserved: false}, + "OUTER": {Keyword: "OUTER", Reserved: true}, + "OUTPUT": {Keyword: "OUTPUT", Reserved: false}, + "OVER": {Keyword: "OVER", Reserved: false}, + "OVERFLOW": {Keyword: "OVERFLOW", Reserved: false}, + "OVERLAPS": {Keyword: "OVERLAPS", Reserved: false}, + "OVERLAY": {Keyword: "OVERLAY", Reserved: false}, + "OVERRIDING": {Keyword: "OVERRIDING", Reserved: false}, + "OWNED": {Keyword: "OWNED", Reserved: false}, + "OWNER": {Keyword: "OWNER", Reserved: false}, + "P": {Keyword: "P", Reserved: false}, + "PAD": {Keyword: "PAD", Reserved: false}, + "PARALLEL": {Keyword: "PARALLEL", Reserved: false}, + "PARAMETER": {Keyword: "PARAMETER", Reserved: false}, + "PARAMETER_MODE": {Keyword: "PARAMETER_MODE", Reserved: false}, + "PARAMETER_NAME": {Keyword: "PARAMETER_NAME", Reserved: false}, + "PARAMETER_ORDINAL_POSITION": {Keyword: "PARAMETER_ORDINAL_POSITION", Reserved: false}, + "PARAMETER_SPECIFIC_CATALOG": {Keyword: "PARAMETER_SPECIFIC_CATALOG", Reserved: false}, + "PARAMETER_SPECIFIC_NAME": {Keyword: "PARAMETER_SPECIFIC_NAME", Reserved: false}, + "PARAMETER_SPECIFIC_SCHEMA": {Keyword: "PARAMETER_SPECIFIC_SCHEMA", Reserved: false}, + "PARSER": {Keyword: "PARSER", Reserved: false}, + "PARTIAL": {Keyword: "PARTIAL", Reserved: false}, + "PARTITION": {Keyword: "PARTITION", Reserved: false}, + "PASCAL": {Keyword: "PASCAL", Reserved: false}, + "PASS": {Keyword: "PASS", Reserved: false}, + "PASSING": {Keyword: "PASSING", Reserved: false}, + "PASSTHROUGH": {Keyword: "PASSTHROUGH", Reserved: false}, + "PASSWORD": {Keyword: "PASSWORD", Reserved: false}, + "PAST": {Keyword: "PAST", Reserved: false}, + "PATH": {Keyword: "PATH", Reserved: false}, + "PATTERN": {Keyword: "PATTERN", Reserved: false}, + "PER": {Keyword: "PER", Reserved: false}, + "PERCENT": {Keyword: "PERCENT", Reserved: false}, + "PERCENTILE_CONT": {Keyword: "PERCENTILE_CONT", Reserved: false}, + "PERCENTILE_DISC": {Keyword: "PERCENTILE_DISC", Reserved: false}, + "PERCENT_RANK": {Keyword: "PERCENT_RANK", Reserved: false}, + "PERIOD": {Keyword: "PERIOD", Reserved: false}, + "PERMISSION": {Keyword: "PERMISSION", Reserved: false}, + "PERMUTE": {Keyword: "PERMUTE", Reserved: false}, + "PIPE": {Keyword: "PIPE", Reserved: false}, + "PLACING": {Keyword: "PLACING", Reserved: true}, + "PLAN": {Keyword: "PLAN", Reserved: false}, + "PLANS": {Keyword: "PLANS", Reserved: false}, + "PLI": {Keyword: "PLI", Reserved: false}, + "POLICY": {Keyword: "POLICY", Reserved: false}, + "PORTION": {Keyword: "PORTION", Reserved: false}, + "POSITION": {Keyword: "POSITION", Reserved: false}, + "POSITION_REGEX": {Keyword: "POSITION_REGEX", Reserved: false}, + "POWER": {Keyword: "POWER", Reserved: false}, + "PRECEDES": {Keyword: "PRECEDES", Reserved: false}, + "PRECEDING": {Keyword: "PRECEDING", Reserved: false}, + "PRECISION": {Keyword: "PRECISION", Reserved: false}, + "PREPARE": {Keyword: "PREPARE", Reserved: false}, + "PREPARED": {Keyword: "PREPARED", Reserved: false}, + "PRESERVE": {Keyword: "PRESERVE", Reserved: false}, + "PREV": {Keyword: "PREV", Reserved: false}, + "PRIMARY": {Keyword: "PRIMARY", Reserved: true}, + "PRIOR": {Keyword: "PRIOR", Reserved: false}, + "PRIVATE": {Keyword: "PRIVATE", Reserved: false}, + "PRIVILEGES": {Keyword: "PRIVILEGES", Reserved: false}, + "PROCEDURAL": {Keyword: "PROCEDURAL", Reserved: false}, + "PROCEDURE": {Keyword: "PROCEDURE", Reserved: false}, + "PROCEDURES": {Keyword: "PROCEDURES", Reserved: false}, + "PROGRAM": {Keyword: "PROGRAM", Reserved: false}, + "PRUNE": {Keyword: "PRUNE", Reserved: false}, + "PTF": {Keyword: "PTF", Reserved: false}, + "PUBLIC": {Keyword: "PUBLIC", Reserved: false}, + "PUBLICATION": {Keyword: "PUBLICATION", Reserved: false}, + "QUOTE": {Keyword: "QUOTE", Reserved: false}, + "QUOTES": {Keyword: "QUOTES", Reserved: false}, + "RANGE": {Keyword: "RANGE", Reserved: false}, + "RANK": {Keyword: "RANK", Reserved: false}, + "READ": {Keyword: "READ", Reserved: false}, + "READS": {Keyword: "READS", Reserved: false}, + "REAL": {Keyword: "REAL", Reserved: false}, + "REASSIGN": {Keyword: "REASSIGN", Reserved: false}, + "RECHECK": {Keyword: "RECHECK", Reserved: false}, + "RECOVERY": {Keyword: "RECOVERY", Reserved: false}, + "RECURSIVE": {Keyword: "RECURSIVE", Reserved: false}, + "REF": {Keyword: "REF", Reserved: false}, + "REFERENCES": {Keyword: "REFERENCES", Reserved: true}, + "REFERENCING": {Keyword: "REFERENCING", Reserved: false}, + "REFRESH": {Keyword: "REFRESH", Reserved: false}, + "REGR_AVGX": {Keyword: "REGR_AVGX", Reserved: false}, + "REGR_AVGY": {Keyword: "REGR_AVGY", Reserved: false}, + "REGR_COUNT": {Keyword: "REGR_COUNT", Reserved: false}, + "REGR_INTERCEPT": {Keyword: "REGR_INTERCEPT", Reserved: false}, + "REGR_R2": {Keyword: "REGR_R2", Reserved: false}, + "REGR_SLOPE": {Keyword: "REGR_SLOPE", Reserved: false}, + "REGR_SXX": {Keyword: "REGR_SXX", Reserved: false}, + "REGR_SXY": {Keyword: "REGR_SXY", Reserved: false}, + "REGR_SYY": {Keyword: "REGR_SYY", Reserved: false}, + "REINDEX": {Keyword: "REINDEX", Reserved: false}, + "RELATIVE": {Keyword: "RELATIVE", Reserved: false}, + "RELEASE": {Keyword: "RELEASE", Reserved: false}, + "RENAME": {Keyword: "RENAME", Reserved: false}, + "REPEATABLE": {Keyword: "REPEATABLE", Reserved: false}, + "REPLACE": {Keyword: "REPLACE", Reserved: false}, + "REPLICA": {Keyword: "REPLICA", Reserved: false}, + "REQUIRING": {Keyword: "REQUIRING", Reserved: false}, + "RESET": {Keyword: "RESET", Reserved: false}, + "RESPECT": {Keyword: "RESPECT", Reserved: false}, + "RESTART": {Keyword: "RESTART", Reserved: false}, + "RESTORE": {Keyword: "RESTORE", Reserved: false}, + "RESTRICT": {Keyword: "RESTRICT", Reserved: false}, + "RESULT": {Keyword: "RESULT", Reserved: false}, + "RETURN": {Keyword: "RETURN", Reserved: false}, + "RETURNED_CARDINALITY": {Keyword: "RETURNED_CARDINALITY", Reserved: false}, + "RETURNED_LENGTH": {Keyword: "RETURNED_LENGTH", Reserved: false}, + "RETURNED_OCTET_LENGTH": {Keyword: "RETURNED_OCTET_LENGTH", Reserved: false}, + "RETURNED_SQLSTATE": {Keyword: "RETURNED_SQLSTATE", Reserved: false}, + "RETURNING": {Keyword: "RETURNING", Reserved: true}, + "RETURNS": {Keyword: "RETURNS", Reserved: false}, + "REVOKE": {Keyword: "REVOKE", Reserved: false}, + "RIGHT": {Keyword: "RIGHT", Reserved: true}, + "ROLE": {Keyword: "ROLE", Reserved: false}, + "ROLLBACK": {Keyword: "ROLLBACK", Reserved: false}, + "ROLLUP": {Keyword: "ROLLUP", Reserved: false}, + "ROUTINE": {Keyword: "ROUTINE", Reserved: false}, + "ROUTINES": {Keyword: "ROUTINES", Reserved: false}, + "ROUTINE_CATALOG": {Keyword: "ROUTINE_CATALOG", Reserved: false}, + "ROUTINE_NAME": {Keyword: "ROUTINE_NAME", Reserved: false}, + "ROUTINE_SCHEMA": {Keyword: "ROUTINE_SCHEMA", Reserved: false}, + "ROW": {Keyword: "ROW", Reserved: false}, + "ROWS": {Keyword: "ROWS", Reserved: false}, + "ROW_COUNT": {Keyword: "ROW_COUNT", Reserved: false}, + "ROW_NUMBER": {Keyword: "ROW_NUMBER", Reserved: false}, + "RPAD": {Keyword: "RPAD", Reserved: false}, + "RTRIM": {Keyword: "RTRIM", Reserved: false}, + "RULE": {Keyword: "RULE", Reserved: false}, + "RUNNING": {Keyword: "RUNNING", Reserved: false}, + "SAVEPOINT": {Keyword: "SAVEPOINT", Reserved: false}, + "SCALAR": {Keyword: "SCALAR", Reserved: false}, + "SCALE": {Keyword: "SCALE", Reserved: false}, + "SCHEMA": {Keyword: "SCHEMA", Reserved: false}, + "SCHEMAS": {Keyword: "SCHEMAS", Reserved: false}, + "SCHEMA_NAME": {Keyword: "SCHEMA_NAME", Reserved: false}, + "SCOPE": {Keyword: "SCOPE", Reserved: false}, + "SCOPE_CATALOG": {Keyword: "SCOPE_CATALOG", Reserved: false}, + "SCOPE_NAME": {Keyword: "SCOPE_NAME", Reserved: false}, + "SCOPE_SCHEMA": {Keyword: "SCOPE_SCHEMA", Reserved: false}, + "SCROLL": {Keyword: "SCROLL", Reserved: false}, + "SEARCH": {Keyword: "SEARCH", Reserved: false}, + "SECOND": {Keyword: "SECOND", Reserved: false}, + "SECTION": {Keyword: "SECTION", Reserved: false}, + "SECURITY": {Keyword: "SECURITY", Reserved: false}, + "SEEK": {Keyword: "SEEK", Reserved: false}, + "SELECT": {Keyword: "SELECT", Reserved: true}, + "SELECTIVE": {Keyword: "SELECTIVE", Reserved: false}, + "SELF": {Keyword: "SELF", Reserved: false}, + "SEMANTICS": {Keyword: "SEMANTICS", Reserved: false}, + "SENSITIVE": {Keyword: "SENSITIVE", Reserved: false}, + "SEQUENCE": {Keyword: "SEQUENCE", Reserved: false}, + "SEQUENCES": {Keyword: "SEQUENCES", Reserved: false}, + "SERIALIZABLE": {Keyword: "SERIALIZABLE", Reserved: false}, + "SERVER": {Keyword: "SERVER", Reserved: false}, + "SERVER_NAME": {Keyword: "SERVER_NAME", Reserved: false}, + "SESSION": {Keyword: "SESSION", Reserved: false}, + "SESSION_USER": {Keyword: "SESSION_USER", Reserved: true}, + "SET": {Keyword: "SET", Reserved: false}, + "SETOF": {Keyword: "SETOF", Reserved: false}, + "SETS": {Keyword: "SETS", Reserved: false}, + "SHARE": {Keyword: "SHARE", Reserved: false}, + "SHOW": {Keyword: "SHOW", Reserved: false}, + "SIMILAR": {Keyword: "SIMILAR", Reserved: true}, + "SIMPLE": {Keyword: "SIMPLE", Reserved: false}, + "SIN": {Keyword: "SIN", Reserved: false}, + "SINH": {Keyword: "SINH", Reserved: false}, + "SIZE": {Keyword: "SIZE", Reserved: false}, + "SKIP": {Keyword: "SKIP", Reserved: false}, + "SMALLINT": {Keyword: "SMALLINT", Reserved: false}, + "SNAPSHOT": {Keyword: "SNAPSHOT", Reserved: false}, + "SOME": {Keyword: "SOME", Reserved: true}, + "SORT_DIRECTION": {Keyword: "SORT_DIRECTION", Reserved: false}, + "SOURCE": {Keyword: "SOURCE", Reserved: false}, + "SPACE": {Keyword: "SPACE", Reserved: false}, + "SPECIFIC": {Keyword: "SPECIFIC", Reserved: false}, + "SPECIFICTYPE": {Keyword: "SPECIFICTYPE", Reserved: false}, + "SPECIFIC_NAME": {Keyword: "SPECIFIC_NAME", Reserved: false}, + "SQL": {Keyword: "SQL", Reserved: false}, + "SQLCODE": {Keyword: "SQLCODE", Reserved: false}, + "SQLERROR": {Keyword: "SQLERROR", Reserved: false}, + "SQLEXCEPTION": {Keyword: "SQLEXCEPTION", Reserved: false}, + "SQLSTATE": {Keyword: "SQLSTATE", Reserved: false}, + "SQLWARNING": {Keyword: "SQLWARNING", Reserved: false}, + "SQRT": {Keyword: "SQRT", Reserved: false}, + "STABLE": {Keyword: "STABLE", Reserved: false}, + "STANDALONE": {Keyword: "STANDALONE", Reserved: false}, + "START": {Keyword: "START", Reserved: false}, + "STATE": {Keyword: "STATE", Reserved: false}, + "STATEMENT": {Keyword: "STATEMENT", Reserved: false}, + "STATIC": {Keyword: "STATIC", Reserved: false}, + "STATISTICS": {Keyword: "STATISTICS", Reserved: false}, + "STDDEV_POP": {Keyword: "STDDEV_POP", Reserved: false}, + "STDDEV_SAMP": {Keyword: "STDDEV_SAMP", Reserved: false}, + "STDIN": {Keyword: "STDIN", Reserved: false}, + "STDOUT": {Keyword: "STDOUT", Reserved: false}, + "STORAGE": {Keyword: "STORAGE", Reserved: false}, + "STORED": {Keyword: "STORED", Reserved: false}, + "STRICT": {Keyword: "STRICT", Reserved: false}, + "STRING": {Keyword: "STRING", Reserved: false}, + "STRIP": {Keyword: "STRIP", Reserved: false}, + "STRUCTURE": {Keyword: "STRUCTURE", Reserved: false}, + "STYLE": {Keyword: "STYLE", Reserved: false}, + "SUBCLASS_ORIGIN": {Keyword: "SUBCLASS_ORIGIN", Reserved: false}, + "SUBMULTISET": {Keyword: "SUBMULTISET", Reserved: false}, + "SUBSCRIPTION": {Keyword: "SUBSCRIPTION", Reserved: false}, + "SUBSET": {Keyword: "SUBSET", Reserved: false}, + "SUBSTRING": {Keyword: "SUBSTRING", Reserved: false}, + "SUBSTRING_REGEX": {Keyword: "SUBSTRING_REGEX", Reserved: false}, + "SUCCEEDS": {Keyword: "SUCCEEDS", Reserved: false}, + "SUM": {Keyword: "SUM", Reserved: false}, + "SUPPORT": {Keyword: "SUPPORT", Reserved: false}, + "SYMMETRIC": {Keyword: "SYMMETRIC", Reserved: true}, + "SYSID": {Keyword: "SYSID", Reserved: false}, + "SYSTEM": {Keyword: "SYSTEM", Reserved: false}, + "SYSTEM_TIME": {Keyword: "SYSTEM_TIME", Reserved: false}, + "SYSTEM_USER": {Keyword: "SYSTEM_USER", Reserved: true}, + "T": {Keyword: "T", Reserved: false}, + "TABLE": {Keyword: "TABLE", Reserved: true}, + "TABLES": {Keyword: "TABLES", Reserved: false}, + "TABLESAMPLE": {Keyword: "TABLESAMPLE", Reserved: true}, + "TABLESPACE": {Keyword: "TABLESPACE", Reserved: false}, + "TABLE_NAME": {Keyword: "TABLE_NAME", Reserved: false}, + "TAN": {Keyword: "TAN", Reserved: false}, + "TANH": {Keyword: "TANH", Reserved: false}, + "TARGET": {Keyword: "TARGET", Reserved: false}, + "TEMP": {Keyword: "TEMP", Reserved: false}, + "TEMPLATE": {Keyword: "TEMPLATE", Reserved: false}, + "TEMPORARY": {Keyword: "TEMPORARY", Reserved: false}, + "TEXT": {Keyword: "TEXT", Reserved: false}, + "THEN": {Keyword: "THEN", Reserved: true}, + "THROUGH": {Keyword: "THROUGH", Reserved: false}, + "TIES": {Keyword: "TIES", Reserved: false}, + "TIME": {Keyword: "TIME", Reserved: false}, + "TIMESTAMP": {Keyword: "TIMESTAMP", Reserved: false}, + "TIMEZONE_HOUR": {Keyword: "TIMEZONE_HOUR", Reserved: false}, + "TIMEZONE_MINUTE": {Keyword: "TIMEZONE_MINUTE", Reserved: false}, + "TO": {Keyword: "TO", Reserved: true}, + "TOKEN": {Keyword: "TOKEN", Reserved: false}, + "TOP_LEVEL_COUNT": {Keyword: "TOP_LEVEL_COUNT", Reserved: false}, + "TRAILING": {Keyword: "TRAILING", Reserved: true}, + "TRANSACTION": {Keyword: "TRANSACTION", Reserved: false}, + "TRANSACTIONS_COMMITTED": {Keyword: "TRANSACTIONS_COMMITTED", Reserved: false}, + "TRANSACTIONS_ROLLED_BACK": {Keyword: "TRANSACTIONS_ROLLED_BACK", Reserved: false}, + "TRANSACTION_ACTIVE": {Keyword: "TRANSACTION_ACTIVE", Reserved: false}, + "TRANSFORM": {Keyword: "TRANSFORM", Reserved: false}, + "TRANSFORMS": {Keyword: "TRANSFORMS", Reserved: false}, + "TRANSLATE": {Keyword: "TRANSLATE", Reserved: false}, + "TRANSLATE_REGEX": {Keyword: "TRANSLATE_REGEX", Reserved: false}, + "TRANSLATION": {Keyword: "TRANSLATION", Reserved: false}, + "TREAT": {Keyword: "TREAT", Reserved: false}, + "TRIGGER": {Keyword: "TRIGGER", Reserved: false}, + "TRIGGER_CATALOG": {Keyword: "TRIGGER_CATALOG", Reserved: false}, + "TRIGGER_NAME": {Keyword: "TRIGGER_NAME", Reserved: false}, + "TRIGGER_SCHEMA": {Keyword: "TRIGGER_SCHEMA", Reserved: false}, + "TRIM": {Keyword: "TRIM", Reserved: false}, + "TRIM_ARRAY": {Keyword: "TRIM_ARRAY", Reserved: false}, + "TRUE": {Keyword: "TRUE", Reserved: true}, + "TRUNCATE": {Keyword: "TRUNCATE", Reserved: false}, + "TRUSTED": {Keyword: "TRUSTED", Reserved: false}, + "TYPE": {Keyword: "TYPE", Reserved: false}, + "TYPES": {Keyword: "TYPES", Reserved: false}, + "UESCAPE": {Keyword: "UESCAPE", Reserved: false}, + "UNBOUNDED": {Keyword: "UNBOUNDED", Reserved: false}, + "UNCOMMITTED": {Keyword: "UNCOMMITTED", Reserved: false}, + "UNCONDITIONAL": {Keyword: "UNCONDITIONAL", Reserved: false}, + "UNDER": {Keyword: "UNDER", Reserved: false}, + "UNENCRYPTED": {Keyword: "UNENCRYPTED", Reserved: false}, + "UNION": {Keyword: "UNION", Reserved: true}, + "UNIQUE": {Keyword: "UNIQUE", Reserved: true}, + "UNKNOWN": {Keyword: "UNKNOWN", Reserved: false}, + "UNLINK": {Keyword: "UNLINK", Reserved: false}, + "UNLISTEN": {Keyword: "UNLISTEN", Reserved: false}, + "UNLOGGED": {Keyword: "UNLOGGED", Reserved: false}, + "UNMATCHED": {Keyword: "UNMATCHED", Reserved: false}, + "UNNAMED": {Keyword: "UNNAMED", Reserved: false}, + "UNNEST": {Keyword: "UNNEST", Reserved: false}, + "UNTIL": {Keyword: "UNTIL", Reserved: false}, + "UNTYPED": {Keyword: "UNTYPED", Reserved: false}, + "UPDATE": {Keyword: "UPDATE", Reserved: false}, + "UPPER": {Keyword: "UPPER", Reserved: false}, + "URI": {Keyword: "URI", Reserved: false}, + "USAGE": {Keyword: "USAGE", Reserved: false}, + "USER": {Keyword: "USER", Reserved: true}, + "USER_DEFINED_TYPE_CATALOG": {Keyword: "USER_DEFINED_TYPE_CATALOG", Reserved: false}, + "USER_DEFINED_TYPE_CODE": {Keyword: "USER_DEFINED_TYPE_CODE", Reserved: false}, + "USER_DEFINED_TYPE_NAME": {Keyword: "USER_DEFINED_TYPE_NAME", Reserved: false}, + "USER_DEFINED_TYPE_SCHEMA": {Keyword: "USER_DEFINED_TYPE_SCHEMA", Reserved: false}, + "USING": {Keyword: "USING", Reserved: true}, + "UTF16": {Keyword: "UTF16", Reserved: false}, + "UTF32": {Keyword: "UTF32", Reserved: false}, + "UTF8": {Keyword: "UTF8", Reserved: false}, + "VACUUM": {Keyword: "VACUUM", Reserved: false}, + "VALID": {Keyword: "VALID", Reserved: false}, + "VALIDATE": {Keyword: "VALIDATE", Reserved: false}, + "VALIDATOR": {Keyword: "VALIDATOR", Reserved: false}, + "VALUE": {Keyword: "VALUE", Reserved: false}, + "VALUES": {Keyword: "VALUES", Reserved: false}, + "VALUE_OF": {Keyword: "VALUE_OF", Reserved: false}, + "VARBINARY": {Keyword: "VARBINARY", Reserved: false}, + "VARCHAR": {Keyword: "VARCHAR", Reserved: false}, + "VARIADIC": {Keyword: "VARIADIC", Reserved: true}, + "VARYING": {Keyword: "VARYING", Reserved: false}, + "VAR_POP": {Keyword: "VAR_POP", Reserved: false}, + "VAR_SAMP": {Keyword: "VAR_SAMP", Reserved: false}, + "VERBOSE": {Keyword: "VERBOSE", Reserved: true}, + "VERSION": {Keyword: "VERSION", Reserved: false}, + "VERSIONING": {Keyword: "VERSIONING", Reserved: false}, + "VIEW": {Keyword: "VIEW", Reserved: false}, + "VIEWS": {Keyword: "VIEWS", Reserved: false}, + "VOLATILE": {Keyword: "VOLATILE", Reserved: false}, + "WHEN": {Keyword: "WHEN", Reserved: true}, + "WHENEVER": {Keyword: "WHENEVER", Reserved: false}, + "WHERE": {Keyword: "WHERE", Reserved: true}, + "WHITESPACE": {Keyword: "WHITESPACE", Reserved: false}, + "WIDTH_BUCKET": {Keyword: "WIDTH_BUCKET", Reserved: false}, + "WINDOW": {Keyword: "WINDOW", Reserved: true}, + "WITH": {Keyword: "WITH", Reserved: true}, + "WITHIN": {Keyword: "WITHIN", Reserved: false}, + "WITHOUT": {Keyword: "WITHOUT", Reserved: false}, + "WORK": {Keyword: "WORK", Reserved: false}, + "WRAPPER": {Keyword: "WRAPPER", Reserved: false}, + "WRITE": {Keyword: "WRITE", Reserved: false}, + "XML": {Keyword: "XML", Reserved: false}, + "XMLAGG": {Keyword: "XMLAGG", Reserved: false}, + "XMLATTRIBUTES": {Keyword: "XMLATTRIBUTES", Reserved: false}, + "XMLBINARY": {Keyword: "XMLBINARY", Reserved: false}, + "XMLCAST": {Keyword: "XMLCAST", Reserved: false}, + "XMLCOMMENT": {Keyword: "XMLCOMMENT", Reserved: false}, + "XMLCONCAT": {Keyword: "XMLCONCAT", Reserved: false}, + "XMLDECLARATION": {Keyword: "XMLDECLARATION", Reserved: false}, + "XMLDOCUMENT": {Keyword: "XMLDOCUMENT", Reserved: false}, + "XMLELEMENT": {Keyword: "XMLELEMENT", Reserved: false}, + "XMLEXISTS": {Keyword: "XMLEXISTS", Reserved: false}, + "XMLFOREST": {Keyword: "XMLFOREST", Reserved: false}, + "XMLITERATE": {Keyword: "XMLITERATE", Reserved: false}, + "XMLNAMESPACES": {Keyword: "XMLNAMESPACES", Reserved: false}, + "XMLPARSE": {Keyword: "XMLPARSE", Reserved: false}, + "XMLPI": {Keyword: "XMLPI", Reserved: false}, + "XMLQUERY": {Keyword: "XMLQUERY", Reserved: false}, + "XMLROOT": {Keyword: "XMLROOT", Reserved: false}, + "XMLSCHEMA": {Keyword: "XMLSCHEMA", Reserved: false}, + "XMLSERIALIZE": {Keyword: "XMLSERIALIZE", Reserved: false}, + "XMLTABLE": {Keyword: "XMLTABLE", Reserved: false}, + "XMLTEXT": {Keyword: "XMLTEXT", Reserved: false}, + "XMLVALIDATE": {Keyword: "XMLVALIDATE", Reserved: false}, + "YEAR": {Keyword: "YEAR", Reserved: false}, + "YES": {Keyword: "YES", Reserved: false}, + "ZONE": {Keyword: "ZONE", Reserved: false}, +} diff --git a/redshift/parser_test.go b/redshift/parser_test.go new file mode 100644 index 0000000..e01370c --- /dev/null +++ b/redshift/parser_test.go @@ -0,0 +1,98 @@ +package redshift_test + +import ( + "os" + "path" + "testing" + + "github.com/antlr4-go/antlr/v4" + "github.com/bytebase/parser/redshift" + "github.com/stretchr/testify/require" +) + +type CustomErrorListener struct { + errors int +} + +func (l *CustomErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.errors += 1 + antlr.ConsoleErrorListenerINSTANCE.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) +} + +func (l *CustomErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) +} + +func (l *CustomErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) +} + +func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) +} + +func TestRedshiftParser(t *testing.T) { + redshiftDir := path.Join("examples", "redshift") + // Check if redshift directory exists + if _, err := os.Stat(redshiftDir); os.IsNotExist(err) { + t.Skip("Redshift examples directory not found") + return + } + + examples, err := os.ReadDir(redshiftDir) + if err != nil { + t.Skip("Cannot read Redshift examples directory") + return + } + + for _, file := range examples { + if file.IsDir() { + continue + } + filePath := path.Join(redshiftDir, file.Name()) + t.Run(filePath, func(t *testing.T) { + // read all the bytes from the file + data, err := os.ReadFile(filePath) + require.NoError(t, err) + + input := antlr.NewInputStream(string(data)) + + lexer := redshift.NewRedshiftLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := redshift.NewRedshiftParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + tree := p.Root() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) + + start := 0 + stop := stream.Size() - 1 + for i := 0; i < stream.Size(); i++ { + if stream.Get(i).GetChannel() == antlr.TokenDefaultChannel { + start = i + break + } + } + for i := stream.Size() - 1; i >= 0; i-- { + if stream.Get(i).GetChannel() == antlr.TokenDefaultChannel && stream.Get(i).GetTokenType() != antlr.TokenEOF { + stop = i + break + } + } + require.Equal(t, start, tree.GetStart().GetTokenIndex()) + require.Equal(t, stop, tree.GetStop().GetTokenIndex()) + }) + } +} diff --git a/redshift/redshift_lexer.go b/redshift/redshift_lexer.go new file mode 100644 index 0000000..842f8af --- /dev/null +++ b/redshift/redshift_lexer.go @@ -0,0 +1,5889 @@ +// Code generated from RedshiftLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package redshift + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type RedshiftLexer struct { + RedshiftLexerBase + channelNames []string + modeNames []string + // TODO: EOF string +} + +var RedshiftLexerLexerStaticData 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 redshiftlexerLexerInit() { + staticData := &RedshiftLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", "EscapeStringConstantMode", "AfterEscapeStringConstantMode", + "AfterEscapeStringConstantWithNewlineMode", "DollarQuotedStringMode", + } + staticData.LiteralNames = []string{ + "", "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'*'", "'='", + "'.'", "'+'", "'-'", "'/'", "'^'", "'<'", "'>'", "'<<'", "'>>'", "':='", + "'<='", "'=>'", "'>='", "'..'", "'<>'", "'::'", "'%'", "", "", "'ALL'", + "'ANALYSE'", "'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", "'AS'", "'ASC'", + "'ASYMMETRIC'", "'BOTH'", "'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", + "'COLUMN'", "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", "'CURRENT_DATE'", + "'CURRENT_ROLE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", + "'DEFAULT'", "'DEFERRABLE'", "'DESC'", "'DISTINCT'", "'DO'", "'ELSE'", + "'EXCEPT'", "'FALSE'", "'FETCH'", "'FOR'", "'FOREIGN'", "'FROM'", "'GRANT'", + "'GROUP'", "'HAVING'", "'IN'", "'INITIALLY'", "'INTERSECT'", "'INTO'", + "'LATERAL'", "'LEADING'", "'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'", + "'NOT'", "'NULL'", "'OFFSET'", "'ON'", "'ONLY'", "'OR'", "'ORDER'", + "'PLACING'", "'PRIMARY'", "'PUBLIC'", "'REFERENCES'", "'RETURNING'", + "'SELECT'", "'SESSION_USER'", "'SOME'", "'SYMMETRIC'", "'TABLE'", "'THEN'", + "'TO'", "'TRAILING'", "'TRUE'", "'UNION'", "'UNIQUE'", "'USER'", "'USING'", + "'VARIADIC'", "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'AUTHORIZATION'", + "'BINARY'", "'BINDING'", "'COLLATION'", "'CONCURRENTLY'", "'CROSS'", + "'CURRENT_SCHEMA'", "'FREEZE'", "'FULL'", "'ILIKE'", "'INNER'", "'IS'", + "'ISNULL'", "'JOIN'", "'LEFT'", "'LIKE'", "'NATURAL'", "'NOTNULL'", + "'OUTER'", "'OVER'", "'OVERLAPS'", "'RIGHT'", "'SIMILAR'", "'VERBOSE'", + "'ABORT'", "'ABSOLUTE'", "'ACCESS'", "'ACTION'", "'ADD'", "'ADMIN'", + "'AFTER'", "'AGGREGATE'", "'ALSO'", "'ALTER'", "'ALWAYS'", "'ASSERTION'", + "'ASSIGNMENT'", "'AT'", "'ATTRIBUTE'", "'BACKWARD'", "'BEFORE'", "'BEGIN'", + "'BY'", "'CACHE'", "'CALLED'", "'CASCADE'", "'CASCADED'", "'CATALOG'", + "'CHAIN'", "'CHARACTERISTICS'", "'CHECKPOINT'", "'CLASS'", "'CLOSE'", + "'CLUSTER'", "'COMMENT'", "'COMMENTS'", "'COMMIT'", "'COMMITTED'", "'CONFIGURATION'", + "'CONNECTION'", "'CONSTRAINTS'", "'CONTENT'", "'CONTINUE'", "'CONVERSION'", + "'COPY'", "'COST'", "'CSV'", "'JSON'", "'CURSOR'", "'CYCLE'", "'DATA'", + "'DATA_CATALOG'", "'DATABASE'", "'DAY'", "'DEALLOCATE'", "'DECLARE'", + "'DEFAULTS'", "'DEFERRED'", "'DEFINER'", "'DELETE'", "'DELIMITER'", + "'DELIMITERS'", "'DICTIONARY'", "'DISABLE'", "'DISCARD'", "'DOCUMENT'", + "'DOMAIN'", "'DOUBLE'", "'DROP'", "'EACH'", "'ENABLE'", "'ENCODING'", + "'ENCRYPTED'", "'ENUM'", "'ESCAPE'", "'EVENT'", "'EXCLUDE'", "'EXCLUDING'", + "'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", "'EXTENSION'", "'EXTERNAL'", + "'FAMILY'", "'FIRST'", "'FOLLOWING'", "'FORCE'", "'FORWARD'", "'FUNCTION'", + "'FUNCTIONS'", "'GLOBAL'", "'GRANTED'", "'HANDLER'", "", "'HOLD'", "'HOUR'", + "", "'IF'", "'IMMEDIATE'", "'IMMUTABLE'", "'IMPLICIT'", "'INCLUDING'", + "'INCREMENT'", "'INDEX'", "'INDEXES'", "'INHERIT'", "'INHERITS'", "'INLINE'", + "'INSENSITIVE'", "'INSERT'", "'INSTEAD'", "'INVOKER'", "'ISOLATION'", + "'KEY'", "'LABEL'", "'LANGUAGE'", "'LARGE'", "'LAST'", "'LEAKPROOF'", + "'LEVEL'", "'LISTEN'", "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", + "'MAPPING'", "'MATCH'", "'MATCHED'", "'MATERIALIZED'", "'MAXVALUE'", + "'MERGE'", "'MINUTE'", "'MINVALUE'", "'MODE'", "'MONTH'", "'MOVE'", + "'NAME'", "'NAMES'", "'NEXT'", "'NO'", "'NOTHING'", "'NOTIFY'", "'NOWAIT'", + "'NULLS'", "'OBJECT'", "'OF'", "'OFF'", "'OIDS'", "'OPERATOR'", "'OPTION'", + "'OPTIONS'", "'OWNED'", "'OWNER'", "'PARSER'", "'PARTIAL'", "'PARTITION'", + "'PASSING'", "'PASSWORD'", "'PLANS'", "'PRECEDING'", "'PREDICATE'", + "'PREPARE'", "'PREPARED'", "'PRESERVE'", "'PRIOR'", "'PRIVILEGES'", + "'PROCEDURAL'", "'PROCEDURE'", "'PROGRAM'", "'QUOTE'", "'RANGE'", "'READ'", + "'REASSIGN'", "'RECHECK'", "'RECURSIVE'", "'REF'", "'REFRESH'", "'REINDEX'", + "'RELATIVE'", "'RELEASE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", + "'REPLICA'", "'RESET'", "'RESTART'", "'RESTRICT'", "'RETURNS'", "'REVOKE'", + "'ROLE'", "'ROLLBACK'", "'ROWS'", "'RULE'", "'SAVEPOINT'", "'SCHEMA'", + "'SCROLL'", "'SEARCH'", "'SECOND'", "'SECURITY'", "'SEQUENCE'", "'SEQUENCES'", + "'SERIALIZABLE'", "'SERVER'", "", "'SET'", "'SHARE'", "'SHOW'", "'SIMPLE'", + "'SNAPSHOT'", "'STABLE'", "'STANDALONE'", "'START'", "'STATEMENT'", + "'STATISTICS'", "'STDIN'", "'STDOUT'", "'STORAGE'", "'STRICT'", "'STRIP'", + "'SYSID'", "'SYSTEM'", "'TABLES'", "'TABLESPACE'", "'TEMP'", "'TEMPLATE'", + "'TEMPORARY'", "'TEXT'", "'TRANSACTION'", "'TRIGGER'", "'TRUNCATE'", + "'TRUSTED'", "'TYPE'", "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNENCRYPTED'", + "'UNKNOWN'", "'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", "'UPDATE'", "'VACUUM'", + "'VALID'", "'VALIDATE'", "'VALIDATOR'", "'VARYING'", "'VERSION'", "'VIEW'", + "'VOLATILE'", "'WHITESPACE'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'WRITE'", + "'XML'", "'YEAR'", "'YES'", "'ZONE'", "'QUALIFY'", "'CONNECT'", "'TOP'", + "'VARBYTE'", "'VARBINARY'", "'CONJUNCTION'", "'DEFINITION'", "'DATASHARE'", + "'FILE'", "'PUBLICACCESSIBLE'", "'INCLUDENEW'", "'IAM_ROLE'", "'CATALOG_ROLE'", + "'CATALOG_ID'", "'HIVE'", "'METASTORE'", "'URI'", "'POSTGRES'", "'MYSQL'", + "'SECRET_ARN'", "'KINESIS'", "'KAFKA'", "'MSK'", "'AUTHENTICATION'", + "'AUTHENTICATION_ARN'", "", "'MTLS'", "'MASKING'", "'RLS'", "", "'PROVIDER'", + "'PROTECTED'", "'MODEL'", "'TARGET'", "'SAGEMAKER'", "'AUTO'", "'MODEL_TYPE'", + "'PROBLEM_TYPE'", "'OBJECTIVE'", "'PREPROCESSORS'", "'HYPERPARAMETERS'", + "'XGBOOST'", "'MLP'", "'LINEAR_LEARNER'", "'KMEANS'", "'FORECAST'", + "'REGRESSION'", "'BINARY_CLASSIFICATION'", "'MULTICLASS_CLASSIFICATION'", + "'S3_BUCKET'", "'TAGS'", "'KMS_KEY_ID'", "'S3_GARBAGE_COLLECT'", "'MAX_CELLS'", + "'MAX_RUNTIME'", "'HORIZON'", "'FREQUENCY'", "'PERCENTILES'", "'MAX_BATCH_ROWS'", + "'UNLOAD'", "'MANIFEST'", "'ADDQUOTES'", "'ALLOWOVERWRITE'", "'CLEANPATH'", + "'MAXFILESIZE'", "'ROWGROUPSIZE'", "'BZIP2'", "'GZIP'", "'ZSTD'", "'DATABASES'", + "'DATASHARES'", "'GRANTS'", "'USE'", "'CANCEL'", "'SESSION_AUTHORIZATION'", + "'SESSION_CHARACTERISTICS'", "'COMPRESSION'", "'LIBRARY'", "'APPEND'", + "'MB'", "'GB'", "'ACCOUNT'", "'NAMESPACE'", "'DESCRIBE'", "'NONATOMIC'", + "'MANAGEDBY'", "'ADX'", "'REMOVE'", "'DUPLICATES'", "'BEDROCK'", "'MODEL_ID'", + "'PROMPT'", "'SUFFIX'", "'REQUEST_TYPE'", "'RESPONSE_TYPE'", "'RAW'", + "'UNIFIED'", "'SUPER'", "'CI'", "'CS'", "'PLPYTHONU'", "'FILLTARGET'", + "'IGNOREEXTRA'", "'CREATEUSER'", "'NOCREATEUSER'", "'REGION'", "'PORT'", + "'REDSHIFT'", "'IAM'", "'CREATEDB'", "'NOCREATEDB'", "'RESTRICTED'", + "'UNLIMITED'", "'EXTERNALID'", "'TIMEOUT'", "'SYSLOG'", "'CREDENTIALS'", + "'UNRESTRICTED'", "'PARAMETERS'", "'APPLICATION_ARN'", "'AUTO_CREATE_ROLES'", + "'COMPROWS'", "'PROVIDER_URL'", "'PROVIDER_URL_PORT'", "'ATTRIBUTE_MAP'", + "'PROVIDER_ARN'", "'ASSUME_ROLE_ARN'", "'PROPERTIES'", "'AVRO'", "'RCFILE'", + "'SEQUENCEFILE'", "'TEXTFILE'", "'ORC'", "'ION'", "'LAMBDA'", "'FIXEDWIDTH'", + "'PARQUET'", "'LZOP'", "'REMOVEQUOTES'", "'TRUNCATECOLUMNS'", "'FILLRECORD'", + "'BLANKSASNULL'", "'EMPTYASNULL'", "'MAXERROR'", "'DATEFORMAT'", "'TIMEFORMAT'", + "'ACCEPTINVCHARS'", "'ACCEPTANYDATE'", "'IGNOREHEADER'", "'IGNOREBLANKLINES'", + "'COMPUPDATE'", "'STATUPDATE'", "'EXPLICIT_IDS'", "'READRATIO'", "'ROUNDEC'", + "'TRIMBLANKS'", "'PRESET'", "'ACCESS_KEY_ID'", "'SECRET_ACCESS_KEY'", + "'SESSION_TOKEN'", "", "'SETTINGS'", "'FUNCTION_NAME'", "'ATOMIC'", + "'BETWEEN'", "'BIGINT'", "'BIT'", "'BOOLEAN'", "'CHAR'", "'CHARACTER'", + "'COALESCE'", "'DEC'", "'DECIMAL'", "'EXISTS'", "'EXTRACT'", "'FLOAT'", + "'GREATEST'", "'INOUT'", "'INT'", "'INTEGER'", "'INTERVAL'", "'LEAST'", + "'NATIONAL'", "'NCHAR'", "'NONE'", "'NULLIF'", "'NUMERIC'", "'OVERLAY'", + "'PARAMETER'", "'POSITION'", "'PRECISION'", "'REAL'", "'ROW'", "'SETOF'", + "'SMALLINT'", "'SUBSTRING'", "'TIME'", "'TIMESTAMP'", "'TREAT'", "'TRIM'", + "'VALUES'", "'VARCHAR'", "'XMLATTRIBUTES'", "'XMLCOMMENT'", "'XMLAGG'", + "'XML_IS_WELL_FORMED'", "'XML_IS_WELL_FORMED_DOCUMENT'", "'XML_IS_WELL_FORMED_CONTENT'", + "'XPATH'", "'XPATH_EXISTS'", "'XMLCONCAT'", "'XMLELEMENT'", "'XMLEXISTS'", + "'XMLFOREST'", "'XMLPARSE'", "'XMLPI'", "'XMLROOT'", "'XMLSERIALIZE'", + "'CALL'", "'CURRENT'", "'ATTACH'", "'DETACH'", "'EXPRESSION'", "'GENERATED'", + "'LOGGED'", "'STORED'", "'SERDE'", "'SERDEPROPERTIES'", "'INPUTFORMAT'", + "'OUTPUTFORMAT'", "'FIELDS'", "'COLLECTION'", "'ITEMS'", "'TERMINATED'", + "'ESCAPED'", "'DEFINED'", "'LINES'", "'KEYS'", "'PARTITIONED'", "'STRUCT'", + "'MAP'", "'STRING'", "'DELIMITED'", "'USAGE'", "'IGNORE'", "'LANGUAGES'", + "'JOB'", "'JOBS'", "'VIA'", "'ASSUMEROLE'", "'RETRY_TIMEOUT'", "'MAX_BATCH_SIZE'", + "'MAX_PAYLOAD_IN_MB'", "'KB'", "'INCLUDE'", "'ROUTINE'", "'TRANSFORM'", + "'IMPORT'", "'POLICY'", "'PRIORITY'", "'METHOD'", "'REFERENCING'", "'NEW'", + "'OLD'", "'VALUE'", "'SUBSCRIPTION'", "'PUBLICATION'", "'OUT'", "'END'", + "'ROUTINES'", "'SCHEMAS'", "'PROCEDURES'", "'INPUT'", "'SUPPORT'", "'PARALLEL'", + "'SQL'", "'DEPENDS'", "'OVERRIDING'", "'CONFLICT'", "'SKIP'", "'LOCKED'", + "'TIES'", "'ROLLUP'", "'CUBE'", "'GROUPING'", "'SETS'", "'TABLESAMPLE'", + "'ORDINALITY'", "'XMLTABLE'", "'COLUMNS'", "'XMLNAMESPACES'", "'ROWTYPE'", + "'NORMALIZED'", "'WITHIN'", "'FILTER'", "'GROUPS'", "'OTHERS'", "'NFC'", + "'NFD'", "'NFKC'", "'NFKD'", "'UESCAPE'", "'VIEWS'", "'NORMALIZE'", + "'DUMP'", "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", "'ERROR'", + "'USE_VARIABLE'", "'USE_COLUMN'", "'ALIAS'", "'CONSTANT'", "'PERFORM'", + "'GET'", "'DIAGNOSTICS'", "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", + "'FOREACH'", "'SLICE'", "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", + "'SQLSTATE'", "'DEBUG'", "'LOG'", "'INFO'", "'NOTICE'", "'WARNING'", + "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", "'ABS'", "'CBRT'", "'CEIL'", + "'CEILING'", "'DEGREES'", "'DIV'", "'EXP'", "'FACTORIAL'", "'FLOOR'", + "'GCD'", "'LCM'", "'LN'", "'LOG10'", "'MIN_SCALE'", "'MOD'", "'PI'", + "'POWER'", "'RADIANS'", "'ROUND'", "'SCALE'", "'SIGN'", "'SQRT'", "'TRIM_SCALE'", + "'TRUNC'", "'WIDTH_BUCKET'", "'RANDOM'", "'SETSEED'", "'ACOS'", "'ACOSD'", + "'ASIN'", "'ASIND'", "'ATAN'", "'ATAND'", "'ATAN2'", "'ATAN2D'", "'COS'", + "'COSD'", "'COT'", "'COTD'", "'SIN'", "'SIND'", "'TAN'", "'TAND'", "'SINH'", + "'COSH'", "'TANH'", "'ASINH'", "'ACOSH'", "'ATANH'", "'BIT_LENGTH'", + "'CHAR_LENGTH'", "'CHARACTER_LENGTH'", "'LOWER'", "'OCTET_LENGTH'", + "'UPPER'", "'ASCII'", "'BTRIM'", "'CHR'", "'CONCAT'", "'CONCAT_WS'", + "'FORMAT'", "'INITCAP'", "'LENGTH'", "'LPAD'", "'LTRIM'", "'MD5'", "'PARSE_IDENT'", + "'PG_CLIENT_ENCODING'", "'QUOTE_IDENT'", "'QUOTE_LITERAL'", "'QUOTE_NULLABLE'", + "'REGEXP_COUNT'", "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_MATCH'", + "'REGEXP_MATCHES'", "'REGEXP_REPLACE'", "'REGEXP_SPLIT_TO_ARRAY'", "'REGEXP_SPLIT_TO_TABLE'", + "'REGEXP_SUBSTR'", "'REPEAT'", "'RPAD'", "'RTRIM'", "'SPLIT_PART'", + "'STARTS_WITH'", "'STRING_TO_ARRAY'", "'STRING_TO_TABLE'", "'STRPOS'", + "'SUBSTR'", "'TO_ASCII'", "'TO_HEX'", "'TRANSLATE'", "'UNISTR'", "'AGE'", + "'CLOCK_TIMESTAMP'", "'DATE_BIN'", "'DATE_PART'", "'DATE_TRUNC'", "'ISFINITE'", + "'JUSTIFY_DAYS'", "'JUSTIFY_HOURS'", "'JUSTIFY_INTERVAL'", "'MAKE_DATE'", + "'MAKE_INTERVAL'", "'MAKE_TIME'", "'MAKE_TIMESTAMP'", "'MAKE_TIMESTAMPTZ'", + "'NOW'", "'STATEMENT_TIMESTAMP'", "'TIMEOFDAY'", "'TRANSACTION_TIMESTAMP'", + "'TO_TIMESTAMP'", "'TO_CHAR'", "'TO_DATE'", "'TO_NUMBER'", "'ENCODE'", + "'DISTKEY'", "'SORTKEY'", "'DISTSTYLE'", "'BACKUP'", "'COMPOUND'", "'INTERLEAVED'", + "'EVEN'", "'CASE_SENSITIVE'", "'QUOTA'", "'TB'", "'BOOST'", "'RECLUSTER'", + "'SORT'", "'PERCENT'", "'CASE_INSENSITIVE'", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "'\\\\'", "", "", "", + "", "", "", "", "", "", "'''", + } + staticData.SymbolicNames = []string{ + "", "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", + "COMMA", "SEMI", "COLON", "STAR", "EQUAL", "DOT", "PLUS", "MINUS", "SLASH", + "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS", + "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", "NOT_EQUALS", + "TYPECAST", "PERCENT", "PARAM", "Operator", "ALL", "ANALYSE", "ANALYZE", + "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", "CASE", "CAST", + "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", "CURRENT_CATALOG", + "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", + "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", + "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP_P", + "HAVING", "IN_P", "INITIALLY", "INTERSECT", "INTO", "LATERAL_P", "LEADING", + "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", "ON", + "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "PUBLIC", "REFERENCES", + "RETURNING", "SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", + "THEN", "TO", "TRAILING", "TRUE_P", "UNION", "UNIQUE", "USER", "USING", + "VARIADIC", "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", "BINARY", + "BINDING", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", + "FULL", "ILIKE", "INNER_P", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", + "NATURAL", "NOTNULL", "OUTER_P", "OVER", "OVERLAPS", "RIGHT", "SIMILAR", + "VERBOSE", "ABORT_P", "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", + "AFTER", "AGGREGATE", "ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", + "AT", "ATTRIBUTE", "BACKWARD", "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", + "CASCADE", "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", + "CLASS", "CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", + "CONFIGURATION", "CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", + "CONVERSION_P", "COPY", "COST", "CSV", "JSON", "CURSOR", "CYCLE", "DATA_P", + "DATA_CATALOG", "DATABASE", "DAY_P", "DEALLOCATE", "DECLARE", "DEFAULTS", + "DEFERRED", "DEFINER", "DELETE_P", "DELIMITER", "DELIMITERS", "DICTIONARY", + "DISABLE_P", "DISCARD", "DOCUMENT_P", "DOMAIN_P", "DOUBLE_P", "DROP", + "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED", "ENUM_P", "ESCAPE", "EVENT", + "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXPLAIN", "EXTENSION", + "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING", "FORCE", "FORWARD", "FUNCTION", + "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER", "HEADER_P", "HOLD", "HOUR_P", + "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", "IMPLICIT_P", "INCLUDING", + "INCREMENT", "INDEX", "INDEXES", "INHERIT", "INHERITS", "INLINE_P", + "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", "ISOLATION", "KEY", "LABEL", + "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", "LEVEL", "LISTEN", "LOAD", + "LOCAL", "LOCATION", "LOCK_P", "MAPPING", "MATCH", "MATCHED", "MATERIALIZED", + "MAXVALUE", "MERGE", "MINUTE_P", "MINVALUE", "MODE", "MONTH_P", "MOVE", + "NAME_P", "NAMES", "NEXT", "NO", "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", + "OBJECT_P", "OF", "OFF", "OIDS", "OPERATOR", "OPTION", "OPTIONS", "OWNED", + "OWNER", "PARSER", "PARTIAL", "PARTITION", "PASSING", "PASSWORD", "PLANS", + "PRECEDING", "PREDICATE", "PREPARE", "PREPARED", "PRESERVE", "PRIOR", + "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "PROGRAM", "QUOTE", "RANGE", + "READ", "REASSIGN", "RECHECK", "RECURSIVE", "REF", "REFRESH", "REINDEX", + "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", + "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", "ROLE", "ROLLBACK", + "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", "SEARCH", "SECOND_P", + "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER", "SESSION", + "SET", "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", "STABLE", "STANDALONE_P", + "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", "STORAGE", "STRICT_P", + "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE", "TEMP", "TEMPLATE", + "TEMPORARY", "TEXT_P", "TRANSACTION", "TRIGGER", "TRUNCATE", "TRUSTED", + "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED", "UNENCRYPTED", "UNKNOWN", + "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", "VACUUM", "VALID", "VALIDATE", + "VALIDATOR", "VARYING", "VERSION_P", "VIEW", "VOLATILE", "WHITESPACE_P", + "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", "YEAR_P", "YES_P", "ZONE", + "QUALIFY", "CONNECT", "TOP", "VARBYTE", "VARBINARY", "CONJUNCTION", + "DEFINITION", "DATASHARE", "FILE", "PUBLICACCESSIBLE", "INCLUDENEW", + "IAM_ROLE", "CATALOG_ROLE", "CATALOG_ID", "HIVE", "METASTORE", "URI", + "POSTGRES", "MYSQL", "SECRET_ARN", "KINESIS", "KAFKA", "MSK", "AUTHENTICATION", + "AUTHENTICATION_ARN", "SESSION_TOKEN", "MTLS", "MASKING", "RLS", "IDENTITY", + "PROVIDER", "PROTECTED", "MODEL", "TARGET", "SAGEMAKER", "AUTO", "MODEL_TYPE", + "PROBLEM_TYPE", "OBJECTIVE", "PREPROCESSORS", "HYPERPARAMETERS", "XGBOOST", + "MLP", "LINEAR_LEARNER", "KMEANS", "FORECAST", "REGRESSION", "BINARY_CLASSIFICATION", + "MULTICLASS_CLASSIFICATION", "S3_BUCKET", "TAGS", "KMS_KEY_ID", "S3_GARBAGE_COLLECT", + "MAX_CELLS", "MAX_RUNTIME", "HORIZON", "FREQUENCY", "PERCENTILES", "MAX_BATCH_ROWS", + "UNLOAD", "MANIFEST", "ADDQUOTES", "ALLOWOVERWRITE", "CLEANPATH", "MAXFILESIZE", + "ROWGROUPSIZE", "BZIP2", "GZIP", "ZSTD", "DATABASES", "DATASHARES", + "GRANTS", "USE", "CANCEL", "SESSION_AUTHORIZATION", "SESSION_CHARACTERISTICS", + "COMPRESSION", "LIBRARY", "APPEND", "MB", "GB", "ACCOUNT", "NAMESPACE", + "DESCRIBE", "NONATOMIC", "MANAGEDBY", "ADX", "REMOVE", "DUPLICATES", + "BEDROCK", "MODEL_ID", "PROMPT", "SUFFIX", "REQUEST_TYPE", "RESPONSE_TYPE", + "RAW", "UNIFIED", "SUPER", "CI", "CS", "PLPYTHONU", "FILLTARGET", "IGNOREEXTRA", + "CREATEUSER", "NOCREATEUSER", "REGION", "PORT", "REDSHIFT", "IAM", "CREATEDB", + "NOCREATEDB", "RESTRICTED", "UNLIMITED", "EXTERNALID", "TIMEOUT", "SYSLOG", + "CREDENTIALS", "UNRESTRICTED", "PARAMETERS", "APPLICATION_ARN", "AUTO_CREATE_ROLES", + "COMPROWS", "PROVIDER_URL", "PROVIDER_URL_PORT", "ATTRIBUTE_MAP", "PROVIDER_ARN", + "ASSUME_ROLE_ARN", "PROPERTIES", "AVRO", "RCFILE", "SEQUENCEFILE", "TEXTFILE", + "ORC", "ION", "LAMBDA", "FIXEDWIDTH", "PARQUET", "LZOP", "REMOVEQUOTES", + "TRUNCATECOLUMNS", "FILLRECORD", "BLANKSASNULL", "EMPTYASNULL", "MAXERROR", + "DATEFORMAT", "TIMEFORMAT", "ACCEPTINVCHARS", "ACCEPTANYDATE", "IGNOREHEADER", + "IGNOREBLANKLINES", "COMPUPDATE", "STATUPDATE", "EXPLICIT_IDS", "READRATIO", + "ROUNDEC", "TRIMBLANKS", "PRESET", "ACCESS_KEY_ID", "SECRET_ACCESS_KEY", + "SESSION_TOKEN_KW", "HEADER", "SETTINGS", "FUNCTION_NAME", "ATOMIC_P", + "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", "CHARACTER", "COALESCE", + "DEC", "DECIMAL_P", "EXISTS", "EXTRACT", "FLOAT_P", "GREATEST", "INOUT", + "INT_P", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", "NCHAR", "NONE", + "NULLIF", "NUMERIC", "OVERLAY", "PARAMETER", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES", "XMLCOMMENT", + "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT", "XML_IS_WELL_FORMED_CONTENT", + "XPATH", "XPATH_EXISTS", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", "XMLFOREST", + "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", "CALL", "CURRENT_P", + "ATTACH", "DETACH", "EXPRESSION", "GENERATED", "LOGGED", "STORED", "SERDE", + "SERDEPROPERTIES", "INPUTFORMAT", "OUTPUTFORMAT", "FIELDS", "COLLECTION", + "ITEMS", "TERMINATED", "ESCAPED", "DEFINED", "LINES", "KEYS", "PARTITIONED", + "STRUCT", "MAP", "STRING", "DELIMITED", "USAGE", "IGNORE", "LANGUAGES", + "JOB", "JOBS", "VIA", "ASSUMEROLE", "RETRY_TIMEOUT", "MAX_BATCH_SIZE", + "MAX_PAYLOAD_IN_MB", "KB", "INCLUDE", "ROUTINE", "TRANSFORM", "IMPORT_P", + "POLICY", "PRIORITY", "METHOD", "REFERENCING", "NEW", "OLD", "VALUE_P", + "SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", "ROUTINES", "SCHEMAS", + "PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", "SQL_P", "DEPENDS", + "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", "ROLLUP", "CUBE", + "GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", "COLUMNS", + "XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", "GROUPS", + "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", "NORMALIZE", + "DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", "USE_VARIABLE", + "USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", "DIAGNOSTICS", + "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", "EXIT", + "RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", "NOTICE", + "WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "ABS", "CBRT", "CEIL", + "CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", "GCD", "LCM", + "LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", "ROUND", + "SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", "RANDOM", + "SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", "ATAN2", + "ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", "TAND", + "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", "CHAR_LENGTH", + "CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", "ASCII", "BTRIM", + "CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", "LENGTH", "LPAD", + "LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", "QUOTE_IDENT", + "QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE", + "REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY", + "REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM", + "SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS", + "SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP", + "DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS", + "JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP", + "MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP", + "TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "ENCODE", "DISTKEY", + "SORTKEY", "DISTSTYLE", "BACKUP", "COMPOUND", "INTERLEAVED", "EVEN", + "CASE_SENSITIVE", "QUOTA", "TB", "BOOST", "RECLUSTER", "SORT", "PERCENT_WORD", + "CASE_INSENSITIVE", "Identifier", "TemporaryIdentifier", "NamespaceUser", + "QuotedIdentifier", "UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", + "InvalidUnterminatedQuotedIdentifier", "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", + "InvalidUnicodeQuotedIdentifier", "InvalidUnterminatedUnicodeQuotedIdentifier", + "StringConstant", "UnterminatedStringConstant", "UnicodeEscapeStringConstant", + "UnterminatedUnicodeEscapeStringConstant", "BeginDollarStringConstant", + "BinaryStringConstant", "UnterminatedBinaryStringConstant", "InvalidBinaryStringConstant", + "InvalidUnterminatedBinaryStringConstant", "HexadecimalStringConstant", + "UnterminatedHexadecimalStringConstant", "InvalidHexadecimalStringConstant", + "InvalidUnterminatedHexadecimalStringConstant", "Integral", "NumericFail", + "Numeric", "PLSQLVARIABLENAME", "PLSQLIDENTIFIER", "Whitespace", "Newline", + "LineComment", "BlockComment", "UnterminatedBlockComment", "MetaCommand", + "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant", "UnterminatedEscapeStringConstant", + "InvalidEscapeStringConstant", "InvalidUnterminatedEscapeStringConstant", + "AfterEscapeStringConstantMode_NotContinued", "AfterEscapeStringConstantWithNewlineMode_NotContinued", + "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued", + } + staticData.RuleNames = []string{ + "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", + "COMMA", "SEMI", "COLON", "STAR", "EQUAL", "DOT", "PLUS", "MINUS", "SLASH", + "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS", + "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", "NOT_EQUALS", + "TYPECAST", "PERCENT", "PARAM", "Operator", "OperatorEndingWithPlusMinus", + "OperatorCharacter", "OperatorCharacterNotAllowPlusMinusAtEnd", "OperatorCharacterAllowPlusMinusAtEnd", + "ALL", "ANALYSE", "ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", + "BOTH", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", + "CREATE", "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", + "CURRENT_TIMESTAMP", "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", + "DISTINCT", "DO", "ELSE", "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", + "FROM", "GRANT", "GROUP_P", "HAVING", "IN_P", "INITIALLY", "INTERSECT", + "INTO", "LATERAL_P", "LEADING", "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", + "NOT", "NULL_P", "OFFSET", "ON", "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", + "PUBLIC", "REFERENCES", "RETURNING", "SELECT", "SESSION_USER", "SOME", + "SYMMETRIC", "TABLE", "THEN", "TO", "TRAILING", "TRUE_P", "UNION", "UNIQUE", + "USER", "USING", "VARIADIC", "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", + "BINARY", "BINDING", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", + "FREEZE", "FULL", "ILIKE", "INNER_P", "IS", "ISNULL", "JOIN", "LEFT", + "LIKE", "NATURAL", "NOTNULL", "OUTER_P", "OVER", "OVERLAPS", "RIGHT", + "SIMILAR", "VERBOSE", "ABORT_P", "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", + "ADMIN", "AFTER", "AGGREGATE", "ALSO", "ALTER", "ALWAYS", "ASSERTION", + "ASSIGNMENT", "AT", "ATTRIBUTE", "BACKWARD", "BEFORE", "BEGIN_P", "BY", + "CACHE", "CALLED", "CASCADE", "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", + "CHECKPOINT", "CLASS", "CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", + "COMMITTED", "CONFIGURATION", "CONNECTION", "CONSTRAINTS", "CONTENT_P", + "CONTINUE_P", "CONVERSION_P", "COPY", "COST", "CSV", "JSON", "CURSOR", + "CYCLE", "DATA_P", "DATA_CATALOG", "DATABASE", "DAY_P", "DEALLOCATE", + "DECLARE", "DEFAULTS", "DEFERRED", "DEFINER", "DELETE_P", "DELIMITER", + "DELIMITERS", "DICTIONARY", "DISABLE_P", "DISCARD", "DOCUMENT_P", "DOMAIN_P", + "DOUBLE_P", "DROP", "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED", "ENUM_P", + "ESCAPE", "EVENT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXPLAIN", + "EXTENSION", "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING", "FORCE", + "FORWARD", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER", + "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", + "IMPLICIT_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", "INHERIT", + "INHERITS", "INLINE_P", "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", + "ISOLATION", "KEY", "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", + "LEVEL", "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK_P", "MAPPING", + "MATCH", "MATCHED", "MATERIALIZED", "MAXVALUE", "MERGE", "MINUTE_P", + "MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P", "NAMES", "NEXT", "NO", + "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", "OBJECT_P", "OF", "OFF", "OIDS", + "OPERATOR", "OPTION", "OPTIONS", "OWNED", "OWNER", "PARSER", "PARTIAL", + "PARTITION", "PASSING", "PASSWORD", "PLANS", "PRECEDING", "PREDICATE", + "PREPARE", "PREPARED", "PRESERVE", "PRIOR", "PRIVILEGES", "PROCEDURAL", + "PROCEDURE", "PROGRAM", "QUOTE", "RANGE", "READ", "REASSIGN", "RECHECK", + "RECURSIVE", "REF", "REFRESH", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", + "REPEATABLE", "REPLACE", "REPLICA", "RESET", "RESTART", "RESTRICT", + "RETURNS", "REVOKE", "ROLE", "ROLLBACK", "ROWS", "RULE", "SAVEPOINT", + "SCHEMA", "SCROLL", "SEARCH", "SECOND_P", "SECURITY", "SEQUENCE", "SEQUENCES", + "SERIALIZABLE", "SERVER", "SESSION", "SET", "SHARE", "SHOW", "SIMPLE", + "SNAPSHOT", "STABLE", "STANDALONE_P", "START", "STATEMENT", "STATISTICS", + "STDIN", "STDOUT", "STORAGE", "STRICT_P", "STRIP_P", "SYSID", "SYSTEM_P", + "TABLES", "TABLESPACE", "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "TRANSACTION", + "TRIGGER", "TRUNCATE", "TRUSTED", "TYPE_P", "TYPES_P", "UNBOUNDED", + "UNCOMMITTED", "UNENCRYPTED", "UNKNOWN", "UNLISTEN", "UNLOGGED", "UNTIL", + "UPDATE", "VACUUM", "VALID", "VALIDATE", "VALIDATOR", "VARYING", "VERSION_P", + "VIEW", "VOLATILE", "WHITESPACE_P", "WITHOUT", "WORK", "WRAPPER", "WRITE", + "XML_P", "YEAR_P", "YES_P", "ZONE", "QUALIFY", "CONNECT", "TOP", "VARBYTE", + "VARBINARY", "CONJUNCTION", "DEFINITION", "DATASHARE", "FILE", "PUBLICACCESSIBLE", + "INCLUDENEW", "IAM_ROLE", "CATALOG_ROLE", "CATALOG_ID", "HIVE", "METASTORE", + "URI", "POSTGRES", "MYSQL", "SECRET_ARN", "KINESIS", "KAFKA", "MSK", + "AUTHENTICATION", "AUTHENTICATION_ARN", "SESSION_TOKEN", "MTLS", "MASKING", + "RLS", "IDENTITY", "PROVIDER", "PROTECTED", "MODEL", "TARGET", "SAGEMAKER", + "AUTO", "MODEL_TYPE", "PROBLEM_TYPE", "OBJECTIVE", "PREPROCESSORS", + "HYPERPARAMETERS", "XGBOOST", "MLP", "LINEAR_LEARNER", "KMEANS", "FORECAST", + "REGRESSION", "BINARY_CLASSIFICATION", "MULTICLASS_CLASSIFICATION", + "S3_BUCKET", "TAGS", "KMS_KEY_ID", "S3_GARBAGE_COLLECT", "MAX_CELLS", + "MAX_RUNTIME", "HORIZON", "FREQUENCY", "PERCENTILES", "MAX_BATCH_ROWS", + "UNLOAD", "MANIFEST", "ADDQUOTES", "ALLOWOVERWRITE", "CLEANPATH", "MAXFILESIZE", + "ROWGROUPSIZE", "BZIP2", "GZIP", "ZSTD", "DATABASES", "DATASHARES", + "GRANTS", "USE", "CANCEL", "SESSION_AUTHORIZATION", "SESSION_CHARACTERISTICS", + "COMPRESSION", "LIBRARY", "APPEND", "MB", "GB", "ACCOUNT", "NAMESPACE", + "DESCRIBE", "NONATOMIC", "MANAGEDBY", "ADX", "REMOVE", "DUPLICATES", + "BEDROCK", "MODEL_ID", "PROMPT", "SUFFIX", "REQUEST_TYPE", "RESPONSE_TYPE", + "RAW", "UNIFIED", "SUPER", "CI", "CS", "PLPYTHONU", "FILLTARGET", "IGNOREEXTRA", + "CREATEUSER", "NOCREATEUSER", "REGION", "PORT", "REDSHIFT", "IAM", "CREATEDB", + "NOCREATEDB", "RESTRICTED", "UNLIMITED", "EXTERNALID", "TIMEOUT", "SYSLOG", + "CREDENTIALS", "UNRESTRICTED", "PARAMETERS", "APPLICATION_ARN", "AUTO_CREATE_ROLES", + "COMPROWS", "PROVIDER_URL", "PROVIDER_URL_PORT", "ATTRIBUTE_MAP", "PROVIDER_ARN", + "ASSUME_ROLE_ARN", "PROPERTIES", "AVRO", "RCFILE", "SEQUENCEFILE", "TEXTFILE", + "ORC", "ION", "LAMBDA", "FIXEDWIDTH", "PARQUET", "LZOP", "REMOVEQUOTES", + "TRUNCATECOLUMNS", "FILLRECORD", "BLANKSASNULL", "EMPTYASNULL", "MAXERROR", + "DATEFORMAT", "TIMEFORMAT", "ACCEPTINVCHARS", "ACCEPTANYDATE", "IGNOREHEADER", + "IGNOREBLANKLINES", "COMPUPDATE", "STATUPDATE", "EXPLICIT_IDS", "READRATIO", + "ROUNDEC", "TRIMBLANKS", "PRESET", "ACCESS_KEY_ID", "SECRET_ACCESS_KEY", + "SESSION_TOKEN_KW", "HEADER", "SETTINGS", "FUNCTION_NAME", "ATOMIC_P", + "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", "CHARACTER", "COALESCE", + "DEC", "DECIMAL_P", "EXISTS", "EXTRACT", "FLOAT_P", "GREATEST", "INOUT", + "INT_P", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", "NCHAR", "NONE", + "NULLIF", "NUMERIC", "OVERLAY", "PARAMETER", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES", "XMLCOMMENT", + "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT", "XML_IS_WELL_FORMED_CONTENT", + "XPATH", "XPATH_EXISTS", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", "XMLFOREST", + "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", "CALL", "CURRENT_P", + "ATTACH", "DETACH", "EXPRESSION", "GENERATED", "LOGGED", "STORED", "SERDE", + "SERDEPROPERTIES", "INPUTFORMAT", "OUTPUTFORMAT", "FIELDS", "COLLECTION", + "ITEMS", "TERMINATED", "ESCAPED", "DEFINED", "LINES", "KEYS", "PARTITIONED", + "STRUCT", "MAP", "STRING", "DELIMITED", "USAGE", "IGNORE", "LANGUAGES", + "JOB", "JOBS", "VIA", "ASSUMEROLE", "RETRY_TIMEOUT", "MAX_BATCH_SIZE", + "MAX_PAYLOAD_IN_MB", "KB", "INCLUDE", "ROUTINE", "TRANSFORM", "IMPORT_P", + "POLICY", "PRIORITY", "METHOD", "REFERENCING", "NEW", "OLD", "VALUE_P", + "SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", "ROUTINES", "SCHEMAS", + "PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", "SQL_P", "DEPENDS", + "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", "ROLLUP", "CUBE", + "GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", "COLUMNS", + "XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", "GROUPS", + "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", "NORMALIZE", + "DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", "USE_VARIABLE", + "USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", "DIAGNOSTICS", + "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", "EXIT", + "RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", "NOTICE", + "WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "ABS", "CBRT", "CEIL", + "CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", "GCD", "LCM", + "LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", "ROUND", + "SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", "RANDOM", + "SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", "ATAN2", + "ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", "TAND", + "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", "CHAR_LENGTH", + "CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", "ASCII", "BTRIM", + "CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", "LENGTH", "LPAD", + "LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", "QUOTE_IDENT", + "QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE", + "REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY", + "REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM", + "SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS", + "SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP", + "DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS", + "JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP", + "MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP", + "TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "ENCODE", "DISTKEY", + "SORTKEY", "DISTSTYLE", "BACKUP", "COMPOUND", "INTERLEAVED", "EVEN", + "CASE_SENSITIVE", "QUOTA", "TB", "BOOST", "RECLUSTER", "SORT", "PERCENT_WORD", + "CASE_INSENSITIVE", "Identifier", "TemporaryIdentifier", "NamespaceUser", + "IdentifierStartChar", "IdentifierChar", "StrictIdentifierChar", "QuotedIdentifier", + "UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", + "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier", + "InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", "UnterminatedStringConstant", + "BeginEscapeStringConstant", "UnicodeEscapeStringConstant", "UnterminatedUnicodeEscapeStringConstant", + "BeginDollarStringConstant", "Tag", "BinaryStringConstant", "UnterminatedBinaryStringConstant", + "InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant", + "HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant", + "InvalidHexadecimalStringConstant", "InvalidUnterminatedHexadecimalStringConstant", + "Integral", "NumericFail", "Numeric", "Digits", "PLSQLVARIABLENAME", + "PLSQLIDENTIFIER", "Whitespace", "Newline", "LineComment", "BlockComment", + "UnterminatedBlockComment", "MetaCommand", "EndMetaCommand", "ErrorCharacter", + "EscapeStringConstant", "UnterminatedEscapeStringConstant", "EscapeStringText", + "InvalidEscapeStringConstant", "InvalidUnterminatedEscapeStringConstant", + "InvalidEscapeStringText", "AfterEscapeStringConstantMode_Whitespace", + "AfterEscapeStringConstantMode_Newline", "AfterEscapeStringConstantMode_NotContinued", + "AfterEscapeStringConstantWithNewlineMode_Whitespace", "AfterEscapeStringConstantWithNewlineMode_Newline", + "AfterEscapeStringConstantWithNewlineMode_Continued", "AfterEscapeStringConstantWithNewlineMode_NotContinued", + "DollarText", "EndDollarStringConstant", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 896, 9322, 6, -1, 6, -1, 6, -1, 6, -1, 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, + 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, + 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, + 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 16, 1, 16, + 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 20, 1, + 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, + 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 27, 1, 27, 4, + 27, 1895, 8, 27, 11, 27, 12, 27, 1896, 1, 28, 1, 28, 1, 28, 1, 28, 4, 28, + 1903, 8, 28, 11, 28, 12, 28, 1904, 1, 28, 1, 28, 1, 28, 3, 28, 1910, 8, + 28, 1, 28, 1, 28, 4, 28, 1914, 8, 28, 11, 28, 12, 28, 1915, 1, 28, 3, 28, + 1919, 8, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 1928, + 8, 29, 10, 29, 12, 29, 1931, 9, 29, 1, 29, 1, 29, 3, 29, 1935, 8, 29, 1, + 29, 1, 29, 1, 29, 4, 29, 1940, 8, 29, 11, 29, 12, 29, 1941, 1, 29, 1, 29, + 1, 30, 1, 30, 1, 31, 1, 31, 1, 32, 1, 32, 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, 35, 1, 35, 1, 35, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, + 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, + 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, + 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 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, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, + 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, + 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, 50, 1, 50, + 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, + 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, + 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, + 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, + 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, + 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 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, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, + 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, + 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, + 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, + 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, + 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, + 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, + 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, + 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, + 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, + 1, 76, 1, 76, 1, 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, 79, 1, 79, 1, 79, + 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, + 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, + 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, + 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, + 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, + 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 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, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, + 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, + 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, + 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 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, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, + 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, + 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, + 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, + 1, 105, 1, 105, 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, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 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, 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, 115, 1, 115, 1, 115, 1, 115, + 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, + 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 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, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 122, + 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 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, 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, 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, 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, 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, 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, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, + 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, + 1, 142, 1, 142, 1, 142, 1, 142, 1, 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, 146, 1, 146, 1, 146, 1, 146, + 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, + 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, + 1, 149, 1, 149, 1, 149, 1, 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, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 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, 157, 1, 157, + 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 159, 1, 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, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, + 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 1, 164, + 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, + 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, + 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, + 1, 167, 1, 167, 1, 167, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, + 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 169, + 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, + 1, 169, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, + 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, + 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, + 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, + 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, + 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, + 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, + 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 179, 1, 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, 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, 184, 1, 184, 1, 184, 1, 184, + 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, + 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 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, 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, 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, 192, 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, 195, 1, 195, 1, 195, + 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, + 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, + 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 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, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, + 1, 201, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, + 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, + 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 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, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, + 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, + 1, 208, 1, 208, 1, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, + 1, 209, 1, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, + 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, + 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, + 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 215, 1, 215, 1, 215, + 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 216, 1, 216, + 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, 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, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, + 1, 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, + 1, 220, 1, 220, 1, 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, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, + 1, 224, 1, 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 226, + 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, + 1, 227, 1, 227, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, 1, 228, + 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, + 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, + 1, 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, + 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 232, 1, 232, 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, 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, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, + 1, 236, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 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, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 241, + 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 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, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, + 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, + 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, + 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, + 1, 248, 1, 248, 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 251, 1, 251, + 1, 251, 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, + 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, + 1, 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, 256, 1, 256, 1, 256, 1, 256, 1, 256, + 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, + 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, + 1, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, + 1, 259, 1, 259, 1, 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, + 1, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, + 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 263, + 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, + 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, 266, + 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 268, + 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, 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, 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, 274, + 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 275, 1, 275, 1, 275, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, + 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, + 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, + 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, + 1, 281, 1, 281, 1, 281, 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, 284, 1, 284, + 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, + 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 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, 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, 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, 292, 1, 292, 1, 292, 1, 292, 1, 292, + 1, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, + 1, 293, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 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, 299, 1, 299, 1, 299, 1, 299, + 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, + 1, 301, 1, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 1, 303, 1, 303, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, + 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 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, 308, 1, 308, 1, 308, + 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, + 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, + 1, 310, 1, 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, 312, 1, 312, 1, 312, 1, 312, + 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, + 1, 313, 1, 313, 1, 313, 1, 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, 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, 318, 1, 318, + 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, + 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, + 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, + 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, + 1, 323, 1, 323, 1, 323, 1, 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, 326, + 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, + 1, 327, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, + 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, + 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, + 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, + 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, + 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, + 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, + 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 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, 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, 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, 342, 1, 342, + 1, 342, 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, 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, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, + 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, + 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 350, 1, 350, 1, 350, 1, 350, + 1, 350, 1, 350, 1, 350, 1, 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, 352, 1, 353, 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, + 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, 1, 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, 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, 359, 1, 359, + 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, + 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, + 1, 361, 1, 361, 1, 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, 364, 1, 364, 1, 364, 1, 364, 1, 364, + 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, + 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, + 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, + 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, + 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 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, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, + 1, 373, 1, 373, 1, 373, 1, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, + 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, + 1, 376, 1, 376, 1, 376, 1, 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, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, + 1, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, + 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, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, 385, + 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, 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, 390, + 1, 390, 1, 390, 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, + 1, 391, 1, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, 1, 392, + 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, + 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, + 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 395, + 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, + 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, + 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, + 1, 397, 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, + 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, 1, 400, + 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, + 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 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, 405, 1, 405, 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, 407, 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, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 410, + 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, + 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 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, 412, + 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, + 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 415, + 1, 415, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, 1, 416, 1, 417, + 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 418, + 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 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, 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, 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, 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, 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, 427, + 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, + 1, 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, + 1, 428, 1, 428, 1, 428, 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, 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, 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, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, + 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, + 1, 435, 1, 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, 435, 1, 436, 1, 436, 1, 436, + 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, + 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, + 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 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, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, + 1, 439, 1, 439, 1, 439, 1, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, + 1, 440, 1, 440, 1, 440, 1, 440, 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, 442, 1, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 444, + 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, + 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 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, 446, 1, 446, 1, 446, + 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, + 1, 448, 1, 448, 1, 448, 1, 448, 1, 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, 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, 450, 1, 450, 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, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, + 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, + 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 456, 1, 456, 1, 456, + 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, + 1, 457, 1, 457, 1, 457, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, + 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, 1, 459, 1, 459, 1, 459, + 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, 1, 460, 1, 460, 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, 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, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 464, 1, 464, 1, 464, + 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, + 1, 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, 467, 1, 467, 1, 467, + 1, 468, 1, 468, 1, 468, 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, 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, 472, + 1, 472, 1, 472, 1, 472, 1, 472, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, + 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, + 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 478, + 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 479, + 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 480, 1, 480, 1, 480, + 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, + 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 482, + 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, + 1, 482, 1, 482, 1, 482, 1, 482, 1, 483, 1, 483, 1, 483, 1, 483, 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, 486, 1, 486, 1, 486, 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, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, + 1, 489, 1, 489, 1, 489, 1, 489, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, + 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 491, 1, 491, + 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, + 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, + 1, 492, 1, 492, 1, 492, 1, 492, 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, 495, 1, 495, + 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 496, 1, 496, + 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, + 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, + 1, 498, 1, 498, 1, 498, 1, 498, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, + 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 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, 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, 504, 1, 504, 1, 504, + 1, 504, 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, 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, 507, 1, 507, 1, 507, + 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, + 1, 507, 1, 507, 1, 507, 1, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, + 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, + 1, 508, 1, 508, 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, + 1, 509, 1, 509, 1, 509, 1, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, + 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, + 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, + 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 512, + 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, + 1, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 514, + 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, 1, 515, + 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 516, + 1, 516, 1, 516, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, + 1, 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, 519, 1, 519, 1, 519, + 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, 1, 520, 1, 520, + 1, 520, 1, 521, 1, 521, 1, 521, 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, + 1, 522, 1, 522, 1, 522, 1, 523, 1, 523, 1, 523, 1, 523, 1, 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, 524, 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, 526, 1, 526, 1, 526, 1, 526, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, + 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, + 1, 527, 1, 527, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 530, + 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, + 1, 530, 1, 530, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, + 1, 531, 1, 531, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, + 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 534, 1, 534, 1, 534, + 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, + 1, 534, 1, 534, 1, 534, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, + 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 536, + 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, + 1, 536, 1, 536, 1, 536, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, + 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, + 1, 537, 1, 537, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, + 1, 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, 539, 1, 540, 1, 540, 1, 540, + 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, + 1, 540, 1, 541, 1, 541, 1, 541, 1, 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, 542, 1, 543, 1, 543, 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, 545, 1, 545, 1, 545, 1, 546, 1, 546, 1, 546, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 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, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, + 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, + 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 551, 1, 551, 1, 551, 1, 551, + 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, 1, 552, + 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, + 1, 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, 557, + 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, + 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, + 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, 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, 564, 1, 564, 1, 564, + 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, + 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 567, 1, 567, + 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 568, 1, 568, 1, 568, + 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 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, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, + 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, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, + 1, 574, 1, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, + 1, 575, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, + 1, 576, 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 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, 580, + 1, 580, 1, 580, 1, 580, 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, 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, 585, 1, 585, 1, 585, + 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 586, 1, 586, + 1, 586, 1, 586, 1, 586, 1, 586, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, + 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 589, 1, 589, + 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 589, 1, 590, 1, 590, 1, 590, + 1, 590, 1, 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, 591, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, + 1, 592, 1, 592, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, + 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, + 1, 593, 1, 593, 1, 593, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, + 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, + 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, + 1, 594, 1, 594, 1, 594, 1, 594, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, + 1, 596, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, + 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 598, 1, 598, 1, 598, 1, 598, + 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, + 1, 599, 1, 599, 1, 599, 1, 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, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, + 1, 601, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, 1, 602, + 1, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 604, 1, 604, + 1, 604, 1, 604, 1, 604, 1, 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, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 607, 1, 607, 1, 607, + 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 608, 1, 608, 1, 608, 1, 608, + 1, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, + 1, 609, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, + 1, 610, 1, 610, 1, 610, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, + 1, 611, 1, 611, 1, 611, 1, 611, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, + 1, 612, 1, 612, 1, 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, 615, 1, 615, 1, 615, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, + 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 616, 1, 617, 1, 617, + 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, + 1, 617, 1, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, + 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, + 1, 619, 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 621, + 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, + 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 624, + 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 1, 625, 1, 625, + 1, 625, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, + 1, 626, 1, 626, 1, 626, 1, 626, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, + 1, 627, 1, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 629, 1, 629, 1, 629, + 1, 629, 1, 629, 1, 629, 1, 629, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, + 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 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, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, + 1, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 635, 1, 635, 1, 635, 1, 635, + 1, 635, 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, 638, 1, 638, + 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, + 1, 638, 1, 638, 1, 638, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, + 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, + 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, + 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, + 1, 641, 1, 641, 1, 641, 1, 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, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, + 1, 644, 1, 644, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, + 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, + 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 648, 1, 648, + 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 649, 1, 649, 1, 649, 1, 649, + 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 650, + 1, 650, 1, 650, 1, 650, 1, 651, 1, 651, 1, 651, 1, 651, 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, 653, 1, 653, 1, 654, + 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, + 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, 655, 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, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, + 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, + 1, 659, 1, 659, 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, 662, 1, 662, 1, 663, 1, 663, + 1, 663, 1, 663, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, + 1, 664, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, + 1, 665, 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, + 1, 666, 1, 666, 1, 666, 1, 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, 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, 673, 1, 673, 1, 673, 1, 673, + 1, 673, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, + 1, 674, 1, 674, 1, 674, 1, 674, 1, 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, 677, 1, 677, 1, 677, + 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 678, 1, 678, 1, 678, 1, 678, + 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, + 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, + 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, + 1, 680, 1, 680, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, 1, 681, + 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 683, 1, 683, + 1, 683, 1, 683, 1, 683, 1, 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, + 1, 684, 1, 684, 1, 684, 1, 685, 1, 685, 1, 685, 1, 685, 1, 686, 1, 686, + 1, 686, 1, 686, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 688, 1, 688, + 1, 688, 1, 688, 1, 688, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, + 1, 689, 1, 689, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 1, 692, 1, 692, 1, 692, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 1, 693, + 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, + 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 694, 1, 694, + 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, + 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 694, 1, 695, 1, 695, + 1, 695, 1, 695, 1, 695, 1, 695, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, + 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 697, + 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, 1, 697, + 1, 697, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 699, 1, 699, + 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 700, 1, 700, + 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 701, 1, 701, 1, 701, + 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, + 1, 702, 1, 702, 1, 702, 1, 702, 1, 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, 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, 707, 1, 707, 1, 707, 1, 707, + 1, 707, 1, 707, 1, 707, 1, 707, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, + 1, 708, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 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, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 713, 1, 713, + 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 714, 1, 714, + 1, 714, 1, 714, 1, 714, 1, 714, 1, 715, 1, 715, 1, 715, 1, 715, 1, 716, + 1, 716, 1, 716, 1, 716, 1, 716, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, + 1, 717, 1, 717, 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, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, + 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 722, 1, 722, 1, 722, 1, 722, + 1, 722, 1, 723, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 1, 724, + 1, 724, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 726, 1, 726, 1, 726, + 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 1, 727, 1, 727, 1, 727, 1, 727, + 1, 727, 1, 727, 1, 727, 1, 727, 1, 728, 1, 728, 1, 728, 1, 728, 1, 729, + 1, 729, 1, 729, 1, 729, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, + 1, 730, 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, + 1, 731, 1, 732, 1, 732, 1, 732, 1, 732, 1, 733, 1, 733, 1, 733, 1, 733, + 1, 734, 1, 734, 1, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, + 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, + 1, 736, 1, 737, 1, 737, 1, 737, 1, 737, 1, 738, 1, 738, 1, 738, 1, 739, + 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 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, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, + 1, 743, 1, 743, 1, 743, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 745, + 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, + 1, 745, 1, 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, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, + 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 750, + 1, 750, 1, 750, 1, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, + 1, 751, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 753, 1, 753, 1, 753, + 1, 753, 1, 753, 1, 753, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 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, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, + 1, 758, 1, 758, 1, 758, 1, 758, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, + 1, 760, 1, 760, 1, 760, 1, 760, 1, 761, 1, 761, 1, 761, 1, 761, 1, 761, + 1, 762, 1, 762, 1, 762, 1, 762, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, + 1, 764, 1, 764, 1, 764, 1, 764, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, + 1, 766, 1, 766, 1, 766, 1, 766, 1, 766, 1, 767, 1, 767, 1, 767, 1, 767, + 1, 767, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 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, 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, 773, + 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, + 1, 773, 1, 773, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, + 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, + 1, 774, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 776, 1, 776, + 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, + 1, 776, 1, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 778, + 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, 1, 779, + 1, 779, 1, 779, 1, 780, 1, 780, 1, 780, 1, 780, 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, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, + 1, 784, 1, 784, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, + 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, 1, 787, 1, 787, 1, 787, 1, 787, + 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, + 1, 789, 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, 790, + 1, 790, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, + 1, 791, 1, 791, 1, 791, 1, 791, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, + 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, + 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, + 1, 793, 1, 793, 1, 793, 1, 793, 1, 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, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, + 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 796, 1, 796, 1, 796, 1, 796, + 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 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, 798, 1, 798, 1, 798, + 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, + 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, + 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, + 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, + 1, 800, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 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, 801, 1, 801, 1, 802, 1, 802, 1, 802, 1, 802, + 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, + 1, 802, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 804, + 1, 804, 1, 804, 1, 804, 1, 804, 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, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, + 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, + 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, + 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 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, 813, 1, 813, 1, 814, 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, 815, 1, 815, 1, 815, 1, 816, 1, 816, 1, 816, 1, 816, 1, 817, + 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, + 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, + 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 819, 1, 819, 1, 819, + 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 820, 1, 820, + 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 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, 823, 1, 823, 1, 823, 1, 823, 1, 823, + 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, + 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, + 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 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, 826, + 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 827, 1, 827, 1, 827, 1, 827, + 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 828, 1, 828, 1, 828, + 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, + 1, 828, 1, 828, 1, 828, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, + 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, + 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, 1, 830, 1, 831, 1, 831, 1, 831, + 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, + 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 832, + 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, 1, 832, + 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, + 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, + 1, 833, 1, 833, 1, 833, 1, 833, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, + 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, + 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 836, 1, 836, + 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 837, 1, 837, 1, 837, + 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 838, 1, 838, + 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, + 1, 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, 841, 1, 841, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, + 1, 842, 1, 842, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, + 1, 843, 1, 843, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, + 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 845, 1, 845, 1, 845, 1, 845, + 1, 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, + 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 847, 1, 847, + 1, 847, 1, 847, 1, 847, 1, 847, 1, 848, 1, 848, 1, 848, 1, 849, 1, 849, + 1, 849, 1, 849, 1, 849, 1, 849, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, + 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, + 1, 851, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, + 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, + 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 854, + 1, 854, 5, 854, 8850, 8, 854, 10, 854, 12, 854, 8853, 9, 854, 1, 855, 1, + 855, 1, 855, 1, 856, 1, 856, 1, 856, 1, 856, 1, 857, 1, 857, 1, 857, 1, + 857, 1, 857, 1, 857, 3, 857, 8868, 8, 857, 1, 858, 1, 858, 3, 858, 8872, + 8, 858, 1, 859, 1, 859, 3, 859, 8876, 8, 859, 1, 860, 1, 860, 1, 860, 1, + 861, 1, 861, 1, 861, 1, 861, 5, 861, 8885, 8, 861, 10, 861, 12, 861, 8888, + 9, 861, 1, 862, 1, 862, 1, 862, 1, 863, 1, 863, 1, 863, 1, 863, 5, 863, + 8897, 8, 863, 10, 863, 12, 863, 8900, 9, 863, 1, 864, 1, 864, 1, 864, 1, + 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 866, 1, 866, 1, 866, 1, 866, 1, + 867, 1, 867, 1, 867, 1, 867, 1, 868, 1, 868, 1, 868, 1, 869, 1, 869, 1, + 869, 1, 869, 5, 869, 8925, 8, 869, 10, 869, 12, 869, 8928, 9, 869, 1, 870, + 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 871, 1, 871, 1, 871, 1, 872, + 1, 872, 1, 872, 1, 872, 1, 873, 1, 873, 3, 873, 8945, 8, 873, 1, 873, 1, + 873, 1, 873, 1, 873, 1, 873, 1, 874, 1, 874, 5, 874, 8954, 8, 874, 10, + 874, 12, 874, 8957, 9, 874, 1, 875, 1, 875, 1, 875, 1, 876, 1, 876, 1, + 876, 5, 876, 8965, 8, 876, 10, 876, 12, 876, 8968, 9, 876, 1, 877, 1, 877, + 1, 877, 1, 878, 1, 878, 1, 878, 1, 879, 1, 879, 1, 879, 1, 880, 1, 880, + 1, 880, 5, 880, 8982, 8, 880, 10, 880, 12, 880, 8985, 9, 880, 1, 881, 1, + 881, 1, 881, 1, 882, 1, 882, 1, 882, 1, 883, 1, 883, 1, 884, 1, 884, 1, + 884, 1, 884, 1, 884, 1, 884, 1, 885, 1, 885, 1, 885, 3, 885, 9004, 8, 885, + 1, 885, 1, 885, 3, 885, 9008, 8, 885, 1, 885, 3, 885, 9011, 8, 885, 1, + 885, 1, 885, 1, 885, 1, 885, 3, 885, 9017, 8, 885, 1, 885, 3, 885, 9020, + 8, 885, 1, 885, 1, 885, 1, 885, 3, 885, 9025, 8, 885, 1, 885, 1, 885, 3, + 885, 9029, 8, 885, 1, 886, 4, 886, 9032, 8, 886, 11, 886, 12, 886, 9033, + 1, 887, 1, 887, 1, 887, 5, 887, 9039, 8, 887, 10, 887, 12, 887, 9042, 9, + 887, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 5, + 888, 9052, 8, 888, 10, 888, 12, 888, 9055, 9, 888, 1, 888, 1, 888, 1, 889, + 1, 889, 1, 889, 1, 889, 1, 890, 1, 890, 3, 890, 9065, 8, 890, 1, 890, 3, + 890, 9068, 8, 890, 1, 890, 1, 890, 1, 891, 1, 891, 1, 891, 1, 891, 5, 891, + 9076, 8, 891, 10, 891, 12, 891, 9079, 9, 891, 1, 891, 1, 891, 1, 892, 1, + 892, 1, 892, 1, 892, 5, 892, 9087, 8, 892, 10, 892, 12, 892, 9090, 9, 892, + 1, 892, 1, 892, 1, 892, 4, 892, 9095, 8, 892, 11, 892, 12, 892, 9096, 1, + 892, 1, 892, 4, 892, 9101, 8, 892, 11, 892, 12, 892, 9102, 1, 892, 5, 892, + 9106, 8, 892, 10, 892, 12, 892, 9109, 9, 892, 1, 892, 5, 892, 9112, 8, + 892, 10, 892, 12, 892, 9115, 9, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, + 892, 1, 893, 1, 893, 1, 893, 1, 893, 5, 893, 9126, 8, 893, 10, 893, 12, + 893, 9129, 9, 893, 1, 893, 1, 893, 1, 893, 4, 893, 9134, 8, 893, 11, 893, + 12, 893, 9135, 1, 893, 1, 893, 4, 893, 9140, 8, 893, 11, 893, 12, 893, + 9141, 1, 893, 3, 893, 9145, 8, 893, 5, 893, 9147, 8, 893, 10, 893, 12, + 893, 9150, 9, 893, 1, 893, 4, 893, 9153, 8, 893, 11, 893, 12, 893, 9154, + 1, 893, 4, 893, 9158, 8, 893, 11, 893, 12, 893, 9159, 1, 893, 5, 893, 9163, + 8, 893, 10, 893, 12, 893, 9166, 9, 893, 1, 893, 3, 893, 9169, 8, 893, 1, + 893, 1, 893, 1, 894, 1, 894, 1, 894, 1, 894, 5, 894, 9177, 8, 894, 10, + 894, 12, 894, 9180, 9, 894, 1, 894, 5, 894, 9183, 8, 894, 10, 894, 12, + 894, 9186, 9, 894, 1, 894, 1, 894, 5, 894, 9190, 8, 894, 10, 894, 12, 894, + 9193, 9, 894, 3, 894, 9195, 8, 894, 1, 895, 1, 895, 1, 895, 1, 896, 1, + 896, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 3, 898, 9209, + 8, 898, 1, 898, 1, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, + 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, + 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 3, 899, 9233, 8, 899, 1, 899, 5, + 899, 9236, 8, 899, 10, 899, 12, 899, 9239, 9, 899, 1, 900, 1, 900, 1, 900, + 1, 900, 1, 900, 1, 901, 1, 901, 3, 901, 9248, 8, 901, 1, 901, 1, 901, 1, + 902, 1, 902, 1, 902, 1, 902, 1, 902, 5, 902, 9257, 8, 902, 10, 902, 12, + 902, 9260, 9, 902, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 904, 1, 904, + 1, 904, 1, 904, 1, 904, 1, 904, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, + 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, + 1, 907, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 909, + 1, 909, 1, 909, 1, 910, 4, 910, 9299, 8, 910, 11, 910, 12, 910, 9300, 1, + 910, 1, 910, 5, 910, 9305, 8, 910, 10, 910, 12, 910, 9308, 9, 910, 3, 910, + 9310, 8, 910, 1, 911, 1, 911, 3, 911, 9314, 8, 911, 1, 911, 1, 911, 1, + 911, 1, 911, 1, 911, 1, 911, 1, 911, 0, 0, 912, 5, 1, 7, 2, 9, 3, 11, 4, + 13, 5, 15, 6, 17, 7, 19, 8, 21, 9, 23, 10, 25, 11, 27, 12, 29, 13, 31, + 14, 33, 15, 35, 16, 37, 17, 39, 18, 41, 19, 43, 20, 45, 21, 47, 22, 49, + 23, 51, 24, 53, 25, 55, 26, 57, 27, 59, 28, 61, 29, 63, 0, 65, 0, 67, 0, + 69, 0, 71, 30, 73, 31, 75, 32, 77, 33, 79, 34, 81, 35, 83, 36, 85, 37, + 87, 38, 89, 39, 91, 40, 93, 41, 95, 42, 97, 43, 99, 44, 101, 45, 103, 46, + 105, 47, 107, 48, 109, 49, 111, 50, 113, 51, 115, 52, 117, 53, 119, 54, + 121, 55, 123, 56, 125, 57, 127, 58, 129, 59, 131, 60, 133, 61, 135, 62, + 137, 63, 139, 64, 141, 65, 143, 66, 145, 67, 147, 68, 149, 69, 151, 70, + 153, 71, 155, 72, 157, 73, 159, 74, 161, 75, 163, 76, 165, 77, 167, 78, + 169, 79, 171, 80, 173, 81, 175, 82, 177, 83, 179, 84, 181, 85, 183, 86, + 185, 87, 187, 88, 189, 89, 191, 90, 193, 91, 195, 92, 197, 93, 199, 94, + 201, 95, 203, 96, 205, 97, 207, 98, 209, 99, 211, 100, 213, 101, 215, 102, + 217, 103, 219, 104, 221, 105, 223, 106, 225, 107, 227, 108, 229, 109, 231, + 110, 233, 111, 235, 112, 237, 113, 239, 114, 241, 115, 243, 116, 245, 117, + 247, 118, 249, 119, 251, 120, 253, 121, 255, 122, 257, 123, 259, 124, 261, + 125, 263, 126, 265, 127, 267, 128, 269, 129, 271, 130, 273, 131, 275, 132, + 277, 133, 279, 134, 281, 135, 283, 136, 285, 137, 287, 138, 289, 139, 291, + 140, 293, 141, 295, 142, 297, 143, 299, 144, 301, 145, 303, 146, 305, 147, + 307, 148, 309, 149, 311, 150, 313, 151, 315, 152, 317, 153, 319, 154, 321, + 155, 323, 156, 325, 157, 327, 158, 329, 159, 331, 160, 333, 161, 335, 162, + 337, 163, 339, 164, 341, 165, 343, 166, 345, 167, 347, 168, 349, 169, 351, + 170, 353, 171, 355, 172, 357, 173, 359, 174, 361, 175, 363, 176, 365, 177, + 367, 178, 369, 179, 371, 180, 373, 181, 375, 182, 377, 183, 379, 184, 381, + 185, 383, 186, 385, 187, 387, 188, 389, 189, 391, 190, 393, 191, 395, 192, + 397, 193, 399, 194, 401, 195, 403, 196, 405, 197, 407, 198, 409, 199, 411, + 200, 413, 201, 415, 202, 417, 203, 419, 204, 421, 205, 423, 206, 425, 207, + 427, 208, 429, 209, 431, 210, 433, 211, 435, 212, 437, 213, 439, 214, 441, + 215, 443, 216, 445, 217, 447, 218, 449, 219, 451, 220, 453, 221, 455, 222, + 457, 223, 459, 224, 461, 225, 463, 226, 465, 227, 467, 228, 469, 229, 471, + 230, 473, 231, 475, 232, 477, 233, 479, 234, 481, 235, 483, 236, 485, 237, + 487, 238, 489, 239, 491, 240, 493, 241, 495, 242, 497, 243, 499, 244, 501, + 245, 503, 246, 505, 247, 507, 248, 509, 249, 511, 250, 513, 251, 515, 252, + 517, 253, 519, 254, 521, 255, 523, 256, 525, 257, 527, 258, 529, 259, 531, + 260, 533, 261, 535, 262, 537, 263, 539, 264, 541, 265, 543, 266, 545, 267, + 547, 268, 549, 269, 551, 270, 553, 271, 555, 272, 557, 273, 559, 274, 561, + 275, 563, 276, 565, 277, 567, 278, 569, 279, 571, 280, 573, 281, 575, 282, + 577, 283, 579, 284, 581, 285, 583, 286, 585, 287, 587, 288, 589, 289, 591, + 290, 593, 291, 595, 292, 597, 293, 599, 294, 601, 295, 603, 296, 605, 297, + 607, 298, 609, 299, 611, 300, 613, 301, 615, 302, 617, 303, 619, 304, 621, + 305, 623, 306, 625, 307, 627, 308, 629, 309, 631, 310, 633, 311, 635, 312, + 637, 313, 639, 314, 641, 315, 643, 316, 645, 317, 647, 318, 649, 319, 651, + 320, 653, 321, 655, 322, 657, 323, 659, 324, 661, 325, 663, 326, 665, 327, + 667, 328, 669, 329, 671, 330, 673, 331, 675, 332, 677, 333, 679, 334, 681, + 335, 683, 336, 685, 337, 687, 338, 689, 339, 691, 340, 693, 341, 695, 342, + 697, 343, 699, 344, 701, 345, 703, 346, 705, 347, 707, 348, 709, 349, 711, + 350, 713, 351, 715, 352, 717, 353, 719, 354, 721, 355, 723, 356, 725, 357, + 727, 358, 729, 359, 731, 360, 733, 361, 735, 362, 737, 363, 739, 364, 741, + 365, 743, 366, 745, 367, 747, 368, 749, 369, 751, 370, 753, 371, 755, 372, + 757, 373, 759, 374, 761, 375, 763, 376, 765, 377, 767, 378, 769, 379, 771, + 380, 773, 381, 775, 382, 777, 383, 779, 384, 781, 385, 783, 386, 785, 387, + 787, 388, 789, 389, 791, 390, 793, 391, 795, 392, 797, 393, 799, 394, 801, + 395, 803, 396, 805, 397, 807, 398, 809, 399, 811, 400, 813, 401, 815, 402, + 817, 403, 819, 404, 821, 405, 823, 406, 825, 407, 827, 408, 829, 409, 831, + 410, 833, 411, 835, 412, 837, 413, 839, 414, 841, 415, 843, 416, 845, 417, + 847, 418, 849, 419, 851, 420, 853, 421, 855, 422, 857, 423, 859, 424, 861, + 425, 863, 426, 865, 427, 867, 428, 869, 429, 871, 430, 873, 431, 875, 432, + 877, 433, 879, 434, 881, 435, 883, 436, 885, 437, 887, 438, 889, 439, 891, + 440, 893, 441, 895, 442, 897, 443, 899, 444, 901, 445, 903, 446, 905, 447, + 907, 448, 909, 449, 911, 450, 913, 451, 915, 452, 917, 453, 919, 454, 921, + 455, 923, 456, 925, 457, 927, 458, 929, 459, 931, 460, 933, 461, 935, 462, + 937, 463, 939, 464, 941, 465, 943, 466, 945, 467, 947, 468, 949, 469, 951, + 470, 953, 471, 955, 472, 957, 473, 959, 474, 961, 475, 963, 476, 965, 477, + 967, 478, 969, 479, 971, 480, 973, 481, 975, 482, 977, 483, 979, 484, 981, + 485, 983, 486, 985, 487, 987, 488, 989, 489, 991, 490, 993, 491, 995, 492, + 997, 493, 999, 494, 1001, 495, 1003, 496, 1005, 497, 1007, 498, 1009, 499, + 1011, 500, 1013, 501, 1015, 502, 1017, 503, 1019, 504, 1021, 505, 1023, + 506, 1025, 507, 1027, 508, 1029, 509, 1031, 510, 1033, 511, 1035, 512, + 1037, 513, 1039, 514, 1041, 515, 1043, 516, 1045, 517, 1047, 518, 1049, + 519, 1051, 520, 1053, 521, 1055, 522, 1057, 523, 1059, 524, 1061, 525, + 1063, 526, 1065, 527, 1067, 528, 1069, 529, 1071, 530, 1073, 531, 1075, + 532, 1077, 533, 1079, 534, 1081, 535, 1083, 536, 1085, 537, 1087, 538, + 1089, 539, 1091, 540, 1093, 541, 1095, 542, 1097, 543, 1099, 544, 1101, + 545, 1103, 546, 1105, 547, 1107, 548, 1109, 549, 1111, 550, 1113, 551, + 1115, 552, 1117, 553, 1119, 554, 1121, 555, 1123, 556, 1125, 557, 1127, + 558, 1129, 559, 1131, 560, 1133, 561, 1135, 562, 1137, 563, 1139, 564, + 1141, 565, 1143, 566, 1145, 567, 1147, 568, 1149, 569, 1151, 570, 1153, + 571, 1155, 572, 1157, 573, 1159, 574, 1161, 575, 1163, 576, 1165, 577, + 1167, 578, 1169, 579, 1171, 580, 1173, 581, 1175, 582, 1177, 583, 1179, + 584, 1181, 585, 1183, 586, 1185, 587, 1187, 588, 1189, 589, 1191, 590, + 1193, 591, 1195, 592, 1197, 593, 1199, 594, 1201, 595, 1203, 596, 1205, + 597, 1207, 598, 1209, 599, 1211, 600, 1213, 601, 1215, 602, 1217, 603, + 1219, 604, 1221, 605, 1223, 606, 1225, 607, 1227, 608, 1229, 609, 1231, + 610, 1233, 611, 1235, 612, 1237, 613, 1239, 614, 1241, 615, 1243, 616, + 1245, 617, 1247, 618, 1249, 619, 1251, 620, 1253, 621, 1255, 622, 1257, + 623, 1259, 624, 1261, 625, 1263, 626, 1265, 627, 1267, 628, 1269, 629, + 1271, 630, 1273, 631, 1275, 632, 1277, 633, 1279, 634, 1281, 635, 1283, + 636, 1285, 637, 1287, 638, 1289, 639, 1291, 640, 1293, 641, 1295, 642, + 1297, 643, 1299, 644, 1301, 645, 1303, 646, 1305, 647, 1307, 648, 1309, + 649, 1311, 650, 1313, 651, 1315, 652, 1317, 653, 1319, 654, 1321, 655, + 1323, 656, 1325, 657, 1327, 658, 1329, 659, 1331, 660, 1333, 661, 1335, + 662, 1337, 663, 1339, 664, 1341, 665, 1343, 666, 1345, 667, 1347, 668, + 1349, 669, 1351, 670, 1353, 671, 1355, 672, 1357, 673, 1359, 674, 1361, + 675, 1363, 676, 1365, 677, 1367, 678, 1369, 679, 1371, 680, 1373, 681, + 1375, 682, 1377, 683, 1379, 684, 1381, 685, 1383, 686, 1385, 687, 1387, + 688, 1389, 689, 1391, 690, 1393, 691, 1395, 692, 1397, 693, 1399, 694, + 1401, 695, 1403, 696, 1405, 697, 1407, 698, 1409, 699, 1411, 700, 1413, + 701, 1415, 702, 1417, 703, 1419, 704, 1421, 705, 1423, 706, 1425, 707, + 1427, 708, 1429, 709, 1431, 710, 1433, 711, 1435, 712, 1437, 713, 1439, + 714, 1441, 715, 1443, 716, 1445, 717, 1447, 718, 1449, 719, 1451, 720, + 1453, 721, 1455, 722, 1457, 723, 1459, 724, 1461, 725, 1463, 726, 1465, + 727, 1467, 728, 1469, 729, 1471, 730, 1473, 731, 1475, 732, 1477, 733, + 1479, 734, 1481, 735, 1483, 736, 1485, 737, 1487, 738, 1489, 739, 1491, + 740, 1493, 741, 1495, 742, 1497, 743, 1499, 744, 1501, 745, 1503, 746, + 1505, 747, 1507, 748, 1509, 749, 1511, 750, 1513, 751, 1515, 752, 1517, + 753, 1519, 754, 1521, 755, 1523, 756, 1525, 757, 1527, 758, 1529, 759, + 1531, 760, 1533, 761, 1535, 762, 1537, 763, 1539, 764, 1541, 765, 1543, + 766, 1545, 767, 1547, 768, 1549, 769, 1551, 770, 1553, 771, 1555, 772, + 1557, 773, 1559, 774, 1561, 775, 1563, 776, 1565, 777, 1567, 778, 1569, + 779, 1571, 780, 1573, 781, 1575, 782, 1577, 783, 1579, 784, 1581, 785, + 1583, 786, 1585, 787, 1587, 788, 1589, 789, 1591, 790, 1593, 791, 1595, + 792, 1597, 793, 1599, 794, 1601, 795, 1603, 796, 1605, 797, 1607, 798, + 1609, 799, 1611, 800, 1613, 801, 1615, 802, 1617, 803, 1619, 804, 1621, + 805, 1623, 806, 1625, 807, 1627, 808, 1629, 809, 1631, 810, 1633, 811, + 1635, 812, 1637, 813, 1639, 814, 1641, 815, 1643, 816, 1645, 817, 1647, + 818, 1649, 819, 1651, 820, 1653, 821, 1655, 822, 1657, 823, 1659, 824, + 1661, 825, 1663, 826, 1665, 827, 1667, 828, 1669, 829, 1671, 830, 1673, + 831, 1675, 832, 1677, 833, 1679, 834, 1681, 835, 1683, 836, 1685, 837, + 1687, 838, 1689, 839, 1691, 840, 1693, 841, 1695, 842, 1697, 843, 1699, + 844, 1701, 845, 1703, 846, 1705, 847, 1707, 848, 1709, 849, 1711, 850, + 1713, 851, 1715, 852, 1717, 853, 1719, 0, 1721, 0, 1723, 0, 1725, 854, + 1727, 855, 1729, 856, 1731, 857, 1733, 858, 1735, 859, 1737, 860, 1739, + 861, 1741, 862, 1743, 863, 1745, 0, 1747, 864, 1749, 865, 1751, 866, 1753, + 0, 1755, 867, 1757, 868, 1759, 869, 1761, 870, 1763, 871, 1765, 872, 1767, + 873, 1769, 874, 1771, 875, 1773, 876, 1775, 877, 1777, 0, 1779, 878, 1781, + 879, 1783, 880, 1785, 881, 1787, 882, 1789, 883, 1791, 884, 1793, 885, + 1795, 886, 1797, 887, 1799, 888, 1801, 889, 1803, 0, 1805, 890, 1807, 891, + 1809, 0, 1811, 0, 1813, 0, 1815, 892, 1817, 0, 1819, 0, 1821, 896, 1823, + 893, 1825, 894, 1827, 895, 5, 0, 1, 2, 3, 4, 51, 1, 0, 48, 57, 2, 0, 43, + 43, 45, 45, 9, 0, 33, 33, 35, 35, 37, 38, 42, 42, 60, 64, 94, 94, 96, 96, + 124, 124, 126, 126, 2, 0, 42, 43, 60, 62, 8, 0, 33, 33, 35, 35, 37, 38, + 63, 64, 94, 94, 96, 96, 124, 124, 126, 126, 2, 0, 65, 65, 97, 97, 2, 0, + 76, 76, 108, 108, 2, 0, 78, 78, 110, 110, 2, 0, 89, 89, 121, 121, 2, 0, + 83, 83, 115, 115, 2, 0, 69, 69, 101, 101, 2, 0, 90, 90, 122, 122, 2, 0, + 68, 68, 100, 100, 2, 0, 82, 82, 114, 114, 2, 0, 67, 67, 99, 99, 2, 0, 77, + 77, 109, 109, 2, 0, 84, 84, 116, 116, 2, 0, 73, 73, 105, 105, 2, 0, 66, + 66, 98, 98, 2, 0, 79, 79, 111, 111, 2, 0, 72, 72, 104, 104, 2, 0, 75, 75, + 107, 107, 2, 0, 85, 85, 117, 117, 2, 0, 71, 71, 103, 103, 2, 0, 80, 80, + 112, 112, 2, 0, 70, 70, 102, 102, 2, 0, 88, 88, 120, 120, 2, 0, 86, 86, + 118, 118, 2, 0, 81, 81, 113, 113, 2, 0, 87, 87, 119, 119, 2, 0, 74, 74, + 106, 106, 9, 0, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 186, 186, + 192, 214, 216, 246, 248, 255, 2, 0, 256, 55295, 57344, 65535, 1, 0, 55296, + 56319, 1, 0, 56320, 57343, 2, 0, 0, 0, 34, 34, 1, 0, 34, 34, 1, 0, 39, + 39, 1, 0, 48, 49, 3, 0, 48, 57, 65, 70, 97, 102, 3, 0, 65, 90, 95, 95, + 97, 122, 5, 0, 36, 36, 48, 57, 65, 90, 95, 95, 97, 122, 2, 0, 34, 34, 92, + 92, 2, 0, 9, 9, 32, 32, 2, 0, 10, 10, 13, 13, 2, 0, 42, 42, 47, 47, 4, + 0, 10, 10, 13, 13, 34, 34, 92, 92, 3, 0, 10, 10, 13, 13, 34, 34, 3, 0, + 85, 85, 117, 117, 120, 120, 2, 0, 39, 39, 92, 92, 1, 0, 36, 36, 9393, 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, 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, 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, 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, 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, 1, 1799, 1, 0, 0, 0, 1, 1801, 1, 0, 0, 0, 1, 1805, 1, 0, 0, + 0, 1, 1807, 1, 0, 0, 0, 2, 1811, 1, 0, 0, 0, 2, 1813, 1, 0, 0, 0, 2, 1815, + 1, 0, 0, 0, 3, 1817, 1, 0, 0, 0, 3, 1819, 1, 0, 0, 0, 3, 1821, 1, 0, 0, + 0, 3, 1823, 1, 0, 0, 0, 4, 1825, 1, 0, 0, 0, 4, 1827, 1, 0, 0, 0, 5, 1829, + 1, 0, 0, 0, 7, 1831, 1, 0, 0, 0, 9, 1833, 1, 0, 0, 0, 11, 1835, 1, 0, 0, + 0, 13, 1837, 1, 0, 0, 0, 15, 1839, 1, 0, 0, 0, 17, 1841, 1, 0, 0, 0, 19, + 1843, 1, 0, 0, 0, 21, 1845, 1, 0, 0, 0, 23, 1847, 1, 0, 0, 0, 25, 1849, + 1, 0, 0, 0, 27, 1851, 1, 0, 0, 0, 29, 1853, 1, 0, 0, 0, 31, 1855, 1, 0, + 0, 0, 33, 1857, 1, 0, 0, 0, 35, 1859, 1, 0, 0, 0, 37, 1861, 1, 0, 0, 0, + 39, 1863, 1, 0, 0, 0, 41, 1866, 1, 0, 0, 0, 43, 1869, 1, 0, 0, 0, 45, 1872, + 1, 0, 0, 0, 47, 1875, 1, 0, 0, 0, 49, 1878, 1, 0, 0, 0, 51, 1881, 1, 0, + 0, 0, 53, 1884, 1, 0, 0, 0, 55, 1887, 1, 0, 0, 0, 57, 1890, 1, 0, 0, 0, + 59, 1892, 1, 0, 0, 0, 61, 1918, 1, 0, 0, 0, 63, 1929, 1, 0, 0, 0, 65, 1945, + 1, 0, 0, 0, 67, 1947, 1, 0, 0, 0, 69, 1949, 1, 0, 0, 0, 71, 1951, 1, 0, + 0, 0, 73, 1955, 1, 0, 0, 0, 75, 1963, 1, 0, 0, 0, 77, 1971, 1, 0, 0, 0, + 79, 1975, 1, 0, 0, 0, 81, 1979, 1, 0, 0, 0, 83, 1985, 1, 0, 0, 0, 85, 1988, + 1, 0, 0, 0, 87, 1992, 1, 0, 0, 0, 89, 2003, 1, 0, 0, 0, 91, 2008, 1, 0, + 0, 0, 93, 2013, 1, 0, 0, 0, 95, 2018, 1, 0, 0, 0, 97, 2024, 1, 0, 0, 0, + 99, 2032, 1, 0, 0, 0, 101, 2039, 1, 0, 0, 0, 103, 2050, 1, 0, 0, 0, 105, + 2057, 1, 0, 0, 0, 107, 2073, 1, 0, 0, 0, 109, 2086, 1, 0, 0, 0, 111, 2099, + 1, 0, 0, 0, 113, 2112, 1, 0, 0, 0, 115, 2130, 1, 0, 0, 0, 117, 2143, 1, + 0, 0, 0, 119, 2151, 1, 0, 0, 0, 121, 2162, 1, 0, 0, 0, 123, 2167, 1, 0, + 0, 0, 125, 2176, 1, 0, 0, 0, 127, 2179, 1, 0, 0, 0, 129, 2184, 1, 0, 0, + 0, 131, 2191, 1, 0, 0, 0, 133, 2197, 1, 0, 0, 0, 135, 2203, 1, 0, 0, 0, + 137, 2207, 1, 0, 0, 0, 139, 2215, 1, 0, 0, 0, 141, 2220, 1, 0, 0, 0, 143, + 2226, 1, 0, 0, 0, 145, 2232, 1, 0, 0, 0, 147, 2239, 1, 0, 0, 0, 149, 2242, + 1, 0, 0, 0, 151, 2252, 1, 0, 0, 0, 153, 2262, 1, 0, 0, 0, 155, 2267, 1, + 0, 0, 0, 157, 2275, 1, 0, 0, 0, 159, 2283, 1, 0, 0, 0, 161, 2289, 1, 0, + 0, 0, 163, 2299, 1, 0, 0, 0, 165, 2314, 1, 0, 0, 0, 167, 2318, 1, 0, 0, + 0, 169, 2323, 1, 0, 0, 0, 171, 2330, 1, 0, 0, 0, 173, 2333, 1, 0, 0, 0, + 175, 2338, 1, 0, 0, 0, 177, 2341, 1, 0, 0, 0, 179, 2347, 1, 0, 0, 0, 181, + 2355, 1, 0, 0, 0, 183, 2363, 1, 0, 0, 0, 185, 2370, 1, 0, 0, 0, 187, 2381, + 1, 0, 0, 0, 189, 2391, 1, 0, 0, 0, 191, 2398, 1, 0, 0, 0, 193, 2411, 1, + 0, 0, 0, 195, 2416, 1, 0, 0, 0, 197, 2426, 1, 0, 0, 0, 199, 2432, 1, 0, + 0, 0, 201, 2437, 1, 0, 0, 0, 203, 2440, 1, 0, 0, 0, 205, 2449, 1, 0, 0, + 0, 207, 2454, 1, 0, 0, 0, 209, 2460, 1, 0, 0, 0, 211, 2467, 1, 0, 0, 0, + 213, 2472, 1, 0, 0, 0, 215, 2478, 1, 0, 0, 0, 217, 2487, 1, 0, 0, 0, 219, + 2492, 1, 0, 0, 0, 221, 2498, 1, 0, 0, 0, 223, 2505, 1, 0, 0, 0, 225, 2510, + 1, 0, 0, 0, 227, 2524, 1, 0, 0, 0, 229, 2531, 1, 0, 0, 0, 231, 2539, 1, + 0, 0, 0, 233, 2549, 1, 0, 0, 0, 235, 2562, 1, 0, 0, 0, 237, 2568, 1, 0, + 0, 0, 239, 2583, 1, 0, 0, 0, 241, 2590, 1, 0, 0, 0, 243, 2595, 1, 0, 0, + 0, 245, 2601, 1, 0, 0, 0, 247, 2607, 1, 0, 0, 0, 249, 2610, 1, 0, 0, 0, + 251, 2617, 1, 0, 0, 0, 253, 2622, 1, 0, 0, 0, 255, 2627, 1, 0, 0, 0, 257, + 2632, 1, 0, 0, 0, 259, 2640, 1, 0, 0, 0, 261, 2648, 1, 0, 0, 0, 263, 2654, + 1, 0, 0, 0, 265, 2659, 1, 0, 0, 0, 267, 2668, 1, 0, 0, 0, 269, 2674, 1, + 0, 0, 0, 271, 2682, 1, 0, 0, 0, 273, 2690, 1, 0, 0, 0, 275, 2696, 1, 0, + 0, 0, 277, 2705, 1, 0, 0, 0, 279, 2712, 1, 0, 0, 0, 281, 2719, 1, 0, 0, + 0, 283, 2723, 1, 0, 0, 0, 285, 2729, 1, 0, 0, 0, 287, 2735, 1, 0, 0, 0, + 289, 2745, 1, 0, 0, 0, 291, 2750, 1, 0, 0, 0, 293, 2756, 1, 0, 0, 0, 295, + 2763, 1, 0, 0, 0, 297, 2773, 1, 0, 0, 0, 299, 2784, 1, 0, 0, 0, 301, 2787, + 1, 0, 0, 0, 303, 2797, 1, 0, 0, 0, 305, 2806, 1, 0, 0, 0, 307, 2813, 1, + 0, 0, 0, 309, 2819, 1, 0, 0, 0, 311, 2822, 1, 0, 0, 0, 313, 2828, 1, 0, + 0, 0, 315, 2835, 1, 0, 0, 0, 317, 2843, 1, 0, 0, 0, 319, 2852, 1, 0, 0, + 0, 321, 2860, 1, 0, 0, 0, 323, 2866, 1, 0, 0, 0, 325, 2882, 1, 0, 0, 0, + 327, 2893, 1, 0, 0, 0, 329, 2899, 1, 0, 0, 0, 331, 2905, 1, 0, 0, 0, 333, + 2913, 1, 0, 0, 0, 335, 2921, 1, 0, 0, 0, 337, 2930, 1, 0, 0, 0, 339, 2937, + 1, 0, 0, 0, 341, 2947, 1, 0, 0, 0, 343, 2961, 1, 0, 0, 0, 345, 2972, 1, + 0, 0, 0, 347, 2984, 1, 0, 0, 0, 349, 2992, 1, 0, 0, 0, 351, 3001, 1, 0, + 0, 0, 353, 3012, 1, 0, 0, 0, 355, 3017, 1, 0, 0, 0, 357, 3022, 1, 0, 0, + 0, 359, 3026, 1, 0, 0, 0, 361, 3031, 1, 0, 0, 0, 363, 3038, 1, 0, 0, 0, + 365, 3044, 1, 0, 0, 0, 367, 3049, 1, 0, 0, 0, 369, 3062, 1, 0, 0, 0, 371, + 3071, 1, 0, 0, 0, 373, 3075, 1, 0, 0, 0, 375, 3086, 1, 0, 0, 0, 377, 3094, + 1, 0, 0, 0, 379, 3103, 1, 0, 0, 0, 381, 3112, 1, 0, 0, 0, 383, 3120, 1, + 0, 0, 0, 385, 3127, 1, 0, 0, 0, 387, 3137, 1, 0, 0, 0, 389, 3148, 1, 0, + 0, 0, 391, 3159, 1, 0, 0, 0, 393, 3167, 1, 0, 0, 0, 395, 3175, 1, 0, 0, + 0, 397, 3184, 1, 0, 0, 0, 399, 3191, 1, 0, 0, 0, 401, 3198, 1, 0, 0, 0, + 403, 3203, 1, 0, 0, 0, 405, 3208, 1, 0, 0, 0, 407, 3215, 1, 0, 0, 0, 409, + 3224, 1, 0, 0, 0, 411, 3234, 1, 0, 0, 0, 413, 3239, 1, 0, 0, 0, 415, 3246, + 1, 0, 0, 0, 417, 3252, 1, 0, 0, 0, 419, 3260, 1, 0, 0, 0, 421, 3270, 1, + 0, 0, 0, 423, 3280, 1, 0, 0, 0, 425, 3288, 1, 0, 0, 0, 427, 3296, 1, 0, + 0, 0, 429, 3306, 1, 0, 0, 0, 431, 3315, 1, 0, 0, 0, 433, 3322, 1, 0, 0, + 0, 435, 3328, 1, 0, 0, 0, 437, 3338, 1, 0, 0, 0, 439, 3344, 1, 0, 0, 0, + 441, 3352, 1, 0, 0, 0, 443, 3361, 1, 0, 0, 0, 445, 3371, 1, 0, 0, 0, 447, + 3378, 1, 0, 0, 0, 449, 3386, 1, 0, 0, 0, 451, 3394, 1, 0, 0, 0, 453, 3401, + 1, 0, 0, 0, 455, 3406, 1, 0, 0, 0, 457, 3411, 1, 0, 0, 0, 459, 3420, 1, + 0, 0, 0, 461, 3423, 1, 0, 0, 0, 463, 3433, 1, 0, 0, 0, 465, 3443, 1, 0, + 0, 0, 467, 3452, 1, 0, 0, 0, 469, 3462, 1, 0, 0, 0, 471, 3472, 1, 0, 0, + 0, 473, 3478, 1, 0, 0, 0, 475, 3486, 1, 0, 0, 0, 477, 3494, 1, 0, 0, 0, + 479, 3503, 1, 0, 0, 0, 481, 3510, 1, 0, 0, 0, 483, 3522, 1, 0, 0, 0, 485, + 3529, 1, 0, 0, 0, 487, 3537, 1, 0, 0, 0, 489, 3545, 1, 0, 0, 0, 491, 3555, + 1, 0, 0, 0, 493, 3559, 1, 0, 0, 0, 495, 3565, 1, 0, 0, 0, 497, 3574, 1, + 0, 0, 0, 499, 3580, 1, 0, 0, 0, 501, 3585, 1, 0, 0, 0, 503, 3595, 1, 0, + 0, 0, 505, 3601, 1, 0, 0, 0, 507, 3608, 1, 0, 0, 0, 509, 3613, 1, 0, 0, + 0, 511, 3619, 1, 0, 0, 0, 513, 3628, 1, 0, 0, 0, 515, 3633, 1, 0, 0, 0, + 517, 3641, 1, 0, 0, 0, 519, 3647, 1, 0, 0, 0, 521, 3655, 1, 0, 0, 0, 523, + 3668, 1, 0, 0, 0, 525, 3677, 1, 0, 0, 0, 527, 3683, 1, 0, 0, 0, 529, 3690, + 1, 0, 0, 0, 531, 3699, 1, 0, 0, 0, 533, 3704, 1, 0, 0, 0, 535, 3710, 1, + 0, 0, 0, 537, 3715, 1, 0, 0, 0, 539, 3720, 1, 0, 0, 0, 541, 3726, 1, 0, + 0, 0, 543, 3731, 1, 0, 0, 0, 545, 3734, 1, 0, 0, 0, 547, 3742, 1, 0, 0, + 0, 549, 3749, 1, 0, 0, 0, 551, 3756, 1, 0, 0, 0, 553, 3762, 1, 0, 0, 0, + 555, 3769, 1, 0, 0, 0, 557, 3772, 1, 0, 0, 0, 559, 3776, 1, 0, 0, 0, 561, + 3781, 1, 0, 0, 0, 563, 3790, 1, 0, 0, 0, 565, 3797, 1, 0, 0, 0, 567, 3805, + 1, 0, 0, 0, 569, 3811, 1, 0, 0, 0, 571, 3817, 1, 0, 0, 0, 573, 3824, 1, + 0, 0, 0, 575, 3832, 1, 0, 0, 0, 577, 3842, 1, 0, 0, 0, 579, 3850, 1, 0, + 0, 0, 581, 3859, 1, 0, 0, 0, 583, 3865, 1, 0, 0, 0, 585, 3875, 1, 0, 0, + 0, 587, 3885, 1, 0, 0, 0, 589, 3893, 1, 0, 0, 0, 591, 3902, 1, 0, 0, 0, + 593, 3911, 1, 0, 0, 0, 595, 3917, 1, 0, 0, 0, 597, 3928, 1, 0, 0, 0, 599, + 3939, 1, 0, 0, 0, 601, 3949, 1, 0, 0, 0, 603, 3957, 1, 0, 0, 0, 605, 3963, + 1, 0, 0, 0, 607, 3969, 1, 0, 0, 0, 609, 3974, 1, 0, 0, 0, 611, 3983, 1, + 0, 0, 0, 613, 3991, 1, 0, 0, 0, 615, 4001, 1, 0, 0, 0, 617, 4005, 1, 0, + 0, 0, 619, 4013, 1, 0, 0, 0, 621, 4021, 1, 0, 0, 0, 623, 4030, 1, 0, 0, + 0, 625, 4038, 1, 0, 0, 0, 627, 4045, 1, 0, 0, 0, 629, 4056, 1, 0, 0, 0, + 631, 4064, 1, 0, 0, 0, 633, 4072, 1, 0, 0, 0, 635, 4078, 1, 0, 0, 0, 637, + 4086, 1, 0, 0, 0, 639, 4095, 1, 0, 0, 0, 641, 4103, 1, 0, 0, 0, 643, 4110, + 1, 0, 0, 0, 645, 4115, 1, 0, 0, 0, 647, 4124, 1, 0, 0, 0, 649, 4129, 1, + 0, 0, 0, 651, 4134, 1, 0, 0, 0, 653, 4144, 1, 0, 0, 0, 655, 4151, 1, 0, + 0, 0, 657, 4158, 1, 0, 0, 0, 659, 4165, 1, 0, 0, 0, 661, 4172, 1, 0, 0, + 0, 663, 4181, 1, 0, 0, 0, 665, 4190, 1, 0, 0, 0, 667, 4200, 1, 0, 0, 0, + 669, 4213, 1, 0, 0, 0, 671, 4220, 1, 0, 0, 0, 673, 4228, 1, 0, 0, 0, 675, + 4232, 1, 0, 0, 0, 677, 4238, 1, 0, 0, 0, 679, 4243, 1, 0, 0, 0, 681, 4250, + 1, 0, 0, 0, 683, 4259, 1, 0, 0, 0, 685, 4266, 1, 0, 0, 0, 687, 4277, 1, + 0, 0, 0, 689, 4283, 1, 0, 0, 0, 691, 4293, 1, 0, 0, 0, 693, 4304, 1, 0, + 0, 0, 695, 4310, 1, 0, 0, 0, 697, 4317, 1, 0, 0, 0, 699, 4325, 1, 0, 0, + 0, 701, 4332, 1, 0, 0, 0, 703, 4338, 1, 0, 0, 0, 705, 4344, 1, 0, 0, 0, + 707, 4351, 1, 0, 0, 0, 709, 4358, 1, 0, 0, 0, 711, 4369, 1, 0, 0, 0, 713, + 4374, 1, 0, 0, 0, 715, 4383, 1, 0, 0, 0, 717, 4393, 1, 0, 0, 0, 719, 4398, + 1, 0, 0, 0, 721, 4410, 1, 0, 0, 0, 723, 4418, 1, 0, 0, 0, 725, 4427, 1, + 0, 0, 0, 727, 4435, 1, 0, 0, 0, 729, 4440, 1, 0, 0, 0, 731, 4446, 1, 0, + 0, 0, 733, 4456, 1, 0, 0, 0, 735, 4468, 1, 0, 0, 0, 737, 4480, 1, 0, 0, + 0, 739, 4488, 1, 0, 0, 0, 741, 4497, 1, 0, 0, 0, 743, 4506, 1, 0, 0, 0, + 745, 4512, 1, 0, 0, 0, 747, 4519, 1, 0, 0, 0, 749, 4526, 1, 0, 0, 0, 751, + 4532, 1, 0, 0, 0, 753, 4541, 1, 0, 0, 0, 755, 4551, 1, 0, 0, 0, 757, 4559, + 1, 0, 0, 0, 759, 4567, 1, 0, 0, 0, 761, 4572, 1, 0, 0, 0, 763, 4581, 1, + 0, 0, 0, 765, 4592, 1, 0, 0, 0, 767, 4600, 1, 0, 0, 0, 769, 4605, 1, 0, + 0, 0, 771, 4613, 1, 0, 0, 0, 773, 4619, 1, 0, 0, 0, 775, 4623, 1, 0, 0, + 0, 777, 4628, 1, 0, 0, 0, 779, 4632, 1, 0, 0, 0, 781, 4637, 1, 0, 0, 0, + 783, 4645, 1, 0, 0, 0, 785, 4653, 1, 0, 0, 0, 787, 4657, 1, 0, 0, 0, 789, + 4665, 1, 0, 0, 0, 791, 4675, 1, 0, 0, 0, 793, 4687, 1, 0, 0, 0, 795, 4698, + 1, 0, 0, 0, 797, 4708, 1, 0, 0, 0, 799, 4713, 1, 0, 0, 0, 801, 4730, 1, + 0, 0, 0, 803, 4741, 1, 0, 0, 0, 805, 4750, 1, 0, 0, 0, 807, 4763, 1, 0, + 0, 0, 809, 4774, 1, 0, 0, 0, 811, 4779, 1, 0, 0, 0, 813, 4789, 1, 0, 0, + 0, 815, 4793, 1, 0, 0, 0, 817, 4802, 1, 0, 0, 0, 819, 4808, 1, 0, 0, 0, + 821, 4819, 1, 0, 0, 0, 823, 4827, 1, 0, 0, 0, 825, 4833, 1, 0, 0, 0, 827, + 4837, 1, 0, 0, 0, 829, 4852, 1, 0, 0, 0, 831, 4871, 1, 0, 0, 0, 833, 4879, + 1, 0, 0, 0, 835, 4884, 1, 0, 0, 0, 837, 4892, 1, 0, 0, 0, 839, 4896, 1, + 0, 0, 0, 841, 4905, 1, 0, 0, 0, 843, 4914, 1, 0, 0, 0, 845, 4924, 1, 0, + 0, 0, 847, 4930, 1, 0, 0, 0, 849, 4937, 1, 0, 0, 0, 851, 4947, 1, 0, 0, + 0, 853, 4952, 1, 0, 0, 0, 855, 4963, 1, 0, 0, 0, 857, 4976, 1, 0, 0, 0, + 859, 4986, 1, 0, 0, 0, 861, 5000, 1, 0, 0, 0, 863, 5016, 1, 0, 0, 0, 865, + 5024, 1, 0, 0, 0, 867, 5028, 1, 0, 0, 0, 869, 5043, 1, 0, 0, 0, 871, 5050, + 1, 0, 0, 0, 873, 5059, 1, 0, 0, 0, 875, 5070, 1, 0, 0, 0, 877, 5092, 1, + 0, 0, 0, 879, 5118, 1, 0, 0, 0, 881, 5128, 1, 0, 0, 0, 883, 5133, 1, 0, + 0, 0, 885, 5144, 1, 0, 0, 0, 887, 5163, 1, 0, 0, 0, 889, 5173, 1, 0, 0, + 0, 891, 5185, 1, 0, 0, 0, 893, 5193, 1, 0, 0, 0, 895, 5203, 1, 0, 0, 0, + 897, 5215, 1, 0, 0, 0, 899, 5230, 1, 0, 0, 0, 901, 5237, 1, 0, 0, 0, 903, + 5246, 1, 0, 0, 0, 905, 5256, 1, 0, 0, 0, 907, 5271, 1, 0, 0, 0, 909, 5281, + 1, 0, 0, 0, 911, 5293, 1, 0, 0, 0, 913, 5306, 1, 0, 0, 0, 915, 5312, 1, + 0, 0, 0, 917, 5317, 1, 0, 0, 0, 919, 5322, 1, 0, 0, 0, 921, 5332, 1, 0, + 0, 0, 923, 5343, 1, 0, 0, 0, 925, 5350, 1, 0, 0, 0, 927, 5354, 1, 0, 0, + 0, 929, 5361, 1, 0, 0, 0, 931, 5383, 1, 0, 0, 0, 933, 5407, 1, 0, 0, 0, + 935, 5419, 1, 0, 0, 0, 937, 5427, 1, 0, 0, 0, 939, 5434, 1, 0, 0, 0, 941, + 5437, 1, 0, 0, 0, 943, 5440, 1, 0, 0, 0, 945, 5448, 1, 0, 0, 0, 947, 5458, + 1, 0, 0, 0, 949, 5467, 1, 0, 0, 0, 951, 5477, 1, 0, 0, 0, 953, 5487, 1, + 0, 0, 0, 955, 5491, 1, 0, 0, 0, 957, 5498, 1, 0, 0, 0, 959, 5509, 1, 0, + 0, 0, 961, 5517, 1, 0, 0, 0, 963, 5526, 1, 0, 0, 0, 965, 5533, 1, 0, 0, + 0, 967, 5540, 1, 0, 0, 0, 969, 5553, 1, 0, 0, 0, 971, 5567, 1, 0, 0, 0, + 973, 5571, 1, 0, 0, 0, 975, 5579, 1, 0, 0, 0, 977, 5585, 1, 0, 0, 0, 979, + 5588, 1, 0, 0, 0, 981, 5591, 1, 0, 0, 0, 983, 5601, 1, 0, 0, 0, 985, 5612, + 1, 0, 0, 0, 987, 5624, 1, 0, 0, 0, 989, 5635, 1, 0, 0, 0, 991, 5648, 1, + 0, 0, 0, 993, 5655, 1, 0, 0, 0, 995, 5660, 1, 0, 0, 0, 997, 5669, 1, 0, + 0, 0, 999, 5673, 1, 0, 0, 0, 1001, 5682, 1, 0, 0, 0, 1003, 5693, 1, 0, + 0, 0, 1005, 5704, 1, 0, 0, 0, 1007, 5714, 1, 0, 0, 0, 1009, 5725, 1, 0, + 0, 0, 1011, 5733, 1, 0, 0, 0, 1013, 5740, 1, 0, 0, 0, 1015, 5752, 1, 0, + 0, 0, 1017, 5765, 1, 0, 0, 0, 1019, 5776, 1, 0, 0, 0, 1021, 5792, 1, 0, + 0, 0, 1023, 5810, 1, 0, 0, 0, 1025, 5819, 1, 0, 0, 0, 1027, 5832, 1, 0, + 0, 0, 1029, 5850, 1, 0, 0, 0, 1031, 5864, 1, 0, 0, 0, 1033, 5877, 1, 0, + 0, 0, 1035, 5893, 1, 0, 0, 0, 1037, 5904, 1, 0, 0, 0, 1039, 5909, 1, 0, + 0, 0, 1041, 5916, 1, 0, 0, 0, 1043, 5929, 1, 0, 0, 0, 1045, 5938, 1, 0, + 0, 0, 1047, 5942, 1, 0, 0, 0, 1049, 5946, 1, 0, 0, 0, 1051, 5953, 1, 0, + 0, 0, 1053, 5964, 1, 0, 0, 0, 1055, 5972, 1, 0, 0, 0, 1057, 5977, 1, 0, + 0, 0, 1059, 5990, 1, 0, 0, 0, 1061, 6006, 1, 0, 0, 0, 1063, 6017, 1, 0, + 0, 0, 1065, 6030, 1, 0, 0, 0, 1067, 6042, 1, 0, 0, 0, 1069, 6051, 1, 0, + 0, 0, 1071, 6062, 1, 0, 0, 0, 1073, 6073, 1, 0, 0, 0, 1075, 6088, 1, 0, + 0, 0, 1077, 6102, 1, 0, 0, 0, 1079, 6115, 1, 0, 0, 0, 1081, 6132, 1, 0, + 0, 0, 1083, 6143, 1, 0, 0, 0, 1085, 6154, 1, 0, 0, 0, 1087, 6167, 1, 0, + 0, 0, 1089, 6177, 1, 0, 0, 0, 1091, 6185, 1, 0, 0, 0, 1093, 6196, 1, 0, + 0, 0, 1095, 6203, 1, 0, 0, 0, 1097, 6217, 1, 0, 0, 0, 1099, 6235, 1, 0, + 0, 0, 1101, 6249, 1, 0, 0, 0, 1103, 6256, 1, 0, 0, 0, 1105, 6265, 1, 0, + 0, 0, 1107, 6279, 1, 0, 0, 0, 1109, 6286, 1, 0, 0, 0, 1111, 6294, 1, 0, + 0, 0, 1113, 6301, 1, 0, 0, 0, 1115, 6305, 1, 0, 0, 0, 1117, 6313, 1, 0, + 0, 0, 1119, 6318, 1, 0, 0, 0, 1121, 6328, 1, 0, 0, 0, 1123, 6337, 1, 0, + 0, 0, 1125, 6341, 1, 0, 0, 0, 1127, 6349, 1, 0, 0, 0, 1129, 6356, 1, 0, + 0, 0, 1131, 6364, 1, 0, 0, 0, 1133, 6370, 1, 0, 0, 0, 1135, 6379, 1, 0, + 0, 0, 1137, 6385, 1, 0, 0, 0, 1139, 6389, 1, 0, 0, 0, 1141, 6397, 1, 0, + 0, 0, 1143, 6406, 1, 0, 0, 0, 1145, 6412, 1, 0, 0, 0, 1147, 6421, 1, 0, + 0, 0, 1149, 6427, 1, 0, 0, 0, 1151, 6432, 1, 0, 0, 0, 1153, 6439, 1, 0, + 0, 0, 1155, 6447, 1, 0, 0, 0, 1157, 6455, 1, 0, 0, 0, 1159, 6465, 1, 0, + 0, 0, 1161, 6474, 1, 0, 0, 0, 1163, 6484, 1, 0, 0, 0, 1165, 6489, 1, 0, + 0, 0, 1167, 6493, 1, 0, 0, 0, 1169, 6499, 1, 0, 0, 0, 1171, 6508, 1, 0, + 0, 0, 1173, 6518, 1, 0, 0, 0, 1175, 6523, 1, 0, 0, 0, 1177, 6533, 1, 0, + 0, 0, 1179, 6539, 1, 0, 0, 0, 1181, 6544, 1, 0, 0, 0, 1183, 6551, 1, 0, + 0, 0, 1185, 6559, 1, 0, 0, 0, 1187, 6573, 1, 0, 0, 0, 1189, 6584, 1, 0, + 0, 0, 1191, 6591, 1, 0, 0, 0, 1193, 6610, 1, 0, 0, 0, 1195, 6638, 1, 0, + 0, 0, 1197, 6665, 1, 0, 0, 0, 1199, 6671, 1, 0, 0, 0, 1201, 6684, 1, 0, + 0, 0, 1203, 6694, 1, 0, 0, 0, 1205, 6705, 1, 0, 0, 0, 1207, 6715, 1, 0, + 0, 0, 1209, 6725, 1, 0, 0, 0, 1211, 6734, 1, 0, 0, 0, 1213, 6740, 1, 0, + 0, 0, 1215, 6748, 1, 0, 0, 0, 1217, 6761, 1, 0, 0, 0, 1219, 6766, 1, 0, + 0, 0, 1221, 6774, 1, 0, 0, 0, 1223, 6781, 1, 0, 0, 0, 1225, 6788, 1, 0, + 0, 0, 1227, 6799, 1, 0, 0, 0, 1229, 6809, 1, 0, 0, 0, 1231, 6816, 1, 0, + 0, 0, 1233, 6823, 1, 0, 0, 0, 1235, 6829, 1, 0, 0, 0, 1237, 6845, 1, 0, + 0, 0, 1239, 6857, 1, 0, 0, 0, 1241, 6870, 1, 0, 0, 0, 1243, 6877, 1, 0, + 0, 0, 1245, 6888, 1, 0, 0, 0, 1247, 6894, 1, 0, 0, 0, 1249, 6905, 1, 0, + 0, 0, 1251, 6913, 1, 0, 0, 0, 1253, 6921, 1, 0, 0, 0, 1255, 6927, 1, 0, + 0, 0, 1257, 6932, 1, 0, 0, 0, 1259, 6944, 1, 0, 0, 0, 1261, 6951, 1, 0, + 0, 0, 1263, 6955, 1, 0, 0, 0, 1265, 6962, 1, 0, 0, 0, 1267, 6972, 1, 0, + 0, 0, 1269, 6978, 1, 0, 0, 0, 1271, 6985, 1, 0, 0, 0, 1273, 6995, 1, 0, + 0, 0, 1275, 6999, 1, 0, 0, 0, 1277, 7004, 1, 0, 0, 0, 1279, 7008, 1, 0, + 0, 0, 1281, 7019, 1, 0, 0, 0, 1283, 7033, 1, 0, 0, 0, 1285, 7048, 1, 0, + 0, 0, 1287, 7066, 1, 0, 0, 0, 1289, 7069, 1, 0, 0, 0, 1291, 7077, 1, 0, + 0, 0, 1293, 7085, 1, 0, 0, 0, 1295, 7095, 1, 0, 0, 0, 1297, 7102, 1, 0, + 0, 0, 1299, 7109, 1, 0, 0, 0, 1301, 7118, 1, 0, 0, 0, 1303, 7125, 1, 0, + 0, 0, 1305, 7137, 1, 0, 0, 0, 1307, 7141, 1, 0, 0, 0, 1309, 7145, 1, 0, + 0, 0, 1311, 7151, 1, 0, 0, 0, 1313, 7164, 1, 0, 0, 0, 1315, 7176, 1, 0, + 0, 0, 1317, 7180, 1, 0, 0, 0, 1319, 7184, 1, 0, 0, 0, 1321, 7193, 1, 0, + 0, 0, 1323, 7201, 1, 0, 0, 0, 1325, 7212, 1, 0, 0, 0, 1327, 7218, 1, 0, + 0, 0, 1329, 7226, 1, 0, 0, 0, 1331, 7235, 1, 0, 0, 0, 1333, 7239, 1, 0, + 0, 0, 1335, 7247, 1, 0, 0, 0, 1337, 7258, 1, 0, 0, 0, 1339, 7267, 1, 0, + 0, 0, 1341, 7272, 1, 0, 0, 0, 1343, 7279, 1, 0, 0, 0, 1345, 7284, 1, 0, + 0, 0, 1347, 7291, 1, 0, 0, 0, 1349, 7296, 1, 0, 0, 0, 1351, 7305, 1, 0, + 0, 0, 1353, 7310, 1, 0, 0, 0, 1355, 7322, 1, 0, 0, 0, 1357, 7333, 1, 0, + 0, 0, 1359, 7342, 1, 0, 0, 0, 1361, 7350, 1, 0, 0, 0, 1363, 7364, 1, 0, + 0, 0, 1365, 7372, 1, 0, 0, 0, 1367, 7383, 1, 0, 0, 0, 1369, 7390, 1, 0, + 0, 0, 1371, 7397, 1, 0, 0, 0, 1373, 7404, 1, 0, 0, 0, 1375, 7411, 1, 0, + 0, 0, 1377, 7415, 1, 0, 0, 0, 1379, 7419, 1, 0, 0, 0, 1381, 7424, 1, 0, + 0, 0, 1383, 7429, 1, 0, 0, 0, 1385, 7437, 1, 0, 0, 0, 1387, 7443, 1, 0, + 0, 0, 1389, 7453, 1, 0, 0, 0, 1391, 7458, 1, 0, 0, 0, 1393, 7478, 1, 0, + 0, 0, 1395, 7496, 1, 0, 0, 0, 1397, 7502, 1, 0, 0, 0, 1399, 7515, 1, 0, + 0, 0, 1401, 7526, 1, 0, 0, 0, 1403, 7532, 1, 0, 0, 0, 1405, 7541, 1, 0, + 0, 0, 1407, 7549, 1, 0, 0, 0, 1409, 7553, 1, 0, 0, 0, 1411, 7565, 1, 0, + 0, 0, 1413, 7573, 1, 0, 0, 0, 1415, 7579, 1, 0, 0, 0, 1417, 7585, 1, 0, + 0, 0, 1419, 7593, 1, 0, 0, 0, 1421, 7601, 1, 0, 0, 0, 1423, 7607, 1, 0, + 0, 0, 1425, 7612, 1, 0, 0, 0, 1427, 7619, 1, 0, 0, 0, 1429, 7625, 1, 0, + 0, 0, 1431, 7631, 1, 0, 0, 0, 1433, 7640, 1, 0, 0, 0, 1435, 7646, 1, 0, + 0, 0, 1437, 7650, 1, 0, 0, 0, 1439, 7655, 1, 0, 0, 0, 1441, 7662, 1, 0, + 0, 0, 1443, 7670, 1, 0, 0, 0, 1445, 7680, 1, 0, 0, 0, 1447, 7687, 1, 0, + 0, 0, 1449, 7692, 1, 0, 0, 0, 1451, 7697, 1, 0, 0, 0, 1453, 7701, 1, 0, + 0, 0, 1455, 7706, 1, 0, 0, 0, 1457, 7711, 1, 0, 0, 0, 1459, 7719, 1, 0, + 0, 0, 1461, 7727, 1, 0, 0, 0, 1463, 7731, 1, 0, 0, 0, 1465, 7735, 1, 0, + 0, 0, 1467, 7745, 1, 0, 0, 0, 1469, 7751, 1, 0, 0, 0, 1471, 7755, 1, 0, + 0, 0, 1473, 7759, 1, 0, 0, 0, 1475, 7762, 1, 0, 0, 0, 1477, 7768, 1, 0, + 0, 0, 1479, 7778, 1, 0, 0, 0, 1481, 7782, 1, 0, 0, 0, 1483, 7785, 1, 0, + 0, 0, 1485, 7791, 1, 0, 0, 0, 1487, 7799, 1, 0, 0, 0, 1489, 7805, 1, 0, + 0, 0, 1491, 7811, 1, 0, 0, 0, 1493, 7816, 1, 0, 0, 0, 1495, 7821, 1, 0, + 0, 0, 1497, 7832, 1, 0, 0, 0, 1499, 7838, 1, 0, 0, 0, 1501, 7851, 1, 0, + 0, 0, 1503, 7858, 1, 0, 0, 0, 1505, 7866, 1, 0, 0, 0, 1507, 7871, 1, 0, + 0, 0, 1509, 7877, 1, 0, 0, 0, 1511, 7882, 1, 0, 0, 0, 1513, 7888, 1, 0, + 0, 0, 1515, 7893, 1, 0, 0, 0, 1517, 7899, 1, 0, 0, 0, 1519, 7905, 1, 0, + 0, 0, 1521, 7912, 1, 0, 0, 0, 1523, 7916, 1, 0, 0, 0, 1525, 7921, 1, 0, + 0, 0, 1527, 7925, 1, 0, 0, 0, 1529, 7930, 1, 0, 0, 0, 1531, 7934, 1, 0, + 0, 0, 1533, 7939, 1, 0, 0, 0, 1535, 7943, 1, 0, 0, 0, 1537, 7948, 1, 0, + 0, 0, 1539, 7953, 1, 0, 0, 0, 1541, 7958, 1, 0, 0, 0, 1543, 7963, 1, 0, + 0, 0, 1545, 7969, 1, 0, 0, 0, 1547, 7975, 1, 0, 0, 0, 1549, 7981, 1, 0, + 0, 0, 1551, 7992, 1, 0, 0, 0, 1553, 8004, 1, 0, 0, 0, 1555, 8021, 1, 0, + 0, 0, 1557, 8027, 1, 0, 0, 0, 1559, 8040, 1, 0, 0, 0, 1561, 8046, 1, 0, + 0, 0, 1563, 8052, 1, 0, 0, 0, 1565, 8058, 1, 0, 0, 0, 1567, 8062, 1, 0, + 0, 0, 1569, 8069, 1, 0, 0, 0, 1571, 8079, 1, 0, 0, 0, 1573, 8086, 1, 0, + 0, 0, 1575, 8094, 1, 0, 0, 0, 1577, 8101, 1, 0, 0, 0, 1579, 8106, 1, 0, + 0, 0, 1581, 8112, 1, 0, 0, 0, 1583, 8116, 1, 0, 0, 0, 1585, 8128, 1, 0, + 0, 0, 1587, 8147, 1, 0, 0, 0, 1589, 8159, 1, 0, 0, 0, 1591, 8173, 1, 0, + 0, 0, 1593, 8188, 1, 0, 0, 0, 1595, 8201, 1, 0, 0, 0, 1597, 8214, 1, 0, + 0, 0, 1599, 8226, 1, 0, 0, 0, 1601, 8239, 1, 0, 0, 0, 1603, 8254, 1, 0, + 0, 0, 1605, 8269, 1, 0, 0, 0, 1607, 8291, 1, 0, 0, 0, 1609, 8313, 1, 0, + 0, 0, 1611, 8327, 1, 0, 0, 0, 1613, 8334, 1, 0, 0, 0, 1615, 8339, 1, 0, + 0, 0, 1617, 8345, 1, 0, 0, 0, 1619, 8356, 1, 0, 0, 0, 1621, 8368, 1, 0, + 0, 0, 1623, 8384, 1, 0, 0, 0, 1625, 8400, 1, 0, 0, 0, 1627, 8407, 1, 0, + 0, 0, 1629, 8414, 1, 0, 0, 0, 1631, 8423, 1, 0, 0, 0, 1633, 8430, 1, 0, + 0, 0, 1635, 8440, 1, 0, 0, 0, 1637, 8447, 1, 0, 0, 0, 1639, 8451, 1, 0, + 0, 0, 1641, 8467, 1, 0, 0, 0, 1643, 8476, 1, 0, 0, 0, 1645, 8486, 1, 0, + 0, 0, 1647, 8497, 1, 0, 0, 0, 1649, 8506, 1, 0, 0, 0, 1651, 8519, 1, 0, + 0, 0, 1653, 8533, 1, 0, 0, 0, 1655, 8550, 1, 0, 0, 0, 1657, 8560, 1, 0, + 0, 0, 1659, 8574, 1, 0, 0, 0, 1661, 8584, 1, 0, 0, 0, 1663, 8599, 1, 0, + 0, 0, 1665, 8616, 1, 0, 0, 0, 1667, 8620, 1, 0, 0, 0, 1669, 8640, 1, 0, + 0, 0, 1671, 8650, 1, 0, 0, 0, 1673, 8672, 1, 0, 0, 0, 1675, 8685, 1, 0, + 0, 0, 1677, 8693, 1, 0, 0, 0, 1679, 8701, 1, 0, 0, 0, 1681, 8711, 1, 0, + 0, 0, 1683, 8718, 1, 0, 0, 0, 1685, 8726, 1, 0, 0, 0, 1687, 8734, 1, 0, + 0, 0, 1689, 8744, 1, 0, 0, 0, 1691, 8751, 1, 0, 0, 0, 1693, 8760, 1, 0, + 0, 0, 1695, 8772, 1, 0, 0, 0, 1697, 8777, 1, 0, 0, 0, 1699, 8792, 1, 0, + 0, 0, 1701, 8798, 1, 0, 0, 0, 1703, 8801, 1, 0, 0, 0, 1705, 8807, 1, 0, + 0, 0, 1707, 8817, 1, 0, 0, 0, 1709, 8822, 1, 0, 0, 0, 1711, 8830, 1, 0, + 0, 0, 1713, 8847, 1, 0, 0, 0, 1715, 8854, 1, 0, 0, 0, 1717, 8857, 1, 0, + 0, 0, 1719, 8867, 1, 0, 0, 0, 1721, 8871, 1, 0, 0, 0, 1723, 8875, 1, 0, + 0, 0, 1725, 8877, 1, 0, 0, 0, 1727, 8880, 1, 0, 0, 0, 1729, 8889, 1, 0, + 0, 0, 1731, 8892, 1, 0, 0, 0, 1733, 8901, 1, 0, 0, 0, 1735, 8905, 1, 0, + 0, 0, 1737, 8909, 1, 0, 0, 0, 1739, 8913, 1, 0, 0, 0, 1741, 8917, 1, 0, + 0, 0, 1743, 8920, 1, 0, 0, 0, 1745, 8929, 1, 0, 0, 0, 1747, 8935, 1, 0, + 0, 0, 1749, 8938, 1, 0, 0, 0, 1751, 8942, 1, 0, 0, 0, 1753, 8951, 1, 0, + 0, 0, 1755, 8958, 1, 0, 0, 0, 1757, 8961, 1, 0, 0, 0, 1759, 8969, 1, 0, + 0, 0, 1761, 8972, 1, 0, 0, 0, 1763, 8975, 1, 0, 0, 0, 1765, 8978, 1, 0, + 0, 0, 1767, 8986, 1, 0, 0, 0, 1769, 8989, 1, 0, 0, 0, 1771, 8992, 1, 0, + 0, 0, 1773, 8994, 1, 0, 0, 0, 1775, 9028, 1, 0, 0, 0, 1777, 9031, 1, 0, + 0, 0, 1779, 9035, 1, 0, 0, 0, 1781, 9043, 1, 0, 0, 0, 1783, 9058, 1, 0, + 0, 0, 1785, 9067, 1, 0, 0, 0, 1787, 9071, 1, 0, 0, 0, 1789, 9082, 1, 0, + 0, 0, 1791, 9121, 1, 0, 0, 0, 1793, 9172, 1, 0, 0, 0, 1795, 9196, 1, 0, + 0, 0, 1797, 9199, 1, 0, 0, 0, 1799, 9201, 1, 0, 0, 0, 1801, 9206, 1, 0, + 0, 0, 1803, 9237, 1, 0, 0, 0, 1805, 9240, 1, 0, 0, 0, 1807, 9245, 1, 0, + 0, 0, 1809, 9258, 1, 0, 0, 0, 1811, 9261, 1, 0, 0, 0, 1813, 9266, 1, 0, + 0, 0, 1815, 9272, 1, 0, 0, 0, 1817, 9277, 1, 0, 0, 0, 1819, 9282, 1, 0, + 0, 0, 1821, 9287, 1, 0, 0, 0, 1823, 9292, 1, 0, 0, 0, 1825, 9309, 1, 0, + 0, 0, 1827, 9311, 1, 0, 0, 0, 1829, 1830, 5, 36, 0, 0, 1830, 6, 1, 0, 0, + 0, 1831, 1832, 5, 40, 0, 0, 1832, 8, 1, 0, 0, 0, 1833, 1834, 5, 41, 0, + 0, 1834, 10, 1, 0, 0, 0, 1835, 1836, 5, 91, 0, 0, 1836, 12, 1, 0, 0, 0, + 1837, 1838, 5, 93, 0, 0, 1838, 14, 1, 0, 0, 0, 1839, 1840, 5, 44, 0, 0, + 1840, 16, 1, 0, 0, 0, 1841, 1842, 5, 59, 0, 0, 1842, 18, 1, 0, 0, 0, 1843, + 1844, 5, 58, 0, 0, 1844, 20, 1, 0, 0, 0, 1845, 1846, 5, 42, 0, 0, 1846, + 22, 1, 0, 0, 0, 1847, 1848, 5, 61, 0, 0, 1848, 24, 1, 0, 0, 0, 1849, 1850, + 5, 46, 0, 0, 1850, 26, 1, 0, 0, 0, 1851, 1852, 5, 43, 0, 0, 1852, 28, 1, + 0, 0, 0, 1853, 1854, 5, 45, 0, 0, 1854, 30, 1, 0, 0, 0, 1855, 1856, 5, + 47, 0, 0, 1856, 32, 1, 0, 0, 0, 1857, 1858, 5, 94, 0, 0, 1858, 34, 1, 0, + 0, 0, 1859, 1860, 5, 60, 0, 0, 1860, 36, 1, 0, 0, 0, 1861, 1862, 5, 62, + 0, 0, 1862, 38, 1, 0, 0, 0, 1863, 1864, 5, 60, 0, 0, 1864, 1865, 5, 60, + 0, 0, 1865, 40, 1, 0, 0, 0, 1866, 1867, 5, 62, 0, 0, 1867, 1868, 5, 62, + 0, 0, 1868, 42, 1, 0, 0, 0, 1869, 1870, 5, 58, 0, 0, 1870, 1871, 5, 61, + 0, 0, 1871, 44, 1, 0, 0, 0, 1872, 1873, 5, 60, 0, 0, 1873, 1874, 5, 61, + 0, 0, 1874, 46, 1, 0, 0, 0, 1875, 1876, 5, 61, 0, 0, 1876, 1877, 5, 62, + 0, 0, 1877, 48, 1, 0, 0, 0, 1878, 1879, 5, 62, 0, 0, 1879, 1880, 5, 61, + 0, 0, 1880, 50, 1, 0, 0, 0, 1881, 1882, 5, 46, 0, 0, 1882, 1883, 5, 46, + 0, 0, 1883, 52, 1, 0, 0, 0, 1884, 1885, 5, 60, 0, 0, 1885, 1886, 5, 62, + 0, 0, 1886, 54, 1, 0, 0, 0, 1887, 1888, 5, 58, 0, 0, 1888, 1889, 5, 58, + 0, 0, 1889, 56, 1, 0, 0, 0, 1890, 1891, 5, 37, 0, 0, 1891, 58, 1, 0, 0, + 0, 1892, 1894, 5, 36, 0, 0, 1893, 1895, 7, 0, 0, 0, 1894, 1893, 1, 0, 0, + 0, 1895, 1896, 1, 0, 0, 0, 1896, 1894, 1, 0, 0, 0, 1896, 1897, 1, 0, 0, + 0, 1897, 60, 1, 0, 0, 0, 1898, 1914, 3, 65, 30, 0, 1899, 1903, 5, 43, 0, + 0, 1900, 1901, 5, 45, 0, 0, 1901, 1903, 4, 28, 0, 0, 1902, 1899, 1, 0, + 0, 0, 1902, 1900, 1, 0, 0, 0, 1903, 1904, 1, 0, 0, 0, 1904, 1902, 1, 0, + 0, 0, 1904, 1905, 1, 0, 0, 0, 1905, 1909, 1, 0, 0, 0, 1906, 1910, 3, 65, + 30, 0, 1907, 1908, 5, 47, 0, 0, 1908, 1910, 4, 28, 1, 0, 1909, 1906, 1, + 0, 0, 0, 1909, 1907, 1, 0, 0, 0, 1910, 1914, 1, 0, 0, 0, 1911, 1912, 5, + 47, 0, 0, 1912, 1914, 4, 28, 2, 0, 1913, 1898, 1, 0, 0, 0, 1913, 1902, + 1, 0, 0, 0, 1913, 1911, 1, 0, 0, 0, 1914, 1915, 1, 0, 0, 0, 1915, 1913, + 1, 0, 0, 0, 1915, 1916, 1, 0, 0, 0, 1916, 1919, 1, 0, 0, 0, 1917, 1919, + 7, 1, 0, 0, 1918, 1913, 1, 0, 0, 0, 1918, 1917, 1, 0, 0, 0, 1919, 1920, + 1, 0, 0, 0, 1920, 1921, 6, 28, 0, 0, 1921, 62, 1, 0, 0, 0, 1922, 1928, + 3, 67, 31, 0, 1923, 1924, 5, 45, 0, 0, 1924, 1928, 4, 29, 3, 0, 1925, 1926, + 5, 47, 0, 0, 1926, 1928, 4, 29, 4, 0, 1927, 1922, 1, 0, 0, 0, 1927, 1923, + 1, 0, 0, 0, 1927, 1925, 1, 0, 0, 0, 1928, 1931, 1, 0, 0, 0, 1929, 1927, + 1, 0, 0, 0, 1929, 1930, 1, 0, 0, 0, 1930, 1932, 1, 0, 0, 0, 1931, 1929, + 1, 0, 0, 0, 1932, 1934, 3, 69, 32, 0, 1933, 1935, 3, 61, 28, 0, 1934, 1933, + 1, 0, 0, 0, 1934, 1935, 1, 0, 0, 0, 1935, 1939, 1, 0, 0, 0, 1936, 1940, + 5, 43, 0, 0, 1937, 1938, 5, 45, 0, 0, 1938, 1940, 4, 29, 5, 0, 1939, 1936, + 1, 0, 0, 0, 1939, 1937, 1, 0, 0, 0, 1940, 1941, 1, 0, 0, 0, 1941, 1939, + 1, 0, 0, 0, 1941, 1942, 1, 0, 0, 0, 1942, 1943, 1, 0, 0, 0, 1943, 1944, + 6, 29, 1, 0, 1944, 64, 1, 0, 0, 0, 1945, 1946, 7, 2, 0, 0, 1946, 66, 1, + 0, 0, 0, 1947, 1948, 7, 3, 0, 0, 1948, 68, 1, 0, 0, 0, 1949, 1950, 7, 4, + 0, 0, 1950, 70, 1, 0, 0, 0, 1951, 1952, 7, 5, 0, 0, 1952, 1953, 7, 6, 0, + 0, 1953, 1954, 7, 6, 0, 0, 1954, 72, 1, 0, 0, 0, 1955, 1956, 7, 5, 0, 0, + 1956, 1957, 7, 7, 0, 0, 1957, 1958, 7, 5, 0, 0, 1958, 1959, 7, 6, 0, 0, + 1959, 1960, 7, 8, 0, 0, 1960, 1961, 7, 9, 0, 0, 1961, 1962, 7, 10, 0, 0, + 1962, 74, 1, 0, 0, 0, 1963, 1964, 7, 5, 0, 0, 1964, 1965, 7, 7, 0, 0, 1965, + 1966, 7, 5, 0, 0, 1966, 1967, 7, 6, 0, 0, 1967, 1968, 7, 8, 0, 0, 1968, + 1969, 7, 11, 0, 0, 1969, 1970, 7, 10, 0, 0, 1970, 76, 1, 0, 0, 0, 1971, + 1972, 7, 5, 0, 0, 1972, 1973, 7, 7, 0, 0, 1973, 1974, 7, 12, 0, 0, 1974, + 78, 1, 0, 0, 0, 1975, 1976, 7, 5, 0, 0, 1976, 1977, 7, 7, 0, 0, 1977, 1978, + 7, 8, 0, 0, 1978, 80, 1, 0, 0, 0, 1979, 1980, 7, 5, 0, 0, 1980, 1981, 7, + 13, 0, 0, 1981, 1982, 7, 13, 0, 0, 1982, 1983, 7, 5, 0, 0, 1983, 1984, + 7, 8, 0, 0, 1984, 82, 1, 0, 0, 0, 1985, 1986, 7, 5, 0, 0, 1986, 1987, 7, + 9, 0, 0, 1987, 84, 1, 0, 0, 0, 1988, 1989, 7, 5, 0, 0, 1989, 1990, 7, 9, + 0, 0, 1990, 1991, 7, 14, 0, 0, 1991, 86, 1, 0, 0, 0, 1992, 1993, 7, 5, + 0, 0, 1993, 1994, 7, 9, 0, 0, 1994, 1995, 7, 8, 0, 0, 1995, 1996, 7, 15, + 0, 0, 1996, 1997, 7, 15, 0, 0, 1997, 1998, 7, 10, 0, 0, 1998, 1999, 7, + 16, 0, 0, 1999, 2000, 7, 13, 0, 0, 2000, 2001, 7, 17, 0, 0, 2001, 2002, + 7, 14, 0, 0, 2002, 88, 1, 0, 0, 0, 2003, 2004, 7, 18, 0, 0, 2004, 2005, + 7, 19, 0, 0, 2005, 2006, 7, 16, 0, 0, 2006, 2007, 7, 20, 0, 0, 2007, 90, + 1, 0, 0, 0, 2008, 2009, 7, 14, 0, 0, 2009, 2010, 7, 5, 0, 0, 2010, 2011, + 7, 9, 0, 0, 2011, 2012, 7, 10, 0, 0, 2012, 92, 1, 0, 0, 0, 2013, 2014, + 7, 14, 0, 0, 2014, 2015, 7, 5, 0, 0, 2015, 2016, 7, 9, 0, 0, 2016, 2017, + 7, 16, 0, 0, 2017, 94, 1, 0, 0, 0, 2018, 2019, 7, 14, 0, 0, 2019, 2020, + 7, 20, 0, 0, 2020, 2021, 7, 10, 0, 0, 2021, 2022, 7, 14, 0, 0, 2022, 2023, + 7, 21, 0, 0, 2023, 96, 1, 0, 0, 0, 2024, 2025, 7, 14, 0, 0, 2025, 2026, + 7, 19, 0, 0, 2026, 2027, 7, 6, 0, 0, 2027, 2028, 7, 6, 0, 0, 2028, 2029, + 7, 5, 0, 0, 2029, 2030, 7, 16, 0, 0, 2030, 2031, 7, 10, 0, 0, 2031, 98, + 1, 0, 0, 0, 2032, 2033, 7, 14, 0, 0, 2033, 2034, 7, 19, 0, 0, 2034, 2035, + 7, 6, 0, 0, 2035, 2036, 7, 22, 0, 0, 2036, 2037, 7, 15, 0, 0, 2037, 2038, + 7, 7, 0, 0, 2038, 100, 1, 0, 0, 0, 2039, 2040, 7, 14, 0, 0, 2040, 2041, + 7, 19, 0, 0, 2041, 2042, 7, 7, 0, 0, 2042, 2043, 7, 9, 0, 0, 2043, 2044, + 7, 16, 0, 0, 2044, 2045, 7, 13, 0, 0, 2045, 2046, 7, 5, 0, 0, 2046, 2047, + 7, 17, 0, 0, 2047, 2048, 7, 7, 0, 0, 2048, 2049, 7, 16, 0, 0, 2049, 102, + 1, 0, 0, 0, 2050, 2051, 7, 14, 0, 0, 2051, 2052, 7, 13, 0, 0, 2052, 2053, + 7, 10, 0, 0, 2053, 2054, 7, 5, 0, 0, 2054, 2055, 7, 16, 0, 0, 2055, 2056, + 7, 10, 0, 0, 2056, 104, 1, 0, 0, 0, 2057, 2058, 7, 14, 0, 0, 2058, 2059, + 7, 22, 0, 0, 2059, 2060, 7, 13, 0, 0, 2060, 2061, 7, 13, 0, 0, 2061, 2062, + 7, 10, 0, 0, 2062, 2063, 7, 7, 0, 0, 2063, 2064, 7, 16, 0, 0, 2064, 2065, + 5, 95, 0, 0, 2065, 2066, 7, 14, 0, 0, 2066, 2067, 7, 5, 0, 0, 2067, 2068, + 7, 16, 0, 0, 2068, 2069, 7, 5, 0, 0, 2069, 2070, 7, 6, 0, 0, 2070, 2071, + 7, 19, 0, 0, 2071, 2072, 7, 23, 0, 0, 2072, 106, 1, 0, 0, 0, 2073, 2074, + 7, 14, 0, 0, 2074, 2075, 7, 22, 0, 0, 2075, 2076, 7, 13, 0, 0, 2076, 2077, + 7, 13, 0, 0, 2077, 2078, 7, 10, 0, 0, 2078, 2079, 7, 7, 0, 0, 2079, 2080, + 7, 16, 0, 0, 2080, 2081, 5, 95, 0, 0, 2081, 2082, 7, 12, 0, 0, 2082, 2083, + 7, 5, 0, 0, 2083, 2084, 7, 16, 0, 0, 2084, 2085, 7, 10, 0, 0, 2085, 108, + 1, 0, 0, 0, 2086, 2087, 7, 14, 0, 0, 2087, 2088, 7, 22, 0, 0, 2088, 2089, + 7, 13, 0, 0, 2089, 2090, 7, 13, 0, 0, 2090, 2091, 7, 10, 0, 0, 2091, 2092, + 7, 7, 0, 0, 2092, 2093, 7, 16, 0, 0, 2093, 2094, 5, 95, 0, 0, 2094, 2095, + 7, 13, 0, 0, 2095, 2096, 7, 19, 0, 0, 2096, 2097, 7, 6, 0, 0, 2097, 2098, + 7, 10, 0, 0, 2098, 110, 1, 0, 0, 0, 2099, 2100, 7, 14, 0, 0, 2100, 2101, + 7, 22, 0, 0, 2101, 2102, 7, 13, 0, 0, 2102, 2103, 7, 13, 0, 0, 2103, 2104, + 7, 10, 0, 0, 2104, 2105, 7, 7, 0, 0, 2105, 2106, 7, 16, 0, 0, 2106, 2107, + 5, 95, 0, 0, 2107, 2108, 7, 16, 0, 0, 2108, 2109, 7, 17, 0, 0, 2109, 2110, + 7, 15, 0, 0, 2110, 2111, 7, 10, 0, 0, 2111, 112, 1, 0, 0, 0, 2112, 2113, + 7, 14, 0, 0, 2113, 2114, 7, 22, 0, 0, 2114, 2115, 7, 13, 0, 0, 2115, 2116, + 7, 13, 0, 0, 2116, 2117, 7, 10, 0, 0, 2117, 2118, 7, 7, 0, 0, 2118, 2119, + 7, 16, 0, 0, 2119, 2120, 5, 95, 0, 0, 2120, 2121, 7, 16, 0, 0, 2121, 2122, + 7, 17, 0, 0, 2122, 2123, 7, 15, 0, 0, 2123, 2124, 7, 10, 0, 0, 2124, 2125, + 7, 9, 0, 0, 2125, 2126, 7, 16, 0, 0, 2126, 2127, 7, 5, 0, 0, 2127, 2128, + 7, 15, 0, 0, 2128, 2129, 7, 24, 0, 0, 2129, 114, 1, 0, 0, 0, 2130, 2131, + 7, 14, 0, 0, 2131, 2132, 7, 22, 0, 0, 2132, 2133, 7, 13, 0, 0, 2133, 2134, + 7, 13, 0, 0, 2134, 2135, 7, 10, 0, 0, 2135, 2136, 7, 7, 0, 0, 2136, 2137, + 7, 16, 0, 0, 2137, 2138, 5, 95, 0, 0, 2138, 2139, 7, 22, 0, 0, 2139, 2140, + 7, 9, 0, 0, 2140, 2141, 7, 10, 0, 0, 2141, 2142, 7, 13, 0, 0, 2142, 116, + 1, 0, 0, 0, 2143, 2144, 7, 12, 0, 0, 2144, 2145, 7, 10, 0, 0, 2145, 2146, + 7, 25, 0, 0, 2146, 2147, 7, 5, 0, 0, 2147, 2148, 7, 22, 0, 0, 2148, 2149, + 7, 6, 0, 0, 2149, 2150, 7, 16, 0, 0, 2150, 118, 1, 0, 0, 0, 2151, 2152, + 7, 12, 0, 0, 2152, 2153, 7, 10, 0, 0, 2153, 2154, 7, 25, 0, 0, 2154, 2155, + 7, 10, 0, 0, 2155, 2156, 7, 13, 0, 0, 2156, 2157, 7, 13, 0, 0, 2157, 2158, + 7, 5, 0, 0, 2158, 2159, 7, 18, 0, 0, 2159, 2160, 7, 6, 0, 0, 2160, 2161, + 7, 10, 0, 0, 2161, 120, 1, 0, 0, 0, 2162, 2163, 7, 12, 0, 0, 2163, 2164, + 7, 10, 0, 0, 2164, 2165, 7, 9, 0, 0, 2165, 2166, 7, 14, 0, 0, 2166, 122, + 1, 0, 0, 0, 2167, 2168, 7, 12, 0, 0, 2168, 2169, 7, 17, 0, 0, 2169, 2170, + 7, 9, 0, 0, 2170, 2171, 7, 16, 0, 0, 2171, 2172, 7, 17, 0, 0, 2172, 2173, + 7, 7, 0, 0, 2173, 2174, 7, 14, 0, 0, 2174, 2175, 7, 16, 0, 0, 2175, 124, + 1, 0, 0, 0, 2176, 2177, 7, 12, 0, 0, 2177, 2178, 7, 19, 0, 0, 2178, 126, + 1, 0, 0, 0, 2179, 2180, 7, 10, 0, 0, 2180, 2181, 7, 6, 0, 0, 2181, 2182, + 7, 9, 0, 0, 2182, 2183, 7, 10, 0, 0, 2183, 128, 1, 0, 0, 0, 2184, 2185, + 7, 10, 0, 0, 2185, 2186, 7, 26, 0, 0, 2186, 2187, 7, 14, 0, 0, 2187, 2188, + 7, 10, 0, 0, 2188, 2189, 7, 24, 0, 0, 2189, 2190, 7, 16, 0, 0, 2190, 130, + 1, 0, 0, 0, 2191, 2192, 7, 25, 0, 0, 2192, 2193, 7, 5, 0, 0, 2193, 2194, + 7, 6, 0, 0, 2194, 2195, 7, 9, 0, 0, 2195, 2196, 7, 10, 0, 0, 2196, 132, + 1, 0, 0, 0, 2197, 2198, 7, 25, 0, 0, 2198, 2199, 7, 10, 0, 0, 2199, 2200, + 7, 16, 0, 0, 2200, 2201, 7, 14, 0, 0, 2201, 2202, 7, 20, 0, 0, 2202, 134, + 1, 0, 0, 0, 2203, 2204, 7, 25, 0, 0, 2204, 2205, 7, 19, 0, 0, 2205, 2206, + 7, 13, 0, 0, 2206, 136, 1, 0, 0, 0, 2207, 2208, 7, 25, 0, 0, 2208, 2209, + 7, 19, 0, 0, 2209, 2210, 7, 13, 0, 0, 2210, 2211, 7, 10, 0, 0, 2211, 2212, + 7, 17, 0, 0, 2212, 2213, 7, 23, 0, 0, 2213, 2214, 7, 7, 0, 0, 2214, 138, + 1, 0, 0, 0, 2215, 2216, 7, 25, 0, 0, 2216, 2217, 7, 13, 0, 0, 2217, 2218, + 7, 19, 0, 0, 2218, 2219, 7, 15, 0, 0, 2219, 140, 1, 0, 0, 0, 2220, 2221, + 7, 23, 0, 0, 2221, 2222, 7, 13, 0, 0, 2222, 2223, 7, 5, 0, 0, 2223, 2224, + 7, 7, 0, 0, 2224, 2225, 7, 16, 0, 0, 2225, 142, 1, 0, 0, 0, 2226, 2227, + 7, 23, 0, 0, 2227, 2228, 7, 13, 0, 0, 2228, 2229, 7, 19, 0, 0, 2229, 2230, + 7, 22, 0, 0, 2230, 2231, 7, 24, 0, 0, 2231, 144, 1, 0, 0, 0, 2232, 2233, + 7, 20, 0, 0, 2233, 2234, 7, 5, 0, 0, 2234, 2235, 7, 27, 0, 0, 2235, 2236, + 7, 17, 0, 0, 2236, 2237, 7, 7, 0, 0, 2237, 2238, 7, 23, 0, 0, 2238, 146, + 1, 0, 0, 0, 2239, 2240, 7, 17, 0, 0, 2240, 2241, 7, 7, 0, 0, 2241, 148, + 1, 0, 0, 0, 2242, 2243, 7, 17, 0, 0, 2243, 2244, 7, 7, 0, 0, 2244, 2245, + 7, 17, 0, 0, 2245, 2246, 7, 16, 0, 0, 2246, 2247, 7, 17, 0, 0, 2247, 2248, + 7, 5, 0, 0, 2248, 2249, 7, 6, 0, 0, 2249, 2250, 7, 6, 0, 0, 2250, 2251, + 7, 8, 0, 0, 2251, 150, 1, 0, 0, 0, 2252, 2253, 7, 17, 0, 0, 2253, 2254, + 7, 7, 0, 0, 2254, 2255, 7, 16, 0, 0, 2255, 2256, 7, 10, 0, 0, 2256, 2257, + 7, 13, 0, 0, 2257, 2258, 7, 9, 0, 0, 2258, 2259, 7, 10, 0, 0, 2259, 2260, + 7, 14, 0, 0, 2260, 2261, 7, 16, 0, 0, 2261, 152, 1, 0, 0, 0, 2262, 2263, + 7, 17, 0, 0, 2263, 2264, 7, 7, 0, 0, 2264, 2265, 7, 16, 0, 0, 2265, 2266, + 7, 19, 0, 0, 2266, 154, 1, 0, 0, 0, 2267, 2268, 7, 6, 0, 0, 2268, 2269, + 7, 5, 0, 0, 2269, 2270, 7, 16, 0, 0, 2270, 2271, 7, 10, 0, 0, 2271, 2272, + 7, 13, 0, 0, 2272, 2273, 7, 5, 0, 0, 2273, 2274, 7, 6, 0, 0, 2274, 156, + 1, 0, 0, 0, 2275, 2276, 7, 6, 0, 0, 2276, 2277, 7, 10, 0, 0, 2277, 2278, + 7, 5, 0, 0, 2278, 2279, 7, 12, 0, 0, 2279, 2280, 7, 17, 0, 0, 2280, 2281, + 7, 7, 0, 0, 2281, 2282, 7, 23, 0, 0, 2282, 158, 1, 0, 0, 0, 2283, 2284, + 7, 6, 0, 0, 2284, 2285, 7, 17, 0, 0, 2285, 2286, 7, 15, 0, 0, 2286, 2287, + 7, 17, 0, 0, 2287, 2288, 7, 16, 0, 0, 2288, 160, 1, 0, 0, 0, 2289, 2290, + 7, 6, 0, 0, 2290, 2291, 7, 19, 0, 0, 2291, 2292, 7, 14, 0, 0, 2292, 2293, + 7, 5, 0, 0, 2293, 2294, 7, 6, 0, 0, 2294, 2295, 7, 16, 0, 0, 2295, 2296, + 7, 17, 0, 0, 2296, 2297, 7, 15, 0, 0, 2297, 2298, 7, 10, 0, 0, 2298, 162, + 1, 0, 0, 0, 2299, 2300, 7, 6, 0, 0, 2300, 2301, 7, 19, 0, 0, 2301, 2302, + 7, 14, 0, 0, 2302, 2303, 7, 5, 0, 0, 2303, 2304, 7, 6, 0, 0, 2304, 2305, + 7, 16, 0, 0, 2305, 2306, 7, 17, 0, 0, 2306, 2307, 7, 15, 0, 0, 2307, 2308, + 7, 10, 0, 0, 2308, 2309, 7, 9, 0, 0, 2309, 2310, 7, 16, 0, 0, 2310, 2311, + 7, 5, 0, 0, 2311, 2312, 7, 15, 0, 0, 2312, 2313, 7, 24, 0, 0, 2313, 164, + 1, 0, 0, 0, 2314, 2315, 7, 7, 0, 0, 2315, 2316, 7, 19, 0, 0, 2316, 2317, + 7, 16, 0, 0, 2317, 166, 1, 0, 0, 0, 2318, 2319, 7, 7, 0, 0, 2319, 2320, + 7, 22, 0, 0, 2320, 2321, 7, 6, 0, 0, 2321, 2322, 7, 6, 0, 0, 2322, 168, + 1, 0, 0, 0, 2323, 2324, 7, 19, 0, 0, 2324, 2325, 7, 25, 0, 0, 2325, 2326, + 7, 25, 0, 0, 2326, 2327, 7, 9, 0, 0, 2327, 2328, 7, 10, 0, 0, 2328, 2329, + 7, 16, 0, 0, 2329, 170, 1, 0, 0, 0, 2330, 2331, 7, 19, 0, 0, 2331, 2332, + 7, 7, 0, 0, 2332, 172, 1, 0, 0, 0, 2333, 2334, 7, 19, 0, 0, 2334, 2335, + 7, 7, 0, 0, 2335, 2336, 7, 6, 0, 0, 2336, 2337, 7, 8, 0, 0, 2337, 174, + 1, 0, 0, 0, 2338, 2339, 7, 19, 0, 0, 2339, 2340, 7, 13, 0, 0, 2340, 176, + 1, 0, 0, 0, 2341, 2342, 7, 19, 0, 0, 2342, 2343, 7, 13, 0, 0, 2343, 2344, + 7, 12, 0, 0, 2344, 2345, 7, 10, 0, 0, 2345, 2346, 7, 13, 0, 0, 2346, 178, + 1, 0, 0, 0, 2347, 2348, 7, 24, 0, 0, 2348, 2349, 7, 6, 0, 0, 2349, 2350, + 7, 5, 0, 0, 2350, 2351, 7, 14, 0, 0, 2351, 2352, 7, 17, 0, 0, 2352, 2353, + 7, 7, 0, 0, 2353, 2354, 7, 23, 0, 0, 2354, 180, 1, 0, 0, 0, 2355, 2356, + 7, 24, 0, 0, 2356, 2357, 7, 13, 0, 0, 2357, 2358, 7, 17, 0, 0, 2358, 2359, + 7, 15, 0, 0, 2359, 2360, 7, 5, 0, 0, 2360, 2361, 7, 13, 0, 0, 2361, 2362, + 7, 8, 0, 0, 2362, 182, 1, 0, 0, 0, 2363, 2364, 7, 24, 0, 0, 2364, 2365, + 7, 22, 0, 0, 2365, 2366, 7, 18, 0, 0, 2366, 2367, 7, 6, 0, 0, 2367, 2368, + 7, 17, 0, 0, 2368, 2369, 7, 14, 0, 0, 2369, 184, 1, 0, 0, 0, 2370, 2371, + 7, 13, 0, 0, 2371, 2372, 7, 10, 0, 0, 2372, 2373, 7, 25, 0, 0, 2373, 2374, + 7, 10, 0, 0, 2374, 2375, 7, 13, 0, 0, 2375, 2376, 7, 10, 0, 0, 2376, 2377, + 7, 7, 0, 0, 2377, 2378, 7, 14, 0, 0, 2378, 2379, 7, 10, 0, 0, 2379, 2380, + 7, 9, 0, 0, 2380, 186, 1, 0, 0, 0, 2381, 2382, 7, 13, 0, 0, 2382, 2383, + 7, 10, 0, 0, 2383, 2384, 7, 16, 0, 0, 2384, 2385, 7, 22, 0, 0, 2385, 2386, + 7, 13, 0, 0, 2386, 2387, 7, 7, 0, 0, 2387, 2388, 7, 17, 0, 0, 2388, 2389, + 7, 7, 0, 0, 2389, 2390, 7, 23, 0, 0, 2390, 188, 1, 0, 0, 0, 2391, 2392, + 7, 9, 0, 0, 2392, 2393, 7, 10, 0, 0, 2393, 2394, 7, 6, 0, 0, 2394, 2395, + 7, 10, 0, 0, 2395, 2396, 7, 14, 0, 0, 2396, 2397, 7, 16, 0, 0, 2397, 190, + 1, 0, 0, 0, 2398, 2399, 7, 9, 0, 0, 2399, 2400, 7, 10, 0, 0, 2400, 2401, + 7, 9, 0, 0, 2401, 2402, 7, 9, 0, 0, 2402, 2403, 7, 17, 0, 0, 2403, 2404, + 7, 19, 0, 0, 2404, 2405, 7, 7, 0, 0, 2405, 2406, 5, 95, 0, 0, 2406, 2407, + 7, 22, 0, 0, 2407, 2408, 7, 9, 0, 0, 2408, 2409, 7, 10, 0, 0, 2409, 2410, + 7, 13, 0, 0, 2410, 192, 1, 0, 0, 0, 2411, 2412, 7, 9, 0, 0, 2412, 2413, + 7, 19, 0, 0, 2413, 2414, 7, 15, 0, 0, 2414, 2415, 7, 10, 0, 0, 2415, 194, + 1, 0, 0, 0, 2416, 2417, 7, 9, 0, 0, 2417, 2418, 7, 8, 0, 0, 2418, 2419, + 7, 15, 0, 0, 2419, 2420, 7, 15, 0, 0, 2420, 2421, 7, 10, 0, 0, 2421, 2422, + 7, 16, 0, 0, 2422, 2423, 7, 13, 0, 0, 2423, 2424, 7, 17, 0, 0, 2424, 2425, + 7, 14, 0, 0, 2425, 196, 1, 0, 0, 0, 2426, 2427, 7, 16, 0, 0, 2427, 2428, + 7, 5, 0, 0, 2428, 2429, 7, 18, 0, 0, 2429, 2430, 7, 6, 0, 0, 2430, 2431, + 7, 10, 0, 0, 2431, 198, 1, 0, 0, 0, 2432, 2433, 7, 16, 0, 0, 2433, 2434, + 7, 20, 0, 0, 2434, 2435, 7, 10, 0, 0, 2435, 2436, 7, 7, 0, 0, 2436, 200, + 1, 0, 0, 0, 2437, 2438, 7, 16, 0, 0, 2438, 2439, 7, 19, 0, 0, 2439, 202, + 1, 0, 0, 0, 2440, 2441, 7, 16, 0, 0, 2441, 2442, 7, 13, 0, 0, 2442, 2443, + 7, 5, 0, 0, 2443, 2444, 7, 17, 0, 0, 2444, 2445, 7, 6, 0, 0, 2445, 2446, + 7, 17, 0, 0, 2446, 2447, 7, 7, 0, 0, 2447, 2448, 7, 23, 0, 0, 2448, 204, + 1, 0, 0, 0, 2449, 2450, 7, 16, 0, 0, 2450, 2451, 7, 13, 0, 0, 2451, 2452, + 7, 22, 0, 0, 2452, 2453, 7, 10, 0, 0, 2453, 206, 1, 0, 0, 0, 2454, 2455, + 7, 22, 0, 0, 2455, 2456, 7, 7, 0, 0, 2456, 2457, 7, 17, 0, 0, 2457, 2458, + 7, 19, 0, 0, 2458, 2459, 7, 7, 0, 0, 2459, 208, 1, 0, 0, 0, 2460, 2461, + 7, 22, 0, 0, 2461, 2462, 7, 7, 0, 0, 2462, 2463, 7, 17, 0, 0, 2463, 2464, + 7, 28, 0, 0, 2464, 2465, 7, 22, 0, 0, 2465, 2466, 7, 10, 0, 0, 2466, 210, + 1, 0, 0, 0, 2467, 2468, 7, 22, 0, 0, 2468, 2469, 7, 9, 0, 0, 2469, 2470, + 7, 10, 0, 0, 2470, 2471, 7, 13, 0, 0, 2471, 212, 1, 0, 0, 0, 2472, 2473, + 7, 22, 0, 0, 2473, 2474, 7, 9, 0, 0, 2474, 2475, 7, 17, 0, 0, 2475, 2476, + 7, 7, 0, 0, 2476, 2477, 7, 23, 0, 0, 2477, 214, 1, 0, 0, 0, 2478, 2479, + 7, 27, 0, 0, 2479, 2480, 7, 5, 0, 0, 2480, 2481, 7, 13, 0, 0, 2481, 2482, + 7, 17, 0, 0, 2482, 2483, 7, 5, 0, 0, 2483, 2484, 7, 12, 0, 0, 2484, 2485, + 7, 17, 0, 0, 2485, 2486, 7, 14, 0, 0, 2486, 216, 1, 0, 0, 0, 2487, 2488, + 7, 29, 0, 0, 2488, 2489, 7, 20, 0, 0, 2489, 2490, 7, 10, 0, 0, 2490, 2491, + 7, 7, 0, 0, 2491, 218, 1, 0, 0, 0, 2492, 2493, 7, 29, 0, 0, 2493, 2494, + 7, 20, 0, 0, 2494, 2495, 7, 10, 0, 0, 2495, 2496, 7, 13, 0, 0, 2496, 2497, + 7, 10, 0, 0, 2497, 220, 1, 0, 0, 0, 2498, 2499, 7, 29, 0, 0, 2499, 2500, + 7, 17, 0, 0, 2500, 2501, 7, 7, 0, 0, 2501, 2502, 7, 12, 0, 0, 2502, 2503, + 7, 19, 0, 0, 2503, 2504, 7, 29, 0, 0, 2504, 222, 1, 0, 0, 0, 2505, 2506, + 7, 29, 0, 0, 2506, 2507, 7, 17, 0, 0, 2507, 2508, 7, 16, 0, 0, 2508, 2509, + 7, 20, 0, 0, 2509, 224, 1, 0, 0, 0, 2510, 2511, 7, 5, 0, 0, 2511, 2512, + 7, 22, 0, 0, 2512, 2513, 7, 16, 0, 0, 2513, 2514, 7, 20, 0, 0, 2514, 2515, + 7, 19, 0, 0, 2515, 2516, 7, 13, 0, 0, 2516, 2517, 7, 17, 0, 0, 2517, 2518, + 7, 11, 0, 0, 2518, 2519, 7, 5, 0, 0, 2519, 2520, 7, 16, 0, 0, 2520, 2521, + 7, 17, 0, 0, 2521, 2522, 7, 19, 0, 0, 2522, 2523, 7, 7, 0, 0, 2523, 226, + 1, 0, 0, 0, 2524, 2525, 7, 18, 0, 0, 2525, 2526, 7, 17, 0, 0, 2526, 2527, + 7, 7, 0, 0, 2527, 2528, 7, 5, 0, 0, 2528, 2529, 7, 13, 0, 0, 2529, 2530, + 7, 8, 0, 0, 2530, 228, 1, 0, 0, 0, 2531, 2532, 7, 18, 0, 0, 2532, 2533, + 7, 17, 0, 0, 2533, 2534, 7, 7, 0, 0, 2534, 2535, 7, 12, 0, 0, 2535, 2536, + 7, 17, 0, 0, 2536, 2537, 7, 7, 0, 0, 2537, 2538, 7, 23, 0, 0, 2538, 230, + 1, 0, 0, 0, 2539, 2540, 7, 14, 0, 0, 2540, 2541, 7, 19, 0, 0, 2541, 2542, + 7, 6, 0, 0, 2542, 2543, 7, 6, 0, 0, 2543, 2544, 7, 5, 0, 0, 2544, 2545, + 7, 16, 0, 0, 2545, 2546, 7, 17, 0, 0, 2546, 2547, 7, 19, 0, 0, 2547, 2548, + 7, 7, 0, 0, 2548, 232, 1, 0, 0, 0, 2549, 2550, 7, 14, 0, 0, 2550, 2551, + 7, 19, 0, 0, 2551, 2552, 7, 7, 0, 0, 2552, 2553, 7, 14, 0, 0, 2553, 2554, + 7, 22, 0, 0, 2554, 2555, 7, 13, 0, 0, 2555, 2556, 7, 13, 0, 0, 2556, 2557, + 7, 10, 0, 0, 2557, 2558, 7, 7, 0, 0, 2558, 2559, 7, 16, 0, 0, 2559, 2560, + 7, 6, 0, 0, 2560, 2561, 7, 8, 0, 0, 2561, 234, 1, 0, 0, 0, 2562, 2563, + 7, 14, 0, 0, 2563, 2564, 7, 13, 0, 0, 2564, 2565, 7, 19, 0, 0, 2565, 2566, + 7, 9, 0, 0, 2566, 2567, 7, 9, 0, 0, 2567, 236, 1, 0, 0, 0, 2568, 2569, + 7, 14, 0, 0, 2569, 2570, 7, 22, 0, 0, 2570, 2571, 7, 13, 0, 0, 2571, 2572, + 7, 13, 0, 0, 2572, 2573, 7, 10, 0, 0, 2573, 2574, 7, 7, 0, 0, 2574, 2575, + 7, 16, 0, 0, 2575, 2576, 5, 95, 0, 0, 2576, 2577, 7, 9, 0, 0, 2577, 2578, + 7, 14, 0, 0, 2578, 2579, 7, 20, 0, 0, 2579, 2580, 7, 10, 0, 0, 2580, 2581, + 7, 15, 0, 0, 2581, 2582, 7, 5, 0, 0, 2582, 238, 1, 0, 0, 0, 2583, 2584, + 7, 25, 0, 0, 2584, 2585, 7, 13, 0, 0, 2585, 2586, 7, 10, 0, 0, 2586, 2587, + 7, 10, 0, 0, 2587, 2588, 7, 11, 0, 0, 2588, 2589, 7, 10, 0, 0, 2589, 240, + 1, 0, 0, 0, 2590, 2591, 7, 25, 0, 0, 2591, 2592, 7, 22, 0, 0, 2592, 2593, + 7, 6, 0, 0, 2593, 2594, 7, 6, 0, 0, 2594, 242, 1, 0, 0, 0, 2595, 2596, + 7, 17, 0, 0, 2596, 2597, 7, 6, 0, 0, 2597, 2598, 7, 17, 0, 0, 2598, 2599, + 7, 21, 0, 0, 2599, 2600, 7, 10, 0, 0, 2600, 244, 1, 0, 0, 0, 2601, 2602, + 7, 17, 0, 0, 2602, 2603, 7, 7, 0, 0, 2603, 2604, 7, 7, 0, 0, 2604, 2605, + 7, 10, 0, 0, 2605, 2606, 7, 13, 0, 0, 2606, 246, 1, 0, 0, 0, 2607, 2608, + 7, 17, 0, 0, 2608, 2609, 7, 9, 0, 0, 2609, 248, 1, 0, 0, 0, 2610, 2611, + 7, 17, 0, 0, 2611, 2612, 7, 9, 0, 0, 2612, 2613, 7, 7, 0, 0, 2613, 2614, + 7, 22, 0, 0, 2614, 2615, 7, 6, 0, 0, 2615, 2616, 7, 6, 0, 0, 2616, 250, + 1, 0, 0, 0, 2617, 2618, 7, 30, 0, 0, 2618, 2619, 7, 19, 0, 0, 2619, 2620, + 7, 17, 0, 0, 2620, 2621, 7, 7, 0, 0, 2621, 252, 1, 0, 0, 0, 2622, 2623, + 7, 6, 0, 0, 2623, 2624, 7, 10, 0, 0, 2624, 2625, 7, 25, 0, 0, 2625, 2626, + 7, 16, 0, 0, 2626, 254, 1, 0, 0, 0, 2627, 2628, 7, 6, 0, 0, 2628, 2629, + 7, 17, 0, 0, 2629, 2630, 7, 21, 0, 0, 2630, 2631, 7, 10, 0, 0, 2631, 256, + 1, 0, 0, 0, 2632, 2633, 7, 7, 0, 0, 2633, 2634, 7, 5, 0, 0, 2634, 2635, + 7, 16, 0, 0, 2635, 2636, 7, 22, 0, 0, 2636, 2637, 7, 13, 0, 0, 2637, 2638, + 7, 5, 0, 0, 2638, 2639, 7, 6, 0, 0, 2639, 258, 1, 0, 0, 0, 2640, 2641, + 7, 7, 0, 0, 2641, 2642, 7, 19, 0, 0, 2642, 2643, 7, 16, 0, 0, 2643, 2644, + 7, 7, 0, 0, 2644, 2645, 7, 22, 0, 0, 2645, 2646, 7, 6, 0, 0, 2646, 2647, + 7, 6, 0, 0, 2647, 260, 1, 0, 0, 0, 2648, 2649, 7, 19, 0, 0, 2649, 2650, + 7, 22, 0, 0, 2650, 2651, 7, 16, 0, 0, 2651, 2652, 7, 10, 0, 0, 2652, 2653, + 7, 13, 0, 0, 2653, 262, 1, 0, 0, 0, 2654, 2655, 7, 19, 0, 0, 2655, 2656, + 7, 27, 0, 0, 2656, 2657, 7, 10, 0, 0, 2657, 2658, 7, 13, 0, 0, 2658, 264, + 1, 0, 0, 0, 2659, 2660, 7, 19, 0, 0, 2660, 2661, 7, 27, 0, 0, 2661, 2662, + 7, 10, 0, 0, 2662, 2663, 7, 13, 0, 0, 2663, 2664, 7, 6, 0, 0, 2664, 2665, + 7, 5, 0, 0, 2665, 2666, 7, 24, 0, 0, 2666, 2667, 7, 9, 0, 0, 2667, 266, + 1, 0, 0, 0, 2668, 2669, 7, 13, 0, 0, 2669, 2670, 7, 17, 0, 0, 2670, 2671, + 7, 23, 0, 0, 2671, 2672, 7, 20, 0, 0, 2672, 2673, 7, 16, 0, 0, 2673, 268, + 1, 0, 0, 0, 2674, 2675, 7, 9, 0, 0, 2675, 2676, 7, 17, 0, 0, 2676, 2677, + 7, 15, 0, 0, 2677, 2678, 7, 17, 0, 0, 2678, 2679, 7, 6, 0, 0, 2679, 2680, + 7, 5, 0, 0, 2680, 2681, 7, 13, 0, 0, 2681, 270, 1, 0, 0, 0, 2682, 2683, + 7, 27, 0, 0, 2683, 2684, 7, 10, 0, 0, 2684, 2685, 7, 13, 0, 0, 2685, 2686, + 7, 18, 0, 0, 2686, 2687, 7, 19, 0, 0, 2687, 2688, 7, 9, 0, 0, 2688, 2689, + 7, 10, 0, 0, 2689, 272, 1, 0, 0, 0, 2690, 2691, 7, 5, 0, 0, 2691, 2692, + 7, 18, 0, 0, 2692, 2693, 7, 19, 0, 0, 2693, 2694, 7, 13, 0, 0, 2694, 2695, + 7, 16, 0, 0, 2695, 274, 1, 0, 0, 0, 2696, 2697, 7, 5, 0, 0, 2697, 2698, + 7, 18, 0, 0, 2698, 2699, 7, 9, 0, 0, 2699, 2700, 7, 19, 0, 0, 2700, 2701, + 7, 6, 0, 0, 2701, 2702, 7, 22, 0, 0, 2702, 2703, 7, 16, 0, 0, 2703, 2704, + 7, 10, 0, 0, 2704, 276, 1, 0, 0, 0, 2705, 2706, 7, 5, 0, 0, 2706, 2707, + 7, 14, 0, 0, 2707, 2708, 7, 14, 0, 0, 2708, 2709, 7, 10, 0, 0, 2709, 2710, + 7, 9, 0, 0, 2710, 2711, 7, 9, 0, 0, 2711, 278, 1, 0, 0, 0, 2712, 2713, + 7, 5, 0, 0, 2713, 2714, 7, 14, 0, 0, 2714, 2715, 7, 16, 0, 0, 2715, 2716, + 7, 17, 0, 0, 2716, 2717, 7, 19, 0, 0, 2717, 2718, 7, 7, 0, 0, 2718, 280, + 1, 0, 0, 0, 2719, 2720, 7, 5, 0, 0, 2720, 2721, 7, 12, 0, 0, 2721, 2722, + 7, 12, 0, 0, 2722, 282, 1, 0, 0, 0, 2723, 2724, 7, 5, 0, 0, 2724, 2725, + 7, 12, 0, 0, 2725, 2726, 7, 15, 0, 0, 2726, 2727, 7, 17, 0, 0, 2727, 2728, + 7, 7, 0, 0, 2728, 284, 1, 0, 0, 0, 2729, 2730, 7, 5, 0, 0, 2730, 2731, + 7, 25, 0, 0, 2731, 2732, 7, 16, 0, 0, 2732, 2733, 7, 10, 0, 0, 2733, 2734, + 7, 13, 0, 0, 2734, 286, 1, 0, 0, 0, 2735, 2736, 7, 5, 0, 0, 2736, 2737, + 7, 23, 0, 0, 2737, 2738, 7, 23, 0, 0, 2738, 2739, 7, 13, 0, 0, 2739, 2740, + 7, 10, 0, 0, 2740, 2741, 7, 23, 0, 0, 2741, 2742, 7, 5, 0, 0, 2742, 2743, + 7, 16, 0, 0, 2743, 2744, 7, 10, 0, 0, 2744, 288, 1, 0, 0, 0, 2745, 2746, + 7, 5, 0, 0, 2746, 2747, 7, 6, 0, 0, 2747, 2748, 7, 9, 0, 0, 2748, 2749, + 7, 19, 0, 0, 2749, 290, 1, 0, 0, 0, 2750, 2751, 7, 5, 0, 0, 2751, 2752, + 7, 6, 0, 0, 2752, 2753, 7, 16, 0, 0, 2753, 2754, 7, 10, 0, 0, 2754, 2755, + 7, 13, 0, 0, 2755, 292, 1, 0, 0, 0, 2756, 2757, 7, 5, 0, 0, 2757, 2758, + 7, 6, 0, 0, 2758, 2759, 7, 29, 0, 0, 2759, 2760, 7, 5, 0, 0, 2760, 2761, + 7, 8, 0, 0, 2761, 2762, 7, 9, 0, 0, 2762, 294, 1, 0, 0, 0, 2763, 2764, + 7, 5, 0, 0, 2764, 2765, 7, 9, 0, 0, 2765, 2766, 7, 9, 0, 0, 2766, 2767, + 7, 10, 0, 0, 2767, 2768, 7, 13, 0, 0, 2768, 2769, 7, 16, 0, 0, 2769, 2770, + 7, 17, 0, 0, 2770, 2771, 7, 19, 0, 0, 2771, 2772, 7, 7, 0, 0, 2772, 296, + 1, 0, 0, 0, 2773, 2774, 7, 5, 0, 0, 2774, 2775, 7, 9, 0, 0, 2775, 2776, + 7, 9, 0, 0, 2776, 2777, 7, 17, 0, 0, 2777, 2778, 7, 23, 0, 0, 2778, 2779, + 7, 7, 0, 0, 2779, 2780, 7, 15, 0, 0, 2780, 2781, 7, 10, 0, 0, 2781, 2782, + 7, 7, 0, 0, 2782, 2783, 7, 16, 0, 0, 2783, 298, 1, 0, 0, 0, 2784, 2785, + 7, 5, 0, 0, 2785, 2786, 7, 16, 0, 0, 2786, 300, 1, 0, 0, 0, 2787, 2788, + 7, 5, 0, 0, 2788, 2789, 7, 16, 0, 0, 2789, 2790, 7, 16, 0, 0, 2790, 2791, + 7, 13, 0, 0, 2791, 2792, 7, 17, 0, 0, 2792, 2793, 7, 18, 0, 0, 2793, 2794, + 7, 22, 0, 0, 2794, 2795, 7, 16, 0, 0, 2795, 2796, 7, 10, 0, 0, 2796, 302, + 1, 0, 0, 0, 2797, 2798, 7, 18, 0, 0, 2798, 2799, 7, 5, 0, 0, 2799, 2800, + 7, 14, 0, 0, 2800, 2801, 7, 21, 0, 0, 2801, 2802, 7, 29, 0, 0, 2802, 2803, + 7, 5, 0, 0, 2803, 2804, 7, 13, 0, 0, 2804, 2805, 7, 12, 0, 0, 2805, 304, + 1, 0, 0, 0, 2806, 2807, 7, 18, 0, 0, 2807, 2808, 7, 10, 0, 0, 2808, 2809, + 7, 25, 0, 0, 2809, 2810, 7, 19, 0, 0, 2810, 2811, 7, 13, 0, 0, 2811, 2812, + 7, 10, 0, 0, 2812, 306, 1, 0, 0, 0, 2813, 2814, 7, 18, 0, 0, 2814, 2815, + 7, 10, 0, 0, 2815, 2816, 7, 23, 0, 0, 2816, 2817, 7, 17, 0, 0, 2817, 2818, + 7, 7, 0, 0, 2818, 308, 1, 0, 0, 0, 2819, 2820, 7, 18, 0, 0, 2820, 2821, + 7, 8, 0, 0, 2821, 310, 1, 0, 0, 0, 2822, 2823, 7, 14, 0, 0, 2823, 2824, + 7, 5, 0, 0, 2824, 2825, 7, 14, 0, 0, 2825, 2826, 7, 20, 0, 0, 2826, 2827, + 7, 10, 0, 0, 2827, 312, 1, 0, 0, 0, 2828, 2829, 7, 14, 0, 0, 2829, 2830, + 7, 5, 0, 0, 2830, 2831, 7, 6, 0, 0, 2831, 2832, 7, 6, 0, 0, 2832, 2833, + 7, 10, 0, 0, 2833, 2834, 7, 12, 0, 0, 2834, 314, 1, 0, 0, 0, 2835, 2836, + 7, 14, 0, 0, 2836, 2837, 7, 5, 0, 0, 2837, 2838, 7, 9, 0, 0, 2838, 2839, + 7, 14, 0, 0, 2839, 2840, 7, 5, 0, 0, 2840, 2841, 7, 12, 0, 0, 2841, 2842, + 7, 10, 0, 0, 2842, 316, 1, 0, 0, 0, 2843, 2844, 7, 14, 0, 0, 2844, 2845, + 7, 5, 0, 0, 2845, 2846, 7, 9, 0, 0, 2846, 2847, 7, 14, 0, 0, 2847, 2848, + 7, 5, 0, 0, 2848, 2849, 7, 12, 0, 0, 2849, 2850, 7, 10, 0, 0, 2850, 2851, + 7, 12, 0, 0, 2851, 318, 1, 0, 0, 0, 2852, 2853, 7, 14, 0, 0, 2853, 2854, + 7, 5, 0, 0, 2854, 2855, 7, 16, 0, 0, 2855, 2856, 7, 5, 0, 0, 2856, 2857, + 7, 6, 0, 0, 2857, 2858, 7, 19, 0, 0, 2858, 2859, 7, 23, 0, 0, 2859, 320, + 1, 0, 0, 0, 2860, 2861, 7, 14, 0, 0, 2861, 2862, 7, 20, 0, 0, 2862, 2863, + 7, 5, 0, 0, 2863, 2864, 7, 17, 0, 0, 2864, 2865, 7, 7, 0, 0, 2865, 322, + 1, 0, 0, 0, 2866, 2867, 7, 14, 0, 0, 2867, 2868, 7, 20, 0, 0, 2868, 2869, + 7, 5, 0, 0, 2869, 2870, 7, 13, 0, 0, 2870, 2871, 7, 5, 0, 0, 2871, 2872, + 7, 14, 0, 0, 2872, 2873, 7, 16, 0, 0, 2873, 2874, 7, 10, 0, 0, 2874, 2875, + 7, 13, 0, 0, 2875, 2876, 7, 17, 0, 0, 2876, 2877, 7, 9, 0, 0, 2877, 2878, + 7, 16, 0, 0, 2878, 2879, 7, 17, 0, 0, 2879, 2880, 7, 14, 0, 0, 2880, 2881, + 7, 9, 0, 0, 2881, 324, 1, 0, 0, 0, 2882, 2883, 7, 14, 0, 0, 2883, 2884, + 7, 20, 0, 0, 2884, 2885, 7, 10, 0, 0, 2885, 2886, 7, 14, 0, 0, 2886, 2887, + 7, 21, 0, 0, 2887, 2888, 7, 24, 0, 0, 2888, 2889, 7, 19, 0, 0, 2889, 2890, + 7, 17, 0, 0, 2890, 2891, 7, 7, 0, 0, 2891, 2892, 7, 16, 0, 0, 2892, 326, + 1, 0, 0, 0, 2893, 2894, 7, 14, 0, 0, 2894, 2895, 7, 6, 0, 0, 2895, 2896, + 7, 5, 0, 0, 2896, 2897, 7, 9, 0, 0, 2897, 2898, 7, 9, 0, 0, 2898, 328, + 1, 0, 0, 0, 2899, 2900, 7, 14, 0, 0, 2900, 2901, 7, 6, 0, 0, 2901, 2902, + 7, 19, 0, 0, 2902, 2903, 7, 9, 0, 0, 2903, 2904, 7, 10, 0, 0, 2904, 330, + 1, 0, 0, 0, 2905, 2906, 7, 14, 0, 0, 2906, 2907, 7, 6, 0, 0, 2907, 2908, + 7, 22, 0, 0, 2908, 2909, 7, 9, 0, 0, 2909, 2910, 7, 16, 0, 0, 2910, 2911, + 7, 10, 0, 0, 2911, 2912, 7, 13, 0, 0, 2912, 332, 1, 0, 0, 0, 2913, 2914, + 7, 14, 0, 0, 2914, 2915, 7, 19, 0, 0, 2915, 2916, 7, 15, 0, 0, 2916, 2917, + 7, 15, 0, 0, 2917, 2918, 7, 10, 0, 0, 2918, 2919, 7, 7, 0, 0, 2919, 2920, + 7, 16, 0, 0, 2920, 334, 1, 0, 0, 0, 2921, 2922, 7, 14, 0, 0, 2922, 2923, + 7, 19, 0, 0, 2923, 2924, 7, 15, 0, 0, 2924, 2925, 7, 15, 0, 0, 2925, 2926, + 7, 10, 0, 0, 2926, 2927, 7, 7, 0, 0, 2927, 2928, 7, 16, 0, 0, 2928, 2929, + 7, 9, 0, 0, 2929, 336, 1, 0, 0, 0, 2930, 2931, 7, 14, 0, 0, 2931, 2932, + 7, 19, 0, 0, 2932, 2933, 7, 15, 0, 0, 2933, 2934, 7, 15, 0, 0, 2934, 2935, + 7, 17, 0, 0, 2935, 2936, 7, 16, 0, 0, 2936, 338, 1, 0, 0, 0, 2937, 2938, + 7, 14, 0, 0, 2938, 2939, 7, 19, 0, 0, 2939, 2940, 7, 15, 0, 0, 2940, 2941, + 7, 15, 0, 0, 2941, 2942, 7, 17, 0, 0, 2942, 2943, 7, 16, 0, 0, 2943, 2944, + 7, 16, 0, 0, 2944, 2945, 7, 10, 0, 0, 2945, 2946, 7, 12, 0, 0, 2946, 340, + 1, 0, 0, 0, 2947, 2948, 7, 14, 0, 0, 2948, 2949, 7, 19, 0, 0, 2949, 2950, + 7, 7, 0, 0, 2950, 2951, 7, 25, 0, 0, 2951, 2952, 7, 17, 0, 0, 2952, 2953, + 7, 23, 0, 0, 2953, 2954, 7, 22, 0, 0, 2954, 2955, 7, 13, 0, 0, 2955, 2956, + 7, 5, 0, 0, 2956, 2957, 7, 16, 0, 0, 2957, 2958, 7, 17, 0, 0, 2958, 2959, + 7, 19, 0, 0, 2959, 2960, 7, 7, 0, 0, 2960, 342, 1, 0, 0, 0, 2961, 2962, + 7, 14, 0, 0, 2962, 2963, 7, 19, 0, 0, 2963, 2964, 7, 7, 0, 0, 2964, 2965, + 7, 7, 0, 0, 2965, 2966, 7, 10, 0, 0, 2966, 2967, 7, 14, 0, 0, 2967, 2968, + 7, 16, 0, 0, 2968, 2969, 7, 17, 0, 0, 2969, 2970, 7, 19, 0, 0, 2970, 2971, + 7, 7, 0, 0, 2971, 344, 1, 0, 0, 0, 2972, 2973, 7, 14, 0, 0, 2973, 2974, + 7, 19, 0, 0, 2974, 2975, 7, 7, 0, 0, 2975, 2976, 7, 9, 0, 0, 2976, 2977, + 7, 16, 0, 0, 2977, 2978, 7, 13, 0, 0, 2978, 2979, 7, 5, 0, 0, 2979, 2980, + 7, 17, 0, 0, 2980, 2981, 7, 7, 0, 0, 2981, 2982, 7, 16, 0, 0, 2982, 2983, + 7, 9, 0, 0, 2983, 346, 1, 0, 0, 0, 2984, 2985, 7, 14, 0, 0, 2985, 2986, + 7, 19, 0, 0, 2986, 2987, 7, 7, 0, 0, 2987, 2988, 7, 16, 0, 0, 2988, 2989, + 7, 10, 0, 0, 2989, 2990, 7, 7, 0, 0, 2990, 2991, 7, 16, 0, 0, 2991, 348, + 1, 0, 0, 0, 2992, 2993, 7, 14, 0, 0, 2993, 2994, 7, 19, 0, 0, 2994, 2995, + 7, 7, 0, 0, 2995, 2996, 7, 16, 0, 0, 2996, 2997, 7, 17, 0, 0, 2997, 2998, + 7, 7, 0, 0, 2998, 2999, 7, 22, 0, 0, 2999, 3000, 7, 10, 0, 0, 3000, 350, + 1, 0, 0, 0, 3001, 3002, 7, 14, 0, 0, 3002, 3003, 7, 19, 0, 0, 3003, 3004, + 7, 7, 0, 0, 3004, 3005, 7, 27, 0, 0, 3005, 3006, 7, 10, 0, 0, 3006, 3007, + 7, 13, 0, 0, 3007, 3008, 7, 9, 0, 0, 3008, 3009, 7, 17, 0, 0, 3009, 3010, + 7, 19, 0, 0, 3010, 3011, 7, 7, 0, 0, 3011, 352, 1, 0, 0, 0, 3012, 3013, + 7, 14, 0, 0, 3013, 3014, 7, 19, 0, 0, 3014, 3015, 7, 24, 0, 0, 3015, 3016, + 7, 8, 0, 0, 3016, 354, 1, 0, 0, 0, 3017, 3018, 7, 14, 0, 0, 3018, 3019, + 7, 19, 0, 0, 3019, 3020, 7, 9, 0, 0, 3020, 3021, 7, 16, 0, 0, 3021, 356, + 1, 0, 0, 0, 3022, 3023, 7, 14, 0, 0, 3023, 3024, 7, 9, 0, 0, 3024, 3025, + 7, 27, 0, 0, 3025, 358, 1, 0, 0, 0, 3026, 3027, 7, 30, 0, 0, 3027, 3028, + 7, 9, 0, 0, 3028, 3029, 7, 19, 0, 0, 3029, 3030, 7, 7, 0, 0, 3030, 360, + 1, 0, 0, 0, 3031, 3032, 7, 14, 0, 0, 3032, 3033, 7, 22, 0, 0, 3033, 3034, + 7, 13, 0, 0, 3034, 3035, 7, 9, 0, 0, 3035, 3036, 7, 19, 0, 0, 3036, 3037, + 7, 13, 0, 0, 3037, 362, 1, 0, 0, 0, 3038, 3039, 7, 14, 0, 0, 3039, 3040, + 7, 8, 0, 0, 3040, 3041, 7, 14, 0, 0, 3041, 3042, 7, 6, 0, 0, 3042, 3043, + 7, 10, 0, 0, 3043, 364, 1, 0, 0, 0, 3044, 3045, 7, 12, 0, 0, 3045, 3046, + 7, 5, 0, 0, 3046, 3047, 7, 16, 0, 0, 3047, 3048, 7, 5, 0, 0, 3048, 366, + 1, 0, 0, 0, 3049, 3050, 7, 12, 0, 0, 3050, 3051, 7, 5, 0, 0, 3051, 3052, + 7, 16, 0, 0, 3052, 3053, 7, 5, 0, 0, 3053, 3054, 5, 95, 0, 0, 3054, 3055, + 7, 14, 0, 0, 3055, 3056, 7, 5, 0, 0, 3056, 3057, 7, 16, 0, 0, 3057, 3058, + 7, 5, 0, 0, 3058, 3059, 7, 6, 0, 0, 3059, 3060, 7, 19, 0, 0, 3060, 3061, + 7, 23, 0, 0, 3061, 368, 1, 0, 0, 0, 3062, 3063, 7, 12, 0, 0, 3063, 3064, + 7, 5, 0, 0, 3064, 3065, 7, 16, 0, 0, 3065, 3066, 7, 5, 0, 0, 3066, 3067, + 7, 18, 0, 0, 3067, 3068, 7, 5, 0, 0, 3068, 3069, 7, 9, 0, 0, 3069, 3070, + 7, 10, 0, 0, 3070, 370, 1, 0, 0, 0, 3071, 3072, 7, 12, 0, 0, 3072, 3073, + 7, 5, 0, 0, 3073, 3074, 7, 8, 0, 0, 3074, 372, 1, 0, 0, 0, 3075, 3076, + 7, 12, 0, 0, 3076, 3077, 7, 10, 0, 0, 3077, 3078, 7, 5, 0, 0, 3078, 3079, + 7, 6, 0, 0, 3079, 3080, 7, 6, 0, 0, 3080, 3081, 7, 19, 0, 0, 3081, 3082, + 7, 14, 0, 0, 3082, 3083, 7, 5, 0, 0, 3083, 3084, 7, 16, 0, 0, 3084, 3085, + 7, 10, 0, 0, 3085, 374, 1, 0, 0, 0, 3086, 3087, 7, 12, 0, 0, 3087, 3088, + 7, 10, 0, 0, 3088, 3089, 7, 14, 0, 0, 3089, 3090, 7, 6, 0, 0, 3090, 3091, + 7, 5, 0, 0, 3091, 3092, 7, 13, 0, 0, 3092, 3093, 7, 10, 0, 0, 3093, 376, + 1, 0, 0, 0, 3094, 3095, 7, 12, 0, 0, 3095, 3096, 7, 10, 0, 0, 3096, 3097, + 7, 25, 0, 0, 3097, 3098, 7, 5, 0, 0, 3098, 3099, 7, 22, 0, 0, 3099, 3100, + 7, 6, 0, 0, 3100, 3101, 7, 16, 0, 0, 3101, 3102, 7, 9, 0, 0, 3102, 378, + 1, 0, 0, 0, 3103, 3104, 7, 12, 0, 0, 3104, 3105, 7, 10, 0, 0, 3105, 3106, + 7, 25, 0, 0, 3106, 3107, 7, 10, 0, 0, 3107, 3108, 7, 13, 0, 0, 3108, 3109, + 7, 13, 0, 0, 3109, 3110, 7, 10, 0, 0, 3110, 3111, 7, 12, 0, 0, 3111, 380, + 1, 0, 0, 0, 3112, 3113, 7, 12, 0, 0, 3113, 3114, 7, 10, 0, 0, 3114, 3115, + 7, 25, 0, 0, 3115, 3116, 7, 17, 0, 0, 3116, 3117, 7, 7, 0, 0, 3117, 3118, + 7, 10, 0, 0, 3118, 3119, 7, 13, 0, 0, 3119, 382, 1, 0, 0, 0, 3120, 3121, + 7, 12, 0, 0, 3121, 3122, 7, 10, 0, 0, 3122, 3123, 7, 6, 0, 0, 3123, 3124, + 7, 10, 0, 0, 3124, 3125, 7, 16, 0, 0, 3125, 3126, 7, 10, 0, 0, 3126, 384, + 1, 0, 0, 0, 3127, 3128, 7, 12, 0, 0, 3128, 3129, 7, 10, 0, 0, 3129, 3130, + 7, 6, 0, 0, 3130, 3131, 7, 17, 0, 0, 3131, 3132, 7, 15, 0, 0, 3132, 3133, + 7, 17, 0, 0, 3133, 3134, 7, 16, 0, 0, 3134, 3135, 7, 10, 0, 0, 3135, 3136, + 7, 13, 0, 0, 3136, 386, 1, 0, 0, 0, 3137, 3138, 7, 12, 0, 0, 3138, 3139, + 7, 10, 0, 0, 3139, 3140, 7, 6, 0, 0, 3140, 3141, 7, 17, 0, 0, 3141, 3142, + 7, 15, 0, 0, 3142, 3143, 7, 17, 0, 0, 3143, 3144, 7, 16, 0, 0, 3144, 3145, + 7, 10, 0, 0, 3145, 3146, 7, 13, 0, 0, 3146, 3147, 7, 9, 0, 0, 3147, 388, + 1, 0, 0, 0, 3148, 3149, 7, 12, 0, 0, 3149, 3150, 7, 17, 0, 0, 3150, 3151, + 7, 14, 0, 0, 3151, 3152, 7, 16, 0, 0, 3152, 3153, 7, 17, 0, 0, 3153, 3154, + 7, 19, 0, 0, 3154, 3155, 7, 7, 0, 0, 3155, 3156, 7, 5, 0, 0, 3156, 3157, + 7, 13, 0, 0, 3157, 3158, 7, 8, 0, 0, 3158, 390, 1, 0, 0, 0, 3159, 3160, + 7, 12, 0, 0, 3160, 3161, 7, 17, 0, 0, 3161, 3162, 7, 9, 0, 0, 3162, 3163, + 7, 5, 0, 0, 3163, 3164, 7, 18, 0, 0, 3164, 3165, 7, 6, 0, 0, 3165, 3166, + 7, 10, 0, 0, 3166, 392, 1, 0, 0, 0, 3167, 3168, 7, 12, 0, 0, 3168, 3169, + 7, 17, 0, 0, 3169, 3170, 7, 9, 0, 0, 3170, 3171, 7, 14, 0, 0, 3171, 3172, + 7, 5, 0, 0, 3172, 3173, 7, 13, 0, 0, 3173, 3174, 7, 12, 0, 0, 3174, 394, + 1, 0, 0, 0, 3175, 3176, 7, 12, 0, 0, 3176, 3177, 7, 19, 0, 0, 3177, 3178, + 7, 14, 0, 0, 3178, 3179, 7, 22, 0, 0, 3179, 3180, 7, 15, 0, 0, 3180, 3181, + 7, 10, 0, 0, 3181, 3182, 7, 7, 0, 0, 3182, 3183, 7, 16, 0, 0, 3183, 396, + 1, 0, 0, 0, 3184, 3185, 7, 12, 0, 0, 3185, 3186, 7, 19, 0, 0, 3186, 3187, + 7, 15, 0, 0, 3187, 3188, 7, 5, 0, 0, 3188, 3189, 7, 17, 0, 0, 3189, 3190, + 7, 7, 0, 0, 3190, 398, 1, 0, 0, 0, 3191, 3192, 7, 12, 0, 0, 3192, 3193, + 7, 19, 0, 0, 3193, 3194, 7, 22, 0, 0, 3194, 3195, 7, 18, 0, 0, 3195, 3196, + 7, 6, 0, 0, 3196, 3197, 7, 10, 0, 0, 3197, 400, 1, 0, 0, 0, 3198, 3199, + 7, 12, 0, 0, 3199, 3200, 7, 13, 0, 0, 3200, 3201, 7, 19, 0, 0, 3201, 3202, + 7, 24, 0, 0, 3202, 402, 1, 0, 0, 0, 3203, 3204, 7, 10, 0, 0, 3204, 3205, + 7, 5, 0, 0, 3205, 3206, 7, 14, 0, 0, 3206, 3207, 7, 20, 0, 0, 3207, 404, + 1, 0, 0, 0, 3208, 3209, 7, 10, 0, 0, 3209, 3210, 7, 7, 0, 0, 3210, 3211, + 7, 5, 0, 0, 3211, 3212, 7, 18, 0, 0, 3212, 3213, 7, 6, 0, 0, 3213, 3214, + 7, 10, 0, 0, 3214, 406, 1, 0, 0, 0, 3215, 3216, 7, 10, 0, 0, 3216, 3217, + 7, 7, 0, 0, 3217, 3218, 7, 14, 0, 0, 3218, 3219, 7, 19, 0, 0, 3219, 3220, + 7, 12, 0, 0, 3220, 3221, 7, 17, 0, 0, 3221, 3222, 7, 7, 0, 0, 3222, 3223, + 7, 23, 0, 0, 3223, 408, 1, 0, 0, 0, 3224, 3225, 7, 10, 0, 0, 3225, 3226, + 7, 7, 0, 0, 3226, 3227, 7, 14, 0, 0, 3227, 3228, 7, 13, 0, 0, 3228, 3229, + 7, 8, 0, 0, 3229, 3230, 7, 24, 0, 0, 3230, 3231, 7, 16, 0, 0, 3231, 3232, + 7, 10, 0, 0, 3232, 3233, 7, 12, 0, 0, 3233, 410, 1, 0, 0, 0, 3234, 3235, + 7, 10, 0, 0, 3235, 3236, 7, 7, 0, 0, 3236, 3237, 7, 22, 0, 0, 3237, 3238, + 7, 15, 0, 0, 3238, 412, 1, 0, 0, 0, 3239, 3240, 7, 10, 0, 0, 3240, 3241, + 7, 9, 0, 0, 3241, 3242, 7, 14, 0, 0, 3242, 3243, 7, 5, 0, 0, 3243, 3244, + 7, 24, 0, 0, 3244, 3245, 7, 10, 0, 0, 3245, 414, 1, 0, 0, 0, 3246, 3247, + 7, 10, 0, 0, 3247, 3248, 7, 27, 0, 0, 3248, 3249, 7, 10, 0, 0, 3249, 3250, + 7, 7, 0, 0, 3250, 3251, 7, 16, 0, 0, 3251, 416, 1, 0, 0, 0, 3252, 3253, + 7, 10, 0, 0, 3253, 3254, 7, 26, 0, 0, 3254, 3255, 7, 14, 0, 0, 3255, 3256, + 7, 6, 0, 0, 3256, 3257, 7, 22, 0, 0, 3257, 3258, 7, 12, 0, 0, 3258, 3259, + 7, 10, 0, 0, 3259, 418, 1, 0, 0, 0, 3260, 3261, 7, 10, 0, 0, 3261, 3262, + 7, 26, 0, 0, 3262, 3263, 7, 14, 0, 0, 3263, 3264, 7, 6, 0, 0, 3264, 3265, + 7, 22, 0, 0, 3265, 3266, 7, 12, 0, 0, 3266, 3267, 7, 17, 0, 0, 3267, 3268, + 7, 7, 0, 0, 3268, 3269, 7, 23, 0, 0, 3269, 420, 1, 0, 0, 0, 3270, 3271, + 7, 10, 0, 0, 3271, 3272, 7, 26, 0, 0, 3272, 3273, 7, 14, 0, 0, 3273, 3274, + 7, 6, 0, 0, 3274, 3275, 7, 22, 0, 0, 3275, 3276, 7, 9, 0, 0, 3276, 3277, + 7, 17, 0, 0, 3277, 3278, 7, 27, 0, 0, 3278, 3279, 7, 10, 0, 0, 3279, 422, + 1, 0, 0, 0, 3280, 3281, 7, 10, 0, 0, 3281, 3282, 7, 26, 0, 0, 3282, 3283, + 7, 10, 0, 0, 3283, 3284, 7, 14, 0, 0, 3284, 3285, 7, 22, 0, 0, 3285, 3286, + 7, 16, 0, 0, 3286, 3287, 7, 10, 0, 0, 3287, 424, 1, 0, 0, 0, 3288, 3289, + 7, 10, 0, 0, 3289, 3290, 7, 26, 0, 0, 3290, 3291, 7, 24, 0, 0, 3291, 3292, + 7, 6, 0, 0, 3292, 3293, 7, 5, 0, 0, 3293, 3294, 7, 17, 0, 0, 3294, 3295, + 7, 7, 0, 0, 3295, 426, 1, 0, 0, 0, 3296, 3297, 7, 10, 0, 0, 3297, 3298, + 7, 26, 0, 0, 3298, 3299, 7, 16, 0, 0, 3299, 3300, 7, 10, 0, 0, 3300, 3301, + 7, 7, 0, 0, 3301, 3302, 7, 9, 0, 0, 3302, 3303, 7, 17, 0, 0, 3303, 3304, + 7, 19, 0, 0, 3304, 3305, 7, 7, 0, 0, 3305, 428, 1, 0, 0, 0, 3306, 3307, + 7, 10, 0, 0, 3307, 3308, 7, 26, 0, 0, 3308, 3309, 7, 16, 0, 0, 3309, 3310, + 7, 10, 0, 0, 3310, 3311, 7, 13, 0, 0, 3311, 3312, 7, 7, 0, 0, 3312, 3313, + 7, 5, 0, 0, 3313, 3314, 7, 6, 0, 0, 3314, 430, 1, 0, 0, 0, 3315, 3316, + 7, 25, 0, 0, 3316, 3317, 7, 5, 0, 0, 3317, 3318, 7, 15, 0, 0, 3318, 3319, + 7, 17, 0, 0, 3319, 3320, 7, 6, 0, 0, 3320, 3321, 7, 8, 0, 0, 3321, 432, + 1, 0, 0, 0, 3322, 3323, 7, 25, 0, 0, 3323, 3324, 7, 17, 0, 0, 3324, 3325, + 7, 13, 0, 0, 3325, 3326, 7, 9, 0, 0, 3326, 3327, 7, 16, 0, 0, 3327, 434, + 1, 0, 0, 0, 3328, 3329, 7, 25, 0, 0, 3329, 3330, 7, 19, 0, 0, 3330, 3331, + 7, 6, 0, 0, 3331, 3332, 7, 6, 0, 0, 3332, 3333, 7, 19, 0, 0, 3333, 3334, + 7, 29, 0, 0, 3334, 3335, 7, 17, 0, 0, 3335, 3336, 7, 7, 0, 0, 3336, 3337, + 7, 23, 0, 0, 3337, 436, 1, 0, 0, 0, 3338, 3339, 7, 25, 0, 0, 3339, 3340, + 7, 19, 0, 0, 3340, 3341, 7, 13, 0, 0, 3341, 3342, 7, 14, 0, 0, 3342, 3343, + 7, 10, 0, 0, 3343, 438, 1, 0, 0, 0, 3344, 3345, 7, 25, 0, 0, 3345, 3346, + 7, 19, 0, 0, 3346, 3347, 7, 13, 0, 0, 3347, 3348, 7, 29, 0, 0, 3348, 3349, + 7, 5, 0, 0, 3349, 3350, 7, 13, 0, 0, 3350, 3351, 7, 12, 0, 0, 3351, 440, + 1, 0, 0, 0, 3352, 3353, 7, 25, 0, 0, 3353, 3354, 7, 22, 0, 0, 3354, 3355, + 7, 7, 0, 0, 3355, 3356, 7, 14, 0, 0, 3356, 3357, 7, 16, 0, 0, 3357, 3358, + 7, 17, 0, 0, 3358, 3359, 7, 19, 0, 0, 3359, 3360, 7, 7, 0, 0, 3360, 442, + 1, 0, 0, 0, 3361, 3362, 7, 25, 0, 0, 3362, 3363, 7, 22, 0, 0, 3363, 3364, + 7, 7, 0, 0, 3364, 3365, 7, 14, 0, 0, 3365, 3366, 7, 16, 0, 0, 3366, 3367, + 7, 17, 0, 0, 3367, 3368, 7, 19, 0, 0, 3368, 3369, 7, 7, 0, 0, 3369, 3370, + 7, 9, 0, 0, 3370, 444, 1, 0, 0, 0, 3371, 3372, 7, 23, 0, 0, 3372, 3373, + 7, 6, 0, 0, 3373, 3374, 7, 19, 0, 0, 3374, 3375, 7, 18, 0, 0, 3375, 3376, + 7, 5, 0, 0, 3376, 3377, 7, 6, 0, 0, 3377, 446, 1, 0, 0, 0, 3378, 3379, + 7, 23, 0, 0, 3379, 3380, 7, 13, 0, 0, 3380, 3381, 7, 5, 0, 0, 3381, 3382, + 7, 7, 0, 0, 3382, 3383, 7, 16, 0, 0, 3383, 3384, 7, 10, 0, 0, 3384, 3385, + 7, 12, 0, 0, 3385, 448, 1, 0, 0, 0, 3386, 3387, 7, 20, 0, 0, 3387, 3388, + 7, 5, 0, 0, 3388, 3389, 7, 7, 0, 0, 3389, 3390, 7, 12, 0, 0, 3390, 3391, + 7, 6, 0, 0, 3391, 3392, 7, 10, 0, 0, 3392, 3393, 7, 13, 0, 0, 3393, 450, + 1, 0, 0, 0, 3394, 3395, 7, 20, 0, 0, 3395, 3396, 7, 10, 0, 0, 3396, 3397, + 7, 5, 0, 0, 3397, 3398, 7, 12, 0, 0, 3398, 3399, 7, 10, 0, 0, 3399, 3400, + 7, 13, 0, 0, 3400, 452, 1, 0, 0, 0, 3401, 3402, 7, 20, 0, 0, 3402, 3403, + 7, 19, 0, 0, 3403, 3404, 7, 6, 0, 0, 3404, 3405, 7, 12, 0, 0, 3405, 454, + 1, 0, 0, 0, 3406, 3407, 7, 20, 0, 0, 3407, 3408, 7, 19, 0, 0, 3408, 3409, + 7, 22, 0, 0, 3409, 3410, 7, 13, 0, 0, 3410, 456, 1, 0, 0, 0, 3411, 3412, + 7, 17, 0, 0, 3412, 3413, 7, 12, 0, 0, 3413, 3414, 7, 10, 0, 0, 3414, 3415, + 7, 7, 0, 0, 3415, 3416, 7, 16, 0, 0, 3416, 3417, 7, 17, 0, 0, 3417, 3418, + 7, 16, 0, 0, 3418, 3419, 7, 8, 0, 0, 3419, 458, 1, 0, 0, 0, 3420, 3421, + 7, 17, 0, 0, 3421, 3422, 7, 25, 0, 0, 3422, 460, 1, 0, 0, 0, 3423, 3424, + 7, 17, 0, 0, 3424, 3425, 7, 15, 0, 0, 3425, 3426, 7, 15, 0, 0, 3426, 3427, + 7, 10, 0, 0, 3427, 3428, 7, 12, 0, 0, 3428, 3429, 7, 17, 0, 0, 3429, 3430, + 7, 5, 0, 0, 3430, 3431, 7, 16, 0, 0, 3431, 3432, 7, 10, 0, 0, 3432, 462, + 1, 0, 0, 0, 3433, 3434, 7, 17, 0, 0, 3434, 3435, 7, 15, 0, 0, 3435, 3436, + 7, 15, 0, 0, 3436, 3437, 7, 22, 0, 0, 3437, 3438, 7, 16, 0, 0, 3438, 3439, + 7, 5, 0, 0, 3439, 3440, 7, 18, 0, 0, 3440, 3441, 7, 6, 0, 0, 3441, 3442, + 7, 10, 0, 0, 3442, 464, 1, 0, 0, 0, 3443, 3444, 7, 17, 0, 0, 3444, 3445, + 7, 15, 0, 0, 3445, 3446, 7, 24, 0, 0, 3446, 3447, 7, 6, 0, 0, 3447, 3448, + 7, 17, 0, 0, 3448, 3449, 7, 14, 0, 0, 3449, 3450, 7, 17, 0, 0, 3450, 3451, + 7, 16, 0, 0, 3451, 466, 1, 0, 0, 0, 3452, 3453, 7, 17, 0, 0, 3453, 3454, + 7, 7, 0, 0, 3454, 3455, 7, 14, 0, 0, 3455, 3456, 7, 6, 0, 0, 3456, 3457, + 7, 22, 0, 0, 3457, 3458, 7, 12, 0, 0, 3458, 3459, 7, 17, 0, 0, 3459, 3460, + 7, 7, 0, 0, 3460, 3461, 7, 23, 0, 0, 3461, 468, 1, 0, 0, 0, 3462, 3463, + 7, 17, 0, 0, 3463, 3464, 7, 7, 0, 0, 3464, 3465, 7, 14, 0, 0, 3465, 3466, + 7, 13, 0, 0, 3466, 3467, 7, 10, 0, 0, 3467, 3468, 7, 15, 0, 0, 3468, 3469, + 7, 10, 0, 0, 3469, 3470, 7, 7, 0, 0, 3470, 3471, 7, 16, 0, 0, 3471, 470, + 1, 0, 0, 0, 3472, 3473, 7, 17, 0, 0, 3473, 3474, 7, 7, 0, 0, 3474, 3475, + 7, 12, 0, 0, 3475, 3476, 7, 10, 0, 0, 3476, 3477, 7, 26, 0, 0, 3477, 472, + 1, 0, 0, 0, 3478, 3479, 7, 17, 0, 0, 3479, 3480, 7, 7, 0, 0, 3480, 3481, + 7, 12, 0, 0, 3481, 3482, 7, 10, 0, 0, 3482, 3483, 7, 26, 0, 0, 3483, 3484, + 7, 10, 0, 0, 3484, 3485, 7, 9, 0, 0, 3485, 474, 1, 0, 0, 0, 3486, 3487, + 7, 17, 0, 0, 3487, 3488, 7, 7, 0, 0, 3488, 3489, 7, 20, 0, 0, 3489, 3490, + 7, 10, 0, 0, 3490, 3491, 7, 13, 0, 0, 3491, 3492, 7, 17, 0, 0, 3492, 3493, + 7, 16, 0, 0, 3493, 476, 1, 0, 0, 0, 3494, 3495, 7, 17, 0, 0, 3495, 3496, + 7, 7, 0, 0, 3496, 3497, 7, 20, 0, 0, 3497, 3498, 7, 10, 0, 0, 3498, 3499, + 7, 13, 0, 0, 3499, 3500, 7, 17, 0, 0, 3500, 3501, 7, 16, 0, 0, 3501, 3502, + 7, 9, 0, 0, 3502, 478, 1, 0, 0, 0, 3503, 3504, 7, 17, 0, 0, 3504, 3505, + 7, 7, 0, 0, 3505, 3506, 7, 6, 0, 0, 3506, 3507, 7, 17, 0, 0, 3507, 3508, + 7, 7, 0, 0, 3508, 3509, 7, 10, 0, 0, 3509, 480, 1, 0, 0, 0, 3510, 3511, + 7, 17, 0, 0, 3511, 3512, 7, 7, 0, 0, 3512, 3513, 7, 9, 0, 0, 3513, 3514, + 7, 10, 0, 0, 3514, 3515, 7, 7, 0, 0, 3515, 3516, 7, 9, 0, 0, 3516, 3517, + 7, 17, 0, 0, 3517, 3518, 7, 16, 0, 0, 3518, 3519, 7, 17, 0, 0, 3519, 3520, + 7, 27, 0, 0, 3520, 3521, 7, 10, 0, 0, 3521, 482, 1, 0, 0, 0, 3522, 3523, + 7, 17, 0, 0, 3523, 3524, 7, 7, 0, 0, 3524, 3525, 7, 9, 0, 0, 3525, 3526, + 7, 10, 0, 0, 3526, 3527, 7, 13, 0, 0, 3527, 3528, 7, 16, 0, 0, 3528, 484, + 1, 0, 0, 0, 3529, 3530, 7, 17, 0, 0, 3530, 3531, 7, 7, 0, 0, 3531, 3532, + 7, 9, 0, 0, 3532, 3533, 7, 16, 0, 0, 3533, 3534, 7, 10, 0, 0, 3534, 3535, + 7, 5, 0, 0, 3535, 3536, 7, 12, 0, 0, 3536, 486, 1, 0, 0, 0, 3537, 3538, + 7, 17, 0, 0, 3538, 3539, 7, 7, 0, 0, 3539, 3540, 7, 27, 0, 0, 3540, 3541, + 7, 19, 0, 0, 3541, 3542, 7, 21, 0, 0, 3542, 3543, 7, 10, 0, 0, 3543, 3544, + 7, 13, 0, 0, 3544, 488, 1, 0, 0, 0, 3545, 3546, 7, 17, 0, 0, 3546, 3547, + 7, 9, 0, 0, 3547, 3548, 7, 19, 0, 0, 3548, 3549, 7, 6, 0, 0, 3549, 3550, + 7, 5, 0, 0, 3550, 3551, 7, 16, 0, 0, 3551, 3552, 7, 17, 0, 0, 3552, 3553, + 7, 19, 0, 0, 3553, 3554, 7, 7, 0, 0, 3554, 490, 1, 0, 0, 0, 3555, 3556, + 7, 21, 0, 0, 3556, 3557, 7, 10, 0, 0, 3557, 3558, 7, 8, 0, 0, 3558, 492, + 1, 0, 0, 0, 3559, 3560, 7, 6, 0, 0, 3560, 3561, 7, 5, 0, 0, 3561, 3562, + 7, 18, 0, 0, 3562, 3563, 7, 10, 0, 0, 3563, 3564, 7, 6, 0, 0, 3564, 494, + 1, 0, 0, 0, 3565, 3566, 7, 6, 0, 0, 3566, 3567, 7, 5, 0, 0, 3567, 3568, + 7, 7, 0, 0, 3568, 3569, 7, 23, 0, 0, 3569, 3570, 7, 22, 0, 0, 3570, 3571, + 7, 5, 0, 0, 3571, 3572, 7, 23, 0, 0, 3572, 3573, 7, 10, 0, 0, 3573, 496, + 1, 0, 0, 0, 3574, 3575, 7, 6, 0, 0, 3575, 3576, 7, 5, 0, 0, 3576, 3577, + 7, 13, 0, 0, 3577, 3578, 7, 23, 0, 0, 3578, 3579, 7, 10, 0, 0, 3579, 498, + 1, 0, 0, 0, 3580, 3581, 7, 6, 0, 0, 3581, 3582, 7, 5, 0, 0, 3582, 3583, + 7, 9, 0, 0, 3583, 3584, 7, 16, 0, 0, 3584, 500, 1, 0, 0, 0, 3585, 3586, + 7, 6, 0, 0, 3586, 3587, 7, 10, 0, 0, 3587, 3588, 7, 5, 0, 0, 3588, 3589, + 7, 21, 0, 0, 3589, 3590, 7, 24, 0, 0, 3590, 3591, 7, 13, 0, 0, 3591, 3592, + 7, 19, 0, 0, 3592, 3593, 7, 19, 0, 0, 3593, 3594, 7, 25, 0, 0, 3594, 502, + 1, 0, 0, 0, 3595, 3596, 7, 6, 0, 0, 3596, 3597, 7, 10, 0, 0, 3597, 3598, + 7, 27, 0, 0, 3598, 3599, 7, 10, 0, 0, 3599, 3600, 7, 6, 0, 0, 3600, 504, + 1, 0, 0, 0, 3601, 3602, 7, 6, 0, 0, 3602, 3603, 7, 17, 0, 0, 3603, 3604, + 7, 9, 0, 0, 3604, 3605, 7, 16, 0, 0, 3605, 3606, 7, 10, 0, 0, 3606, 3607, + 7, 7, 0, 0, 3607, 506, 1, 0, 0, 0, 3608, 3609, 7, 6, 0, 0, 3609, 3610, + 7, 19, 0, 0, 3610, 3611, 7, 5, 0, 0, 3611, 3612, 7, 12, 0, 0, 3612, 508, + 1, 0, 0, 0, 3613, 3614, 7, 6, 0, 0, 3614, 3615, 7, 19, 0, 0, 3615, 3616, + 7, 14, 0, 0, 3616, 3617, 7, 5, 0, 0, 3617, 3618, 7, 6, 0, 0, 3618, 510, + 1, 0, 0, 0, 3619, 3620, 7, 6, 0, 0, 3620, 3621, 7, 19, 0, 0, 3621, 3622, + 7, 14, 0, 0, 3622, 3623, 7, 5, 0, 0, 3623, 3624, 7, 16, 0, 0, 3624, 3625, + 7, 17, 0, 0, 3625, 3626, 7, 19, 0, 0, 3626, 3627, 7, 7, 0, 0, 3627, 512, + 1, 0, 0, 0, 3628, 3629, 7, 6, 0, 0, 3629, 3630, 7, 19, 0, 0, 3630, 3631, + 7, 14, 0, 0, 3631, 3632, 7, 21, 0, 0, 3632, 514, 1, 0, 0, 0, 3633, 3634, + 7, 15, 0, 0, 3634, 3635, 7, 5, 0, 0, 3635, 3636, 7, 24, 0, 0, 3636, 3637, + 7, 24, 0, 0, 3637, 3638, 7, 17, 0, 0, 3638, 3639, 7, 7, 0, 0, 3639, 3640, + 7, 23, 0, 0, 3640, 516, 1, 0, 0, 0, 3641, 3642, 7, 15, 0, 0, 3642, 3643, + 7, 5, 0, 0, 3643, 3644, 7, 16, 0, 0, 3644, 3645, 7, 14, 0, 0, 3645, 3646, + 7, 20, 0, 0, 3646, 518, 1, 0, 0, 0, 3647, 3648, 7, 15, 0, 0, 3648, 3649, + 7, 5, 0, 0, 3649, 3650, 7, 16, 0, 0, 3650, 3651, 7, 14, 0, 0, 3651, 3652, + 7, 20, 0, 0, 3652, 3653, 7, 10, 0, 0, 3653, 3654, 7, 12, 0, 0, 3654, 520, + 1, 0, 0, 0, 3655, 3656, 7, 15, 0, 0, 3656, 3657, 7, 5, 0, 0, 3657, 3658, + 7, 16, 0, 0, 3658, 3659, 7, 10, 0, 0, 3659, 3660, 7, 13, 0, 0, 3660, 3661, + 7, 17, 0, 0, 3661, 3662, 7, 5, 0, 0, 3662, 3663, 7, 6, 0, 0, 3663, 3664, + 7, 17, 0, 0, 3664, 3665, 7, 11, 0, 0, 3665, 3666, 7, 10, 0, 0, 3666, 3667, + 7, 12, 0, 0, 3667, 522, 1, 0, 0, 0, 3668, 3669, 7, 15, 0, 0, 3669, 3670, + 7, 5, 0, 0, 3670, 3671, 7, 26, 0, 0, 3671, 3672, 7, 27, 0, 0, 3672, 3673, + 7, 5, 0, 0, 3673, 3674, 7, 6, 0, 0, 3674, 3675, 7, 22, 0, 0, 3675, 3676, + 7, 10, 0, 0, 3676, 524, 1, 0, 0, 0, 3677, 3678, 7, 15, 0, 0, 3678, 3679, + 7, 10, 0, 0, 3679, 3680, 7, 13, 0, 0, 3680, 3681, 7, 23, 0, 0, 3681, 3682, + 7, 10, 0, 0, 3682, 526, 1, 0, 0, 0, 3683, 3684, 7, 15, 0, 0, 3684, 3685, + 7, 17, 0, 0, 3685, 3686, 7, 7, 0, 0, 3686, 3687, 7, 22, 0, 0, 3687, 3688, + 7, 16, 0, 0, 3688, 3689, 7, 10, 0, 0, 3689, 528, 1, 0, 0, 0, 3690, 3691, + 7, 15, 0, 0, 3691, 3692, 7, 17, 0, 0, 3692, 3693, 7, 7, 0, 0, 3693, 3694, + 7, 27, 0, 0, 3694, 3695, 7, 5, 0, 0, 3695, 3696, 7, 6, 0, 0, 3696, 3697, + 7, 22, 0, 0, 3697, 3698, 7, 10, 0, 0, 3698, 530, 1, 0, 0, 0, 3699, 3700, + 7, 15, 0, 0, 3700, 3701, 7, 19, 0, 0, 3701, 3702, 7, 12, 0, 0, 3702, 3703, + 7, 10, 0, 0, 3703, 532, 1, 0, 0, 0, 3704, 3705, 7, 15, 0, 0, 3705, 3706, + 7, 19, 0, 0, 3706, 3707, 7, 7, 0, 0, 3707, 3708, 7, 16, 0, 0, 3708, 3709, + 7, 20, 0, 0, 3709, 534, 1, 0, 0, 0, 3710, 3711, 7, 15, 0, 0, 3711, 3712, + 7, 19, 0, 0, 3712, 3713, 7, 27, 0, 0, 3713, 3714, 7, 10, 0, 0, 3714, 536, + 1, 0, 0, 0, 3715, 3716, 7, 7, 0, 0, 3716, 3717, 7, 5, 0, 0, 3717, 3718, + 7, 15, 0, 0, 3718, 3719, 7, 10, 0, 0, 3719, 538, 1, 0, 0, 0, 3720, 3721, + 7, 7, 0, 0, 3721, 3722, 7, 5, 0, 0, 3722, 3723, 7, 15, 0, 0, 3723, 3724, + 7, 10, 0, 0, 3724, 3725, 7, 9, 0, 0, 3725, 540, 1, 0, 0, 0, 3726, 3727, + 7, 7, 0, 0, 3727, 3728, 7, 10, 0, 0, 3728, 3729, 7, 26, 0, 0, 3729, 3730, + 7, 16, 0, 0, 3730, 542, 1, 0, 0, 0, 3731, 3732, 7, 7, 0, 0, 3732, 3733, + 7, 19, 0, 0, 3733, 544, 1, 0, 0, 0, 3734, 3735, 7, 7, 0, 0, 3735, 3736, + 7, 19, 0, 0, 3736, 3737, 7, 16, 0, 0, 3737, 3738, 7, 20, 0, 0, 3738, 3739, + 7, 17, 0, 0, 3739, 3740, 7, 7, 0, 0, 3740, 3741, 7, 23, 0, 0, 3741, 546, + 1, 0, 0, 0, 3742, 3743, 7, 7, 0, 0, 3743, 3744, 7, 19, 0, 0, 3744, 3745, + 7, 16, 0, 0, 3745, 3746, 7, 17, 0, 0, 3746, 3747, 7, 25, 0, 0, 3747, 3748, + 7, 8, 0, 0, 3748, 548, 1, 0, 0, 0, 3749, 3750, 7, 7, 0, 0, 3750, 3751, + 7, 19, 0, 0, 3751, 3752, 7, 29, 0, 0, 3752, 3753, 7, 5, 0, 0, 3753, 3754, + 7, 17, 0, 0, 3754, 3755, 7, 16, 0, 0, 3755, 550, 1, 0, 0, 0, 3756, 3757, + 7, 7, 0, 0, 3757, 3758, 7, 22, 0, 0, 3758, 3759, 7, 6, 0, 0, 3759, 3760, + 7, 6, 0, 0, 3760, 3761, 7, 9, 0, 0, 3761, 552, 1, 0, 0, 0, 3762, 3763, + 7, 19, 0, 0, 3763, 3764, 7, 18, 0, 0, 3764, 3765, 7, 30, 0, 0, 3765, 3766, + 7, 10, 0, 0, 3766, 3767, 7, 14, 0, 0, 3767, 3768, 7, 16, 0, 0, 3768, 554, + 1, 0, 0, 0, 3769, 3770, 7, 19, 0, 0, 3770, 3771, 7, 25, 0, 0, 3771, 556, + 1, 0, 0, 0, 3772, 3773, 7, 19, 0, 0, 3773, 3774, 7, 25, 0, 0, 3774, 3775, + 7, 25, 0, 0, 3775, 558, 1, 0, 0, 0, 3776, 3777, 7, 19, 0, 0, 3777, 3778, + 7, 17, 0, 0, 3778, 3779, 7, 12, 0, 0, 3779, 3780, 7, 9, 0, 0, 3780, 560, + 1, 0, 0, 0, 3781, 3782, 7, 19, 0, 0, 3782, 3783, 7, 24, 0, 0, 3783, 3784, + 7, 10, 0, 0, 3784, 3785, 7, 13, 0, 0, 3785, 3786, 7, 5, 0, 0, 3786, 3787, + 7, 16, 0, 0, 3787, 3788, 7, 19, 0, 0, 3788, 3789, 7, 13, 0, 0, 3789, 562, + 1, 0, 0, 0, 3790, 3791, 7, 19, 0, 0, 3791, 3792, 7, 24, 0, 0, 3792, 3793, + 7, 16, 0, 0, 3793, 3794, 7, 17, 0, 0, 3794, 3795, 7, 19, 0, 0, 3795, 3796, + 7, 7, 0, 0, 3796, 564, 1, 0, 0, 0, 3797, 3798, 7, 19, 0, 0, 3798, 3799, + 7, 24, 0, 0, 3799, 3800, 7, 16, 0, 0, 3800, 3801, 7, 17, 0, 0, 3801, 3802, + 7, 19, 0, 0, 3802, 3803, 7, 7, 0, 0, 3803, 3804, 7, 9, 0, 0, 3804, 566, + 1, 0, 0, 0, 3805, 3806, 7, 19, 0, 0, 3806, 3807, 7, 29, 0, 0, 3807, 3808, + 7, 7, 0, 0, 3808, 3809, 7, 10, 0, 0, 3809, 3810, 7, 12, 0, 0, 3810, 568, + 1, 0, 0, 0, 3811, 3812, 7, 19, 0, 0, 3812, 3813, 7, 29, 0, 0, 3813, 3814, + 7, 7, 0, 0, 3814, 3815, 7, 10, 0, 0, 3815, 3816, 7, 13, 0, 0, 3816, 570, + 1, 0, 0, 0, 3817, 3818, 7, 24, 0, 0, 3818, 3819, 7, 5, 0, 0, 3819, 3820, + 7, 13, 0, 0, 3820, 3821, 7, 9, 0, 0, 3821, 3822, 7, 10, 0, 0, 3822, 3823, + 7, 13, 0, 0, 3823, 572, 1, 0, 0, 0, 3824, 3825, 7, 24, 0, 0, 3825, 3826, + 7, 5, 0, 0, 3826, 3827, 7, 13, 0, 0, 3827, 3828, 7, 16, 0, 0, 3828, 3829, + 7, 17, 0, 0, 3829, 3830, 7, 5, 0, 0, 3830, 3831, 7, 6, 0, 0, 3831, 574, + 1, 0, 0, 0, 3832, 3833, 7, 24, 0, 0, 3833, 3834, 7, 5, 0, 0, 3834, 3835, + 7, 13, 0, 0, 3835, 3836, 7, 16, 0, 0, 3836, 3837, 7, 17, 0, 0, 3837, 3838, + 7, 16, 0, 0, 3838, 3839, 7, 17, 0, 0, 3839, 3840, 7, 19, 0, 0, 3840, 3841, + 7, 7, 0, 0, 3841, 576, 1, 0, 0, 0, 3842, 3843, 7, 24, 0, 0, 3843, 3844, + 7, 5, 0, 0, 3844, 3845, 7, 9, 0, 0, 3845, 3846, 7, 9, 0, 0, 3846, 3847, + 7, 17, 0, 0, 3847, 3848, 7, 7, 0, 0, 3848, 3849, 7, 23, 0, 0, 3849, 578, + 1, 0, 0, 0, 3850, 3851, 7, 24, 0, 0, 3851, 3852, 7, 5, 0, 0, 3852, 3853, + 7, 9, 0, 0, 3853, 3854, 7, 9, 0, 0, 3854, 3855, 7, 29, 0, 0, 3855, 3856, + 7, 19, 0, 0, 3856, 3857, 7, 13, 0, 0, 3857, 3858, 7, 12, 0, 0, 3858, 580, + 1, 0, 0, 0, 3859, 3860, 7, 24, 0, 0, 3860, 3861, 7, 6, 0, 0, 3861, 3862, + 7, 5, 0, 0, 3862, 3863, 7, 7, 0, 0, 3863, 3864, 7, 9, 0, 0, 3864, 582, + 1, 0, 0, 0, 3865, 3866, 7, 24, 0, 0, 3866, 3867, 7, 13, 0, 0, 3867, 3868, + 7, 10, 0, 0, 3868, 3869, 7, 14, 0, 0, 3869, 3870, 7, 10, 0, 0, 3870, 3871, + 7, 12, 0, 0, 3871, 3872, 7, 17, 0, 0, 3872, 3873, 7, 7, 0, 0, 3873, 3874, + 7, 23, 0, 0, 3874, 584, 1, 0, 0, 0, 3875, 3876, 7, 24, 0, 0, 3876, 3877, + 7, 13, 0, 0, 3877, 3878, 7, 10, 0, 0, 3878, 3879, 7, 12, 0, 0, 3879, 3880, + 7, 17, 0, 0, 3880, 3881, 7, 14, 0, 0, 3881, 3882, 7, 5, 0, 0, 3882, 3883, + 7, 16, 0, 0, 3883, 3884, 7, 10, 0, 0, 3884, 586, 1, 0, 0, 0, 3885, 3886, + 7, 24, 0, 0, 3886, 3887, 7, 13, 0, 0, 3887, 3888, 7, 10, 0, 0, 3888, 3889, + 7, 24, 0, 0, 3889, 3890, 7, 5, 0, 0, 3890, 3891, 7, 13, 0, 0, 3891, 3892, + 7, 10, 0, 0, 3892, 588, 1, 0, 0, 0, 3893, 3894, 7, 24, 0, 0, 3894, 3895, + 7, 13, 0, 0, 3895, 3896, 7, 10, 0, 0, 3896, 3897, 7, 24, 0, 0, 3897, 3898, + 7, 5, 0, 0, 3898, 3899, 7, 13, 0, 0, 3899, 3900, 7, 10, 0, 0, 3900, 3901, + 7, 12, 0, 0, 3901, 590, 1, 0, 0, 0, 3902, 3903, 7, 24, 0, 0, 3903, 3904, + 7, 13, 0, 0, 3904, 3905, 7, 10, 0, 0, 3905, 3906, 7, 9, 0, 0, 3906, 3907, + 7, 10, 0, 0, 3907, 3908, 7, 13, 0, 0, 3908, 3909, 7, 27, 0, 0, 3909, 3910, + 7, 10, 0, 0, 3910, 592, 1, 0, 0, 0, 3911, 3912, 7, 24, 0, 0, 3912, 3913, + 7, 13, 0, 0, 3913, 3914, 7, 17, 0, 0, 3914, 3915, 7, 19, 0, 0, 3915, 3916, + 7, 13, 0, 0, 3916, 594, 1, 0, 0, 0, 3917, 3918, 7, 24, 0, 0, 3918, 3919, + 7, 13, 0, 0, 3919, 3920, 7, 17, 0, 0, 3920, 3921, 7, 27, 0, 0, 3921, 3922, + 7, 17, 0, 0, 3922, 3923, 7, 6, 0, 0, 3923, 3924, 7, 10, 0, 0, 3924, 3925, + 7, 23, 0, 0, 3925, 3926, 7, 10, 0, 0, 3926, 3927, 7, 9, 0, 0, 3927, 596, + 1, 0, 0, 0, 3928, 3929, 7, 24, 0, 0, 3929, 3930, 7, 13, 0, 0, 3930, 3931, + 7, 19, 0, 0, 3931, 3932, 7, 14, 0, 0, 3932, 3933, 7, 10, 0, 0, 3933, 3934, + 7, 12, 0, 0, 3934, 3935, 7, 22, 0, 0, 3935, 3936, 7, 13, 0, 0, 3936, 3937, + 7, 5, 0, 0, 3937, 3938, 7, 6, 0, 0, 3938, 598, 1, 0, 0, 0, 3939, 3940, + 7, 24, 0, 0, 3940, 3941, 7, 13, 0, 0, 3941, 3942, 7, 19, 0, 0, 3942, 3943, + 7, 14, 0, 0, 3943, 3944, 7, 10, 0, 0, 3944, 3945, 7, 12, 0, 0, 3945, 3946, + 7, 22, 0, 0, 3946, 3947, 7, 13, 0, 0, 3947, 3948, 7, 10, 0, 0, 3948, 600, + 1, 0, 0, 0, 3949, 3950, 7, 24, 0, 0, 3950, 3951, 7, 13, 0, 0, 3951, 3952, + 7, 19, 0, 0, 3952, 3953, 7, 23, 0, 0, 3953, 3954, 7, 13, 0, 0, 3954, 3955, + 7, 5, 0, 0, 3955, 3956, 7, 15, 0, 0, 3956, 602, 1, 0, 0, 0, 3957, 3958, + 7, 28, 0, 0, 3958, 3959, 7, 22, 0, 0, 3959, 3960, 7, 19, 0, 0, 3960, 3961, + 7, 16, 0, 0, 3961, 3962, 7, 10, 0, 0, 3962, 604, 1, 0, 0, 0, 3963, 3964, + 7, 13, 0, 0, 3964, 3965, 7, 5, 0, 0, 3965, 3966, 7, 7, 0, 0, 3966, 3967, + 7, 23, 0, 0, 3967, 3968, 7, 10, 0, 0, 3968, 606, 1, 0, 0, 0, 3969, 3970, + 7, 13, 0, 0, 3970, 3971, 7, 10, 0, 0, 3971, 3972, 7, 5, 0, 0, 3972, 3973, + 7, 12, 0, 0, 3973, 608, 1, 0, 0, 0, 3974, 3975, 7, 13, 0, 0, 3975, 3976, + 7, 10, 0, 0, 3976, 3977, 7, 5, 0, 0, 3977, 3978, 7, 9, 0, 0, 3978, 3979, + 7, 9, 0, 0, 3979, 3980, 7, 17, 0, 0, 3980, 3981, 7, 23, 0, 0, 3981, 3982, + 7, 7, 0, 0, 3982, 610, 1, 0, 0, 0, 3983, 3984, 7, 13, 0, 0, 3984, 3985, + 7, 10, 0, 0, 3985, 3986, 7, 14, 0, 0, 3986, 3987, 7, 20, 0, 0, 3987, 3988, + 7, 10, 0, 0, 3988, 3989, 7, 14, 0, 0, 3989, 3990, 7, 21, 0, 0, 3990, 612, + 1, 0, 0, 0, 3991, 3992, 7, 13, 0, 0, 3992, 3993, 7, 10, 0, 0, 3993, 3994, + 7, 14, 0, 0, 3994, 3995, 7, 22, 0, 0, 3995, 3996, 7, 13, 0, 0, 3996, 3997, + 7, 9, 0, 0, 3997, 3998, 7, 17, 0, 0, 3998, 3999, 7, 27, 0, 0, 3999, 4000, + 7, 10, 0, 0, 4000, 614, 1, 0, 0, 0, 4001, 4002, 7, 13, 0, 0, 4002, 4003, + 7, 10, 0, 0, 4003, 4004, 7, 25, 0, 0, 4004, 616, 1, 0, 0, 0, 4005, 4006, + 7, 13, 0, 0, 4006, 4007, 7, 10, 0, 0, 4007, 4008, 7, 25, 0, 0, 4008, 4009, + 7, 13, 0, 0, 4009, 4010, 7, 10, 0, 0, 4010, 4011, 7, 9, 0, 0, 4011, 4012, + 7, 20, 0, 0, 4012, 618, 1, 0, 0, 0, 4013, 4014, 7, 13, 0, 0, 4014, 4015, + 7, 10, 0, 0, 4015, 4016, 7, 17, 0, 0, 4016, 4017, 7, 7, 0, 0, 4017, 4018, + 7, 12, 0, 0, 4018, 4019, 7, 10, 0, 0, 4019, 4020, 7, 26, 0, 0, 4020, 620, + 1, 0, 0, 0, 4021, 4022, 7, 13, 0, 0, 4022, 4023, 7, 10, 0, 0, 4023, 4024, + 7, 6, 0, 0, 4024, 4025, 7, 5, 0, 0, 4025, 4026, 7, 16, 0, 0, 4026, 4027, + 7, 17, 0, 0, 4027, 4028, 7, 27, 0, 0, 4028, 4029, 7, 10, 0, 0, 4029, 622, + 1, 0, 0, 0, 4030, 4031, 7, 13, 0, 0, 4031, 4032, 7, 10, 0, 0, 4032, 4033, + 7, 6, 0, 0, 4033, 4034, 7, 10, 0, 0, 4034, 4035, 7, 5, 0, 0, 4035, 4036, + 7, 9, 0, 0, 4036, 4037, 7, 10, 0, 0, 4037, 624, 1, 0, 0, 0, 4038, 4039, + 7, 13, 0, 0, 4039, 4040, 7, 10, 0, 0, 4040, 4041, 7, 7, 0, 0, 4041, 4042, + 7, 5, 0, 0, 4042, 4043, 7, 15, 0, 0, 4043, 4044, 7, 10, 0, 0, 4044, 626, + 1, 0, 0, 0, 4045, 4046, 7, 13, 0, 0, 4046, 4047, 7, 10, 0, 0, 4047, 4048, + 7, 24, 0, 0, 4048, 4049, 7, 10, 0, 0, 4049, 4050, 7, 5, 0, 0, 4050, 4051, + 7, 16, 0, 0, 4051, 4052, 7, 5, 0, 0, 4052, 4053, 7, 18, 0, 0, 4053, 4054, + 7, 6, 0, 0, 4054, 4055, 7, 10, 0, 0, 4055, 628, 1, 0, 0, 0, 4056, 4057, + 7, 13, 0, 0, 4057, 4058, 7, 10, 0, 0, 4058, 4059, 7, 24, 0, 0, 4059, 4060, + 7, 6, 0, 0, 4060, 4061, 7, 5, 0, 0, 4061, 4062, 7, 14, 0, 0, 4062, 4063, + 7, 10, 0, 0, 4063, 630, 1, 0, 0, 0, 4064, 4065, 7, 13, 0, 0, 4065, 4066, + 7, 10, 0, 0, 4066, 4067, 7, 24, 0, 0, 4067, 4068, 7, 6, 0, 0, 4068, 4069, + 7, 17, 0, 0, 4069, 4070, 7, 14, 0, 0, 4070, 4071, 7, 5, 0, 0, 4071, 632, + 1, 0, 0, 0, 4072, 4073, 7, 13, 0, 0, 4073, 4074, 7, 10, 0, 0, 4074, 4075, + 7, 9, 0, 0, 4075, 4076, 7, 10, 0, 0, 4076, 4077, 7, 16, 0, 0, 4077, 634, + 1, 0, 0, 0, 4078, 4079, 7, 13, 0, 0, 4079, 4080, 7, 10, 0, 0, 4080, 4081, + 7, 9, 0, 0, 4081, 4082, 7, 16, 0, 0, 4082, 4083, 7, 5, 0, 0, 4083, 4084, + 7, 13, 0, 0, 4084, 4085, 7, 16, 0, 0, 4085, 636, 1, 0, 0, 0, 4086, 4087, + 7, 13, 0, 0, 4087, 4088, 7, 10, 0, 0, 4088, 4089, 7, 9, 0, 0, 4089, 4090, + 7, 16, 0, 0, 4090, 4091, 7, 13, 0, 0, 4091, 4092, 7, 17, 0, 0, 4092, 4093, + 7, 14, 0, 0, 4093, 4094, 7, 16, 0, 0, 4094, 638, 1, 0, 0, 0, 4095, 4096, + 7, 13, 0, 0, 4096, 4097, 7, 10, 0, 0, 4097, 4098, 7, 16, 0, 0, 4098, 4099, + 7, 22, 0, 0, 4099, 4100, 7, 13, 0, 0, 4100, 4101, 7, 7, 0, 0, 4101, 4102, + 7, 9, 0, 0, 4102, 640, 1, 0, 0, 0, 4103, 4104, 7, 13, 0, 0, 4104, 4105, + 7, 10, 0, 0, 4105, 4106, 7, 27, 0, 0, 4106, 4107, 7, 19, 0, 0, 4107, 4108, + 7, 21, 0, 0, 4108, 4109, 7, 10, 0, 0, 4109, 642, 1, 0, 0, 0, 4110, 4111, + 7, 13, 0, 0, 4111, 4112, 7, 19, 0, 0, 4112, 4113, 7, 6, 0, 0, 4113, 4114, + 7, 10, 0, 0, 4114, 644, 1, 0, 0, 0, 4115, 4116, 7, 13, 0, 0, 4116, 4117, + 7, 19, 0, 0, 4117, 4118, 7, 6, 0, 0, 4118, 4119, 7, 6, 0, 0, 4119, 4120, + 7, 18, 0, 0, 4120, 4121, 7, 5, 0, 0, 4121, 4122, 7, 14, 0, 0, 4122, 4123, + 7, 21, 0, 0, 4123, 646, 1, 0, 0, 0, 4124, 4125, 7, 13, 0, 0, 4125, 4126, + 7, 19, 0, 0, 4126, 4127, 7, 29, 0, 0, 4127, 4128, 7, 9, 0, 0, 4128, 648, + 1, 0, 0, 0, 4129, 4130, 7, 13, 0, 0, 4130, 4131, 7, 22, 0, 0, 4131, 4132, + 7, 6, 0, 0, 4132, 4133, 7, 10, 0, 0, 4133, 650, 1, 0, 0, 0, 4134, 4135, + 7, 9, 0, 0, 4135, 4136, 7, 5, 0, 0, 4136, 4137, 7, 27, 0, 0, 4137, 4138, + 7, 10, 0, 0, 4138, 4139, 7, 24, 0, 0, 4139, 4140, 7, 19, 0, 0, 4140, 4141, + 7, 17, 0, 0, 4141, 4142, 7, 7, 0, 0, 4142, 4143, 7, 16, 0, 0, 4143, 652, + 1, 0, 0, 0, 4144, 4145, 7, 9, 0, 0, 4145, 4146, 7, 14, 0, 0, 4146, 4147, + 7, 20, 0, 0, 4147, 4148, 7, 10, 0, 0, 4148, 4149, 7, 15, 0, 0, 4149, 4150, + 7, 5, 0, 0, 4150, 654, 1, 0, 0, 0, 4151, 4152, 7, 9, 0, 0, 4152, 4153, + 7, 14, 0, 0, 4153, 4154, 7, 13, 0, 0, 4154, 4155, 7, 19, 0, 0, 4155, 4156, + 7, 6, 0, 0, 4156, 4157, 7, 6, 0, 0, 4157, 656, 1, 0, 0, 0, 4158, 4159, + 7, 9, 0, 0, 4159, 4160, 7, 10, 0, 0, 4160, 4161, 7, 5, 0, 0, 4161, 4162, + 7, 13, 0, 0, 4162, 4163, 7, 14, 0, 0, 4163, 4164, 7, 20, 0, 0, 4164, 658, + 1, 0, 0, 0, 4165, 4166, 7, 9, 0, 0, 4166, 4167, 7, 10, 0, 0, 4167, 4168, + 7, 14, 0, 0, 4168, 4169, 7, 19, 0, 0, 4169, 4170, 7, 7, 0, 0, 4170, 4171, + 7, 12, 0, 0, 4171, 660, 1, 0, 0, 0, 4172, 4173, 7, 9, 0, 0, 4173, 4174, + 7, 10, 0, 0, 4174, 4175, 7, 14, 0, 0, 4175, 4176, 7, 22, 0, 0, 4176, 4177, + 7, 13, 0, 0, 4177, 4178, 7, 17, 0, 0, 4178, 4179, 7, 16, 0, 0, 4179, 4180, + 7, 8, 0, 0, 4180, 662, 1, 0, 0, 0, 4181, 4182, 7, 9, 0, 0, 4182, 4183, + 7, 10, 0, 0, 4183, 4184, 7, 28, 0, 0, 4184, 4185, 7, 22, 0, 0, 4185, 4186, + 7, 10, 0, 0, 4186, 4187, 7, 7, 0, 0, 4187, 4188, 7, 14, 0, 0, 4188, 4189, + 7, 10, 0, 0, 4189, 664, 1, 0, 0, 0, 4190, 4191, 7, 9, 0, 0, 4191, 4192, + 7, 10, 0, 0, 4192, 4193, 7, 28, 0, 0, 4193, 4194, 7, 22, 0, 0, 4194, 4195, + 7, 10, 0, 0, 4195, 4196, 7, 7, 0, 0, 4196, 4197, 7, 14, 0, 0, 4197, 4198, + 7, 10, 0, 0, 4198, 4199, 7, 9, 0, 0, 4199, 666, 1, 0, 0, 0, 4200, 4201, + 7, 9, 0, 0, 4201, 4202, 7, 10, 0, 0, 4202, 4203, 7, 13, 0, 0, 4203, 4204, + 7, 17, 0, 0, 4204, 4205, 7, 5, 0, 0, 4205, 4206, 7, 6, 0, 0, 4206, 4207, + 7, 17, 0, 0, 4207, 4208, 7, 11, 0, 0, 4208, 4209, 7, 5, 0, 0, 4209, 4210, + 7, 18, 0, 0, 4210, 4211, 7, 6, 0, 0, 4211, 4212, 7, 10, 0, 0, 4212, 668, + 1, 0, 0, 0, 4213, 4214, 7, 9, 0, 0, 4214, 4215, 7, 10, 0, 0, 4215, 4216, + 7, 13, 0, 0, 4216, 4217, 7, 27, 0, 0, 4217, 4218, 7, 10, 0, 0, 4218, 4219, + 7, 13, 0, 0, 4219, 670, 1, 0, 0, 0, 4220, 4221, 7, 9, 0, 0, 4221, 4222, + 7, 10, 0, 0, 4222, 4223, 7, 9, 0, 0, 4223, 4224, 7, 9, 0, 0, 4224, 4225, + 7, 17, 0, 0, 4225, 4226, 7, 19, 0, 0, 4226, 4227, 7, 7, 0, 0, 4227, 672, + 1, 0, 0, 0, 4228, 4229, 7, 9, 0, 0, 4229, 4230, 7, 10, 0, 0, 4230, 4231, + 7, 16, 0, 0, 4231, 674, 1, 0, 0, 0, 4232, 4233, 7, 9, 0, 0, 4233, 4234, + 7, 20, 0, 0, 4234, 4235, 7, 5, 0, 0, 4235, 4236, 7, 13, 0, 0, 4236, 4237, + 7, 10, 0, 0, 4237, 676, 1, 0, 0, 0, 4238, 4239, 7, 9, 0, 0, 4239, 4240, + 7, 20, 0, 0, 4240, 4241, 7, 19, 0, 0, 4241, 4242, 7, 29, 0, 0, 4242, 678, + 1, 0, 0, 0, 4243, 4244, 7, 9, 0, 0, 4244, 4245, 7, 17, 0, 0, 4245, 4246, + 7, 15, 0, 0, 4246, 4247, 7, 24, 0, 0, 4247, 4248, 7, 6, 0, 0, 4248, 4249, + 7, 10, 0, 0, 4249, 680, 1, 0, 0, 0, 4250, 4251, 7, 9, 0, 0, 4251, 4252, + 7, 7, 0, 0, 4252, 4253, 7, 5, 0, 0, 4253, 4254, 7, 24, 0, 0, 4254, 4255, + 7, 9, 0, 0, 4255, 4256, 7, 20, 0, 0, 4256, 4257, 7, 19, 0, 0, 4257, 4258, + 7, 16, 0, 0, 4258, 682, 1, 0, 0, 0, 4259, 4260, 7, 9, 0, 0, 4260, 4261, + 7, 16, 0, 0, 4261, 4262, 7, 5, 0, 0, 4262, 4263, 7, 18, 0, 0, 4263, 4264, + 7, 6, 0, 0, 4264, 4265, 7, 10, 0, 0, 4265, 684, 1, 0, 0, 0, 4266, 4267, + 7, 9, 0, 0, 4267, 4268, 7, 16, 0, 0, 4268, 4269, 7, 5, 0, 0, 4269, 4270, + 7, 7, 0, 0, 4270, 4271, 7, 12, 0, 0, 4271, 4272, 7, 5, 0, 0, 4272, 4273, + 7, 6, 0, 0, 4273, 4274, 7, 19, 0, 0, 4274, 4275, 7, 7, 0, 0, 4275, 4276, + 7, 10, 0, 0, 4276, 686, 1, 0, 0, 0, 4277, 4278, 7, 9, 0, 0, 4278, 4279, + 7, 16, 0, 0, 4279, 4280, 7, 5, 0, 0, 4280, 4281, 7, 13, 0, 0, 4281, 4282, + 7, 16, 0, 0, 4282, 688, 1, 0, 0, 0, 4283, 4284, 7, 9, 0, 0, 4284, 4285, + 7, 16, 0, 0, 4285, 4286, 7, 5, 0, 0, 4286, 4287, 7, 16, 0, 0, 4287, 4288, + 7, 10, 0, 0, 4288, 4289, 7, 15, 0, 0, 4289, 4290, 7, 10, 0, 0, 4290, 4291, + 7, 7, 0, 0, 4291, 4292, 7, 16, 0, 0, 4292, 690, 1, 0, 0, 0, 4293, 4294, + 7, 9, 0, 0, 4294, 4295, 7, 16, 0, 0, 4295, 4296, 7, 5, 0, 0, 4296, 4297, + 7, 16, 0, 0, 4297, 4298, 7, 17, 0, 0, 4298, 4299, 7, 9, 0, 0, 4299, 4300, + 7, 16, 0, 0, 4300, 4301, 7, 17, 0, 0, 4301, 4302, 7, 14, 0, 0, 4302, 4303, + 7, 9, 0, 0, 4303, 692, 1, 0, 0, 0, 4304, 4305, 7, 9, 0, 0, 4305, 4306, + 7, 16, 0, 0, 4306, 4307, 7, 12, 0, 0, 4307, 4308, 7, 17, 0, 0, 4308, 4309, + 7, 7, 0, 0, 4309, 694, 1, 0, 0, 0, 4310, 4311, 7, 9, 0, 0, 4311, 4312, + 7, 16, 0, 0, 4312, 4313, 7, 12, 0, 0, 4313, 4314, 7, 19, 0, 0, 4314, 4315, + 7, 22, 0, 0, 4315, 4316, 7, 16, 0, 0, 4316, 696, 1, 0, 0, 0, 4317, 4318, + 7, 9, 0, 0, 4318, 4319, 7, 16, 0, 0, 4319, 4320, 7, 19, 0, 0, 4320, 4321, + 7, 13, 0, 0, 4321, 4322, 7, 5, 0, 0, 4322, 4323, 7, 23, 0, 0, 4323, 4324, + 7, 10, 0, 0, 4324, 698, 1, 0, 0, 0, 4325, 4326, 7, 9, 0, 0, 4326, 4327, + 7, 16, 0, 0, 4327, 4328, 7, 13, 0, 0, 4328, 4329, 7, 17, 0, 0, 4329, 4330, + 7, 14, 0, 0, 4330, 4331, 7, 16, 0, 0, 4331, 700, 1, 0, 0, 0, 4332, 4333, + 7, 9, 0, 0, 4333, 4334, 7, 16, 0, 0, 4334, 4335, 7, 13, 0, 0, 4335, 4336, + 7, 17, 0, 0, 4336, 4337, 7, 24, 0, 0, 4337, 702, 1, 0, 0, 0, 4338, 4339, + 7, 9, 0, 0, 4339, 4340, 7, 8, 0, 0, 4340, 4341, 7, 9, 0, 0, 4341, 4342, + 7, 17, 0, 0, 4342, 4343, 7, 12, 0, 0, 4343, 704, 1, 0, 0, 0, 4344, 4345, + 7, 9, 0, 0, 4345, 4346, 7, 8, 0, 0, 4346, 4347, 7, 9, 0, 0, 4347, 4348, + 7, 16, 0, 0, 4348, 4349, 7, 10, 0, 0, 4349, 4350, 7, 15, 0, 0, 4350, 706, + 1, 0, 0, 0, 4351, 4352, 7, 16, 0, 0, 4352, 4353, 7, 5, 0, 0, 4353, 4354, + 7, 18, 0, 0, 4354, 4355, 7, 6, 0, 0, 4355, 4356, 7, 10, 0, 0, 4356, 4357, + 7, 9, 0, 0, 4357, 708, 1, 0, 0, 0, 4358, 4359, 7, 16, 0, 0, 4359, 4360, + 7, 5, 0, 0, 4360, 4361, 7, 18, 0, 0, 4361, 4362, 7, 6, 0, 0, 4362, 4363, + 7, 10, 0, 0, 4363, 4364, 7, 9, 0, 0, 4364, 4365, 7, 24, 0, 0, 4365, 4366, + 7, 5, 0, 0, 4366, 4367, 7, 14, 0, 0, 4367, 4368, 7, 10, 0, 0, 4368, 710, + 1, 0, 0, 0, 4369, 4370, 7, 16, 0, 0, 4370, 4371, 7, 10, 0, 0, 4371, 4372, + 7, 15, 0, 0, 4372, 4373, 7, 24, 0, 0, 4373, 712, 1, 0, 0, 0, 4374, 4375, + 7, 16, 0, 0, 4375, 4376, 7, 10, 0, 0, 4376, 4377, 7, 15, 0, 0, 4377, 4378, + 7, 24, 0, 0, 4378, 4379, 7, 6, 0, 0, 4379, 4380, 7, 5, 0, 0, 4380, 4381, + 7, 16, 0, 0, 4381, 4382, 7, 10, 0, 0, 4382, 714, 1, 0, 0, 0, 4383, 4384, + 7, 16, 0, 0, 4384, 4385, 7, 10, 0, 0, 4385, 4386, 7, 15, 0, 0, 4386, 4387, + 7, 24, 0, 0, 4387, 4388, 7, 19, 0, 0, 4388, 4389, 7, 13, 0, 0, 4389, 4390, + 7, 5, 0, 0, 4390, 4391, 7, 13, 0, 0, 4391, 4392, 7, 8, 0, 0, 4392, 716, + 1, 0, 0, 0, 4393, 4394, 7, 16, 0, 0, 4394, 4395, 7, 10, 0, 0, 4395, 4396, + 7, 26, 0, 0, 4396, 4397, 7, 16, 0, 0, 4397, 718, 1, 0, 0, 0, 4398, 4399, + 7, 16, 0, 0, 4399, 4400, 7, 13, 0, 0, 4400, 4401, 7, 5, 0, 0, 4401, 4402, + 7, 7, 0, 0, 4402, 4403, 7, 9, 0, 0, 4403, 4404, 7, 5, 0, 0, 4404, 4405, + 7, 14, 0, 0, 4405, 4406, 7, 16, 0, 0, 4406, 4407, 7, 17, 0, 0, 4407, 4408, + 7, 19, 0, 0, 4408, 4409, 7, 7, 0, 0, 4409, 720, 1, 0, 0, 0, 4410, 4411, + 7, 16, 0, 0, 4411, 4412, 7, 13, 0, 0, 4412, 4413, 7, 17, 0, 0, 4413, 4414, + 7, 23, 0, 0, 4414, 4415, 7, 23, 0, 0, 4415, 4416, 7, 10, 0, 0, 4416, 4417, + 7, 13, 0, 0, 4417, 722, 1, 0, 0, 0, 4418, 4419, 7, 16, 0, 0, 4419, 4420, + 7, 13, 0, 0, 4420, 4421, 7, 22, 0, 0, 4421, 4422, 7, 7, 0, 0, 4422, 4423, + 7, 14, 0, 0, 4423, 4424, 7, 5, 0, 0, 4424, 4425, 7, 16, 0, 0, 4425, 4426, + 7, 10, 0, 0, 4426, 724, 1, 0, 0, 0, 4427, 4428, 7, 16, 0, 0, 4428, 4429, + 7, 13, 0, 0, 4429, 4430, 7, 22, 0, 0, 4430, 4431, 7, 9, 0, 0, 4431, 4432, + 7, 16, 0, 0, 4432, 4433, 7, 10, 0, 0, 4433, 4434, 7, 12, 0, 0, 4434, 726, + 1, 0, 0, 0, 4435, 4436, 7, 16, 0, 0, 4436, 4437, 7, 8, 0, 0, 4437, 4438, + 7, 24, 0, 0, 4438, 4439, 7, 10, 0, 0, 4439, 728, 1, 0, 0, 0, 4440, 4441, + 7, 16, 0, 0, 4441, 4442, 7, 8, 0, 0, 4442, 4443, 7, 24, 0, 0, 4443, 4444, + 7, 10, 0, 0, 4444, 4445, 7, 9, 0, 0, 4445, 730, 1, 0, 0, 0, 4446, 4447, + 7, 22, 0, 0, 4447, 4448, 7, 7, 0, 0, 4448, 4449, 7, 18, 0, 0, 4449, 4450, + 7, 19, 0, 0, 4450, 4451, 7, 22, 0, 0, 4451, 4452, 7, 7, 0, 0, 4452, 4453, + 7, 12, 0, 0, 4453, 4454, 7, 10, 0, 0, 4454, 4455, 7, 12, 0, 0, 4455, 732, + 1, 0, 0, 0, 4456, 4457, 7, 22, 0, 0, 4457, 4458, 7, 7, 0, 0, 4458, 4459, + 7, 14, 0, 0, 4459, 4460, 7, 19, 0, 0, 4460, 4461, 7, 15, 0, 0, 4461, 4462, + 7, 15, 0, 0, 4462, 4463, 7, 17, 0, 0, 4463, 4464, 7, 16, 0, 0, 4464, 4465, + 7, 16, 0, 0, 4465, 4466, 7, 10, 0, 0, 4466, 4467, 7, 12, 0, 0, 4467, 734, + 1, 0, 0, 0, 4468, 4469, 7, 22, 0, 0, 4469, 4470, 7, 7, 0, 0, 4470, 4471, + 7, 10, 0, 0, 4471, 4472, 7, 7, 0, 0, 4472, 4473, 7, 14, 0, 0, 4473, 4474, + 7, 13, 0, 0, 4474, 4475, 7, 8, 0, 0, 4475, 4476, 7, 24, 0, 0, 4476, 4477, + 7, 16, 0, 0, 4477, 4478, 7, 10, 0, 0, 4478, 4479, 7, 12, 0, 0, 4479, 736, + 1, 0, 0, 0, 4480, 4481, 7, 22, 0, 0, 4481, 4482, 7, 7, 0, 0, 4482, 4483, + 7, 21, 0, 0, 4483, 4484, 7, 7, 0, 0, 4484, 4485, 7, 19, 0, 0, 4485, 4486, + 7, 29, 0, 0, 4486, 4487, 7, 7, 0, 0, 4487, 738, 1, 0, 0, 0, 4488, 4489, + 7, 22, 0, 0, 4489, 4490, 7, 7, 0, 0, 4490, 4491, 7, 6, 0, 0, 4491, 4492, + 7, 17, 0, 0, 4492, 4493, 7, 9, 0, 0, 4493, 4494, 7, 16, 0, 0, 4494, 4495, + 7, 10, 0, 0, 4495, 4496, 7, 7, 0, 0, 4496, 740, 1, 0, 0, 0, 4497, 4498, + 7, 22, 0, 0, 4498, 4499, 7, 7, 0, 0, 4499, 4500, 7, 6, 0, 0, 4500, 4501, + 7, 19, 0, 0, 4501, 4502, 7, 23, 0, 0, 4502, 4503, 7, 23, 0, 0, 4503, 4504, + 7, 10, 0, 0, 4504, 4505, 7, 12, 0, 0, 4505, 742, 1, 0, 0, 0, 4506, 4507, + 7, 22, 0, 0, 4507, 4508, 7, 7, 0, 0, 4508, 4509, 7, 16, 0, 0, 4509, 4510, + 7, 17, 0, 0, 4510, 4511, 7, 6, 0, 0, 4511, 744, 1, 0, 0, 0, 4512, 4513, + 7, 22, 0, 0, 4513, 4514, 7, 24, 0, 0, 4514, 4515, 7, 12, 0, 0, 4515, 4516, + 7, 5, 0, 0, 4516, 4517, 7, 16, 0, 0, 4517, 4518, 7, 10, 0, 0, 4518, 746, + 1, 0, 0, 0, 4519, 4520, 7, 27, 0, 0, 4520, 4521, 7, 5, 0, 0, 4521, 4522, + 7, 14, 0, 0, 4522, 4523, 7, 22, 0, 0, 4523, 4524, 7, 22, 0, 0, 4524, 4525, + 7, 15, 0, 0, 4525, 748, 1, 0, 0, 0, 4526, 4527, 7, 27, 0, 0, 4527, 4528, + 7, 5, 0, 0, 4528, 4529, 7, 6, 0, 0, 4529, 4530, 7, 17, 0, 0, 4530, 4531, + 7, 12, 0, 0, 4531, 750, 1, 0, 0, 0, 4532, 4533, 7, 27, 0, 0, 4533, 4534, + 7, 5, 0, 0, 4534, 4535, 7, 6, 0, 0, 4535, 4536, 7, 17, 0, 0, 4536, 4537, + 7, 12, 0, 0, 4537, 4538, 7, 5, 0, 0, 4538, 4539, 7, 16, 0, 0, 4539, 4540, + 7, 10, 0, 0, 4540, 752, 1, 0, 0, 0, 4541, 4542, 7, 27, 0, 0, 4542, 4543, + 7, 5, 0, 0, 4543, 4544, 7, 6, 0, 0, 4544, 4545, 7, 17, 0, 0, 4545, 4546, + 7, 12, 0, 0, 4546, 4547, 7, 5, 0, 0, 4547, 4548, 7, 16, 0, 0, 4548, 4549, + 7, 19, 0, 0, 4549, 4550, 7, 13, 0, 0, 4550, 754, 1, 0, 0, 0, 4551, 4552, + 7, 27, 0, 0, 4552, 4553, 7, 5, 0, 0, 4553, 4554, 7, 13, 0, 0, 4554, 4555, + 7, 8, 0, 0, 4555, 4556, 7, 17, 0, 0, 4556, 4557, 7, 7, 0, 0, 4557, 4558, + 7, 23, 0, 0, 4558, 756, 1, 0, 0, 0, 4559, 4560, 7, 27, 0, 0, 4560, 4561, + 7, 10, 0, 0, 4561, 4562, 7, 13, 0, 0, 4562, 4563, 7, 9, 0, 0, 4563, 4564, + 7, 17, 0, 0, 4564, 4565, 7, 19, 0, 0, 4565, 4566, 7, 7, 0, 0, 4566, 758, + 1, 0, 0, 0, 4567, 4568, 7, 27, 0, 0, 4568, 4569, 7, 17, 0, 0, 4569, 4570, + 7, 10, 0, 0, 4570, 4571, 7, 29, 0, 0, 4571, 760, 1, 0, 0, 0, 4572, 4573, + 7, 27, 0, 0, 4573, 4574, 7, 19, 0, 0, 4574, 4575, 7, 6, 0, 0, 4575, 4576, + 7, 5, 0, 0, 4576, 4577, 7, 16, 0, 0, 4577, 4578, 7, 17, 0, 0, 4578, 4579, + 7, 6, 0, 0, 4579, 4580, 7, 10, 0, 0, 4580, 762, 1, 0, 0, 0, 4581, 4582, + 7, 29, 0, 0, 4582, 4583, 7, 20, 0, 0, 4583, 4584, 7, 17, 0, 0, 4584, 4585, + 7, 16, 0, 0, 4585, 4586, 7, 10, 0, 0, 4586, 4587, 7, 9, 0, 0, 4587, 4588, + 7, 24, 0, 0, 4588, 4589, 7, 5, 0, 0, 4589, 4590, 7, 14, 0, 0, 4590, 4591, + 7, 10, 0, 0, 4591, 764, 1, 0, 0, 0, 4592, 4593, 7, 29, 0, 0, 4593, 4594, + 7, 17, 0, 0, 4594, 4595, 7, 16, 0, 0, 4595, 4596, 7, 20, 0, 0, 4596, 4597, + 7, 19, 0, 0, 4597, 4598, 7, 22, 0, 0, 4598, 4599, 7, 16, 0, 0, 4599, 766, + 1, 0, 0, 0, 4600, 4601, 7, 29, 0, 0, 4601, 4602, 7, 19, 0, 0, 4602, 4603, + 7, 13, 0, 0, 4603, 4604, 7, 21, 0, 0, 4604, 768, 1, 0, 0, 0, 4605, 4606, + 7, 29, 0, 0, 4606, 4607, 7, 13, 0, 0, 4607, 4608, 7, 5, 0, 0, 4608, 4609, + 7, 24, 0, 0, 4609, 4610, 7, 24, 0, 0, 4610, 4611, 7, 10, 0, 0, 4611, 4612, + 7, 13, 0, 0, 4612, 770, 1, 0, 0, 0, 4613, 4614, 7, 29, 0, 0, 4614, 4615, + 7, 13, 0, 0, 4615, 4616, 7, 17, 0, 0, 4616, 4617, 7, 16, 0, 0, 4617, 4618, + 7, 10, 0, 0, 4618, 772, 1, 0, 0, 0, 4619, 4620, 7, 26, 0, 0, 4620, 4621, + 7, 15, 0, 0, 4621, 4622, 7, 6, 0, 0, 4622, 774, 1, 0, 0, 0, 4623, 4624, + 7, 8, 0, 0, 4624, 4625, 7, 10, 0, 0, 4625, 4626, 7, 5, 0, 0, 4626, 4627, + 7, 13, 0, 0, 4627, 776, 1, 0, 0, 0, 4628, 4629, 7, 8, 0, 0, 4629, 4630, + 7, 10, 0, 0, 4630, 4631, 7, 9, 0, 0, 4631, 778, 1, 0, 0, 0, 4632, 4633, + 7, 11, 0, 0, 4633, 4634, 7, 19, 0, 0, 4634, 4635, 7, 7, 0, 0, 4635, 4636, + 7, 10, 0, 0, 4636, 780, 1, 0, 0, 0, 4637, 4638, 7, 28, 0, 0, 4638, 4639, + 7, 22, 0, 0, 4639, 4640, 7, 5, 0, 0, 4640, 4641, 7, 6, 0, 0, 4641, 4642, + 7, 17, 0, 0, 4642, 4643, 7, 25, 0, 0, 4643, 4644, 7, 8, 0, 0, 4644, 782, + 1, 0, 0, 0, 4645, 4646, 7, 14, 0, 0, 4646, 4647, 7, 19, 0, 0, 4647, 4648, + 7, 7, 0, 0, 4648, 4649, 7, 7, 0, 0, 4649, 4650, 7, 10, 0, 0, 4650, 4651, + 7, 14, 0, 0, 4651, 4652, 7, 16, 0, 0, 4652, 784, 1, 0, 0, 0, 4653, 4654, + 7, 16, 0, 0, 4654, 4655, 7, 19, 0, 0, 4655, 4656, 7, 24, 0, 0, 4656, 786, + 1, 0, 0, 0, 4657, 4658, 7, 27, 0, 0, 4658, 4659, 7, 5, 0, 0, 4659, 4660, + 7, 13, 0, 0, 4660, 4661, 7, 18, 0, 0, 4661, 4662, 7, 8, 0, 0, 4662, 4663, + 7, 16, 0, 0, 4663, 4664, 7, 10, 0, 0, 4664, 788, 1, 0, 0, 0, 4665, 4666, + 7, 27, 0, 0, 4666, 4667, 7, 5, 0, 0, 4667, 4668, 7, 13, 0, 0, 4668, 4669, + 7, 18, 0, 0, 4669, 4670, 7, 17, 0, 0, 4670, 4671, 7, 7, 0, 0, 4671, 4672, + 7, 5, 0, 0, 4672, 4673, 7, 13, 0, 0, 4673, 4674, 7, 8, 0, 0, 4674, 790, + 1, 0, 0, 0, 4675, 4676, 7, 14, 0, 0, 4676, 4677, 7, 19, 0, 0, 4677, 4678, + 7, 7, 0, 0, 4678, 4679, 7, 30, 0, 0, 4679, 4680, 7, 22, 0, 0, 4680, 4681, + 7, 7, 0, 0, 4681, 4682, 7, 14, 0, 0, 4682, 4683, 7, 16, 0, 0, 4683, 4684, + 7, 17, 0, 0, 4684, 4685, 7, 19, 0, 0, 4685, 4686, 7, 7, 0, 0, 4686, 792, + 1, 0, 0, 0, 4687, 4688, 7, 12, 0, 0, 4688, 4689, 7, 10, 0, 0, 4689, 4690, + 7, 25, 0, 0, 4690, 4691, 7, 17, 0, 0, 4691, 4692, 7, 7, 0, 0, 4692, 4693, + 7, 17, 0, 0, 4693, 4694, 7, 16, 0, 0, 4694, 4695, 7, 17, 0, 0, 4695, 4696, + 7, 19, 0, 0, 4696, 4697, 7, 7, 0, 0, 4697, 794, 1, 0, 0, 0, 4698, 4699, + 7, 12, 0, 0, 4699, 4700, 7, 5, 0, 0, 4700, 4701, 7, 16, 0, 0, 4701, 4702, + 7, 5, 0, 0, 4702, 4703, 7, 9, 0, 0, 4703, 4704, 7, 20, 0, 0, 4704, 4705, + 7, 5, 0, 0, 4705, 4706, 7, 13, 0, 0, 4706, 4707, 7, 10, 0, 0, 4707, 796, + 1, 0, 0, 0, 4708, 4709, 7, 25, 0, 0, 4709, 4710, 7, 17, 0, 0, 4710, 4711, + 7, 6, 0, 0, 4711, 4712, 7, 10, 0, 0, 4712, 798, 1, 0, 0, 0, 4713, 4714, + 7, 24, 0, 0, 4714, 4715, 7, 22, 0, 0, 4715, 4716, 7, 18, 0, 0, 4716, 4717, + 7, 6, 0, 0, 4717, 4718, 7, 17, 0, 0, 4718, 4719, 7, 14, 0, 0, 4719, 4720, + 7, 5, 0, 0, 4720, 4721, 7, 14, 0, 0, 4721, 4722, 7, 14, 0, 0, 4722, 4723, + 7, 10, 0, 0, 4723, 4724, 7, 9, 0, 0, 4724, 4725, 7, 9, 0, 0, 4725, 4726, + 7, 17, 0, 0, 4726, 4727, 7, 18, 0, 0, 4727, 4728, 7, 6, 0, 0, 4728, 4729, + 7, 10, 0, 0, 4729, 800, 1, 0, 0, 0, 4730, 4731, 7, 17, 0, 0, 4731, 4732, + 7, 7, 0, 0, 4732, 4733, 7, 14, 0, 0, 4733, 4734, 7, 6, 0, 0, 4734, 4735, + 7, 22, 0, 0, 4735, 4736, 7, 12, 0, 0, 4736, 4737, 7, 10, 0, 0, 4737, 4738, + 7, 7, 0, 0, 4738, 4739, 7, 10, 0, 0, 4739, 4740, 7, 29, 0, 0, 4740, 802, + 1, 0, 0, 0, 4741, 4742, 7, 17, 0, 0, 4742, 4743, 7, 5, 0, 0, 4743, 4744, + 7, 15, 0, 0, 4744, 4745, 5, 95, 0, 0, 4745, 4746, 7, 13, 0, 0, 4746, 4747, + 7, 19, 0, 0, 4747, 4748, 7, 6, 0, 0, 4748, 4749, 7, 10, 0, 0, 4749, 804, + 1, 0, 0, 0, 4750, 4751, 7, 14, 0, 0, 4751, 4752, 7, 5, 0, 0, 4752, 4753, + 7, 16, 0, 0, 4753, 4754, 7, 5, 0, 0, 4754, 4755, 7, 6, 0, 0, 4755, 4756, + 7, 19, 0, 0, 4756, 4757, 7, 23, 0, 0, 4757, 4758, 5, 95, 0, 0, 4758, 4759, + 7, 13, 0, 0, 4759, 4760, 7, 19, 0, 0, 4760, 4761, 7, 6, 0, 0, 4761, 4762, + 7, 10, 0, 0, 4762, 806, 1, 0, 0, 0, 4763, 4764, 7, 14, 0, 0, 4764, 4765, + 7, 5, 0, 0, 4765, 4766, 7, 16, 0, 0, 4766, 4767, 7, 5, 0, 0, 4767, 4768, + 7, 6, 0, 0, 4768, 4769, 7, 19, 0, 0, 4769, 4770, 7, 23, 0, 0, 4770, 4771, + 5, 95, 0, 0, 4771, 4772, 7, 17, 0, 0, 4772, 4773, 7, 12, 0, 0, 4773, 808, + 1, 0, 0, 0, 4774, 4775, 7, 20, 0, 0, 4775, 4776, 7, 17, 0, 0, 4776, 4777, + 7, 27, 0, 0, 4777, 4778, 7, 10, 0, 0, 4778, 810, 1, 0, 0, 0, 4779, 4780, + 7, 15, 0, 0, 4780, 4781, 7, 10, 0, 0, 4781, 4782, 7, 16, 0, 0, 4782, 4783, + 7, 5, 0, 0, 4783, 4784, 7, 9, 0, 0, 4784, 4785, 7, 16, 0, 0, 4785, 4786, + 7, 19, 0, 0, 4786, 4787, 7, 13, 0, 0, 4787, 4788, 7, 10, 0, 0, 4788, 812, + 1, 0, 0, 0, 4789, 4790, 7, 22, 0, 0, 4790, 4791, 7, 13, 0, 0, 4791, 4792, + 7, 17, 0, 0, 4792, 814, 1, 0, 0, 0, 4793, 4794, 7, 24, 0, 0, 4794, 4795, + 7, 19, 0, 0, 4795, 4796, 7, 9, 0, 0, 4796, 4797, 7, 16, 0, 0, 4797, 4798, + 7, 23, 0, 0, 4798, 4799, 7, 13, 0, 0, 4799, 4800, 7, 10, 0, 0, 4800, 4801, + 7, 9, 0, 0, 4801, 816, 1, 0, 0, 0, 4802, 4803, 7, 15, 0, 0, 4803, 4804, + 7, 8, 0, 0, 4804, 4805, 7, 9, 0, 0, 4805, 4806, 7, 28, 0, 0, 4806, 4807, + 7, 6, 0, 0, 4807, 818, 1, 0, 0, 0, 4808, 4809, 7, 9, 0, 0, 4809, 4810, + 7, 10, 0, 0, 4810, 4811, 7, 14, 0, 0, 4811, 4812, 7, 13, 0, 0, 4812, 4813, + 7, 10, 0, 0, 4813, 4814, 7, 16, 0, 0, 4814, 4815, 5, 95, 0, 0, 4815, 4816, + 7, 5, 0, 0, 4816, 4817, 7, 13, 0, 0, 4817, 4818, 7, 7, 0, 0, 4818, 820, + 1, 0, 0, 0, 4819, 4820, 7, 21, 0, 0, 4820, 4821, 7, 17, 0, 0, 4821, 4822, + 7, 7, 0, 0, 4822, 4823, 7, 10, 0, 0, 4823, 4824, 7, 9, 0, 0, 4824, 4825, + 7, 17, 0, 0, 4825, 4826, 7, 9, 0, 0, 4826, 822, 1, 0, 0, 0, 4827, 4828, + 7, 21, 0, 0, 4828, 4829, 7, 5, 0, 0, 4829, 4830, 7, 25, 0, 0, 4830, 4831, + 7, 21, 0, 0, 4831, 4832, 7, 5, 0, 0, 4832, 824, 1, 0, 0, 0, 4833, 4834, + 7, 15, 0, 0, 4834, 4835, 7, 9, 0, 0, 4835, 4836, 7, 21, 0, 0, 4836, 826, + 1, 0, 0, 0, 4837, 4838, 7, 5, 0, 0, 4838, 4839, 7, 22, 0, 0, 4839, 4840, + 7, 16, 0, 0, 4840, 4841, 7, 20, 0, 0, 4841, 4842, 7, 10, 0, 0, 4842, 4843, + 7, 7, 0, 0, 4843, 4844, 7, 16, 0, 0, 4844, 4845, 7, 17, 0, 0, 4845, 4846, + 7, 14, 0, 0, 4846, 4847, 7, 5, 0, 0, 4847, 4848, 7, 16, 0, 0, 4848, 4849, + 7, 17, 0, 0, 4849, 4850, 7, 19, 0, 0, 4850, 4851, 7, 7, 0, 0, 4851, 828, + 1, 0, 0, 0, 4852, 4853, 7, 5, 0, 0, 4853, 4854, 7, 22, 0, 0, 4854, 4855, + 7, 16, 0, 0, 4855, 4856, 7, 20, 0, 0, 4856, 4857, 7, 10, 0, 0, 4857, 4858, + 7, 7, 0, 0, 4858, 4859, 7, 16, 0, 0, 4859, 4860, 7, 17, 0, 0, 4860, 4861, + 7, 14, 0, 0, 4861, 4862, 7, 5, 0, 0, 4862, 4863, 7, 16, 0, 0, 4863, 4864, + 7, 17, 0, 0, 4864, 4865, 7, 19, 0, 0, 4865, 4866, 7, 7, 0, 0, 4866, 4867, + 5, 95, 0, 0, 4867, 4868, 7, 5, 0, 0, 4868, 4869, 7, 13, 0, 0, 4869, 4870, + 7, 7, 0, 0, 4870, 830, 1, 0, 0, 0, 4871, 4872, 7, 9, 0, 0, 4872, 4873, + 7, 10, 0, 0, 4873, 4874, 7, 9, 0, 0, 4874, 4875, 7, 9, 0, 0, 4875, 4876, + 7, 17, 0, 0, 4876, 4877, 7, 19, 0, 0, 4877, 4878, 7, 7, 0, 0, 4878, 832, + 1, 0, 0, 0, 4879, 4880, 7, 15, 0, 0, 4880, 4881, 7, 16, 0, 0, 4881, 4882, + 7, 6, 0, 0, 4882, 4883, 7, 9, 0, 0, 4883, 834, 1, 0, 0, 0, 4884, 4885, + 7, 15, 0, 0, 4885, 4886, 7, 5, 0, 0, 4886, 4887, 7, 9, 0, 0, 4887, 4888, + 7, 21, 0, 0, 4888, 4889, 7, 17, 0, 0, 4889, 4890, 7, 7, 0, 0, 4890, 4891, + 7, 23, 0, 0, 4891, 836, 1, 0, 0, 0, 4892, 4893, 7, 13, 0, 0, 4893, 4894, + 7, 6, 0, 0, 4894, 4895, 7, 9, 0, 0, 4895, 838, 1, 0, 0, 0, 4896, 4897, + 7, 17, 0, 0, 4897, 4898, 7, 12, 0, 0, 4898, 4899, 7, 10, 0, 0, 4899, 4900, + 7, 7, 0, 0, 4900, 4901, 7, 16, 0, 0, 4901, 4902, 7, 17, 0, 0, 4902, 4903, + 7, 16, 0, 0, 4903, 4904, 7, 8, 0, 0, 4904, 840, 1, 0, 0, 0, 4905, 4906, + 7, 24, 0, 0, 4906, 4907, 7, 13, 0, 0, 4907, 4908, 7, 19, 0, 0, 4908, 4909, + 7, 27, 0, 0, 4909, 4910, 7, 17, 0, 0, 4910, 4911, 7, 12, 0, 0, 4911, 4912, + 7, 10, 0, 0, 4912, 4913, 7, 13, 0, 0, 4913, 842, 1, 0, 0, 0, 4914, 4915, + 7, 24, 0, 0, 4915, 4916, 7, 13, 0, 0, 4916, 4917, 7, 19, 0, 0, 4917, 4918, + 7, 16, 0, 0, 4918, 4919, 7, 10, 0, 0, 4919, 4920, 7, 14, 0, 0, 4920, 4921, + 7, 16, 0, 0, 4921, 4922, 7, 10, 0, 0, 4922, 4923, 7, 12, 0, 0, 4923, 844, + 1, 0, 0, 0, 4924, 4925, 7, 15, 0, 0, 4925, 4926, 7, 19, 0, 0, 4926, 4927, + 7, 12, 0, 0, 4927, 4928, 7, 10, 0, 0, 4928, 4929, 7, 6, 0, 0, 4929, 846, + 1, 0, 0, 0, 4930, 4931, 7, 16, 0, 0, 4931, 4932, 7, 5, 0, 0, 4932, 4933, + 7, 13, 0, 0, 4933, 4934, 7, 23, 0, 0, 4934, 4935, 7, 10, 0, 0, 4935, 4936, + 7, 16, 0, 0, 4936, 848, 1, 0, 0, 0, 4937, 4938, 7, 9, 0, 0, 4938, 4939, + 7, 5, 0, 0, 4939, 4940, 7, 23, 0, 0, 4940, 4941, 7, 10, 0, 0, 4941, 4942, + 7, 15, 0, 0, 4942, 4943, 7, 5, 0, 0, 4943, 4944, 7, 21, 0, 0, 4944, 4945, + 7, 10, 0, 0, 4945, 4946, 7, 13, 0, 0, 4946, 850, 1, 0, 0, 0, 4947, 4948, + 7, 5, 0, 0, 4948, 4949, 7, 22, 0, 0, 4949, 4950, 7, 16, 0, 0, 4950, 4951, + 7, 19, 0, 0, 4951, 852, 1, 0, 0, 0, 4952, 4953, 7, 15, 0, 0, 4953, 4954, + 7, 19, 0, 0, 4954, 4955, 7, 12, 0, 0, 4955, 4956, 7, 10, 0, 0, 4956, 4957, + 7, 6, 0, 0, 4957, 4958, 5, 95, 0, 0, 4958, 4959, 7, 16, 0, 0, 4959, 4960, + 7, 8, 0, 0, 4960, 4961, 7, 24, 0, 0, 4961, 4962, 7, 10, 0, 0, 4962, 854, + 1, 0, 0, 0, 4963, 4964, 7, 24, 0, 0, 4964, 4965, 7, 13, 0, 0, 4965, 4966, + 7, 19, 0, 0, 4966, 4967, 7, 18, 0, 0, 4967, 4968, 7, 6, 0, 0, 4968, 4969, + 7, 10, 0, 0, 4969, 4970, 7, 15, 0, 0, 4970, 4971, 5, 95, 0, 0, 4971, 4972, + 7, 16, 0, 0, 4972, 4973, 7, 8, 0, 0, 4973, 4974, 7, 24, 0, 0, 4974, 4975, + 7, 10, 0, 0, 4975, 856, 1, 0, 0, 0, 4976, 4977, 7, 19, 0, 0, 4977, 4978, + 7, 18, 0, 0, 4978, 4979, 7, 30, 0, 0, 4979, 4980, 7, 10, 0, 0, 4980, 4981, + 7, 14, 0, 0, 4981, 4982, 7, 16, 0, 0, 4982, 4983, 7, 17, 0, 0, 4983, 4984, + 7, 27, 0, 0, 4984, 4985, 7, 10, 0, 0, 4985, 858, 1, 0, 0, 0, 4986, 4987, + 7, 24, 0, 0, 4987, 4988, 7, 13, 0, 0, 4988, 4989, 7, 10, 0, 0, 4989, 4990, + 7, 24, 0, 0, 4990, 4991, 7, 13, 0, 0, 4991, 4992, 7, 19, 0, 0, 4992, 4993, + 7, 14, 0, 0, 4993, 4994, 7, 10, 0, 0, 4994, 4995, 7, 9, 0, 0, 4995, 4996, + 7, 9, 0, 0, 4996, 4997, 7, 19, 0, 0, 4997, 4998, 7, 13, 0, 0, 4998, 4999, + 7, 9, 0, 0, 4999, 860, 1, 0, 0, 0, 5000, 5001, 7, 20, 0, 0, 5001, 5002, + 7, 8, 0, 0, 5002, 5003, 7, 24, 0, 0, 5003, 5004, 7, 10, 0, 0, 5004, 5005, + 7, 13, 0, 0, 5005, 5006, 7, 24, 0, 0, 5006, 5007, 7, 5, 0, 0, 5007, 5008, + 7, 13, 0, 0, 5008, 5009, 7, 5, 0, 0, 5009, 5010, 7, 15, 0, 0, 5010, 5011, + 7, 10, 0, 0, 5011, 5012, 7, 16, 0, 0, 5012, 5013, 7, 10, 0, 0, 5013, 5014, + 7, 13, 0, 0, 5014, 5015, 7, 9, 0, 0, 5015, 862, 1, 0, 0, 0, 5016, 5017, + 7, 26, 0, 0, 5017, 5018, 7, 23, 0, 0, 5018, 5019, 7, 18, 0, 0, 5019, 5020, + 7, 19, 0, 0, 5020, 5021, 7, 19, 0, 0, 5021, 5022, 7, 9, 0, 0, 5022, 5023, + 7, 16, 0, 0, 5023, 864, 1, 0, 0, 0, 5024, 5025, 7, 15, 0, 0, 5025, 5026, + 7, 6, 0, 0, 5026, 5027, 7, 24, 0, 0, 5027, 866, 1, 0, 0, 0, 5028, 5029, + 7, 6, 0, 0, 5029, 5030, 7, 17, 0, 0, 5030, 5031, 7, 7, 0, 0, 5031, 5032, + 7, 10, 0, 0, 5032, 5033, 7, 5, 0, 0, 5033, 5034, 7, 13, 0, 0, 5034, 5035, + 5, 95, 0, 0, 5035, 5036, 7, 6, 0, 0, 5036, 5037, 7, 10, 0, 0, 5037, 5038, + 7, 5, 0, 0, 5038, 5039, 7, 13, 0, 0, 5039, 5040, 7, 7, 0, 0, 5040, 5041, + 7, 10, 0, 0, 5041, 5042, 7, 13, 0, 0, 5042, 868, 1, 0, 0, 0, 5043, 5044, + 7, 21, 0, 0, 5044, 5045, 7, 15, 0, 0, 5045, 5046, 7, 10, 0, 0, 5046, 5047, + 7, 5, 0, 0, 5047, 5048, 7, 7, 0, 0, 5048, 5049, 7, 9, 0, 0, 5049, 870, + 1, 0, 0, 0, 5050, 5051, 7, 25, 0, 0, 5051, 5052, 7, 19, 0, 0, 5052, 5053, + 7, 13, 0, 0, 5053, 5054, 7, 10, 0, 0, 5054, 5055, 7, 14, 0, 0, 5055, 5056, + 7, 5, 0, 0, 5056, 5057, 7, 9, 0, 0, 5057, 5058, 7, 16, 0, 0, 5058, 872, + 1, 0, 0, 0, 5059, 5060, 7, 13, 0, 0, 5060, 5061, 7, 10, 0, 0, 5061, 5062, + 7, 23, 0, 0, 5062, 5063, 7, 13, 0, 0, 5063, 5064, 7, 10, 0, 0, 5064, 5065, + 7, 9, 0, 0, 5065, 5066, 7, 9, 0, 0, 5066, 5067, 7, 17, 0, 0, 5067, 5068, + 7, 19, 0, 0, 5068, 5069, 7, 7, 0, 0, 5069, 874, 1, 0, 0, 0, 5070, 5071, + 7, 18, 0, 0, 5071, 5072, 7, 17, 0, 0, 5072, 5073, 7, 7, 0, 0, 5073, 5074, + 7, 5, 0, 0, 5074, 5075, 7, 13, 0, 0, 5075, 5076, 7, 8, 0, 0, 5076, 5077, + 5, 95, 0, 0, 5077, 5078, 7, 14, 0, 0, 5078, 5079, 7, 6, 0, 0, 5079, 5080, + 7, 5, 0, 0, 5080, 5081, 7, 9, 0, 0, 5081, 5082, 7, 9, 0, 0, 5082, 5083, + 7, 17, 0, 0, 5083, 5084, 7, 25, 0, 0, 5084, 5085, 7, 17, 0, 0, 5085, 5086, + 7, 14, 0, 0, 5086, 5087, 7, 5, 0, 0, 5087, 5088, 7, 16, 0, 0, 5088, 5089, + 7, 17, 0, 0, 5089, 5090, 7, 19, 0, 0, 5090, 5091, 7, 7, 0, 0, 5091, 876, + 1, 0, 0, 0, 5092, 5093, 7, 15, 0, 0, 5093, 5094, 7, 22, 0, 0, 5094, 5095, + 7, 6, 0, 0, 5095, 5096, 7, 16, 0, 0, 5096, 5097, 7, 17, 0, 0, 5097, 5098, + 7, 14, 0, 0, 5098, 5099, 7, 6, 0, 0, 5099, 5100, 7, 5, 0, 0, 5100, 5101, + 7, 9, 0, 0, 5101, 5102, 7, 9, 0, 0, 5102, 5103, 5, 95, 0, 0, 5103, 5104, + 7, 14, 0, 0, 5104, 5105, 7, 6, 0, 0, 5105, 5106, 7, 5, 0, 0, 5106, 5107, + 7, 9, 0, 0, 5107, 5108, 7, 9, 0, 0, 5108, 5109, 7, 17, 0, 0, 5109, 5110, + 7, 25, 0, 0, 5110, 5111, 7, 17, 0, 0, 5111, 5112, 7, 14, 0, 0, 5112, 5113, + 7, 5, 0, 0, 5113, 5114, 7, 16, 0, 0, 5114, 5115, 7, 17, 0, 0, 5115, 5116, + 7, 19, 0, 0, 5116, 5117, 7, 7, 0, 0, 5117, 878, 1, 0, 0, 0, 5118, 5119, + 7, 9, 0, 0, 5119, 5120, 5, 51, 0, 0, 5120, 5121, 5, 95, 0, 0, 5121, 5122, + 7, 18, 0, 0, 5122, 5123, 7, 22, 0, 0, 5123, 5124, 7, 14, 0, 0, 5124, 5125, + 7, 21, 0, 0, 5125, 5126, 7, 10, 0, 0, 5126, 5127, 7, 16, 0, 0, 5127, 880, + 1, 0, 0, 0, 5128, 5129, 7, 16, 0, 0, 5129, 5130, 7, 5, 0, 0, 5130, 5131, + 7, 23, 0, 0, 5131, 5132, 7, 9, 0, 0, 5132, 882, 1, 0, 0, 0, 5133, 5134, + 7, 21, 0, 0, 5134, 5135, 7, 15, 0, 0, 5135, 5136, 7, 9, 0, 0, 5136, 5137, + 5, 95, 0, 0, 5137, 5138, 7, 21, 0, 0, 5138, 5139, 7, 10, 0, 0, 5139, 5140, + 7, 8, 0, 0, 5140, 5141, 5, 95, 0, 0, 5141, 5142, 7, 17, 0, 0, 5142, 5143, + 7, 12, 0, 0, 5143, 884, 1, 0, 0, 0, 5144, 5145, 7, 9, 0, 0, 5145, 5146, + 5, 51, 0, 0, 5146, 5147, 5, 95, 0, 0, 5147, 5148, 7, 23, 0, 0, 5148, 5149, + 7, 5, 0, 0, 5149, 5150, 7, 13, 0, 0, 5150, 5151, 7, 18, 0, 0, 5151, 5152, + 7, 5, 0, 0, 5152, 5153, 7, 23, 0, 0, 5153, 5154, 7, 10, 0, 0, 5154, 5155, + 5, 95, 0, 0, 5155, 5156, 7, 14, 0, 0, 5156, 5157, 7, 19, 0, 0, 5157, 5158, + 7, 6, 0, 0, 5158, 5159, 7, 6, 0, 0, 5159, 5160, 7, 10, 0, 0, 5160, 5161, + 7, 14, 0, 0, 5161, 5162, 7, 16, 0, 0, 5162, 886, 1, 0, 0, 0, 5163, 5164, + 7, 15, 0, 0, 5164, 5165, 7, 5, 0, 0, 5165, 5166, 7, 26, 0, 0, 5166, 5167, + 5, 95, 0, 0, 5167, 5168, 7, 14, 0, 0, 5168, 5169, 7, 10, 0, 0, 5169, 5170, + 7, 6, 0, 0, 5170, 5171, 7, 6, 0, 0, 5171, 5172, 7, 9, 0, 0, 5172, 888, + 1, 0, 0, 0, 5173, 5174, 7, 15, 0, 0, 5174, 5175, 7, 5, 0, 0, 5175, 5176, + 7, 26, 0, 0, 5176, 5177, 5, 95, 0, 0, 5177, 5178, 7, 13, 0, 0, 5178, 5179, + 7, 22, 0, 0, 5179, 5180, 7, 7, 0, 0, 5180, 5181, 7, 16, 0, 0, 5181, 5182, + 7, 17, 0, 0, 5182, 5183, 7, 15, 0, 0, 5183, 5184, 7, 10, 0, 0, 5184, 890, + 1, 0, 0, 0, 5185, 5186, 7, 20, 0, 0, 5186, 5187, 7, 19, 0, 0, 5187, 5188, + 7, 13, 0, 0, 5188, 5189, 7, 17, 0, 0, 5189, 5190, 7, 11, 0, 0, 5190, 5191, + 7, 19, 0, 0, 5191, 5192, 7, 7, 0, 0, 5192, 892, 1, 0, 0, 0, 5193, 5194, + 7, 25, 0, 0, 5194, 5195, 7, 13, 0, 0, 5195, 5196, 7, 10, 0, 0, 5196, 5197, + 7, 28, 0, 0, 5197, 5198, 7, 22, 0, 0, 5198, 5199, 7, 10, 0, 0, 5199, 5200, + 7, 7, 0, 0, 5200, 5201, 7, 14, 0, 0, 5201, 5202, 7, 8, 0, 0, 5202, 894, + 1, 0, 0, 0, 5203, 5204, 7, 24, 0, 0, 5204, 5205, 7, 10, 0, 0, 5205, 5206, + 7, 13, 0, 0, 5206, 5207, 7, 14, 0, 0, 5207, 5208, 7, 10, 0, 0, 5208, 5209, + 7, 7, 0, 0, 5209, 5210, 7, 16, 0, 0, 5210, 5211, 7, 17, 0, 0, 5211, 5212, + 7, 6, 0, 0, 5212, 5213, 7, 10, 0, 0, 5213, 5214, 7, 9, 0, 0, 5214, 896, + 1, 0, 0, 0, 5215, 5216, 7, 15, 0, 0, 5216, 5217, 7, 5, 0, 0, 5217, 5218, + 7, 26, 0, 0, 5218, 5219, 5, 95, 0, 0, 5219, 5220, 7, 18, 0, 0, 5220, 5221, + 7, 5, 0, 0, 5221, 5222, 7, 16, 0, 0, 5222, 5223, 7, 14, 0, 0, 5223, 5224, + 7, 20, 0, 0, 5224, 5225, 5, 95, 0, 0, 5225, 5226, 7, 13, 0, 0, 5226, 5227, + 7, 19, 0, 0, 5227, 5228, 7, 29, 0, 0, 5228, 5229, 7, 9, 0, 0, 5229, 898, + 1, 0, 0, 0, 5230, 5231, 7, 22, 0, 0, 5231, 5232, 7, 7, 0, 0, 5232, 5233, + 7, 6, 0, 0, 5233, 5234, 7, 19, 0, 0, 5234, 5235, 7, 5, 0, 0, 5235, 5236, + 7, 12, 0, 0, 5236, 900, 1, 0, 0, 0, 5237, 5238, 7, 15, 0, 0, 5238, 5239, + 7, 5, 0, 0, 5239, 5240, 7, 7, 0, 0, 5240, 5241, 7, 17, 0, 0, 5241, 5242, + 7, 25, 0, 0, 5242, 5243, 7, 10, 0, 0, 5243, 5244, 7, 9, 0, 0, 5244, 5245, + 7, 16, 0, 0, 5245, 902, 1, 0, 0, 0, 5246, 5247, 7, 5, 0, 0, 5247, 5248, + 7, 12, 0, 0, 5248, 5249, 7, 12, 0, 0, 5249, 5250, 7, 28, 0, 0, 5250, 5251, + 7, 22, 0, 0, 5251, 5252, 7, 19, 0, 0, 5252, 5253, 7, 16, 0, 0, 5253, 5254, + 7, 10, 0, 0, 5254, 5255, 7, 9, 0, 0, 5255, 904, 1, 0, 0, 0, 5256, 5257, + 7, 5, 0, 0, 5257, 5258, 7, 6, 0, 0, 5258, 5259, 7, 6, 0, 0, 5259, 5260, + 7, 19, 0, 0, 5260, 5261, 7, 29, 0, 0, 5261, 5262, 7, 19, 0, 0, 5262, 5263, + 7, 27, 0, 0, 5263, 5264, 7, 10, 0, 0, 5264, 5265, 7, 13, 0, 0, 5265, 5266, + 7, 29, 0, 0, 5266, 5267, 7, 13, 0, 0, 5267, 5268, 7, 17, 0, 0, 5268, 5269, + 7, 16, 0, 0, 5269, 5270, 7, 10, 0, 0, 5270, 906, 1, 0, 0, 0, 5271, 5272, + 7, 14, 0, 0, 5272, 5273, 7, 6, 0, 0, 5273, 5274, 7, 10, 0, 0, 5274, 5275, + 7, 5, 0, 0, 5275, 5276, 7, 7, 0, 0, 5276, 5277, 7, 24, 0, 0, 5277, 5278, + 7, 5, 0, 0, 5278, 5279, 7, 16, 0, 0, 5279, 5280, 7, 20, 0, 0, 5280, 908, + 1, 0, 0, 0, 5281, 5282, 7, 15, 0, 0, 5282, 5283, 7, 5, 0, 0, 5283, 5284, + 7, 26, 0, 0, 5284, 5285, 7, 25, 0, 0, 5285, 5286, 7, 17, 0, 0, 5286, 5287, + 7, 6, 0, 0, 5287, 5288, 7, 10, 0, 0, 5288, 5289, 7, 9, 0, 0, 5289, 5290, + 7, 17, 0, 0, 5290, 5291, 7, 11, 0, 0, 5291, 5292, 7, 10, 0, 0, 5292, 910, + 1, 0, 0, 0, 5293, 5294, 7, 13, 0, 0, 5294, 5295, 7, 19, 0, 0, 5295, 5296, + 7, 29, 0, 0, 5296, 5297, 7, 23, 0, 0, 5297, 5298, 7, 13, 0, 0, 5298, 5299, + 7, 19, 0, 0, 5299, 5300, 7, 22, 0, 0, 5300, 5301, 7, 24, 0, 0, 5301, 5302, + 7, 9, 0, 0, 5302, 5303, 7, 17, 0, 0, 5303, 5304, 7, 11, 0, 0, 5304, 5305, + 7, 10, 0, 0, 5305, 912, 1, 0, 0, 0, 5306, 5307, 7, 18, 0, 0, 5307, 5308, + 7, 11, 0, 0, 5308, 5309, 7, 17, 0, 0, 5309, 5310, 7, 24, 0, 0, 5310, 5311, + 5, 50, 0, 0, 5311, 914, 1, 0, 0, 0, 5312, 5313, 7, 23, 0, 0, 5313, 5314, + 7, 11, 0, 0, 5314, 5315, 7, 17, 0, 0, 5315, 5316, 7, 24, 0, 0, 5316, 916, + 1, 0, 0, 0, 5317, 5318, 7, 11, 0, 0, 5318, 5319, 7, 9, 0, 0, 5319, 5320, + 7, 16, 0, 0, 5320, 5321, 7, 12, 0, 0, 5321, 918, 1, 0, 0, 0, 5322, 5323, + 7, 12, 0, 0, 5323, 5324, 7, 5, 0, 0, 5324, 5325, 7, 16, 0, 0, 5325, 5326, + 7, 5, 0, 0, 5326, 5327, 7, 18, 0, 0, 5327, 5328, 7, 5, 0, 0, 5328, 5329, + 7, 9, 0, 0, 5329, 5330, 7, 10, 0, 0, 5330, 5331, 7, 9, 0, 0, 5331, 920, + 1, 0, 0, 0, 5332, 5333, 7, 12, 0, 0, 5333, 5334, 7, 5, 0, 0, 5334, 5335, + 7, 16, 0, 0, 5335, 5336, 7, 5, 0, 0, 5336, 5337, 7, 9, 0, 0, 5337, 5338, + 7, 20, 0, 0, 5338, 5339, 7, 5, 0, 0, 5339, 5340, 7, 13, 0, 0, 5340, 5341, + 7, 10, 0, 0, 5341, 5342, 7, 9, 0, 0, 5342, 922, 1, 0, 0, 0, 5343, 5344, + 7, 23, 0, 0, 5344, 5345, 7, 13, 0, 0, 5345, 5346, 7, 5, 0, 0, 5346, 5347, + 7, 7, 0, 0, 5347, 5348, 7, 16, 0, 0, 5348, 5349, 7, 9, 0, 0, 5349, 924, + 1, 0, 0, 0, 5350, 5351, 7, 22, 0, 0, 5351, 5352, 7, 9, 0, 0, 5352, 5353, + 7, 10, 0, 0, 5353, 926, 1, 0, 0, 0, 5354, 5355, 7, 14, 0, 0, 5355, 5356, + 7, 5, 0, 0, 5356, 5357, 7, 7, 0, 0, 5357, 5358, 7, 14, 0, 0, 5358, 5359, + 7, 10, 0, 0, 5359, 5360, 7, 6, 0, 0, 5360, 928, 1, 0, 0, 0, 5361, 5362, + 7, 9, 0, 0, 5362, 5363, 7, 10, 0, 0, 5363, 5364, 7, 9, 0, 0, 5364, 5365, + 7, 9, 0, 0, 5365, 5366, 7, 17, 0, 0, 5366, 5367, 7, 19, 0, 0, 5367, 5368, + 7, 7, 0, 0, 5368, 5369, 5, 95, 0, 0, 5369, 5370, 7, 5, 0, 0, 5370, 5371, + 7, 22, 0, 0, 5371, 5372, 7, 16, 0, 0, 5372, 5373, 7, 20, 0, 0, 5373, 5374, + 7, 19, 0, 0, 5374, 5375, 7, 13, 0, 0, 5375, 5376, 7, 17, 0, 0, 5376, 5377, + 7, 11, 0, 0, 5377, 5378, 7, 5, 0, 0, 5378, 5379, 7, 16, 0, 0, 5379, 5380, + 7, 17, 0, 0, 5380, 5381, 7, 19, 0, 0, 5381, 5382, 7, 7, 0, 0, 5382, 930, + 1, 0, 0, 0, 5383, 5384, 7, 9, 0, 0, 5384, 5385, 7, 10, 0, 0, 5385, 5386, + 7, 9, 0, 0, 5386, 5387, 7, 9, 0, 0, 5387, 5388, 7, 17, 0, 0, 5388, 5389, + 7, 19, 0, 0, 5389, 5390, 7, 7, 0, 0, 5390, 5391, 5, 95, 0, 0, 5391, 5392, + 7, 14, 0, 0, 5392, 5393, 7, 20, 0, 0, 5393, 5394, 7, 5, 0, 0, 5394, 5395, + 7, 13, 0, 0, 5395, 5396, 7, 5, 0, 0, 5396, 5397, 7, 14, 0, 0, 5397, 5398, + 7, 16, 0, 0, 5398, 5399, 7, 10, 0, 0, 5399, 5400, 7, 13, 0, 0, 5400, 5401, + 7, 17, 0, 0, 5401, 5402, 7, 9, 0, 0, 5402, 5403, 7, 16, 0, 0, 5403, 5404, + 7, 17, 0, 0, 5404, 5405, 7, 14, 0, 0, 5405, 5406, 7, 9, 0, 0, 5406, 932, + 1, 0, 0, 0, 5407, 5408, 7, 14, 0, 0, 5408, 5409, 7, 19, 0, 0, 5409, 5410, + 7, 15, 0, 0, 5410, 5411, 7, 24, 0, 0, 5411, 5412, 7, 13, 0, 0, 5412, 5413, + 7, 10, 0, 0, 5413, 5414, 7, 9, 0, 0, 5414, 5415, 7, 9, 0, 0, 5415, 5416, + 7, 17, 0, 0, 5416, 5417, 7, 19, 0, 0, 5417, 5418, 7, 7, 0, 0, 5418, 934, + 1, 0, 0, 0, 5419, 5420, 7, 6, 0, 0, 5420, 5421, 7, 17, 0, 0, 5421, 5422, + 7, 18, 0, 0, 5422, 5423, 7, 13, 0, 0, 5423, 5424, 7, 5, 0, 0, 5424, 5425, + 7, 13, 0, 0, 5425, 5426, 7, 8, 0, 0, 5426, 936, 1, 0, 0, 0, 5427, 5428, + 7, 5, 0, 0, 5428, 5429, 7, 24, 0, 0, 5429, 5430, 7, 24, 0, 0, 5430, 5431, + 7, 10, 0, 0, 5431, 5432, 7, 7, 0, 0, 5432, 5433, 7, 12, 0, 0, 5433, 938, + 1, 0, 0, 0, 5434, 5435, 7, 15, 0, 0, 5435, 5436, 7, 18, 0, 0, 5436, 940, + 1, 0, 0, 0, 5437, 5438, 7, 23, 0, 0, 5438, 5439, 7, 18, 0, 0, 5439, 942, + 1, 0, 0, 0, 5440, 5441, 7, 5, 0, 0, 5441, 5442, 7, 14, 0, 0, 5442, 5443, + 7, 14, 0, 0, 5443, 5444, 7, 19, 0, 0, 5444, 5445, 7, 22, 0, 0, 5445, 5446, + 7, 7, 0, 0, 5446, 5447, 7, 16, 0, 0, 5447, 944, 1, 0, 0, 0, 5448, 5449, + 7, 7, 0, 0, 5449, 5450, 7, 5, 0, 0, 5450, 5451, 7, 15, 0, 0, 5451, 5452, + 7, 10, 0, 0, 5452, 5453, 7, 9, 0, 0, 5453, 5454, 7, 24, 0, 0, 5454, 5455, + 7, 5, 0, 0, 5455, 5456, 7, 14, 0, 0, 5456, 5457, 7, 10, 0, 0, 5457, 946, + 1, 0, 0, 0, 5458, 5459, 7, 12, 0, 0, 5459, 5460, 7, 10, 0, 0, 5460, 5461, + 7, 9, 0, 0, 5461, 5462, 7, 14, 0, 0, 5462, 5463, 7, 13, 0, 0, 5463, 5464, + 7, 17, 0, 0, 5464, 5465, 7, 18, 0, 0, 5465, 5466, 7, 10, 0, 0, 5466, 948, + 1, 0, 0, 0, 5467, 5468, 7, 7, 0, 0, 5468, 5469, 7, 19, 0, 0, 5469, 5470, + 7, 7, 0, 0, 5470, 5471, 7, 5, 0, 0, 5471, 5472, 7, 16, 0, 0, 5472, 5473, + 7, 19, 0, 0, 5473, 5474, 7, 15, 0, 0, 5474, 5475, 7, 17, 0, 0, 5475, 5476, + 7, 14, 0, 0, 5476, 950, 1, 0, 0, 0, 5477, 5478, 7, 15, 0, 0, 5478, 5479, + 7, 5, 0, 0, 5479, 5480, 7, 7, 0, 0, 5480, 5481, 7, 5, 0, 0, 5481, 5482, + 7, 23, 0, 0, 5482, 5483, 7, 10, 0, 0, 5483, 5484, 7, 12, 0, 0, 5484, 5485, + 7, 18, 0, 0, 5485, 5486, 7, 8, 0, 0, 5486, 952, 1, 0, 0, 0, 5487, 5488, + 7, 5, 0, 0, 5488, 5489, 7, 12, 0, 0, 5489, 5490, 7, 26, 0, 0, 5490, 954, + 1, 0, 0, 0, 5491, 5492, 7, 13, 0, 0, 5492, 5493, 7, 10, 0, 0, 5493, 5494, + 7, 15, 0, 0, 5494, 5495, 7, 19, 0, 0, 5495, 5496, 7, 27, 0, 0, 5496, 5497, + 7, 10, 0, 0, 5497, 956, 1, 0, 0, 0, 5498, 5499, 7, 12, 0, 0, 5499, 5500, + 7, 22, 0, 0, 5500, 5501, 7, 24, 0, 0, 5501, 5502, 7, 6, 0, 0, 5502, 5503, + 7, 17, 0, 0, 5503, 5504, 7, 14, 0, 0, 5504, 5505, 7, 5, 0, 0, 5505, 5506, + 7, 16, 0, 0, 5506, 5507, 7, 10, 0, 0, 5507, 5508, 7, 9, 0, 0, 5508, 958, + 1, 0, 0, 0, 5509, 5510, 7, 18, 0, 0, 5510, 5511, 7, 10, 0, 0, 5511, 5512, + 7, 12, 0, 0, 5512, 5513, 7, 13, 0, 0, 5513, 5514, 7, 19, 0, 0, 5514, 5515, + 7, 14, 0, 0, 5515, 5516, 7, 21, 0, 0, 5516, 960, 1, 0, 0, 0, 5517, 5518, + 7, 15, 0, 0, 5518, 5519, 7, 19, 0, 0, 5519, 5520, 7, 12, 0, 0, 5520, 5521, + 7, 10, 0, 0, 5521, 5522, 7, 6, 0, 0, 5522, 5523, 5, 95, 0, 0, 5523, 5524, + 7, 17, 0, 0, 5524, 5525, 7, 12, 0, 0, 5525, 962, 1, 0, 0, 0, 5526, 5527, + 7, 24, 0, 0, 5527, 5528, 7, 13, 0, 0, 5528, 5529, 7, 19, 0, 0, 5529, 5530, + 7, 15, 0, 0, 5530, 5531, 7, 24, 0, 0, 5531, 5532, 7, 16, 0, 0, 5532, 964, + 1, 0, 0, 0, 5533, 5534, 7, 9, 0, 0, 5534, 5535, 7, 22, 0, 0, 5535, 5536, + 7, 25, 0, 0, 5536, 5537, 7, 25, 0, 0, 5537, 5538, 7, 17, 0, 0, 5538, 5539, + 7, 26, 0, 0, 5539, 966, 1, 0, 0, 0, 5540, 5541, 7, 13, 0, 0, 5541, 5542, + 7, 10, 0, 0, 5542, 5543, 7, 28, 0, 0, 5543, 5544, 7, 22, 0, 0, 5544, 5545, + 7, 10, 0, 0, 5545, 5546, 7, 9, 0, 0, 5546, 5547, 7, 16, 0, 0, 5547, 5548, + 5, 95, 0, 0, 5548, 5549, 7, 16, 0, 0, 5549, 5550, 7, 8, 0, 0, 5550, 5551, + 7, 24, 0, 0, 5551, 5552, 7, 10, 0, 0, 5552, 968, 1, 0, 0, 0, 5553, 5554, + 7, 13, 0, 0, 5554, 5555, 7, 10, 0, 0, 5555, 5556, 7, 9, 0, 0, 5556, 5557, + 7, 24, 0, 0, 5557, 5558, 7, 19, 0, 0, 5558, 5559, 7, 7, 0, 0, 5559, 5560, + 7, 9, 0, 0, 5560, 5561, 7, 10, 0, 0, 5561, 5562, 5, 95, 0, 0, 5562, 5563, + 7, 16, 0, 0, 5563, 5564, 7, 8, 0, 0, 5564, 5565, 7, 24, 0, 0, 5565, 5566, + 7, 10, 0, 0, 5566, 970, 1, 0, 0, 0, 5567, 5568, 7, 13, 0, 0, 5568, 5569, + 7, 5, 0, 0, 5569, 5570, 7, 29, 0, 0, 5570, 972, 1, 0, 0, 0, 5571, 5572, + 7, 22, 0, 0, 5572, 5573, 7, 7, 0, 0, 5573, 5574, 7, 17, 0, 0, 5574, 5575, + 7, 25, 0, 0, 5575, 5576, 7, 17, 0, 0, 5576, 5577, 7, 10, 0, 0, 5577, 5578, + 7, 12, 0, 0, 5578, 974, 1, 0, 0, 0, 5579, 5580, 7, 9, 0, 0, 5580, 5581, + 7, 22, 0, 0, 5581, 5582, 7, 24, 0, 0, 5582, 5583, 7, 10, 0, 0, 5583, 5584, + 7, 13, 0, 0, 5584, 976, 1, 0, 0, 0, 5585, 5586, 7, 14, 0, 0, 5586, 5587, + 7, 17, 0, 0, 5587, 978, 1, 0, 0, 0, 5588, 5589, 7, 14, 0, 0, 5589, 5590, + 7, 9, 0, 0, 5590, 980, 1, 0, 0, 0, 5591, 5592, 7, 24, 0, 0, 5592, 5593, + 7, 6, 0, 0, 5593, 5594, 7, 24, 0, 0, 5594, 5595, 7, 8, 0, 0, 5595, 5596, + 7, 16, 0, 0, 5596, 5597, 7, 20, 0, 0, 5597, 5598, 7, 19, 0, 0, 5598, 5599, + 7, 7, 0, 0, 5599, 5600, 7, 22, 0, 0, 5600, 982, 1, 0, 0, 0, 5601, 5602, + 7, 25, 0, 0, 5602, 5603, 7, 17, 0, 0, 5603, 5604, 7, 6, 0, 0, 5604, 5605, + 7, 6, 0, 0, 5605, 5606, 7, 16, 0, 0, 5606, 5607, 7, 5, 0, 0, 5607, 5608, + 7, 13, 0, 0, 5608, 5609, 7, 23, 0, 0, 5609, 5610, 7, 10, 0, 0, 5610, 5611, + 7, 16, 0, 0, 5611, 984, 1, 0, 0, 0, 5612, 5613, 7, 17, 0, 0, 5613, 5614, + 7, 23, 0, 0, 5614, 5615, 7, 7, 0, 0, 5615, 5616, 7, 19, 0, 0, 5616, 5617, + 7, 13, 0, 0, 5617, 5618, 7, 10, 0, 0, 5618, 5619, 7, 10, 0, 0, 5619, 5620, + 7, 26, 0, 0, 5620, 5621, 7, 16, 0, 0, 5621, 5622, 7, 13, 0, 0, 5622, 5623, + 7, 5, 0, 0, 5623, 986, 1, 0, 0, 0, 5624, 5625, 7, 14, 0, 0, 5625, 5626, + 7, 13, 0, 0, 5626, 5627, 7, 10, 0, 0, 5627, 5628, 7, 5, 0, 0, 5628, 5629, + 7, 16, 0, 0, 5629, 5630, 7, 10, 0, 0, 5630, 5631, 7, 22, 0, 0, 5631, 5632, + 7, 9, 0, 0, 5632, 5633, 7, 10, 0, 0, 5633, 5634, 7, 13, 0, 0, 5634, 988, + 1, 0, 0, 0, 5635, 5636, 7, 7, 0, 0, 5636, 5637, 7, 19, 0, 0, 5637, 5638, + 7, 14, 0, 0, 5638, 5639, 7, 13, 0, 0, 5639, 5640, 7, 10, 0, 0, 5640, 5641, + 7, 5, 0, 0, 5641, 5642, 7, 16, 0, 0, 5642, 5643, 7, 10, 0, 0, 5643, 5644, + 7, 22, 0, 0, 5644, 5645, 7, 9, 0, 0, 5645, 5646, 7, 10, 0, 0, 5646, 5647, + 7, 13, 0, 0, 5647, 990, 1, 0, 0, 0, 5648, 5649, 7, 13, 0, 0, 5649, 5650, + 7, 10, 0, 0, 5650, 5651, 7, 23, 0, 0, 5651, 5652, 7, 17, 0, 0, 5652, 5653, + 7, 19, 0, 0, 5653, 5654, 7, 7, 0, 0, 5654, 992, 1, 0, 0, 0, 5655, 5656, + 7, 24, 0, 0, 5656, 5657, 7, 19, 0, 0, 5657, 5658, 7, 13, 0, 0, 5658, 5659, + 7, 16, 0, 0, 5659, 994, 1, 0, 0, 0, 5660, 5661, 7, 13, 0, 0, 5661, 5662, + 7, 10, 0, 0, 5662, 5663, 7, 12, 0, 0, 5663, 5664, 7, 9, 0, 0, 5664, 5665, + 7, 20, 0, 0, 5665, 5666, 7, 17, 0, 0, 5666, 5667, 7, 25, 0, 0, 5667, 5668, + 7, 16, 0, 0, 5668, 996, 1, 0, 0, 0, 5669, 5670, 7, 17, 0, 0, 5670, 5671, + 7, 5, 0, 0, 5671, 5672, 7, 15, 0, 0, 5672, 998, 1, 0, 0, 0, 5673, 5674, + 7, 14, 0, 0, 5674, 5675, 7, 13, 0, 0, 5675, 5676, 7, 10, 0, 0, 5676, 5677, + 7, 5, 0, 0, 5677, 5678, 7, 16, 0, 0, 5678, 5679, 7, 10, 0, 0, 5679, 5680, + 7, 12, 0, 0, 5680, 5681, 7, 18, 0, 0, 5681, 1000, 1, 0, 0, 0, 5682, 5683, + 7, 7, 0, 0, 5683, 5684, 7, 19, 0, 0, 5684, 5685, 7, 14, 0, 0, 5685, 5686, + 7, 13, 0, 0, 5686, 5687, 7, 10, 0, 0, 5687, 5688, 7, 5, 0, 0, 5688, 5689, + 7, 16, 0, 0, 5689, 5690, 7, 10, 0, 0, 5690, 5691, 7, 12, 0, 0, 5691, 5692, + 7, 18, 0, 0, 5692, 1002, 1, 0, 0, 0, 5693, 5694, 7, 13, 0, 0, 5694, 5695, + 7, 10, 0, 0, 5695, 5696, 7, 9, 0, 0, 5696, 5697, 7, 16, 0, 0, 5697, 5698, + 7, 13, 0, 0, 5698, 5699, 7, 17, 0, 0, 5699, 5700, 7, 14, 0, 0, 5700, 5701, + 7, 16, 0, 0, 5701, 5702, 7, 10, 0, 0, 5702, 5703, 7, 12, 0, 0, 5703, 1004, + 1, 0, 0, 0, 5704, 5705, 7, 22, 0, 0, 5705, 5706, 7, 7, 0, 0, 5706, 5707, + 7, 6, 0, 0, 5707, 5708, 7, 17, 0, 0, 5708, 5709, 7, 15, 0, 0, 5709, 5710, + 7, 17, 0, 0, 5710, 5711, 7, 16, 0, 0, 5711, 5712, 7, 10, 0, 0, 5712, 5713, + 7, 12, 0, 0, 5713, 1006, 1, 0, 0, 0, 5714, 5715, 7, 10, 0, 0, 5715, 5716, + 7, 26, 0, 0, 5716, 5717, 7, 16, 0, 0, 5717, 5718, 7, 10, 0, 0, 5718, 5719, + 7, 13, 0, 0, 5719, 5720, 7, 7, 0, 0, 5720, 5721, 7, 5, 0, 0, 5721, 5722, + 7, 6, 0, 0, 5722, 5723, 7, 17, 0, 0, 5723, 5724, 7, 12, 0, 0, 5724, 1008, + 1, 0, 0, 0, 5725, 5726, 7, 16, 0, 0, 5726, 5727, 7, 17, 0, 0, 5727, 5728, + 7, 15, 0, 0, 5728, 5729, 7, 10, 0, 0, 5729, 5730, 7, 19, 0, 0, 5730, 5731, + 7, 22, 0, 0, 5731, 5732, 7, 16, 0, 0, 5732, 1010, 1, 0, 0, 0, 5733, 5734, + 7, 9, 0, 0, 5734, 5735, 7, 8, 0, 0, 5735, 5736, 7, 9, 0, 0, 5736, 5737, + 7, 6, 0, 0, 5737, 5738, 7, 19, 0, 0, 5738, 5739, 7, 23, 0, 0, 5739, 1012, + 1, 0, 0, 0, 5740, 5741, 7, 14, 0, 0, 5741, 5742, 7, 13, 0, 0, 5742, 5743, + 7, 10, 0, 0, 5743, 5744, 7, 12, 0, 0, 5744, 5745, 7, 10, 0, 0, 5745, 5746, + 7, 7, 0, 0, 5746, 5747, 7, 16, 0, 0, 5747, 5748, 7, 17, 0, 0, 5748, 5749, + 7, 5, 0, 0, 5749, 5750, 7, 6, 0, 0, 5750, 5751, 7, 9, 0, 0, 5751, 1014, + 1, 0, 0, 0, 5752, 5753, 7, 22, 0, 0, 5753, 5754, 7, 7, 0, 0, 5754, 5755, + 7, 13, 0, 0, 5755, 5756, 7, 10, 0, 0, 5756, 5757, 7, 9, 0, 0, 5757, 5758, + 7, 16, 0, 0, 5758, 5759, 7, 13, 0, 0, 5759, 5760, 7, 17, 0, 0, 5760, 5761, + 7, 14, 0, 0, 5761, 5762, 7, 16, 0, 0, 5762, 5763, 7, 10, 0, 0, 5763, 5764, + 7, 12, 0, 0, 5764, 1016, 1, 0, 0, 0, 5765, 5766, 7, 24, 0, 0, 5766, 5767, + 7, 5, 0, 0, 5767, 5768, 7, 13, 0, 0, 5768, 5769, 7, 5, 0, 0, 5769, 5770, + 7, 15, 0, 0, 5770, 5771, 7, 10, 0, 0, 5771, 5772, 7, 16, 0, 0, 5772, 5773, + 7, 10, 0, 0, 5773, 5774, 7, 13, 0, 0, 5774, 5775, 7, 9, 0, 0, 5775, 1018, + 1, 0, 0, 0, 5776, 5777, 7, 5, 0, 0, 5777, 5778, 7, 24, 0, 0, 5778, 5779, + 7, 24, 0, 0, 5779, 5780, 7, 6, 0, 0, 5780, 5781, 7, 17, 0, 0, 5781, 5782, + 7, 14, 0, 0, 5782, 5783, 7, 5, 0, 0, 5783, 5784, 7, 16, 0, 0, 5784, 5785, + 7, 17, 0, 0, 5785, 5786, 7, 19, 0, 0, 5786, 5787, 7, 7, 0, 0, 5787, 5788, + 5, 95, 0, 0, 5788, 5789, 7, 5, 0, 0, 5789, 5790, 7, 13, 0, 0, 5790, 5791, + 7, 7, 0, 0, 5791, 1020, 1, 0, 0, 0, 5792, 5793, 7, 5, 0, 0, 5793, 5794, + 7, 22, 0, 0, 5794, 5795, 7, 16, 0, 0, 5795, 5796, 7, 19, 0, 0, 5796, 5797, + 5, 95, 0, 0, 5797, 5798, 7, 14, 0, 0, 5798, 5799, 7, 13, 0, 0, 5799, 5800, + 7, 10, 0, 0, 5800, 5801, 7, 5, 0, 0, 5801, 5802, 7, 16, 0, 0, 5802, 5803, + 7, 10, 0, 0, 5803, 5804, 5, 95, 0, 0, 5804, 5805, 7, 13, 0, 0, 5805, 5806, + 7, 19, 0, 0, 5806, 5807, 7, 6, 0, 0, 5807, 5808, 7, 10, 0, 0, 5808, 5809, + 7, 9, 0, 0, 5809, 1022, 1, 0, 0, 0, 5810, 5811, 7, 14, 0, 0, 5811, 5812, + 7, 19, 0, 0, 5812, 5813, 7, 15, 0, 0, 5813, 5814, 7, 24, 0, 0, 5814, 5815, + 7, 13, 0, 0, 5815, 5816, 7, 19, 0, 0, 5816, 5817, 7, 29, 0, 0, 5817, 5818, + 7, 9, 0, 0, 5818, 1024, 1, 0, 0, 0, 5819, 5820, 7, 24, 0, 0, 5820, 5821, + 7, 13, 0, 0, 5821, 5822, 7, 19, 0, 0, 5822, 5823, 7, 27, 0, 0, 5823, 5824, + 7, 17, 0, 0, 5824, 5825, 7, 12, 0, 0, 5825, 5826, 7, 10, 0, 0, 5826, 5827, + 7, 13, 0, 0, 5827, 5828, 5, 95, 0, 0, 5828, 5829, 7, 22, 0, 0, 5829, 5830, + 7, 13, 0, 0, 5830, 5831, 7, 6, 0, 0, 5831, 1026, 1, 0, 0, 0, 5832, 5833, + 7, 24, 0, 0, 5833, 5834, 7, 13, 0, 0, 5834, 5835, 7, 19, 0, 0, 5835, 5836, + 7, 27, 0, 0, 5836, 5837, 7, 17, 0, 0, 5837, 5838, 7, 12, 0, 0, 5838, 5839, + 7, 10, 0, 0, 5839, 5840, 7, 13, 0, 0, 5840, 5841, 5, 95, 0, 0, 5841, 5842, + 7, 22, 0, 0, 5842, 5843, 7, 13, 0, 0, 5843, 5844, 7, 6, 0, 0, 5844, 5845, + 5, 95, 0, 0, 5845, 5846, 7, 24, 0, 0, 5846, 5847, 7, 19, 0, 0, 5847, 5848, + 7, 13, 0, 0, 5848, 5849, 7, 16, 0, 0, 5849, 1028, 1, 0, 0, 0, 5850, 5851, + 7, 5, 0, 0, 5851, 5852, 7, 16, 0, 0, 5852, 5853, 7, 16, 0, 0, 5853, 5854, + 7, 13, 0, 0, 5854, 5855, 7, 17, 0, 0, 5855, 5856, 7, 18, 0, 0, 5856, 5857, + 7, 22, 0, 0, 5857, 5858, 7, 16, 0, 0, 5858, 5859, 7, 10, 0, 0, 5859, 5860, + 5, 95, 0, 0, 5860, 5861, 7, 15, 0, 0, 5861, 5862, 7, 5, 0, 0, 5862, 5863, + 7, 24, 0, 0, 5863, 1030, 1, 0, 0, 0, 5864, 5865, 7, 24, 0, 0, 5865, 5866, + 7, 13, 0, 0, 5866, 5867, 7, 19, 0, 0, 5867, 5868, 7, 27, 0, 0, 5868, 5869, + 7, 17, 0, 0, 5869, 5870, 7, 12, 0, 0, 5870, 5871, 7, 10, 0, 0, 5871, 5872, + 7, 13, 0, 0, 5872, 5873, 5, 95, 0, 0, 5873, 5874, 7, 5, 0, 0, 5874, 5875, + 7, 13, 0, 0, 5875, 5876, 7, 7, 0, 0, 5876, 1032, 1, 0, 0, 0, 5877, 5878, + 7, 5, 0, 0, 5878, 5879, 7, 9, 0, 0, 5879, 5880, 7, 9, 0, 0, 5880, 5881, + 7, 22, 0, 0, 5881, 5882, 7, 15, 0, 0, 5882, 5883, 7, 10, 0, 0, 5883, 5884, + 5, 95, 0, 0, 5884, 5885, 7, 13, 0, 0, 5885, 5886, 7, 19, 0, 0, 5886, 5887, + 7, 6, 0, 0, 5887, 5888, 7, 10, 0, 0, 5888, 5889, 5, 95, 0, 0, 5889, 5890, + 7, 5, 0, 0, 5890, 5891, 7, 13, 0, 0, 5891, 5892, 7, 7, 0, 0, 5892, 1034, + 1, 0, 0, 0, 5893, 5894, 7, 24, 0, 0, 5894, 5895, 7, 13, 0, 0, 5895, 5896, + 7, 19, 0, 0, 5896, 5897, 7, 24, 0, 0, 5897, 5898, 7, 10, 0, 0, 5898, 5899, + 7, 13, 0, 0, 5899, 5900, 7, 16, 0, 0, 5900, 5901, 7, 17, 0, 0, 5901, 5902, + 7, 10, 0, 0, 5902, 5903, 7, 9, 0, 0, 5903, 1036, 1, 0, 0, 0, 5904, 5905, + 7, 5, 0, 0, 5905, 5906, 7, 27, 0, 0, 5906, 5907, 7, 13, 0, 0, 5907, 5908, + 7, 19, 0, 0, 5908, 1038, 1, 0, 0, 0, 5909, 5910, 7, 13, 0, 0, 5910, 5911, + 7, 14, 0, 0, 5911, 5912, 7, 25, 0, 0, 5912, 5913, 7, 17, 0, 0, 5913, 5914, + 7, 6, 0, 0, 5914, 5915, 7, 10, 0, 0, 5915, 1040, 1, 0, 0, 0, 5916, 5917, + 7, 9, 0, 0, 5917, 5918, 7, 10, 0, 0, 5918, 5919, 7, 28, 0, 0, 5919, 5920, + 7, 22, 0, 0, 5920, 5921, 7, 10, 0, 0, 5921, 5922, 7, 7, 0, 0, 5922, 5923, + 7, 14, 0, 0, 5923, 5924, 7, 10, 0, 0, 5924, 5925, 7, 25, 0, 0, 5925, 5926, + 7, 17, 0, 0, 5926, 5927, 7, 6, 0, 0, 5927, 5928, 7, 10, 0, 0, 5928, 1042, + 1, 0, 0, 0, 5929, 5930, 7, 16, 0, 0, 5930, 5931, 7, 10, 0, 0, 5931, 5932, + 7, 26, 0, 0, 5932, 5933, 7, 16, 0, 0, 5933, 5934, 7, 25, 0, 0, 5934, 5935, + 7, 17, 0, 0, 5935, 5936, 7, 6, 0, 0, 5936, 5937, 7, 10, 0, 0, 5937, 1044, + 1, 0, 0, 0, 5938, 5939, 7, 19, 0, 0, 5939, 5940, 7, 13, 0, 0, 5940, 5941, + 7, 14, 0, 0, 5941, 1046, 1, 0, 0, 0, 5942, 5943, 7, 17, 0, 0, 5943, 5944, + 7, 19, 0, 0, 5944, 5945, 7, 7, 0, 0, 5945, 1048, 1, 0, 0, 0, 5946, 5947, + 7, 6, 0, 0, 5947, 5948, 7, 5, 0, 0, 5948, 5949, 7, 15, 0, 0, 5949, 5950, + 7, 18, 0, 0, 5950, 5951, 7, 12, 0, 0, 5951, 5952, 7, 5, 0, 0, 5952, 1050, + 1, 0, 0, 0, 5953, 5954, 7, 25, 0, 0, 5954, 5955, 7, 17, 0, 0, 5955, 5956, + 7, 26, 0, 0, 5956, 5957, 7, 10, 0, 0, 5957, 5958, 7, 12, 0, 0, 5958, 5959, + 7, 29, 0, 0, 5959, 5960, 7, 17, 0, 0, 5960, 5961, 7, 12, 0, 0, 5961, 5962, + 7, 16, 0, 0, 5962, 5963, 7, 20, 0, 0, 5963, 1052, 1, 0, 0, 0, 5964, 5965, + 7, 24, 0, 0, 5965, 5966, 7, 5, 0, 0, 5966, 5967, 7, 13, 0, 0, 5967, 5968, + 7, 28, 0, 0, 5968, 5969, 7, 22, 0, 0, 5969, 5970, 7, 10, 0, 0, 5970, 5971, + 7, 16, 0, 0, 5971, 1054, 1, 0, 0, 0, 5972, 5973, 7, 6, 0, 0, 5973, 5974, + 7, 11, 0, 0, 5974, 5975, 7, 19, 0, 0, 5975, 5976, 7, 24, 0, 0, 5976, 1056, + 1, 0, 0, 0, 5977, 5978, 7, 13, 0, 0, 5978, 5979, 7, 10, 0, 0, 5979, 5980, + 7, 15, 0, 0, 5980, 5981, 7, 19, 0, 0, 5981, 5982, 7, 27, 0, 0, 5982, 5983, + 7, 10, 0, 0, 5983, 5984, 7, 28, 0, 0, 5984, 5985, 7, 22, 0, 0, 5985, 5986, + 7, 19, 0, 0, 5986, 5987, 7, 16, 0, 0, 5987, 5988, 7, 10, 0, 0, 5988, 5989, + 7, 9, 0, 0, 5989, 1058, 1, 0, 0, 0, 5990, 5991, 7, 16, 0, 0, 5991, 5992, + 7, 13, 0, 0, 5992, 5993, 7, 22, 0, 0, 5993, 5994, 7, 7, 0, 0, 5994, 5995, + 7, 14, 0, 0, 5995, 5996, 7, 5, 0, 0, 5996, 5997, 7, 16, 0, 0, 5997, 5998, + 7, 10, 0, 0, 5998, 5999, 7, 14, 0, 0, 5999, 6000, 7, 19, 0, 0, 6000, 6001, + 7, 6, 0, 0, 6001, 6002, 7, 22, 0, 0, 6002, 6003, 7, 15, 0, 0, 6003, 6004, + 7, 7, 0, 0, 6004, 6005, 7, 9, 0, 0, 6005, 1060, 1, 0, 0, 0, 6006, 6007, + 7, 25, 0, 0, 6007, 6008, 7, 17, 0, 0, 6008, 6009, 7, 6, 0, 0, 6009, 6010, + 7, 6, 0, 0, 6010, 6011, 7, 13, 0, 0, 6011, 6012, 7, 10, 0, 0, 6012, 6013, + 7, 14, 0, 0, 6013, 6014, 7, 19, 0, 0, 6014, 6015, 7, 13, 0, 0, 6015, 6016, + 7, 12, 0, 0, 6016, 1062, 1, 0, 0, 0, 6017, 6018, 7, 18, 0, 0, 6018, 6019, + 7, 6, 0, 0, 6019, 6020, 7, 5, 0, 0, 6020, 6021, 7, 7, 0, 0, 6021, 6022, + 7, 21, 0, 0, 6022, 6023, 7, 9, 0, 0, 6023, 6024, 7, 5, 0, 0, 6024, 6025, + 7, 9, 0, 0, 6025, 6026, 7, 7, 0, 0, 6026, 6027, 7, 22, 0, 0, 6027, 6028, + 7, 6, 0, 0, 6028, 6029, 7, 6, 0, 0, 6029, 1064, 1, 0, 0, 0, 6030, 6031, + 7, 10, 0, 0, 6031, 6032, 7, 15, 0, 0, 6032, 6033, 7, 24, 0, 0, 6033, 6034, + 7, 16, 0, 0, 6034, 6035, 7, 8, 0, 0, 6035, 6036, 7, 5, 0, 0, 6036, 6037, + 7, 9, 0, 0, 6037, 6038, 7, 7, 0, 0, 6038, 6039, 7, 22, 0, 0, 6039, 6040, + 7, 6, 0, 0, 6040, 6041, 7, 6, 0, 0, 6041, 1066, 1, 0, 0, 0, 6042, 6043, + 7, 15, 0, 0, 6043, 6044, 7, 5, 0, 0, 6044, 6045, 7, 26, 0, 0, 6045, 6046, + 7, 10, 0, 0, 6046, 6047, 7, 13, 0, 0, 6047, 6048, 7, 13, 0, 0, 6048, 6049, + 7, 19, 0, 0, 6049, 6050, 7, 13, 0, 0, 6050, 1068, 1, 0, 0, 0, 6051, 6052, + 7, 12, 0, 0, 6052, 6053, 7, 5, 0, 0, 6053, 6054, 7, 16, 0, 0, 6054, 6055, + 7, 10, 0, 0, 6055, 6056, 7, 25, 0, 0, 6056, 6057, 7, 19, 0, 0, 6057, 6058, + 7, 13, 0, 0, 6058, 6059, 7, 15, 0, 0, 6059, 6060, 7, 5, 0, 0, 6060, 6061, + 7, 16, 0, 0, 6061, 1070, 1, 0, 0, 0, 6062, 6063, 7, 16, 0, 0, 6063, 6064, + 7, 17, 0, 0, 6064, 6065, 7, 15, 0, 0, 6065, 6066, 7, 10, 0, 0, 6066, 6067, + 7, 25, 0, 0, 6067, 6068, 7, 19, 0, 0, 6068, 6069, 7, 13, 0, 0, 6069, 6070, + 7, 15, 0, 0, 6070, 6071, 7, 5, 0, 0, 6071, 6072, 7, 16, 0, 0, 6072, 1072, + 1, 0, 0, 0, 6073, 6074, 7, 5, 0, 0, 6074, 6075, 7, 14, 0, 0, 6075, 6076, + 7, 14, 0, 0, 6076, 6077, 7, 10, 0, 0, 6077, 6078, 7, 24, 0, 0, 6078, 6079, + 7, 16, 0, 0, 6079, 6080, 7, 17, 0, 0, 6080, 6081, 7, 7, 0, 0, 6081, 6082, + 7, 27, 0, 0, 6082, 6083, 7, 14, 0, 0, 6083, 6084, 7, 20, 0, 0, 6084, 6085, + 7, 5, 0, 0, 6085, 6086, 7, 13, 0, 0, 6086, 6087, 7, 9, 0, 0, 6087, 1074, + 1, 0, 0, 0, 6088, 6089, 7, 5, 0, 0, 6089, 6090, 7, 14, 0, 0, 6090, 6091, + 7, 14, 0, 0, 6091, 6092, 7, 10, 0, 0, 6092, 6093, 7, 24, 0, 0, 6093, 6094, + 7, 16, 0, 0, 6094, 6095, 7, 5, 0, 0, 6095, 6096, 7, 7, 0, 0, 6096, 6097, + 7, 8, 0, 0, 6097, 6098, 7, 12, 0, 0, 6098, 6099, 7, 5, 0, 0, 6099, 6100, + 7, 16, 0, 0, 6100, 6101, 7, 10, 0, 0, 6101, 1076, 1, 0, 0, 0, 6102, 6103, + 7, 17, 0, 0, 6103, 6104, 7, 23, 0, 0, 6104, 6105, 7, 7, 0, 0, 6105, 6106, + 7, 19, 0, 0, 6106, 6107, 7, 13, 0, 0, 6107, 6108, 7, 10, 0, 0, 6108, 6109, + 7, 20, 0, 0, 6109, 6110, 7, 10, 0, 0, 6110, 6111, 7, 5, 0, 0, 6111, 6112, + 7, 12, 0, 0, 6112, 6113, 7, 10, 0, 0, 6113, 6114, 7, 13, 0, 0, 6114, 1078, + 1, 0, 0, 0, 6115, 6116, 7, 17, 0, 0, 6116, 6117, 7, 23, 0, 0, 6117, 6118, + 7, 7, 0, 0, 6118, 6119, 7, 19, 0, 0, 6119, 6120, 7, 13, 0, 0, 6120, 6121, + 7, 10, 0, 0, 6121, 6122, 7, 18, 0, 0, 6122, 6123, 7, 6, 0, 0, 6123, 6124, + 7, 5, 0, 0, 6124, 6125, 7, 7, 0, 0, 6125, 6126, 7, 21, 0, 0, 6126, 6127, + 7, 6, 0, 0, 6127, 6128, 7, 17, 0, 0, 6128, 6129, 7, 7, 0, 0, 6129, 6130, + 7, 10, 0, 0, 6130, 6131, 7, 9, 0, 0, 6131, 1080, 1, 0, 0, 0, 6132, 6133, + 7, 14, 0, 0, 6133, 6134, 7, 19, 0, 0, 6134, 6135, 7, 15, 0, 0, 6135, 6136, + 7, 24, 0, 0, 6136, 6137, 7, 22, 0, 0, 6137, 6138, 7, 24, 0, 0, 6138, 6139, + 7, 12, 0, 0, 6139, 6140, 7, 5, 0, 0, 6140, 6141, 7, 16, 0, 0, 6141, 6142, + 7, 10, 0, 0, 6142, 1082, 1, 0, 0, 0, 6143, 6144, 7, 9, 0, 0, 6144, 6145, + 7, 16, 0, 0, 6145, 6146, 7, 5, 0, 0, 6146, 6147, 7, 16, 0, 0, 6147, 6148, + 7, 22, 0, 0, 6148, 6149, 7, 24, 0, 0, 6149, 6150, 7, 12, 0, 0, 6150, 6151, + 7, 5, 0, 0, 6151, 6152, 7, 16, 0, 0, 6152, 6153, 7, 10, 0, 0, 6153, 1084, + 1, 0, 0, 0, 6154, 6155, 7, 10, 0, 0, 6155, 6156, 7, 26, 0, 0, 6156, 6157, + 7, 24, 0, 0, 6157, 6158, 7, 6, 0, 0, 6158, 6159, 7, 17, 0, 0, 6159, 6160, + 7, 14, 0, 0, 6160, 6161, 7, 17, 0, 0, 6161, 6162, 7, 16, 0, 0, 6162, 6163, + 5, 95, 0, 0, 6163, 6164, 7, 17, 0, 0, 6164, 6165, 7, 12, 0, 0, 6165, 6166, + 7, 9, 0, 0, 6166, 1086, 1, 0, 0, 0, 6167, 6168, 7, 13, 0, 0, 6168, 6169, + 7, 10, 0, 0, 6169, 6170, 7, 5, 0, 0, 6170, 6171, 7, 12, 0, 0, 6171, 6172, + 7, 13, 0, 0, 6172, 6173, 7, 5, 0, 0, 6173, 6174, 7, 16, 0, 0, 6174, 6175, + 7, 17, 0, 0, 6175, 6176, 7, 19, 0, 0, 6176, 1088, 1, 0, 0, 0, 6177, 6178, + 7, 13, 0, 0, 6178, 6179, 7, 19, 0, 0, 6179, 6180, 7, 22, 0, 0, 6180, 6181, + 7, 7, 0, 0, 6181, 6182, 7, 12, 0, 0, 6182, 6183, 7, 10, 0, 0, 6183, 6184, + 7, 14, 0, 0, 6184, 1090, 1, 0, 0, 0, 6185, 6186, 7, 16, 0, 0, 6186, 6187, + 7, 13, 0, 0, 6187, 6188, 7, 17, 0, 0, 6188, 6189, 7, 15, 0, 0, 6189, 6190, + 7, 18, 0, 0, 6190, 6191, 7, 6, 0, 0, 6191, 6192, 7, 5, 0, 0, 6192, 6193, + 7, 7, 0, 0, 6193, 6194, 7, 21, 0, 0, 6194, 6195, 7, 9, 0, 0, 6195, 1092, + 1, 0, 0, 0, 6196, 6197, 7, 24, 0, 0, 6197, 6198, 7, 13, 0, 0, 6198, 6199, + 7, 10, 0, 0, 6199, 6200, 7, 9, 0, 0, 6200, 6201, 7, 10, 0, 0, 6201, 6202, + 7, 16, 0, 0, 6202, 1094, 1, 0, 0, 0, 6203, 6204, 7, 5, 0, 0, 6204, 6205, + 7, 14, 0, 0, 6205, 6206, 7, 14, 0, 0, 6206, 6207, 7, 10, 0, 0, 6207, 6208, + 7, 9, 0, 0, 6208, 6209, 7, 9, 0, 0, 6209, 6210, 5, 95, 0, 0, 6210, 6211, + 7, 21, 0, 0, 6211, 6212, 7, 10, 0, 0, 6212, 6213, 7, 8, 0, 0, 6213, 6214, + 5, 95, 0, 0, 6214, 6215, 7, 17, 0, 0, 6215, 6216, 7, 12, 0, 0, 6216, 1096, + 1, 0, 0, 0, 6217, 6218, 7, 9, 0, 0, 6218, 6219, 7, 10, 0, 0, 6219, 6220, + 7, 14, 0, 0, 6220, 6221, 7, 13, 0, 0, 6221, 6222, 7, 10, 0, 0, 6222, 6223, + 7, 16, 0, 0, 6223, 6224, 5, 95, 0, 0, 6224, 6225, 7, 5, 0, 0, 6225, 6226, + 7, 14, 0, 0, 6226, 6227, 7, 14, 0, 0, 6227, 6228, 7, 10, 0, 0, 6228, 6229, + 7, 9, 0, 0, 6229, 6230, 7, 9, 0, 0, 6230, 6231, 5, 95, 0, 0, 6231, 6232, + 7, 21, 0, 0, 6232, 6233, 7, 10, 0, 0, 6233, 6234, 7, 8, 0, 0, 6234, 1098, + 1, 0, 0, 0, 6235, 6236, 7, 9, 0, 0, 6236, 6237, 7, 10, 0, 0, 6237, 6238, + 7, 9, 0, 0, 6238, 6239, 7, 9, 0, 0, 6239, 6240, 7, 17, 0, 0, 6240, 6241, + 7, 19, 0, 0, 6241, 6242, 7, 7, 0, 0, 6242, 6243, 5, 95, 0, 0, 6243, 6244, + 7, 16, 0, 0, 6244, 6245, 7, 19, 0, 0, 6245, 6246, 7, 21, 0, 0, 6246, 6247, + 7, 10, 0, 0, 6247, 6248, 7, 7, 0, 0, 6248, 1100, 1, 0, 0, 0, 6249, 6250, + 7, 20, 0, 0, 6250, 6251, 7, 10, 0, 0, 6251, 6252, 7, 5, 0, 0, 6252, 6253, + 7, 12, 0, 0, 6253, 6254, 7, 10, 0, 0, 6254, 6255, 7, 13, 0, 0, 6255, 1102, + 1, 0, 0, 0, 6256, 6257, 7, 9, 0, 0, 6257, 6258, 7, 10, 0, 0, 6258, 6259, + 7, 16, 0, 0, 6259, 6260, 7, 16, 0, 0, 6260, 6261, 7, 17, 0, 0, 6261, 6262, + 7, 7, 0, 0, 6262, 6263, 7, 23, 0, 0, 6263, 6264, 7, 9, 0, 0, 6264, 1104, + 1, 0, 0, 0, 6265, 6266, 7, 25, 0, 0, 6266, 6267, 7, 22, 0, 0, 6267, 6268, + 7, 7, 0, 0, 6268, 6269, 7, 14, 0, 0, 6269, 6270, 7, 16, 0, 0, 6270, 6271, + 7, 17, 0, 0, 6271, 6272, 7, 19, 0, 0, 6272, 6273, 7, 7, 0, 0, 6273, 6274, + 5, 95, 0, 0, 6274, 6275, 7, 7, 0, 0, 6275, 6276, 7, 5, 0, 0, 6276, 6277, + 7, 15, 0, 0, 6277, 6278, 7, 10, 0, 0, 6278, 1106, 1, 0, 0, 0, 6279, 6280, + 7, 5, 0, 0, 6280, 6281, 7, 16, 0, 0, 6281, 6282, 7, 19, 0, 0, 6282, 6283, + 7, 15, 0, 0, 6283, 6284, 7, 17, 0, 0, 6284, 6285, 7, 14, 0, 0, 6285, 1108, + 1, 0, 0, 0, 6286, 6287, 7, 18, 0, 0, 6287, 6288, 7, 10, 0, 0, 6288, 6289, + 7, 16, 0, 0, 6289, 6290, 7, 29, 0, 0, 6290, 6291, 7, 10, 0, 0, 6291, 6292, + 7, 10, 0, 0, 6292, 6293, 7, 7, 0, 0, 6293, 1110, 1, 0, 0, 0, 6294, 6295, + 7, 18, 0, 0, 6295, 6296, 7, 17, 0, 0, 6296, 6297, 7, 23, 0, 0, 6297, 6298, + 7, 17, 0, 0, 6298, 6299, 7, 7, 0, 0, 6299, 6300, 7, 16, 0, 0, 6300, 1112, + 1, 0, 0, 0, 6301, 6302, 7, 18, 0, 0, 6302, 6303, 7, 17, 0, 0, 6303, 6304, + 7, 16, 0, 0, 6304, 1114, 1, 0, 0, 0, 6305, 6306, 7, 18, 0, 0, 6306, 6307, + 7, 19, 0, 0, 6307, 6308, 7, 19, 0, 0, 6308, 6309, 7, 6, 0, 0, 6309, 6310, + 7, 10, 0, 0, 6310, 6311, 7, 5, 0, 0, 6311, 6312, 7, 7, 0, 0, 6312, 1116, + 1, 0, 0, 0, 6313, 6314, 7, 14, 0, 0, 6314, 6315, 7, 20, 0, 0, 6315, 6316, + 7, 5, 0, 0, 6316, 6317, 7, 13, 0, 0, 6317, 1118, 1, 0, 0, 0, 6318, 6319, + 7, 14, 0, 0, 6319, 6320, 7, 20, 0, 0, 6320, 6321, 7, 5, 0, 0, 6321, 6322, + 7, 13, 0, 0, 6322, 6323, 7, 5, 0, 0, 6323, 6324, 7, 14, 0, 0, 6324, 6325, + 7, 16, 0, 0, 6325, 6326, 7, 10, 0, 0, 6326, 6327, 7, 13, 0, 0, 6327, 1120, + 1, 0, 0, 0, 6328, 6329, 7, 14, 0, 0, 6329, 6330, 7, 19, 0, 0, 6330, 6331, + 7, 5, 0, 0, 6331, 6332, 7, 6, 0, 0, 6332, 6333, 7, 10, 0, 0, 6333, 6334, + 7, 9, 0, 0, 6334, 6335, 7, 14, 0, 0, 6335, 6336, 7, 10, 0, 0, 6336, 1122, + 1, 0, 0, 0, 6337, 6338, 7, 12, 0, 0, 6338, 6339, 7, 10, 0, 0, 6339, 6340, + 7, 14, 0, 0, 6340, 1124, 1, 0, 0, 0, 6341, 6342, 7, 12, 0, 0, 6342, 6343, + 7, 10, 0, 0, 6343, 6344, 7, 14, 0, 0, 6344, 6345, 7, 17, 0, 0, 6345, 6346, + 7, 15, 0, 0, 6346, 6347, 7, 5, 0, 0, 6347, 6348, 7, 6, 0, 0, 6348, 1126, + 1, 0, 0, 0, 6349, 6350, 7, 10, 0, 0, 6350, 6351, 7, 26, 0, 0, 6351, 6352, + 7, 17, 0, 0, 6352, 6353, 7, 9, 0, 0, 6353, 6354, 7, 16, 0, 0, 6354, 6355, + 7, 9, 0, 0, 6355, 1128, 1, 0, 0, 0, 6356, 6357, 7, 10, 0, 0, 6357, 6358, + 7, 26, 0, 0, 6358, 6359, 7, 16, 0, 0, 6359, 6360, 7, 13, 0, 0, 6360, 6361, + 7, 5, 0, 0, 6361, 6362, 7, 14, 0, 0, 6362, 6363, 7, 16, 0, 0, 6363, 1130, + 1, 0, 0, 0, 6364, 6365, 7, 25, 0, 0, 6365, 6366, 7, 6, 0, 0, 6366, 6367, + 7, 19, 0, 0, 6367, 6368, 7, 5, 0, 0, 6368, 6369, 7, 16, 0, 0, 6369, 1132, + 1, 0, 0, 0, 6370, 6371, 7, 23, 0, 0, 6371, 6372, 7, 13, 0, 0, 6372, 6373, + 7, 10, 0, 0, 6373, 6374, 7, 5, 0, 0, 6374, 6375, 7, 16, 0, 0, 6375, 6376, + 7, 10, 0, 0, 6376, 6377, 7, 9, 0, 0, 6377, 6378, 7, 16, 0, 0, 6378, 1134, + 1, 0, 0, 0, 6379, 6380, 7, 17, 0, 0, 6380, 6381, 7, 7, 0, 0, 6381, 6382, + 7, 19, 0, 0, 6382, 6383, 7, 22, 0, 0, 6383, 6384, 7, 16, 0, 0, 6384, 1136, + 1, 0, 0, 0, 6385, 6386, 7, 17, 0, 0, 6386, 6387, 7, 7, 0, 0, 6387, 6388, + 7, 16, 0, 0, 6388, 1138, 1, 0, 0, 0, 6389, 6390, 7, 17, 0, 0, 6390, 6391, + 7, 7, 0, 0, 6391, 6392, 7, 16, 0, 0, 6392, 6393, 7, 10, 0, 0, 6393, 6394, + 7, 23, 0, 0, 6394, 6395, 7, 10, 0, 0, 6395, 6396, 7, 13, 0, 0, 6396, 1140, + 1, 0, 0, 0, 6397, 6398, 7, 17, 0, 0, 6398, 6399, 7, 7, 0, 0, 6399, 6400, + 7, 16, 0, 0, 6400, 6401, 7, 10, 0, 0, 6401, 6402, 7, 13, 0, 0, 6402, 6403, + 7, 27, 0, 0, 6403, 6404, 7, 5, 0, 0, 6404, 6405, 7, 6, 0, 0, 6405, 1142, + 1, 0, 0, 0, 6406, 6407, 7, 6, 0, 0, 6407, 6408, 7, 10, 0, 0, 6408, 6409, + 7, 5, 0, 0, 6409, 6410, 7, 9, 0, 0, 6410, 6411, 7, 16, 0, 0, 6411, 1144, + 1, 0, 0, 0, 6412, 6413, 7, 7, 0, 0, 6413, 6414, 7, 5, 0, 0, 6414, 6415, + 7, 16, 0, 0, 6415, 6416, 7, 17, 0, 0, 6416, 6417, 7, 19, 0, 0, 6417, 6418, + 7, 7, 0, 0, 6418, 6419, 7, 5, 0, 0, 6419, 6420, 7, 6, 0, 0, 6420, 1146, + 1, 0, 0, 0, 6421, 6422, 7, 7, 0, 0, 6422, 6423, 7, 14, 0, 0, 6423, 6424, + 7, 20, 0, 0, 6424, 6425, 7, 5, 0, 0, 6425, 6426, 7, 13, 0, 0, 6426, 1148, + 1, 0, 0, 0, 6427, 6428, 7, 7, 0, 0, 6428, 6429, 7, 19, 0, 0, 6429, 6430, + 7, 7, 0, 0, 6430, 6431, 7, 10, 0, 0, 6431, 1150, 1, 0, 0, 0, 6432, 6433, + 7, 7, 0, 0, 6433, 6434, 7, 22, 0, 0, 6434, 6435, 7, 6, 0, 0, 6435, 6436, + 7, 6, 0, 0, 6436, 6437, 7, 17, 0, 0, 6437, 6438, 7, 25, 0, 0, 6438, 1152, + 1, 0, 0, 0, 6439, 6440, 7, 7, 0, 0, 6440, 6441, 7, 22, 0, 0, 6441, 6442, + 7, 15, 0, 0, 6442, 6443, 7, 10, 0, 0, 6443, 6444, 7, 13, 0, 0, 6444, 6445, + 7, 17, 0, 0, 6445, 6446, 7, 14, 0, 0, 6446, 1154, 1, 0, 0, 0, 6447, 6448, + 7, 19, 0, 0, 6448, 6449, 7, 27, 0, 0, 6449, 6450, 7, 10, 0, 0, 6450, 6451, + 7, 13, 0, 0, 6451, 6452, 7, 6, 0, 0, 6452, 6453, 7, 5, 0, 0, 6453, 6454, + 7, 8, 0, 0, 6454, 1156, 1, 0, 0, 0, 6455, 6456, 7, 24, 0, 0, 6456, 6457, + 7, 5, 0, 0, 6457, 6458, 7, 13, 0, 0, 6458, 6459, 7, 5, 0, 0, 6459, 6460, + 7, 15, 0, 0, 6460, 6461, 7, 10, 0, 0, 6461, 6462, 7, 16, 0, 0, 6462, 6463, + 7, 10, 0, 0, 6463, 6464, 7, 13, 0, 0, 6464, 1158, 1, 0, 0, 0, 6465, 6466, + 7, 24, 0, 0, 6466, 6467, 7, 19, 0, 0, 6467, 6468, 7, 9, 0, 0, 6468, 6469, + 7, 17, 0, 0, 6469, 6470, 7, 16, 0, 0, 6470, 6471, 7, 17, 0, 0, 6471, 6472, + 7, 19, 0, 0, 6472, 6473, 7, 7, 0, 0, 6473, 1160, 1, 0, 0, 0, 6474, 6475, + 7, 24, 0, 0, 6475, 6476, 7, 13, 0, 0, 6476, 6477, 7, 10, 0, 0, 6477, 6478, + 7, 14, 0, 0, 6478, 6479, 7, 17, 0, 0, 6479, 6480, 7, 9, 0, 0, 6480, 6481, + 7, 17, 0, 0, 6481, 6482, 7, 19, 0, 0, 6482, 6483, 7, 7, 0, 0, 6483, 1162, + 1, 0, 0, 0, 6484, 6485, 7, 13, 0, 0, 6485, 6486, 7, 10, 0, 0, 6486, 6487, + 7, 5, 0, 0, 6487, 6488, 7, 6, 0, 0, 6488, 1164, 1, 0, 0, 0, 6489, 6490, + 7, 13, 0, 0, 6490, 6491, 7, 19, 0, 0, 6491, 6492, 7, 29, 0, 0, 6492, 1166, + 1, 0, 0, 0, 6493, 6494, 7, 9, 0, 0, 6494, 6495, 7, 10, 0, 0, 6495, 6496, + 7, 16, 0, 0, 6496, 6497, 7, 19, 0, 0, 6497, 6498, 7, 25, 0, 0, 6498, 1168, + 1, 0, 0, 0, 6499, 6500, 7, 9, 0, 0, 6500, 6501, 7, 15, 0, 0, 6501, 6502, + 7, 5, 0, 0, 6502, 6503, 7, 6, 0, 0, 6503, 6504, 7, 6, 0, 0, 6504, 6505, + 7, 17, 0, 0, 6505, 6506, 7, 7, 0, 0, 6506, 6507, 7, 16, 0, 0, 6507, 1170, + 1, 0, 0, 0, 6508, 6509, 7, 9, 0, 0, 6509, 6510, 7, 22, 0, 0, 6510, 6511, + 7, 18, 0, 0, 6511, 6512, 7, 9, 0, 0, 6512, 6513, 7, 16, 0, 0, 6513, 6514, + 7, 13, 0, 0, 6514, 6515, 7, 17, 0, 0, 6515, 6516, 7, 7, 0, 0, 6516, 6517, + 7, 23, 0, 0, 6517, 1172, 1, 0, 0, 0, 6518, 6519, 7, 16, 0, 0, 6519, 6520, + 7, 17, 0, 0, 6520, 6521, 7, 15, 0, 0, 6521, 6522, 7, 10, 0, 0, 6522, 1174, + 1, 0, 0, 0, 6523, 6524, 7, 16, 0, 0, 6524, 6525, 7, 17, 0, 0, 6525, 6526, + 7, 15, 0, 0, 6526, 6527, 7, 10, 0, 0, 6527, 6528, 7, 9, 0, 0, 6528, 6529, + 7, 16, 0, 0, 6529, 6530, 7, 5, 0, 0, 6530, 6531, 7, 15, 0, 0, 6531, 6532, + 7, 24, 0, 0, 6532, 1176, 1, 0, 0, 0, 6533, 6534, 7, 16, 0, 0, 6534, 6535, + 7, 13, 0, 0, 6535, 6536, 7, 10, 0, 0, 6536, 6537, 7, 5, 0, 0, 6537, 6538, + 7, 16, 0, 0, 6538, 1178, 1, 0, 0, 0, 6539, 6540, 7, 16, 0, 0, 6540, 6541, + 7, 13, 0, 0, 6541, 6542, 7, 17, 0, 0, 6542, 6543, 7, 15, 0, 0, 6543, 1180, + 1, 0, 0, 0, 6544, 6545, 7, 27, 0, 0, 6545, 6546, 7, 5, 0, 0, 6546, 6547, + 7, 6, 0, 0, 6547, 6548, 7, 22, 0, 0, 6548, 6549, 7, 10, 0, 0, 6549, 6550, + 7, 9, 0, 0, 6550, 1182, 1, 0, 0, 0, 6551, 6552, 7, 27, 0, 0, 6552, 6553, + 7, 5, 0, 0, 6553, 6554, 7, 13, 0, 0, 6554, 6555, 7, 14, 0, 0, 6555, 6556, + 7, 20, 0, 0, 6556, 6557, 7, 5, 0, 0, 6557, 6558, 7, 13, 0, 0, 6558, 1184, + 1, 0, 0, 0, 6559, 6560, 7, 26, 0, 0, 6560, 6561, 7, 15, 0, 0, 6561, 6562, + 7, 6, 0, 0, 6562, 6563, 7, 5, 0, 0, 6563, 6564, 7, 16, 0, 0, 6564, 6565, + 7, 16, 0, 0, 6565, 6566, 7, 13, 0, 0, 6566, 6567, 7, 17, 0, 0, 6567, 6568, + 7, 18, 0, 0, 6568, 6569, 7, 22, 0, 0, 6569, 6570, 7, 16, 0, 0, 6570, 6571, + 7, 10, 0, 0, 6571, 6572, 7, 9, 0, 0, 6572, 1186, 1, 0, 0, 0, 6573, 6574, + 7, 26, 0, 0, 6574, 6575, 7, 15, 0, 0, 6575, 6576, 7, 6, 0, 0, 6576, 6577, + 7, 14, 0, 0, 6577, 6578, 7, 19, 0, 0, 6578, 6579, 7, 15, 0, 0, 6579, 6580, + 7, 15, 0, 0, 6580, 6581, 7, 10, 0, 0, 6581, 6582, 7, 7, 0, 0, 6582, 6583, + 7, 16, 0, 0, 6583, 1188, 1, 0, 0, 0, 6584, 6585, 7, 26, 0, 0, 6585, 6586, + 7, 15, 0, 0, 6586, 6587, 7, 6, 0, 0, 6587, 6588, 7, 5, 0, 0, 6588, 6589, + 7, 23, 0, 0, 6589, 6590, 7, 23, 0, 0, 6590, 1190, 1, 0, 0, 0, 6591, 6592, + 7, 26, 0, 0, 6592, 6593, 7, 15, 0, 0, 6593, 6594, 7, 6, 0, 0, 6594, 6595, + 5, 95, 0, 0, 6595, 6596, 7, 17, 0, 0, 6596, 6597, 7, 9, 0, 0, 6597, 6598, + 5, 95, 0, 0, 6598, 6599, 7, 29, 0, 0, 6599, 6600, 7, 10, 0, 0, 6600, 6601, + 7, 6, 0, 0, 6601, 6602, 7, 6, 0, 0, 6602, 6603, 5, 95, 0, 0, 6603, 6604, + 7, 25, 0, 0, 6604, 6605, 7, 19, 0, 0, 6605, 6606, 7, 13, 0, 0, 6606, 6607, + 7, 15, 0, 0, 6607, 6608, 7, 10, 0, 0, 6608, 6609, 7, 12, 0, 0, 6609, 1192, + 1, 0, 0, 0, 6610, 6611, 7, 26, 0, 0, 6611, 6612, 7, 15, 0, 0, 6612, 6613, + 7, 6, 0, 0, 6613, 6614, 5, 95, 0, 0, 6614, 6615, 7, 17, 0, 0, 6615, 6616, + 7, 9, 0, 0, 6616, 6617, 5, 95, 0, 0, 6617, 6618, 7, 29, 0, 0, 6618, 6619, + 7, 10, 0, 0, 6619, 6620, 7, 6, 0, 0, 6620, 6621, 7, 6, 0, 0, 6621, 6622, + 5, 95, 0, 0, 6622, 6623, 7, 25, 0, 0, 6623, 6624, 7, 19, 0, 0, 6624, 6625, + 7, 13, 0, 0, 6625, 6626, 7, 15, 0, 0, 6626, 6627, 7, 10, 0, 0, 6627, 6628, + 7, 12, 0, 0, 6628, 6629, 5, 95, 0, 0, 6629, 6630, 7, 12, 0, 0, 6630, 6631, + 7, 19, 0, 0, 6631, 6632, 7, 14, 0, 0, 6632, 6633, 7, 22, 0, 0, 6633, 6634, + 7, 15, 0, 0, 6634, 6635, 7, 10, 0, 0, 6635, 6636, 7, 7, 0, 0, 6636, 6637, + 7, 16, 0, 0, 6637, 1194, 1, 0, 0, 0, 6638, 6639, 7, 26, 0, 0, 6639, 6640, + 7, 15, 0, 0, 6640, 6641, 7, 6, 0, 0, 6641, 6642, 5, 95, 0, 0, 6642, 6643, + 7, 17, 0, 0, 6643, 6644, 7, 9, 0, 0, 6644, 6645, 5, 95, 0, 0, 6645, 6646, + 7, 29, 0, 0, 6646, 6647, 7, 10, 0, 0, 6647, 6648, 7, 6, 0, 0, 6648, 6649, + 7, 6, 0, 0, 6649, 6650, 5, 95, 0, 0, 6650, 6651, 7, 25, 0, 0, 6651, 6652, + 7, 19, 0, 0, 6652, 6653, 7, 13, 0, 0, 6653, 6654, 7, 15, 0, 0, 6654, 6655, + 7, 10, 0, 0, 6655, 6656, 7, 12, 0, 0, 6656, 6657, 5, 95, 0, 0, 6657, 6658, + 7, 14, 0, 0, 6658, 6659, 7, 19, 0, 0, 6659, 6660, 7, 7, 0, 0, 6660, 6661, + 7, 16, 0, 0, 6661, 6662, 7, 10, 0, 0, 6662, 6663, 7, 7, 0, 0, 6663, 6664, + 7, 16, 0, 0, 6664, 1196, 1, 0, 0, 0, 6665, 6666, 7, 26, 0, 0, 6666, 6667, + 7, 24, 0, 0, 6667, 6668, 7, 5, 0, 0, 6668, 6669, 7, 16, 0, 0, 6669, 6670, + 7, 20, 0, 0, 6670, 1198, 1, 0, 0, 0, 6671, 6672, 7, 26, 0, 0, 6672, 6673, + 7, 24, 0, 0, 6673, 6674, 7, 5, 0, 0, 6674, 6675, 7, 16, 0, 0, 6675, 6676, + 7, 20, 0, 0, 6676, 6677, 5, 95, 0, 0, 6677, 6678, 7, 10, 0, 0, 6678, 6679, + 7, 26, 0, 0, 6679, 6680, 7, 17, 0, 0, 6680, 6681, 7, 9, 0, 0, 6681, 6682, + 7, 16, 0, 0, 6682, 6683, 7, 9, 0, 0, 6683, 1200, 1, 0, 0, 0, 6684, 6685, + 7, 26, 0, 0, 6685, 6686, 7, 15, 0, 0, 6686, 6687, 7, 6, 0, 0, 6687, 6688, + 7, 14, 0, 0, 6688, 6689, 7, 19, 0, 0, 6689, 6690, 7, 7, 0, 0, 6690, 6691, + 7, 14, 0, 0, 6691, 6692, 7, 5, 0, 0, 6692, 6693, 7, 16, 0, 0, 6693, 1202, + 1, 0, 0, 0, 6694, 6695, 7, 26, 0, 0, 6695, 6696, 7, 15, 0, 0, 6696, 6697, + 7, 6, 0, 0, 6697, 6698, 7, 10, 0, 0, 6698, 6699, 7, 6, 0, 0, 6699, 6700, + 7, 10, 0, 0, 6700, 6701, 7, 15, 0, 0, 6701, 6702, 7, 10, 0, 0, 6702, 6703, + 7, 7, 0, 0, 6703, 6704, 7, 16, 0, 0, 6704, 1204, 1, 0, 0, 0, 6705, 6706, + 7, 26, 0, 0, 6706, 6707, 7, 15, 0, 0, 6707, 6708, 7, 6, 0, 0, 6708, 6709, + 7, 10, 0, 0, 6709, 6710, 7, 26, 0, 0, 6710, 6711, 7, 17, 0, 0, 6711, 6712, + 7, 9, 0, 0, 6712, 6713, 7, 16, 0, 0, 6713, 6714, 7, 9, 0, 0, 6714, 1206, + 1, 0, 0, 0, 6715, 6716, 7, 26, 0, 0, 6716, 6717, 7, 15, 0, 0, 6717, 6718, + 7, 6, 0, 0, 6718, 6719, 7, 25, 0, 0, 6719, 6720, 7, 19, 0, 0, 6720, 6721, + 7, 13, 0, 0, 6721, 6722, 7, 10, 0, 0, 6722, 6723, 7, 9, 0, 0, 6723, 6724, + 7, 16, 0, 0, 6724, 1208, 1, 0, 0, 0, 6725, 6726, 7, 26, 0, 0, 6726, 6727, + 7, 15, 0, 0, 6727, 6728, 7, 6, 0, 0, 6728, 6729, 7, 24, 0, 0, 6729, 6730, + 7, 5, 0, 0, 6730, 6731, 7, 13, 0, 0, 6731, 6732, 7, 9, 0, 0, 6732, 6733, + 7, 10, 0, 0, 6733, 1210, 1, 0, 0, 0, 6734, 6735, 7, 26, 0, 0, 6735, 6736, + 7, 15, 0, 0, 6736, 6737, 7, 6, 0, 0, 6737, 6738, 7, 24, 0, 0, 6738, 6739, + 7, 17, 0, 0, 6739, 1212, 1, 0, 0, 0, 6740, 6741, 7, 26, 0, 0, 6741, 6742, + 7, 15, 0, 0, 6742, 6743, 7, 6, 0, 0, 6743, 6744, 7, 13, 0, 0, 6744, 6745, + 7, 19, 0, 0, 6745, 6746, 7, 19, 0, 0, 6746, 6747, 7, 16, 0, 0, 6747, 1214, + 1, 0, 0, 0, 6748, 6749, 7, 26, 0, 0, 6749, 6750, 7, 15, 0, 0, 6750, 6751, + 7, 6, 0, 0, 6751, 6752, 7, 9, 0, 0, 6752, 6753, 7, 10, 0, 0, 6753, 6754, + 7, 13, 0, 0, 6754, 6755, 7, 17, 0, 0, 6755, 6756, 7, 5, 0, 0, 6756, 6757, + 7, 6, 0, 0, 6757, 6758, 7, 17, 0, 0, 6758, 6759, 7, 11, 0, 0, 6759, 6760, + 7, 10, 0, 0, 6760, 1216, 1, 0, 0, 0, 6761, 6762, 7, 14, 0, 0, 6762, 6763, + 7, 5, 0, 0, 6763, 6764, 7, 6, 0, 0, 6764, 6765, 7, 6, 0, 0, 6765, 1218, + 1, 0, 0, 0, 6766, 6767, 7, 14, 0, 0, 6767, 6768, 7, 22, 0, 0, 6768, 6769, + 7, 13, 0, 0, 6769, 6770, 7, 13, 0, 0, 6770, 6771, 7, 10, 0, 0, 6771, 6772, + 7, 7, 0, 0, 6772, 6773, 7, 16, 0, 0, 6773, 1220, 1, 0, 0, 0, 6774, 6775, + 7, 5, 0, 0, 6775, 6776, 7, 16, 0, 0, 6776, 6777, 7, 16, 0, 0, 6777, 6778, + 7, 5, 0, 0, 6778, 6779, 7, 14, 0, 0, 6779, 6780, 7, 20, 0, 0, 6780, 1222, + 1, 0, 0, 0, 6781, 6782, 7, 12, 0, 0, 6782, 6783, 7, 10, 0, 0, 6783, 6784, + 7, 16, 0, 0, 6784, 6785, 7, 5, 0, 0, 6785, 6786, 7, 14, 0, 0, 6786, 6787, + 7, 20, 0, 0, 6787, 1224, 1, 0, 0, 0, 6788, 6789, 7, 10, 0, 0, 6789, 6790, + 7, 26, 0, 0, 6790, 6791, 7, 24, 0, 0, 6791, 6792, 7, 13, 0, 0, 6792, 6793, + 7, 10, 0, 0, 6793, 6794, 7, 9, 0, 0, 6794, 6795, 7, 9, 0, 0, 6795, 6796, + 7, 17, 0, 0, 6796, 6797, 7, 19, 0, 0, 6797, 6798, 7, 7, 0, 0, 6798, 1226, + 1, 0, 0, 0, 6799, 6800, 7, 23, 0, 0, 6800, 6801, 7, 10, 0, 0, 6801, 6802, + 7, 7, 0, 0, 6802, 6803, 7, 10, 0, 0, 6803, 6804, 7, 13, 0, 0, 6804, 6805, + 7, 5, 0, 0, 6805, 6806, 7, 16, 0, 0, 6806, 6807, 7, 10, 0, 0, 6807, 6808, + 7, 12, 0, 0, 6808, 1228, 1, 0, 0, 0, 6809, 6810, 7, 6, 0, 0, 6810, 6811, + 7, 19, 0, 0, 6811, 6812, 7, 23, 0, 0, 6812, 6813, 7, 23, 0, 0, 6813, 6814, + 7, 10, 0, 0, 6814, 6815, 7, 12, 0, 0, 6815, 1230, 1, 0, 0, 0, 6816, 6817, + 7, 9, 0, 0, 6817, 6818, 7, 16, 0, 0, 6818, 6819, 7, 19, 0, 0, 6819, 6820, + 7, 13, 0, 0, 6820, 6821, 7, 10, 0, 0, 6821, 6822, 7, 12, 0, 0, 6822, 1232, + 1, 0, 0, 0, 6823, 6824, 7, 9, 0, 0, 6824, 6825, 7, 10, 0, 0, 6825, 6826, + 7, 13, 0, 0, 6826, 6827, 7, 12, 0, 0, 6827, 6828, 7, 10, 0, 0, 6828, 1234, + 1, 0, 0, 0, 6829, 6830, 7, 9, 0, 0, 6830, 6831, 7, 10, 0, 0, 6831, 6832, + 7, 13, 0, 0, 6832, 6833, 7, 12, 0, 0, 6833, 6834, 7, 10, 0, 0, 6834, 6835, + 7, 24, 0, 0, 6835, 6836, 7, 13, 0, 0, 6836, 6837, 7, 19, 0, 0, 6837, 6838, + 7, 24, 0, 0, 6838, 6839, 7, 10, 0, 0, 6839, 6840, 7, 13, 0, 0, 6840, 6841, + 7, 16, 0, 0, 6841, 6842, 7, 17, 0, 0, 6842, 6843, 7, 10, 0, 0, 6843, 6844, + 7, 9, 0, 0, 6844, 1236, 1, 0, 0, 0, 6845, 6846, 7, 17, 0, 0, 6846, 6847, + 7, 7, 0, 0, 6847, 6848, 7, 24, 0, 0, 6848, 6849, 7, 22, 0, 0, 6849, 6850, + 7, 16, 0, 0, 6850, 6851, 7, 25, 0, 0, 6851, 6852, 7, 19, 0, 0, 6852, 6853, + 7, 13, 0, 0, 6853, 6854, 7, 15, 0, 0, 6854, 6855, 7, 5, 0, 0, 6855, 6856, + 7, 16, 0, 0, 6856, 1238, 1, 0, 0, 0, 6857, 6858, 7, 19, 0, 0, 6858, 6859, + 7, 22, 0, 0, 6859, 6860, 7, 16, 0, 0, 6860, 6861, 7, 24, 0, 0, 6861, 6862, + 7, 22, 0, 0, 6862, 6863, 7, 16, 0, 0, 6863, 6864, 7, 25, 0, 0, 6864, 6865, + 7, 19, 0, 0, 6865, 6866, 7, 13, 0, 0, 6866, 6867, 7, 15, 0, 0, 6867, 6868, + 7, 5, 0, 0, 6868, 6869, 7, 16, 0, 0, 6869, 1240, 1, 0, 0, 0, 6870, 6871, + 7, 25, 0, 0, 6871, 6872, 7, 17, 0, 0, 6872, 6873, 7, 10, 0, 0, 6873, 6874, + 7, 6, 0, 0, 6874, 6875, 7, 12, 0, 0, 6875, 6876, 7, 9, 0, 0, 6876, 1242, + 1, 0, 0, 0, 6877, 6878, 7, 14, 0, 0, 6878, 6879, 7, 19, 0, 0, 6879, 6880, + 7, 6, 0, 0, 6880, 6881, 7, 6, 0, 0, 6881, 6882, 7, 10, 0, 0, 6882, 6883, + 7, 14, 0, 0, 6883, 6884, 7, 16, 0, 0, 6884, 6885, 7, 17, 0, 0, 6885, 6886, + 7, 19, 0, 0, 6886, 6887, 7, 7, 0, 0, 6887, 1244, 1, 0, 0, 0, 6888, 6889, + 7, 17, 0, 0, 6889, 6890, 7, 16, 0, 0, 6890, 6891, 7, 10, 0, 0, 6891, 6892, + 7, 15, 0, 0, 6892, 6893, 7, 9, 0, 0, 6893, 1246, 1, 0, 0, 0, 6894, 6895, + 7, 16, 0, 0, 6895, 6896, 7, 10, 0, 0, 6896, 6897, 7, 13, 0, 0, 6897, 6898, + 7, 15, 0, 0, 6898, 6899, 7, 17, 0, 0, 6899, 6900, 7, 7, 0, 0, 6900, 6901, + 7, 5, 0, 0, 6901, 6902, 7, 16, 0, 0, 6902, 6903, 7, 10, 0, 0, 6903, 6904, + 7, 12, 0, 0, 6904, 1248, 1, 0, 0, 0, 6905, 6906, 7, 10, 0, 0, 6906, 6907, + 7, 9, 0, 0, 6907, 6908, 7, 14, 0, 0, 6908, 6909, 7, 5, 0, 0, 6909, 6910, + 7, 24, 0, 0, 6910, 6911, 7, 10, 0, 0, 6911, 6912, 7, 12, 0, 0, 6912, 1250, + 1, 0, 0, 0, 6913, 6914, 7, 12, 0, 0, 6914, 6915, 7, 10, 0, 0, 6915, 6916, + 7, 25, 0, 0, 6916, 6917, 7, 17, 0, 0, 6917, 6918, 7, 7, 0, 0, 6918, 6919, + 7, 10, 0, 0, 6919, 6920, 7, 12, 0, 0, 6920, 1252, 1, 0, 0, 0, 6921, 6922, + 7, 6, 0, 0, 6922, 6923, 7, 17, 0, 0, 6923, 6924, 7, 7, 0, 0, 6924, 6925, + 7, 10, 0, 0, 6925, 6926, 7, 9, 0, 0, 6926, 1254, 1, 0, 0, 0, 6927, 6928, + 7, 21, 0, 0, 6928, 6929, 7, 10, 0, 0, 6929, 6930, 7, 8, 0, 0, 6930, 6931, + 7, 9, 0, 0, 6931, 1256, 1, 0, 0, 0, 6932, 6933, 7, 24, 0, 0, 6933, 6934, + 7, 5, 0, 0, 6934, 6935, 7, 13, 0, 0, 6935, 6936, 7, 16, 0, 0, 6936, 6937, + 7, 17, 0, 0, 6937, 6938, 7, 16, 0, 0, 6938, 6939, 7, 17, 0, 0, 6939, 6940, + 7, 19, 0, 0, 6940, 6941, 7, 7, 0, 0, 6941, 6942, 7, 10, 0, 0, 6942, 6943, + 7, 12, 0, 0, 6943, 1258, 1, 0, 0, 0, 6944, 6945, 7, 9, 0, 0, 6945, 6946, + 7, 16, 0, 0, 6946, 6947, 7, 13, 0, 0, 6947, 6948, 7, 22, 0, 0, 6948, 6949, + 7, 14, 0, 0, 6949, 6950, 7, 16, 0, 0, 6950, 1260, 1, 0, 0, 0, 6951, 6952, + 7, 15, 0, 0, 6952, 6953, 7, 5, 0, 0, 6953, 6954, 7, 24, 0, 0, 6954, 1262, + 1, 0, 0, 0, 6955, 6956, 7, 9, 0, 0, 6956, 6957, 7, 16, 0, 0, 6957, 6958, + 7, 13, 0, 0, 6958, 6959, 7, 17, 0, 0, 6959, 6960, 7, 7, 0, 0, 6960, 6961, + 7, 23, 0, 0, 6961, 1264, 1, 0, 0, 0, 6962, 6963, 7, 12, 0, 0, 6963, 6964, + 7, 10, 0, 0, 6964, 6965, 7, 6, 0, 0, 6965, 6966, 7, 17, 0, 0, 6966, 6967, + 7, 15, 0, 0, 6967, 6968, 7, 17, 0, 0, 6968, 6969, 7, 16, 0, 0, 6969, 6970, + 7, 10, 0, 0, 6970, 6971, 7, 12, 0, 0, 6971, 1266, 1, 0, 0, 0, 6972, 6973, + 7, 22, 0, 0, 6973, 6974, 7, 9, 0, 0, 6974, 6975, 7, 5, 0, 0, 6975, 6976, + 7, 23, 0, 0, 6976, 6977, 7, 10, 0, 0, 6977, 1268, 1, 0, 0, 0, 6978, 6979, + 7, 17, 0, 0, 6979, 6980, 7, 23, 0, 0, 6980, 6981, 7, 7, 0, 0, 6981, 6982, + 7, 19, 0, 0, 6982, 6983, 7, 13, 0, 0, 6983, 6984, 7, 10, 0, 0, 6984, 1270, + 1, 0, 0, 0, 6985, 6986, 7, 6, 0, 0, 6986, 6987, 7, 5, 0, 0, 6987, 6988, + 7, 7, 0, 0, 6988, 6989, 7, 23, 0, 0, 6989, 6990, 7, 22, 0, 0, 6990, 6991, + 7, 5, 0, 0, 6991, 6992, 7, 23, 0, 0, 6992, 6993, 7, 10, 0, 0, 6993, 6994, + 7, 9, 0, 0, 6994, 1272, 1, 0, 0, 0, 6995, 6996, 7, 30, 0, 0, 6996, 6997, + 7, 19, 0, 0, 6997, 6998, 7, 18, 0, 0, 6998, 1274, 1, 0, 0, 0, 6999, 7000, + 7, 30, 0, 0, 7000, 7001, 7, 19, 0, 0, 7001, 7002, 7, 18, 0, 0, 7002, 7003, + 7, 9, 0, 0, 7003, 1276, 1, 0, 0, 0, 7004, 7005, 7, 27, 0, 0, 7005, 7006, + 7, 17, 0, 0, 7006, 7007, 7, 5, 0, 0, 7007, 1278, 1, 0, 0, 0, 7008, 7009, + 7, 5, 0, 0, 7009, 7010, 7, 9, 0, 0, 7010, 7011, 7, 9, 0, 0, 7011, 7012, + 7, 22, 0, 0, 7012, 7013, 7, 15, 0, 0, 7013, 7014, 7, 10, 0, 0, 7014, 7015, + 7, 13, 0, 0, 7015, 7016, 7, 19, 0, 0, 7016, 7017, 7, 6, 0, 0, 7017, 7018, + 7, 10, 0, 0, 7018, 1280, 1, 0, 0, 0, 7019, 7020, 7, 13, 0, 0, 7020, 7021, + 7, 10, 0, 0, 7021, 7022, 7, 16, 0, 0, 7022, 7023, 7, 13, 0, 0, 7023, 7024, + 7, 8, 0, 0, 7024, 7025, 5, 95, 0, 0, 7025, 7026, 7, 16, 0, 0, 7026, 7027, + 7, 17, 0, 0, 7027, 7028, 7, 15, 0, 0, 7028, 7029, 7, 10, 0, 0, 7029, 7030, + 7, 19, 0, 0, 7030, 7031, 7, 22, 0, 0, 7031, 7032, 7, 16, 0, 0, 7032, 1282, + 1, 0, 0, 0, 7033, 7034, 7, 15, 0, 0, 7034, 7035, 7, 5, 0, 0, 7035, 7036, + 7, 26, 0, 0, 7036, 7037, 5, 95, 0, 0, 7037, 7038, 7, 18, 0, 0, 7038, 7039, + 7, 5, 0, 0, 7039, 7040, 7, 16, 0, 0, 7040, 7041, 7, 14, 0, 0, 7041, 7042, + 7, 20, 0, 0, 7042, 7043, 5, 95, 0, 0, 7043, 7044, 7, 9, 0, 0, 7044, 7045, + 7, 17, 0, 0, 7045, 7046, 7, 11, 0, 0, 7046, 7047, 7, 10, 0, 0, 7047, 1284, + 1, 0, 0, 0, 7048, 7049, 7, 15, 0, 0, 7049, 7050, 7, 5, 0, 0, 7050, 7051, + 7, 26, 0, 0, 7051, 7052, 5, 95, 0, 0, 7052, 7053, 7, 24, 0, 0, 7053, 7054, + 7, 5, 0, 0, 7054, 7055, 7, 8, 0, 0, 7055, 7056, 7, 6, 0, 0, 7056, 7057, + 7, 19, 0, 0, 7057, 7058, 7, 5, 0, 0, 7058, 7059, 7, 12, 0, 0, 7059, 7060, + 5, 95, 0, 0, 7060, 7061, 7, 17, 0, 0, 7061, 7062, 7, 7, 0, 0, 7062, 7063, + 5, 95, 0, 0, 7063, 7064, 7, 15, 0, 0, 7064, 7065, 7, 18, 0, 0, 7065, 1286, + 1, 0, 0, 0, 7066, 7067, 7, 21, 0, 0, 7067, 7068, 7, 18, 0, 0, 7068, 1288, + 1, 0, 0, 0, 7069, 7070, 7, 17, 0, 0, 7070, 7071, 7, 7, 0, 0, 7071, 7072, + 7, 14, 0, 0, 7072, 7073, 7, 6, 0, 0, 7073, 7074, 7, 22, 0, 0, 7074, 7075, + 7, 12, 0, 0, 7075, 7076, 7, 10, 0, 0, 7076, 1290, 1, 0, 0, 0, 7077, 7078, + 7, 13, 0, 0, 7078, 7079, 7, 19, 0, 0, 7079, 7080, 7, 22, 0, 0, 7080, 7081, + 7, 16, 0, 0, 7081, 7082, 7, 17, 0, 0, 7082, 7083, 7, 7, 0, 0, 7083, 7084, + 7, 10, 0, 0, 7084, 1292, 1, 0, 0, 0, 7085, 7086, 7, 16, 0, 0, 7086, 7087, + 7, 13, 0, 0, 7087, 7088, 7, 5, 0, 0, 7088, 7089, 7, 7, 0, 0, 7089, 7090, + 7, 9, 0, 0, 7090, 7091, 7, 25, 0, 0, 7091, 7092, 7, 19, 0, 0, 7092, 7093, + 7, 13, 0, 0, 7093, 7094, 7, 15, 0, 0, 7094, 1294, 1, 0, 0, 0, 7095, 7096, + 7, 17, 0, 0, 7096, 7097, 7, 15, 0, 0, 7097, 7098, 7, 24, 0, 0, 7098, 7099, + 7, 19, 0, 0, 7099, 7100, 7, 13, 0, 0, 7100, 7101, 7, 16, 0, 0, 7101, 1296, + 1, 0, 0, 0, 7102, 7103, 7, 24, 0, 0, 7103, 7104, 7, 19, 0, 0, 7104, 7105, + 7, 6, 0, 0, 7105, 7106, 7, 17, 0, 0, 7106, 7107, 7, 14, 0, 0, 7107, 7108, + 7, 8, 0, 0, 7108, 1298, 1, 0, 0, 0, 7109, 7110, 7, 24, 0, 0, 7110, 7111, + 7, 13, 0, 0, 7111, 7112, 7, 17, 0, 0, 7112, 7113, 7, 19, 0, 0, 7113, 7114, + 7, 13, 0, 0, 7114, 7115, 7, 17, 0, 0, 7115, 7116, 7, 16, 0, 0, 7116, 7117, + 7, 8, 0, 0, 7117, 1300, 1, 0, 0, 0, 7118, 7119, 7, 15, 0, 0, 7119, 7120, + 7, 10, 0, 0, 7120, 7121, 7, 16, 0, 0, 7121, 7122, 7, 20, 0, 0, 7122, 7123, + 7, 19, 0, 0, 7123, 7124, 7, 12, 0, 0, 7124, 1302, 1, 0, 0, 0, 7125, 7126, + 7, 13, 0, 0, 7126, 7127, 7, 10, 0, 0, 7127, 7128, 7, 25, 0, 0, 7128, 7129, + 7, 10, 0, 0, 7129, 7130, 7, 13, 0, 0, 7130, 7131, 7, 10, 0, 0, 7131, 7132, + 7, 7, 0, 0, 7132, 7133, 7, 14, 0, 0, 7133, 7134, 7, 17, 0, 0, 7134, 7135, + 7, 7, 0, 0, 7135, 7136, 7, 23, 0, 0, 7136, 1304, 1, 0, 0, 0, 7137, 7138, + 7, 7, 0, 0, 7138, 7139, 7, 10, 0, 0, 7139, 7140, 7, 29, 0, 0, 7140, 1306, + 1, 0, 0, 0, 7141, 7142, 7, 19, 0, 0, 7142, 7143, 7, 6, 0, 0, 7143, 7144, + 7, 12, 0, 0, 7144, 1308, 1, 0, 0, 0, 7145, 7146, 7, 27, 0, 0, 7146, 7147, + 7, 5, 0, 0, 7147, 7148, 7, 6, 0, 0, 7148, 7149, 7, 22, 0, 0, 7149, 7150, + 7, 10, 0, 0, 7150, 1310, 1, 0, 0, 0, 7151, 7152, 7, 9, 0, 0, 7152, 7153, + 7, 22, 0, 0, 7153, 7154, 7, 18, 0, 0, 7154, 7155, 7, 9, 0, 0, 7155, 7156, + 7, 14, 0, 0, 7156, 7157, 7, 13, 0, 0, 7157, 7158, 7, 17, 0, 0, 7158, 7159, + 7, 24, 0, 0, 7159, 7160, 7, 16, 0, 0, 7160, 7161, 7, 17, 0, 0, 7161, 7162, + 7, 19, 0, 0, 7162, 7163, 7, 7, 0, 0, 7163, 1312, 1, 0, 0, 0, 7164, 7165, + 7, 24, 0, 0, 7165, 7166, 7, 22, 0, 0, 7166, 7167, 7, 18, 0, 0, 7167, 7168, + 7, 6, 0, 0, 7168, 7169, 7, 17, 0, 0, 7169, 7170, 7, 14, 0, 0, 7170, 7171, + 7, 5, 0, 0, 7171, 7172, 7, 16, 0, 0, 7172, 7173, 7, 17, 0, 0, 7173, 7174, + 7, 19, 0, 0, 7174, 7175, 7, 7, 0, 0, 7175, 1314, 1, 0, 0, 0, 7176, 7177, + 7, 19, 0, 0, 7177, 7178, 7, 22, 0, 0, 7178, 7179, 7, 16, 0, 0, 7179, 1316, + 1, 0, 0, 0, 7180, 7181, 7, 10, 0, 0, 7181, 7182, 7, 7, 0, 0, 7182, 7183, + 7, 12, 0, 0, 7183, 1318, 1, 0, 0, 0, 7184, 7185, 7, 13, 0, 0, 7185, 7186, + 7, 19, 0, 0, 7186, 7187, 7, 22, 0, 0, 7187, 7188, 7, 16, 0, 0, 7188, 7189, + 7, 17, 0, 0, 7189, 7190, 7, 7, 0, 0, 7190, 7191, 7, 10, 0, 0, 7191, 7192, + 7, 9, 0, 0, 7192, 1320, 1, 0, 0, 0, 7193, 7194, 7, 9, 0, 0, 7194, 7195, + 7, 14, 0, 0, 7195, 7196, 7, 20, 0, 0, 7196, 7197, 7, 10, 0, 0, 7197, 7198, + 7, 15, 0, 0, 7198, 7199, 7, 5, 0, 0, 7199, 7200, 7, 9, 0, 0, 7200, 1322, + 1, 0, 0, 0, 7201, 7202, 7, 24, 0, 0, 7202, 7203, 7, 13, 0, 0, 7203, 7204, + 7, 19, 0, 0, 7204, 7205, 7, 14, 0, 0, 7205, 7206, 7, 10, 0, 0, 7206, 7207, + 7, 12, 0, 0, 7207, 7208, 7, 22, 0, 0, 7208, 7209, 7, 13, 0, 0, 7209, 7210, + 7, 10, 0, 0, 7210, 7211, 7, 9, 0, 0, 7211, 1324, 1, 0, 0, 0, 7212, 7213, + 7, 17, 0, 0, 7213, 7214, 7, 7, 0, 0, 7214, 7215, 7, 24, 0, 0, 7215, 7216, + 7, 22, 0, 0, 7216, 7217, 7, 16, 0, 0, 7217, 1326, 1, 0, 0, 0, 7218, 7219, + 7, 9, 0, 0, 7219, 7220, 7, 22, 0, 0, 7220, 7221, 7, 24, 0, 0, 7221, 7222, + 7, 24, 0, 0, 7222, 7223, 7, 19, 0, 0, 7223, 7224, 7, 13, 0, 0, 7224, 7225, + 7, 16, 0, 0, 7225, 1328, 1, 0, 0, 0, 7226, 7227, 7, 24, 0, 0, 7227, 7228, + 7, 5, 0, 0, 7228, 7229, 7, 13, 0, 0, 7229, 7230, 7, 5, 0, 0, 7230, 7231, + 7, 6, 0, 0, 7231, 7232, 7, 6, 0, 0, 7232, 7233, 7, 10, 0, 0, 7233, 7234, + 7, 6, 0, 0, 7234, 1330, 1, 0, 0, 0, 7235, 7236, 7, 9, 0, 0, 7236, 7237, + 7, 28, 0, 0, 7237, 7238, 7, 6, 0, 0, 7238, 1332, 1, 0, 0, 0, 7239, 7240, + 7, 12, 0, 0, 7240, 7241, 7, 10, 0, 0, 7241, 7242, 7, 24, 0, 0, 7242, 7243, + 7, 10, 0, 0, 7243, 7244, 7, 7, 0, 0, 7244, 7245, 7, 12, 0, 0, 7245, 7246, + 7, 9, 0, 0, 7246, 1334, 1, 0, 0, 0, 7247, 7248, 7, 19, 0, 0, 7248, 7249, + 7, 27, 0, 0, 7249, 7250, 7, 10, 0, 0, 7250, 7251, 7, 13, 0, 0, 7251, 7252, + 7, 13, 0, 0, 7252, 7253, 7, 17, 0, 0, 7253, 7254, 7, 12, 0, 0, 7254, 7255, + 7, 17, 0, 0, 7255, 7256, 7, 7, 0, 0, 7256, 7257, 7, 23, 0, 0, 7257, 1336, + 1, 0, 0, 0, 7258, 7259, 7, 14, 0, 0, 7259, 7260, 7, 19, 0, 0, 7260, 7261, + 7, 7, 0, 0, 7261, 7262, 7, 25, 0, 0, 7262, 7263, 7, 6, 0, 0, 7263, 7264, + 7, 17, 0, 0, 7264, 7265, 7, 14, 0, 0, 7265, 7266, 7, 16, 0, 0, 7266, 1338, + 1, 0, 0, 0, 7267, 7268, 7, 9, 0, 0, 7268, 7269, 7, 21, 0, 0, 7269, 7270, + 7, 17, 0, 0, 7270, 7271, 7, 24, 0, 0, 7271, 1340, 1, 0, 0, 0, 7272, 7273, + 7, 6, 0, 0, 7273, 7274, 7, 19, 0, 0, 7274, 7275, 7, 14, 0, 0, 7275, 7276, + 7, 21, 0, 0, 7276, 7277, 7, 10, 0, 0, 7277, 7278, 7, 12, 0, 0, 7278, 1342, + 1, 0, 0, 0, 7279, 7280, 7, 16, 0, 0, 7280, 7281, 7, 17, 0, 0, 7281, 7282, + 7, 10, 0, 0, 7282, 7283, 7, 9, 0, 0, 7283, 1344, 1, 0, 0, 0, 7284, 7285, + 7, 13, 0, 0, 7285, 7286, 7, 19, 0, 0, 7286, 7287, 7, 6, 0, 0, 7287, 7288, + 7, 6, 0, 0, 7288, 7289, 7, 22, 0, 0, 7289, 7290, 7, 24, 0, 0, 7290, 1346, + 1, 0, 0, 0, 7291, 7292, 7, 14, 0, 0, 7292, 7293, 7, 22, 0, 0, 7293, 7294, + 7, 18, 0, 0, 7294, 7295, 7, 10, 0, 0, 7295, 1348, 1, 0, 0, 0, 7296, 7297, + 7, 23, 0, 0, 7297, 7298, 7, 13, 0, 0, 7298, 7299, 7, 19, 0, 0, 7299, 7300, + 7, 22, 0, 0, 7300, 7301, 7, 24, 0, 0, 7301, 7302, 7, 17, 0, 0, 7302, 7303, + 7, 7, 0, 0, 7303, 7304, 7, 23, 0, 0, 7304, 1350, 1, 0, 0, 0, 7305, 7306, + 7, 9, 0, 0, 7306, 7307, 7, 10, 0, 0, 7307, 7308, 7, 16, 0, 0, 7308, 7309, + 7, 9, 0, 0, 7309, 1352, 1, 0, 0, 0, 7310, 7311, 7, 16, 0, 0, 7311, 7312, + 7, 5, 0, 0, 7312, 7313, 7, 18, 0, 0, 7313, 7314, 7, 6, 0, 0, 7314, 7315, + 7, 10, 0, 0, 7315, 7316, 7, 9, 0, 0, 7316, 7317, 7, 5, 0, 0, 7317, 7318, + 7, 15, 0, 0, 7318, 7319, 7, 24, 0, 0, 7319, 7320, 7, 6, 0, 0, 7320, 7321, + 7, 10, 0, 0, 7321, 1354, 1, 0, 0, 0, 7322, 7323, 7, 19, 0, 0, 7323, 7324, + 7, 13, 0, 0, 7324, 7325, 7, 12, 0, 0, 7325, 7326, 7, 17, 0, 0, 7326, 7327, + 7, 7, 0, 0, 7327, 7328, 7, 5, 0, 0, 7328, 7329, 7, 6, 0, 0, 7329, 7330, + 7, 17, 0, 0, 7330, 7331, 7, 16, 0, 0, 7331, 7332, 7, 8, 0, 0, 7332, 1356, + 1, 0, 0, 0, 7333, 7334, 7, 26, 0, 0, 7334, 7335, 7, 15, 0, 0, 7335, 7336, + 7, 6, 0, 0, 7336, 7337, 7, 16, 0, 0, 7337, 7338, 7, 5, 0, 0, 7338, 7339, + 7, 18, 0, 0, 7339, 7340, 7, 6, 0, 0, 7340, 7341, 7, 10, 0, 0, 7341, 1358, + 1, 0, 0, 0, 7342, 7343, 7, 14, 0, 0, 7343, 7344, 7, 19, 0, 0, 7344, 7345, + 7, 6, 0, 0, 7345, 7346, 7, 22, 0, 0, 7346, 7347, 7, 15, 0, 0, 7347, 7348, + 7, 7, 0, 0, 7348, 7349, 7, 9, 0, 0, 7349, 1360, 1, 0, 0, 0, 7350, 7351, + 7, 26, 0, 0, 7351, 7352, 7, 15, 0, 0, 7352, 7353, 7, 6, 0, 0, 7353, 7354, + 7, 7, 0, 0, 7354, 7355, 7, 5, 0, 0, 7355, 7356, 7, 15, 0, 0, 7356, 7357, + 7, 10, 0, 0, 7357, 7358, 7, 9, 0, 0, 7358, 7359, 7, 24, 0, 0, 7359, 7360, + 7, 5, 0, 0, 7360, 7361, 7, 14, 0, 0, 7361, 7362, 7, 10, 0, 0, 7362, 7363, + 7, 9, 0, 0, 7363, 1362, 1, 0, 0, 0, 7364, 7365, 7, 13, 0, 0, 7365, 7366, + 7, 19, 0, 0, 7366, 7367, 7, 29, 0, 0, 7367, 7368, 7, 16, 0, 0, 7368, 7369, + 7, 8, 0, 0, 7369, 7370, 7, 24, 0, 0, 7370, 7371, 7, 10, 0, 0, 7371, 1364, + 1, 0, 0, 0, 7372, 7373, 7, 7, 0, 0, 7373, 7374, 7, 19, 0, 0, 7374, 7375, + 7, 13, 0, 0, 7375, 7376, 7, 15, 0, 0, 7376, 7377, 7, 5, 0, 0, 7377, 7378, + 7, 6, 0, 0, 7378, 7379, 7, 17, 0, 0, 7379, 7380, 7, 11, 0, 0, 7380, 7381, + 7, 10, 0, 0, 7381, 7382, 7, 12, 0, 0, 7382, 1366, 1, 0, 0, 0, 7383, 7384, + 7, 29, 0, 0, 7384, 7385, 7, 17, 0, 0, 7385, 7386, 7, 16, 0, 0, 7386, 7387, + 7, 20, 0, 0, 7387, 7388, 7, 17, 0, 0, 7388, 7389, 7, 7, 0, 0, 7389, 1368, + 1, 0, 0, 0, 7390, 7391, 7, 25, 0, 0, 7391, 7392, 7, 17, 0, 0, 7392, 7393, + 7, 6, 0, 0, 7393, 7394, 7, 16, 0, 0, 7394, 7395, 7, 10, 0, 0, 7395, 7396, + 7, 13, 0, 0, 7396, 1370, 1, 0, 0, 0, 7397, 7398, 7, 23, 0, 0, 7398, 7399, + 7, 13, 0, 0, 7399, 7400, 7, 19, 0, 0, 7400, 7401, 7, 22, 0, 0, 7401, 7402, + 7, 24, 0, 0, 7402, 7403, 7, 9, 0, 0, 7403, 1372, 1, 0, 0, 0, 7404, 7405, + 7, 19, 0, 0, 7405, 7406, 7, 16, 0, 0, 7406, 7407, 7, 20, 0, 0, 7407, 7408, + 7, 10, 0, 0, 7408, 7409, 7, 13, 0, 0, 7409, 7410, 7, 9, 0, 0, 7410, 1374, + 1, 0, 0, 0, 7411, 7412, 7, 7, 0, 0, 7412, 7413, 7, 25, 0, 0, 7413, 7414, + 7, 14, 0, 0, 7414, 1376, 1, 0, 0, 0, 7415, 7416, 7, 7, 0, 0, 7416, 7417, + 7, 25, 0, 0, 7417, 7418, 7, 12, 0, 0, 7418, 1378, 1, 0, 0, 0, 7419, 7420, + 7, 7, 0, 0, 7420, 7421, 7, 25, 0, 0, 7421, 7422, 7, 21, 0, 0, 7422, 7423, + 7, 14, 0, 0, 7423, 1380, 1, 0, 0, 0, 7424, 7425, 7, 7, 0, 0, 7425, 7426, + 7, 25, 0, 0, 7426, 7427, 7, 21, 0, 0, 7427, 7428, 7, 12, 0, 0, 7428, 1382, + 1, 0, 0, 0, 7429, 7430, 7, 22, 0, 0, 7430, 7431, 7, 10, 0, 0, 7431, 7432, + 7, 9, 0, 0, 7432, 7433, 7, 14, 0, 0, 7433, 7434, 7, 5, 0, 0, 7434, 7435, + 7, 24, 0, 0, 7435, 7436, 7, 10, 0, 0, 7436, 1384, 1, 0, 0, 0, 7437, 7438, + 7, 27, 0, 0, 7438, 7439, 7, 17, 0, 0, 7439, 7440, 7, 10, 0, 0, 7440, 7441, + 7, 29, 0, 0, 7441, 7442, 7, 9, 0, 0, 7442, 1386, 1, 0, 0, 0, 7443, 7444, + 7, 7, 0, 0, 7444, 7445, 7, 19, 0, 0, 7445, 7446, 7, 13, 0, 0, 7446, 7447, + 7, 15, 0, 0, 7447, 7448, 7, 5, 0, 0, 7448, 7449, 7, 6, 0, 0, 7449, 7450, + 7, 17, 0, 0, 7450, 7451, 7, 11, 0, 0, 7451, 7452, 7, 10, 0, 0, 7452, 1388, + 1, 0, 0, 0, 7453, 7454, 7, 12, 0, 0, 7454, 7455, 7, 22, 0, 0, 7455, 7456, + 7, 15, 0, 0, 7456, 7457, 7, 24, 0, 0, 7457, 1390, 1, 0, 0, 0, 7458, 7459, + 7, 24, 0, 0, 7459, 7460, 7, 13, 0, 0, 7460, 7461, 7, 17, 0, 0, 7461, 7462, + 7, 7, 0, 0, 7462, 7463, 7, 16, 0, 0, 7463, 7464, 5, 95, 0, 0, 7464, 7465, + 7, 9, 0, 0, 7465, 7466, 7, 16, 0, 0, 7466, 7467, 7, 13, 0, 0, 7467, 7468, + 7, 17, 0, 0, 7468, 7469, 7, 14, 0, 0, 7469, 7470, 7, 16, 0, 0, 7470, 7471, + 5, 95, 0, 0, 7471, 7472, 7, 24, 0, 0, 7472, 7473, 7, 5, 0, 0, 7473, 7474, + 7, 13, 0, 0, 7474, 7475, 7, 5, 0, 0, 7475, 7476, 7, 15, 0, 0, 7476, 7477, + 7, 9, 0, 0, 7477, 1392, 1, 0, 0, 0, 7478, 7479, 7, 27, 0, 0, 7479, 7480, + 7, 5, 0, 0, 7480, 7481, 7, 13, 0, 0, 7481, 7482, 7, 17, 0, 0, 7482, 7483, + 7, 5, 0, 0, 7483, 7484, 7, 18, 0, 0, 7484, 7485, 7, 6, 0, 0, 7485, 7486, + 7, 10, 0, 0, 7486, 7487, 5, 95, 0, 0, 7487, 7488, 7, 14, 0, 0, 7488, 7489, + 7, 19, 0, 0, 7489, 7490, 7, 7, 0, 0, 7490, 7491, 7, 25, 0, 0, 7491, 7492, + 7, 6, 0, 0, 7492, 7493, 7, 17, 0, 0, 7493, 7494, 7, 14, 0, 0, 7494, 7495, + 7, 16, 0, 0, 7495, 1394, 1, 0, 0, 0, 7496, 7497, 7, 10, 0, 0, 7497, 7498, + 7, 13, 0, 0, 7498, 7499, 7, 13, 0, 0, 7499, 7500, 7, 19, 0, 0, 7500, 7501, + 7, 13, 0, 0, 7501, 1396, 1, 0, 0, 0, 7502, 7503, 7, 22, 0, 0, 7503, 7504, + 7, 9, 0, 0, 7504, 7505, 7, 10, 0, 0, 7505, 7506, 5, 95, 0, 0, 7506, 7507, + 7, 27, 0, 0, 7507, 7508, 7, 5, 0, 0, 7508, 7509, 7, 13, 0, 0, 7509, 7510, + 7, 17, 0, 0, 7510, 7511, 7, 5, 0, 0, 7511, 7512, 7, 18, 0, 0, 7512, 7513, + 7, 6, 0, 0, 7513, 7514, 7, 10, 0, 0, 7514, 1398, 1, 0, 0, 0, 7515, 7516, + 7, 22, 0, 0, 7516, 7517, 7, 9, 0, 0, 7517, 7518, 7, 10, 0, 0, 7518, 7519, + 5, 95, 0, 0, 7519, 7520, 7, 14, 0, 0, 7520, 7521, 7, 19, 0, 0, 7521, 7522, + 7, 6, 0, 0, 7522, 7523, 7, 22, 0, 0, 7523, 7524, 7, 15, 0, 0, 7524, 7525, + 7, 7, 0, 0, 7525, 1400, 1, 0, 0, 0, 7526, 7527, 7, 5, 0, 0, 7527, 7528, + 7, 6, 0, 0, 7528, 7529, 7, 17, 0, 0, 7529, 7530, 7, 5, 0, 0, 7530, 7531, + 7, 9, 0, 0, 7531, 1402, 1, 0, 0, 0, 7532, 7533, 7, 14, 0, 0, 7533, 7534, + 7, 19, 0, 0, 7534, 7535, 7, 7, 0, 0, 7535, 7536, 7, 9, 0, 0, 7536, 7537, + 7, 16, 0, 0, 7537, 7538, 7, 5, 0, 0, 7538, 7539, 7, 7, 0, 0, 7539, 7540, + 7, 16, 0, 0, 7540, 1404, 1, 0, 0, 0, 7541, 7542, 7, 24, 0, 0, 7542, 7543, + 7, 10, 0, 0, 7543, 7544, 7, 13, 0, 0, 7544, 7545, 7, 25, 0, 0, 7545, 7546, + 7, 19, 0, 0, 7546, 7547, 7, 13, 0, 0, 7547, 7548, 7, 15, 0, 0, 7548, 1406, + 1, 0, 0, 0, 7549, 7550, 7, 23, 0, 0, 7550, 7551, 7, 10, 0, 0, 7551, 7552, + 7, 16, 0, 0, 7552, 1408, 1, 0, 0, 0, 7553, 7554, 7, 12, 0, 0, 7554, 7555, + 7, 17, 0, 0, 7555, 7556, 7, 5, 0, 0, 7556, 7557, 7, 23, 0, 0, 7557, 7558, + 7, 7, 0, 0, 7558, 7559, 7, 19, 0, 0, 7559, 7560, 7, 9, 0, 0, 7560, 7561, + 7, 16, 0, 0, 7561, 7562, 7, 17, 0, 0, 7562, 7563, 7, 14, 0, 0, 7563, 7564, + 7, 9, 0, 0, 7564, 1410, 1, 0, 0, 0, 7565, 7566, 7, 9, 0, 0, 7566, 7567, + 7, 16, 0, 0, 7567, 7568, 7, 5, 0, 0, 7568, 7569, 7, 14, 0, 0, 7569, 7570, + 7, 21, 0, 0, 7570, 7571, 7, 10, 0, 0, 7571, 7572, 7, 12, 0, 0, 7572, 1412, + 1, 0, 0, 0, 7573, 7574, 7, 10, 0, 0, 7574, 7575, 7, 6, 0, 0, 7575, 7576, + 7, 9, 0, 0, 7576, 7577, 7, 17, 0, 0, 7577, 7578, 7, 25, 0, 0, 7578, 1414, + 1, 0, 0, 0, 7579, 7580, 7, 29, 0, 0, 7580, 7581, 7, 20, 0, 0, 7581, 7582, + 7, 17, 0, 0, 7582, 7583, 7, 6, 0, 0, 7583, 7584, 7, 10, 0, 0, 7584, 1416, + 1, 0, 0, 0, 7585, 7586, 7, 13, 0, 0, 7586, 7587, 7, 10, 0, 0, 7587, 7588, + 7, 27, 0, 0, 7588, 7589, 7, 10, 0, 0, 7589, 7590, 7, 13, 0, 0, 7590, 7591, + 7, 9, 0, 0, 7591, 7592, 7, 10, 0, 0, 7592, 1418, 1, 0, 0, 0, 7593, 7594, + 7, 25, 0, 0, 7594, 7595, 7, 19, 0, 0, 7595, 7596, 7, 13, 0, 0, 7596, 7597, + 7, 10, 0, 0, 7597, 7598, 7, 5, 0, 0, 7598, 7599, 7, 14, 0, 0, 7599, 7600, + 7, 20, 0, 0, 7600, 1420, 1, 0, 0, 0, 7601, 7602, 7, 9, 0, 0, 7602, 7603, + 7, 6, 0, 0, 7603, 7604, 7, 17, 0, 0, 7604, 7605, 7, 14, 0, 0, 7605, 7606, + 7, 10, 0, 0, 7606, 1422, 1, 0, 0, 0, 7607, 7608, 7, 10, 0, 0, 7608, 7609, + 7, 26, 0, 0, 7609, 7610, 7, 17, 0, 0, 7610, 7611, 7, 16, 0, 0, 7611, 1424, + 1, 0, 0, 0, 7612, 7613, 7, 13, 0, 0, 7613, 7614, 7, 10, 0, 0, 7614, 7615, + 7, 16, 0, 0, 7615, 7616, 7, 22, 0, 0, 7616, 7617, 7, 13, 0, 0, 7617, 7618, + 7, 7, 0, 0, 7618, 1426, 1, 0, 0, 0, 7619, 7620, 7, 28, 0, 0, 7620, 7621, + 7, 22, 0, 0, 7621, 7622, 7, 10, 0, 0, 7622, 7623, 7, 13, 0, 0, 7623, 7624, + 7, 8, 0, 0, 7624, 1428, 1, 0, 0, 0, 7625, 7626, 7, 13, 0, 0, 7626, 7627, + 7, 5, 0, 0, 7627, 7628, 7, 17, 0, 0, 7628, 7629, 7, 9, 0, 0, 7629, 7630, + 7, 10, 0, 0, 7630, 1430, 1, 0, 0, 0, 7631, 7632, 7, 9, 0, 0, 7632, 7633, + 7, 28, 0, 0, 7633, 7634, 7, 6, 0, 0, 7634, 7635, 7, 9, 0, 0, 7635, 7636, + 7, 16, 0, 0, 7636, 7637, 7, 5, 0, 0, 7637, 7638, 7, 16, 0, 0, 7638, 7639, + 7, 10, 0, 0, 7639, 1432, 1, 0, 0, 0, 7640, 7641, 7, 12, 0, 0, 7641, 7642, + 7, 10, 0, 0, 7642, 7643, 7, 18, 0, 0, 7643, 7644, 7, 22, 0, 0, 7644, 7645, + 7, 23, 0, 0, 7645, 1434, 1, 0, 0, 0, 7646, 7647, 7, 6, 0, 0, 7647, 7648, + 7, 19, 0, 0, 7648, 7649, 7, 23, 0, 0, 7649, 1436, 1, 0, 0, 0, 7650, 7651, + 7, 17, 0, 0, 7651, 7652, 7, 7, 0, 0, 7652, 7653, 7, 25, 0, 0, 7653, 7654, + 7, 19, 0, 0, 7654, 1438, 1, 0, 0, 0, 7655, 7656, 7, 7, 0, 0, 7656, 7657, + 7, 19, 0, 0, 7657, 7658, 7, 16, 0, 0, 7658, 7659, 7, 17, 0, 0, 7659, 7660, + 7, 14, 0, 0, 7660, 7661, 7, 10, 0, 0, 7661, 1440, 1, 0, 0, 0, 7662, 7663, + 7, 29, 0, 0, 7663, 7664, 7, 5, 0, 0, 7664, 7665, 7, 13, 0, 0, 7665, 7666, + 7, 7, 0, 0, 7666, 7667, 7, 17, 0, 0, 7667, 7668, 7, 7, 0, 0, 7668, 7669, + 7, 23, 0, 0, 7669, 1442, 1, 0, 0, 0, 7670, 7671, 7, 10, 0, 0, 7671, 7672, + 7, 26, 0, 0, 7672, 7673, 7, 14, 0, 0, 7673, 7674, 7, 10, 0, 0, 7674, 7675, + 7, 24, 0, 0, 7675, 7676, 7, 16, 0, 0, 7676, 7677, 7, 17, 0, 0, 7677, 7678, + 7, 19, 0, 0, 7678, 7679, 7, 7, 0, 0, 7679, 1444, 1, 0, 0, 0, 7680, 7681, + 7, 5, 0, 0, 7681, 7682, 7, 9, 0, 0, 7682, 7683, 7, 9, 0, 0, 7683, 7684, + 7, 10, 0, 0, 7684, 7685, 7, 13, 0, 0, 7685, 7686, 7, 16, 0, 0, 7686, 1446, + 1, 0, 0, 0, 7687, 7688, 7, 6, 0, 0, 7688, 7689, 7, 19, 0, 0, 7689, 7690, + 7, 19, 0, 0, 7690, 7691, 7, 24, 0, 0, 7691, 1448, 1, 0, 0, 0, 7692, 7693, + 7, 19, 0, 0, 7693, 7694, 7, 24, 0, 0, 7694, 7695, 7, 10, 0, 0, 7695, 7696, + 7, 7, 0, 0, 7696, 1450, 1, 0, 0, 0, 7697, 7698, 7, 5, 0, 0, 7698, 7699, + 7, 18, 0, 0, 7699, 7700, 7, 9, 0, 0, 7700, 1452, 1, 0, 0, 0, 7701, 7702, + 7, 14, 0, 0, 7702, 7703, 7, 18, 0, 0, 7703, 7704, 7, 13, 0, 0, 7704, 7705, + 7, 16, 0, 0, 7705, 1454, 1, 0, 0, 0, 7706, 7707, 7, 14, 0, 0, 7707, 7708, + 7, 10, 0, 0, 7708, 7709, 7, 17, 0, 0, 7709, 7710, 7, 6, 0, 0, 7710, 1456, + 1, 0, 0, 0, 7711, 7712, 7, 14, 0, 0, 7712, 7713, 7, 10, 0, 0, 7713, 7714, + 7, 17, 0, 0, 7714, 7715, 7, 6, 0, 0, 7715, 7716, 7, 17, 0, 0, 7716, 7717, + 7, 7, 0, 0, 7717, 7718, 7, 23, 0, 0, 7718, 1458, 1, 0, 0, 0, 7719, 7720, + 7, 12, 0, 0, 7720, 7721, 7, 10, 0, 0, 7721, 7722, 7, 23, 0, 0, 7722, 7723, + 7, 13, 0, 0, 7723, 7724, 7, 10, 0, 0, 7724, 7725, 7, 10, 0, 0, 7725, 7726, + 7, 9, 0, 0, 7726, 1460, 1, 0, 0, 0, 7727, 7728, 7, 12, 0, 0, 7728, 7729, + 7, 17, 0, 0, 7729, 7730, 7, 27, 0, 0, 7730, 1462, 1, 0, 0, 0, 7731, 7732, + 7, 10, 0, 0, 7732, 7733, 7, 26, 0, 0, 7733, 7734, 7, 24, 0, 0, 7734, 1464, + 1, 0, 0, 0, 7735, 7736, 7, 25, 0, 0, 7736, 7737, 7, 5, 0, 0, 7737, 7738, + 7, 14, 0, 0, 7738, 7739, 7, 16, 0, 0, 7739, 7740, 7, 19, 0, 0, 7740, 7741, + 7, 13, 0, 0, 7741, 7742, 7, 17, 0, 0, 7742, 7743, 7, 5, 0, 0, 7743, 7744, + 7, 6, 0, 0, 7744, 1466, 1, 0, 0, 0, 7745, 7746, 7, 25, 0, 0, 7746, 7747, + 7, 6, 0, 0, 7747, 7748, 7, 19, 0, 0, 7748, 7749, 7, 19, 0, 0, 7749, 7750, + 7, 13, 0, 0, 7750, 1468, 1, 0, 0, 0, 7751, 7752, 7, 23, 0, 0, 7752, 7753, + 7, 14, 0, 0, 7753, 7754, 7, 12, 0, 0, 7754, 1470, 1, 0, 0, 0, 7755, 7756, + 7, 6, 0, 0, 7756, 7757, 7, 14, 0, 0, 7757, 7758, 7, 15, 0, 0, 7758, 1472, + 1, 0, 0, 0, 7759, 7760, 7, 6, 0, 0, 7760, 7761, 7, 7, 0, 0, 7761, 1474, + 1, 0, 0, 0, 7762, 7763, 7, 6, 0, 0, 7763, 7764, 7, 19, 0, 0, 7764, 7765, + 7, 23, 0, 0, 7765, 7766, 5, 49, 0, 0, 7766, 7767, 5, 48, 0, 0, 7767, 1476, + 1, 0, 0, 0, 7768, 7769, 7, 15, 0, 0, 7769, 7770, 7, 17, 0, 0, 7770, 7771, + 7, 7, 0, 0, 7771, 7772, 5, 95, 0, 0, 7772, 7773, 7, 9, 0, 0, 7773, 7774, + 7, 14, 0, 0, 7774, 7775, 7, 5, 0, 0, 7775, 7776, 7, 6, 0, 0, 7776, 7777, + 7, 10, 0, 0, 7777, 1478, 1, 0, 0, 0, 7778, 7779, 7, 15, 0, 0, 7779, 7780, + 7, 19, 0, 0, 7780, 7781, 7, 12, 0, 0, 7781, 1480, 1, 0, 0, 0, 7782, 7783, + 7, 24, 0, 0, 7783, 7784, 7, 17, 0, 0, 7784, 1482, 1, 0, 0, 0, 7785, 7786, + 7, 24, 0, 0, 7786, 7787, 7, 19, 0, 0, 7787, 7788, 7, 29, 0, 0, 7788, 7789, + 7, 10, 0, 0, 7789, 7790, 7, 13, 0, 0, 7790, 1484, 1, 0, 0, 0, 7791, 7792, + 7, 13, 0, 0, 7792, 7793, 7, 5, 0, 0, 7793, 7794, 7, 12, 0, 0, 7794, 7795, + 7, 17, 0, 0, 7795, 7796, 7, 5, 0, 0, 7796, 7797, 7, 7, 0, 0, 7797, 7798, + 7, 9, 0, 0, 7798, 1486, 1, 0, 0, 0, 7799, 7800, 7, 13, 0, 0, 7800, 7801, + 7, 19, 0, 0, 7801, 7802, 7, 22, 0, 0, 7802, 7803, 7, 7, 0, 0, 7803, 7804, + 7, 12, 0, 0, 7804, 1488, 1, 0, 0, 0, 7805, 7806, 7, 9, 0, 0, 7806, 7807, + 7, 14, 0, 0, 7807, 7808, 7, 5, 0, 0, 7808, 7809, 7, 6, 0, 0, 7809, 7810, + 7, 10, 0, 0, 7810, 1490, 1, 0, 0, 0, 7811, 7812, 7, 9, 0, 0, 7812, 7813, + 7, 17, 0, 0, 7813, 7814, 7, 23, 0, 0, 7814, 7815, 7, 7, 0, 0, 7815, 1492, + 1, 0, 0, 0, 7816, 7817, 7, 9, 0, 0, 7817, 7818, 7, 28, 0, 0, 7818, 7819, + 7, 13, 0, 0, 7819, 7820, 7, 16, 0, 0, 7820, 1494, 1, 0, 0, 0, 7821, 7822, + 7, 16, 0, 0, 7822, 7823, 7, 13, 0, 0, 7823, 7824, 7, 17, 0, 0, 7824, 7825, + 7, 15, 0, 0, 7825, 7826, 5, 95, 0, 0, 7826, 7827, 7, 9, 0, 0, 7827, 7828, + 7, 14, 0, 0, 7828, 7829, 7, 5, 0, 0, 7829, 7830, 7, 6, 0, 0, 7830, 7831, + 7, 10, 0, 0, 7831, 1496, 1, 0, 0, 0, 7832, 7833, 7, 16, 0, 0, 7833, 7834, + 7, 13, 0, 0, 7834, 7835, 7, 22, 0, 0, 7835, 7836, 7, 7, 0, 0, 7836, 7837, + 7, 14, 0, 0, 7837, 1498, 1, 0, 0, 0, 7838, 7839, 7, 29, 0, 0, 7839, 7840, + 7, 17, 0, 0, 7840, 7841, 7, 12, 0, 0, 7841, 7842, 7, 16, 0, 0, 7842, 7843, + 7, 20, 0, 0, 7843, 7844, 5, 95, 0, 0, 7844, 7845, 7, 18, 0, 0, 7845, 7846, + 7, 22, 0, 0, 7846, 7847, 7, 14, 0, 0, 7847, 7848, 7, 21, 0, 0, 7848, 7849, + 7, 10, 0, 0, 7849, 7850, 7, 16, 0, 0, 7850, 1500, 1, 0, 0, 0, 7851, 7852, + 7, 13, 0, 0, 7852, 7853, 7, 5, 0, 0, 7853, 7854, 7, 7, 0, 0, 7854, 7855, + 7, 12, 0, 0, 7855, 7856, 7, 19, 0, 0, 7856, 7857, 7, 15, 0, 0, 7857, 1502, + 1, 0, 0, 0, 7858, 7859, 7, 9, 0, 0, 7859, 7860, 7, 10, 0, 0, 7860, 7861, + 7, 16, 0, 0, 7861, 7862, 7, 9, 0, 0, 7862, 7863, 7, 10, 0, 0, 7863, 7864, + 7, 10, 0, 0, 7864, 7865, 7, 12, 0, 0, 7865, 1504, 1, 0, 0, 0, 7866, 7867, + 7, 5, 0, 0, 7867, 7868, 7, 14, 0, 0, 7868, 7869, 7, 19, 0, 0, 7869, 7870, + 7, 9, 0, 0, 7870, 1506, 1, 0, 0, 0, 7871, 7872, 7, 5, 0, 0, 7872, 7873, + 7, 14, 0, 0, 7873, 7874, 7, 19, 0, 0, 7874, 7875, 7, 9, 0, 0, 7875, 7876, + 7, 12, 0, 0, 7876, 1508, 1, 0, 0, 0, 7877, 7878, 7, 5, 0, 0, 7878, 7879, + 7, 9, 0, 0, 7879, 7880, 7, 17, 0, 0, 7880, 7881, 7, 7, 0, 0, 7881, 1510, + 1, 0, 0, 0, 7882, 7883, 7, 5, 0, 0, 7883, 7884, 7, 9, 0, 0, 7884, 7885, + 7, 17, 0, 0, 7885, 7886, 7, 7, 0, 0, 7886, 7887, 7, 12, 0, 0, 7887, 1512, + 1, 0, 0, 0, 7888, 7889, 7, 5, 0, 0, 7889, 7890, 7, 16, 0, 0, 7890, 7891, + 7, 5, 0, 0, 7891, 7892, 7, 7, 0, 0, 7892, 1514, 1, 0, 0, 0, 7893, 7894, + 7, 5, 0, 0, 7894, 7895, 7, 16, 0, 0, 7895, 7896, 7, 5, 0, 0, 7896, 7897, + 7, 7, 0, 0, 7897, 7898, 7, 12, 0, 0, 7898, 1516, 1, 0, 0, 0, 7899, 7900, + 7, 5, 0, 0, 7900, 7901, 7, 16, 0, 0, 7901, 7902, 7, 5, 0, 0, 7902, 7903, + 7, 7, 0, 0, 7903, 7904, 5, 50, 0, 0, 7904, 1518, 1, 0, 0, 0, 7905, 7906, + 7, 5, 0, 0, 7906, 7907, 7, 16, 0, 0, 7907, 7908, 7, 5, 0, 0, 7908, 7909, + 7, 7, 0, 0, 7909, 7910, 5, 50, 0, 0, 7910, 7911, 7, 12, 0, 0, 7911, 1520, + 1, 0, 0, 0, 7912, 7913, 7, 14, 0, 0, 7913, 7914, 7, 19, 0, 0, 7914, 7915, + 7, 9, 0, 0, 7915, 1522, 1, 0, 0, 0, 7916, 7917, 7, 14, 0, 0, 7917, 7918, + 7, 19, 0, 0, 7918, 7919, 7, 9, 0, 0, 7919, 7920, 7, 12, 0, 0, 7920, 1524, + 1, 0, 0, 0, 7921, 7922, 7, 14, 0, 0, 7922, 7923, 7, 19, 0, 0, 7923, 7924, + 7, 16, 0, 0, 7924, 1526, 1, 0, 0, 0, 7925, 7926, 7, 14, 0, 0, 7926, 7927, + 7, 19, 0, 0, 7927, 7928, 7, 16, 0, 0, 7928, 7929, 7, 12, 0, 0, 7929, 1528, + 1, 0, 0, 0, 7930, 7931, 7, 9, 0, 0, 7931, 7932, 7, 17, 0, 0, 7932, 7933, + 7, 7, 0, 0, 7933, 1530, 1, 0, 0, 0, 7934, 7935, 7, 9, 0, 0, 7935, 7936, + 7, 17, 0, 0, 7936, 7937, 7, 7, 0, 0, 7937, 7938, 7, 12, 0, 0, 7938, 1532, + 1, 0, 0, 0, 7939, 7940, 7, 16, 0, 0, 7940, 7941, 7, 5, 0, 0, 7941, 7942, + 7, 7, 0, 0, 7942, 1534, 1, 0, 0, 0, 7943, 7944, 7, 16, 0, 0, 7944, 7945, + 7, 5, 0, 0, 7945, 7946, 7, 7, 0, 0, 7946, 7947, 7, 12, 0, 0, 7947, 1536, + 1, 0, 0, 0, 7948, 7949, 7, 9, 0, 0, 7949, 7950, 7, 17, 0, 0, 7950, 7951, + 7, 7, 0, 0, 7951, 7952, 7, 20, 0, 0, 7952, 1538, 1, 0, 0, 0, 7953, 7954, + 7, 14, 0, 0, 7954, 7955, 7, 19, 0, 0, 7955, 7956, 7, 9, 0, 0, 7956, 7957, + 7, 20, 0, 0, 7957, 1540, 1, 0, 0, 0, 7958, 7959, 7, 16, 0, 0, 7959, 7960, + 7, 5, 0, 0, 7960, 7961, 7, 7, 0, 0, 7961, 7962, 7, 20, 0, 0, 7962, 1542, + 1, 0, 0, 0, 7963, 7964, 7, 5, 0, 0, 7964, 7965, 7, 9, 0, 0, 7965, 7966, + 7, 17, 0, 0, 7966, 7967, 7, 7, 0, 0, 7967, 7968, 7, 20, 0, 0, 7968, 1544, + 1, 0, 0, 0, 7969, 7970, 7, 5, 0, 0, 7970, 7971, 7, 14, 0, 0, 7971, 7972, + 7, 19, 0, 0, 7972, 7973, 7, 9, 0, 0, 7973, 7974, 7, 20, 0, 0, 7974, 1546, + 1, 0, 0, 0, 7975, 7976, 7, 5, 0, 0, 7976, 7977, 7, 16, 0, 0, 7977, 7978, + 7, 5, 0, 0, 7978, 7979, 7, 7, 0, 0, 7979, 7980, 7, 20, 0, 0, 7980, 1548, + 1, 0, 0, 0, 7981, 7982, 7, 18, 0, 0, 7982, 7983, 7, 17, 0, 0, 7983, 7984, + 7, 16, 0, 0, 7984, 7985, 5, 95, 0, 0, 7985, 7986, 7, 6, 0, 0, 7986, 7987, + 7, 10, 0, 0, 7987, 7988, 7, 7, 0, 0, 7988, 7989, 7, 23, 0, 0, 7989, 7990, + 7, 16, 0, 0, 7990, 7991, 7, 20, 0, 0, 7991, 1550, 1, 0, 0, 0, 7992, 7993, + 7, 14, 0, 0, 7993, 7994, 7, 20, 0, 0, 7994, 7995, 7, 5, 0, 0, 7995, 7996, + 7, 13, 0, 0, 7996, 7997, 5, 95, 0, 0, 7997, 7998, 7, 6, 0, 0, 7998, 7999, + 7, 10, 0, 0, 7999, 8000, 7, 7, 0, 0, 8000, 8001, 7, 23, 0, 0, 8001, 8002, + 7, 16, 0, 0, 8002, 8003, 7, 20, 0, 0, 8003, 1552, 1, 0, 0, 0, 8004, 8005, + 7, 14, 0, 0, 8005, 8006, 7, 20, 0, 0, 8006, 8007, 7, 5, 0, 0, 8007, 8008, + 7, 13, 0, 0, 8008, 8009, 7, 5, 0, 0, 8009, 8010, 7, 14, 0, 0, 8010, 8011, + 7, 16, 0, 0, 8011, 8012, 7, 10, 0, 0, 8012, 8013, 7, 13, 0, 0, 8013, 8014, + 5, 95, 0, 0, 8014, 8015, 7, 6, 0, 0, 8015, 8016, 7, 10, 0, 0, 8016, 8017, + 7, 7, 0, 0, 8017, 8018, 7, 23, 0, 0, 8018, 8019, 7, 16, 0, 0, 8019, 8020, + 7, 20, 0, 0, 8020, 1554, 1, 0, 0, 0, 8021, 8022, 7, 6, 0, 0, 8022, 8023, + 7, 19, 0, 0, 8023, 8024, 7, 29, 0, 0, 8024, 8025, 7, 10, 0, 0, 8025, 8026, + 7, 13, 0, 0, 8026, 1556, 1, 0, 0, 0, 8027, 8028, 7, 19, 0, 0, 8028, 8029, + 7, 14, 0, 0, 8029, 8030, 7, 16, 0, 0, 8030, 8031, 7, 10, 0, 0, 8031, 8032, + 7, 16, 0, 0, 8032, 8033, 5, 95, 0, 0, 8033, 8034, 7, 6, 0, 0, 8034, 8035, + 7, 10, 0, 0, 8035, 8036, 7, 7, 0, 0, 8036, 8037, 7, 23, 0, 0, 8037, 8038, + 7, 16, 0, 0, 8038, 8039, 7, 20, 0, 0, 8039, 1558, 1, 0, 0, 0, 8040, 8041, + 7, 22, 0, 0, 8041, 8042, 7, 24, 0, 0, 8042, 8043, 7, 24, 0, 0, 8043, 8044, + 7, 10, 0, 0, 8044, 8045, 7, 13, 0, 0, 8045, 1560, 1, 0, 0, 0, 8046, 8047, + 7, 5, 0, 0, 8047, 8048, 7, 9, 0, 0, 8048, 8049, 7, 14, 0, 0, 8049, 8050, + 7, 17, 0, 0, 8050, 8051, 7, 17, 0, 0, 8051, 1562, 1, 0, 0, 0, 8052, 8053, + 7, 18, 0, 0, 8053, 8054, 7, 16, 0, 0, 8054, 8055, 7, 13, 0, 0, 8055, 8056, + 7, 17, 0, 0, 8056, 8057, 7, 15, 0, 0, 8057, 1564, 1, 0, 0, 0, 8058, 8059, + 7, 14, 0, 0, 8059, 8060, 7, 20, 0, 0, 8060, 8061, 7, 13, 0, 0, 8061, 1566, + 1, 0, 0, 0, 8062, 8063, 7, 14, 0, 0, 8063, 8064, 7, 19, 0, 0, 8064, 8065, + 7, 7, 0, 0, 8065, 8066, 7, 14, 0, 0, 8066, 8067, 7, 5, 0, 0, 8067, 8068, + 7, 16, 0, 0, 8068, 1568, 1, 0, 0, 0, 8069, 8070, 7, 14, 0, 0, 8070, 8071, + 7, 19, 0, 0, 8071, 8072, 7, 7, 0, 0, 8072, 8073, 7, 14, 0, 0, 8073, 8074, + 7, 5, 0, 0, 8074, 8075, 7, 16, 0, 0, 8075, 8076, 5, 95, 0, 0, 8076, 8077, + 7, 29, 0, 0, 8077, 8078, 7, 9, 0, 0, 8078, 1570, 1, 0, 0, 0, 8079, 8080, + 7, 25, 0, 0, 8080, 8081, 7, 19, 0, 0, 8081, 8082, 7, 13, 0, 0, 8082, 8083, + 7, 15, 0, 0, 8083, 8084, 7, 5, 0, 0, 8084, 8085, 7, 16, 0, 0, 8085, 1572, + 1, 0, 0, 0, 8086, 8087, 7, 17, 0, 0, 8087, 8088, 7, 7, 0, 0, 8088, 8089, + 7, 17, 0, 0, 8089, 8090, 7, 16, 0, 0, 8090, 8091, 7, 14, 0, 0, 8091, 8092, + 7, 5, 0, 0, 8092, 8093, 7, 24, 0, 0, 8093, 1574, 1, 0, 0, 0, 8094, 8095, + 7, 6, 0, 0, 8095, 8096, 7, 10, 0, 0, 8096, 8097, 7, 7, 0, 0, 8097, 8098, + 7, 23, 0, 0, 8098, 8099, 7, 16, 0, 0, 8099, 8100, 7, 20, 0, 0, 8100, 1576, + 1, 0, 0, 0, 8101, 8102, 7, 6, 0, 0, 8102, 8103, 7, 24, 0, 0, 8103, 8104, + 7, 5, 0, 0, 8104, 8105, 7, 12, 0, 0, 8105, 1578, 1, 0, 0, 0, 8106, 8107, + 7, 6, 0, 0, 8107, 8108, 7, 16, 0, 0, 8108, 8109, 7, 13, 0, 0, 8109, 8110, + 7, 17, 0, 0, 8110, 8111, 7, 15, 0, 0, 8111, 1580, 1, 0, 0, 0, 8112, 8113, + 7, 15, 0, 0, 8113, 8114, 7, 12, 0, 0, 8114, 8115, 5, 53, 0, 0, 8115, 1582, + 1, 0, 0, 0, 8116, 8117, 7, 24, 0, 0, 8117, 8118, 7, 5, 0, 0, 8118, 8119, + 7, 13, 0, 0, 8119, 8120, 7, 9, 0, 0, 8120, 8121, 7, 10, 0, 0, 8121, 8122, + 5, 95, 0, 0, 8122, 8123, 7, 17, 0, 0, 8123, 8124, 7, 12, 0, 0, 8124, 8125, + 7, 10, 0, 0, 8125, 8126, 7, 7, 0, 0, 8126, 8127, 7, 16, 0, 0, 8127, 1584, + 1, 0, 0, 0, 8128, 8129, 7, 24, 0, 0, 8129, 8130, 7, 23, 0, 0, 8130, 8131, + 5, 95, 0, 0, 8131, 8132, 7, 14, 0, 0, 8132, 8133, 7, 6, 0, 0, 8133, 8134, + 7, 17, 0, 0, 8134, 8135, 7, 10, 0, 0, 8135, 8136, 7, 7, 0, 0, 8136, 8137, + 7, 16, 0, 0, 8137, 8138, 5, 95, 0, 0, 8138, 8139, 7, 10, 0, 0, 8139, 8140, + 7, 7, 0, 0, 8140, 8141, 7, 14, 0, 0, 8141, 8142, 7, 19, 0, 0, 8142, 8143, + 7, 12, 0, 0, 8143, 8144, 7, 17, 0, 0, 8144, 8145, 7, 7, 0, 0, 8145, 8146, + 7, 23, 0, 0, 8146, 1586, 1, 0, 0, 0, 8147, 8148, 7, 28, 0, 0, 8148, 8149, + 7, 22, 0, 0, 8149, 8150, 7, 19, 0, 0, 8150, 8151, 7, 16, 0, 0, 8151, 8152, + 7, 10, 0, 0, 8152, 8153, 5, 95, 0, 0, 8153, 8154, 7, 17, 0, 0, 8154, 8155, + 7, 12, 0, 0, 8155, 8156, 7, 10, 0, 0, 8156, 8157, 7, 7, 0, 0, 8157, 8158, + 7, 16, 0, 0, 8158, 1588, 1, 0, 0, 0, 8159, 8160, 7, 28, 0, 0, 8160, 8161, + 7, 22, 0, 0, 8161, 8162, 7, 19, 0, 0, 8162, 8163, 7, 16, 0, 0, 8163, 8164, + 7, 10, 0, 0, 8164, 8165, 5, 95, 0, 0, 8165, 8166, 7, 6, 0, 0, 8166, 8167, + 7, 17, 0, 0, 8167, 8168, 7, 16, 0, 0, 8168, 8169, 7, 10, 0, 0, 8169, 8170, + 7, 13, 0, 0, 8170, 8171, 7, 5, 0, 0, 8171, 8172, 7, 6, 0, 0, 8172, 1590, + 1, 0, 0, 0, 8173, 8174, 7, 28, 0, 0, 8174, 8175, 7, 22, 0, 0, 8175, 8176, + 7, 19, 0, 0, 8176, 8177, 7, 16, 0, 0, 8177, 8178, 7, 10, 0, 0, 8178, 8179, + 5, 95, 0, 0, 8179, 8180, 7, 7, 0, 0, 8180, 8181, 7, 22, 0, 0, 8181, 8182, + 7, 6, 0, 0, 8182, 8183, 7, 6, 0, 0, 8183, 8184, 7, 5, 0, 0, 8184, 8185, + 7, 18, 0, 0, 8185, 8186, 7, 6, 0, 0, 8186, 8187, 7, 10, 0, 0, 8187, 1592, + 1, 0, 0, 0, 8188, 8189, 7, 13, 0, 0, 8189, 8190, 7, 10, 0, 0, 8190, 8191, + 7, 23, 0, 0, 8191, 8192, 7, 10, 0, 0, 8192, 8193, 7, 26, 0, 0, 8193, 8194, + 7, 24, 0, 0, 8194, 8195, 5, 95, 0, 0, 8195, 8196, 7, 14, 0, 0, 8196, 8197, + 7, 19, 0, 0, 8197, 8198, 7, 22, 0, 0, 8198, 8199, 7, 7, 0, 0, 8199, 8200, + 7, 16, 0, 0, 8200, 1594, 1, 0, 0, 0, 8201, 8202, 7, 13, 0, 0, 8202, 8203, + 7, 10, 0, 0, 8203, 8204, 7, 23, 0, 0, 8204, 8205, 7, 10, 0, 0, 8205, 8206, + 7, 26, 0, 0, 8206, 8207, 7, 24, 0, 0, 8207, 8208, 5, 95, 0, 0, 8208, 8209, + 7, 17, 0, 0, 8209, 8210, 7, 7, 0, 0, 8210, 8211, 7, 9, 0, 0, 8211, 8212, + 7, 16, 0, 0, 8212, 8213, 7, 13, 0, 0, 8213, 1596, 1, 0, 0, 0, 8214, 8215, + 7, 13, 0, 0, 8215, 8216, 7, 10, 0, 0, 8216, 8217, 7, 23, 0, 0, 8217, 8218, + 7, 10, 0, 0, 8218, 8219, 7, 26, 0, 0, 8219, 8220, 7, 24, 0, 0, 8220, 8221, + 5, 95, 0, 0, 8221, 8222, 7, 6, 0, 0, 8222, 8223, 7, 17, 0, 0, 8223, 8224, + 7, 21, 0, 0, 8224, 8225, 7, 10, 0, 0, 8225, 1598, 1, 0, 0, 0, 8226, 8227, + 7, 13, 0, 0, 8227, 8228, 7, 10, 0, 0, 8228, 8229, 7, 23, 0, 0, 8229, 8230, + 7, 10, 0, 0, 8230, 8231, 7, 26, 0, 0, 8231, 8232, 7, 24, 0, 0, 8232, 8233, + 5, 95, 0, 0, 8233, 8234, 7, 15, 0, 0, 8234, 8235, 7, 5, 0, 0, 8235, 8236, + 7, 16, 0, 0, 8236, 8237, 7, 14, 0, 0, 8237, 8238, 7, 20, 0, 0, 8238, 1600, + 1, 0, 0, 0, 8239, 8240, 7, 13, 0, 0, 8240, 8241, 7, 10, 0, 0, 8241, 8242, + 7, 23, 0, 0, 8242, 8243, 7, 10, 0, 0, 8243, 8244, 7, 26, 0, 0, 8244, 8245, + 7, 24, 0, 0, 8245, 8246, 5, 95, 0, 0, 8246, 8247, 7, 15, 0, 0, 8247, 8248, + 7, 5, 0, 0, 8248, 8249, 7, 16, 0, 0, 8249, 8250, 7, 14, 0, 0, 8250, 8251, + 7, 20, 0, 0, 8251, 8252, 7, 10, 0, 0, 8252, 8253, 7, 9, 0, 0, 8253, 1602, + 1, 0, 0, 0, 8254, 8255, 7, 13, 0, 0, 8255, 8256, 7, 10, 0, 0, 8256, 8257, + 7, 23, 0, 0, 8257, 8258, 7, 10, 0, 0, 8258, 8259, 7, 26, 0, 0, 8259, 8260, + 7, 24, 0, 0, 8260, 8261, 5, 95, 0, 0, 8261, 8262, 7, 13, 0, 0, 8262, 8263, + 7, 10, 0, 0, 8263, 8264, 7, 24, 0, 0, 8264, 8265, 7, 6, 0, 0, 8265, 8266, + 7, 5, 0, 0, 8266, 8267, 7, 14, 0, 0, 8267, 8268, 7, 10, 0, 0, 8268, 1604, + 1, 0, 0, 0, 8269, 8270, 7, 13, 0, 0, 8270, 8271, 7, 10, 0, 0, 8271, 8272, + 7, 23, 0, 0, 8272, 8273, 7, 10, 0, 0, 8273, 8274, 7, 26, 0, 0, 8274, 8275, + 7, 24, 0, 0, 8275, 8276, 5, 95, 0, 0, 8276, 8277, 7, 9, 0, 0, 8277, 8278, + 7, 24, 0, 0, 8278, 8279, 7, 6, 0, 0, 8279, 8280, 7, 17, 0, 0, 8280, 8281, + 7, 16, 0, 0, 8281, 8282, 5, 95, 0, 0, 8282, 8283, 7, 16, 0, 0, 8283, 8284, + 7, 19, 0, 0, 8284, 8285, 5, 95, 0, 0, 8285, 8286, 7, 5, 0, 0, 8286, 8287, + 7, 13, 0, 0, 8287, 8288, 7, 13, 0, 0, 8288, 8289, 7, 5, 0, 0, 8289, 8290, + 7, 8, 0, 0, 8290, 1606, 1, 0, 0, 0, 8291, 8292, 7, 13, 0, 0, 8292, 8293, + 7, 10, 0, 0, 8293, 8294, 7, 23, 0, 0, 8294, 8295, 7, 10, 0, 0, 8295, 8296, + 7, 26, 0, 0, 8296, 8297, 7, 24, 0, 0, 8297, 8298, 5, 95, 0, 0, 8298, 8299, + 7, 9, 0, 0, 8299, 8300, 7, 24, 0, 0, 8300, 8301, 7, 6, 0, 0, 8301, 8302, + 7, 17, 0, 0, 8302, 8303, 7, 16, 0, 0, 8303, 8304, 5, 95, 0, 0, 8304, 8305, + 7, 16, 0, 0, 8305, 8306, 7, 19, 0, 0, 8306, 8307, 5, 95, 0, 0, 8307, 8308, + 7, 16, 0, 0, 8308, 8309, 7, 5, 0, 0, 8309, 8310, 7, 18, 0, 0, 8310, 8311, + 7, 6, 0, 0, 8311, 8312, 7, 10, 0, 0, 8312, 1608, 1, 0, 0, 0, 8313, 8314, + 7, 13, 0, 0, 8314, 8315, 7, 10, 0, 0, 8315, 8316, 7, 23, 0, 0, 8316, 8317, + 7, 10, 0, 0, 8317, 8318, 7, 26, 0, 0, 8318, 8319, 7, 24, 0, 0, 8319, 8320, + 5, 95, 0, 0, 8320, 8321, 7, 9, 0, 0, 8321, 8322, 7, 22, 0, 0, 8322, 8323, + 7, 18, 0, 0, 8323, 8324, 7, 9, 0, 0, 8324, 8325, 7, 16, 0, 0, 8325, 8326, + 7, 13, 0, 0, 8326, 1610, 1, 0, 0, 0, 8327, 8328, 7, 13, 0, 0, 8328, 8329, + 7, 10, 0, 0, 8329, 8330, 7, 24, 0, 0, 8330, 8331, 7, 10, 0, 0, 8331, 8332, + 7, 5, 0, 0, 8332, 8333, 7, 16, 0, 0, 8333, 1612, 1, 0, 0, 0, 8334, 8335, + 7, 13, 0, 0, 8335, 8336, 7, 24, 0, 0, 8336, 8337, 7, 5, 0, 0, 8337, 8338, + 7, 12, 0, 0, 8338, 1614, 1, 0, 0, 0, 8339, 8340, 7, 13, 0, 0, 8340, 8341, + 7, 16, 0, 0, 8341, 8342, 7, 13, 0, 0, 8342, 8343, 7, 17, 0, 0, 8343, 8344, + 7, 15, 0, 0, 8344, 1616, 1, 0, 0, 0, 8345, 8346, 7, 9, 0, 0, 8346, 8347, + 7, 24, 0, 0, 8347, 8348, 7, 6, 0, 0, 8348, 8349, 7, 17, 0, 0, 8349, 8350, + 7, 16, 0, 0, 8350, 8351, 5, 95, 0, 0, 8351, 8352, 7, 24, 0, 0, 8352, 8353, + 7, 5, 0, 0, 8353, 8354, 7, 13, 0, 0, 8354, 8355, 7, 16, 0, 0, 8355, 1618, + 1, 0, 0, 0, 8356, 8357, 7, 9, 0, 0, 8357, 8358, 7, 16, 0, 0, 8358, 8359, + 7, 5, 0, 0, 8359, 8360, 7, 13, 0, 0, 8360, 8361, 7, 16, 0, 0, 8361, 8362, + 7, 9, 0, 0, 8362, 8363, 5, 95, 0, 0, 8363, 8364, 7, 29, 0, 0, 8364, 8365, + 7, 17, 0, 0, 8365, 8366, 7, 16, 0, 0, 8366, 8367, 7, 20, 0, 0, 8367, 1620, + 1, 0, 0, 0, 8368, 8369, 7, 9, 0, 0, 8369, 8370, 7, 16, 0, 0, 8370, 8371, + 7, 13, 0, 0, 8371, 8372, 7, 17, 0, 0, 8372, 8373, 7, 7, 0, 0, 8373, 8374, + 7, 23, 0, 0, 8374, 8375, 5, 95, 0, 0, 8375, 8376, 7, 16, 0, 0, 8376, 8377, + 7, 19, 0, 0, 8377, 8378, 5, 95, 0, 0, 8378, 8379, 7, 5, 0, 0, 8379, 8380, + 7, 13, 0, 0, 8380, 8381, 7, 13, 0, 0, 8381, 8382, 7, 5, 0, 0, 8382, 8383, + 7, 8, 0, 0, 8383, 1622, 1, 0, 0, 0, 8384, 8385, 7, 9, 0, 0, 8385, 8386, + 7, 16, 0, 0, 8386, 8387, 7, 13, 0, 0, 8387, 8388, 7, 17, 0, 0, 8388, 8389, + 7, 7, 0, 0, 8389, 8390, 7, 23, 0, 0, 8390, 8391, 5, 95, 0, 0, 8391, 8392, + 7, 16, 0, 0, 8392, 8393, 7, 19, 0, 0, 8393, 8394, 5, 95, 0, 0, 8394, 8395, + 7, 16, 0, 0, 8395, 8396, 7, 5, 0, 0, 8396, 8397, 7, 18, 0, 0, 8397, 8398, + 7, 6, 0, 0, 8398, 8399, 7, 10, 0, 0, 8399, 1624, 1, 0, 0, 0, 8400, 8401, + 7, 9, 0, 0, 8401, 8402, 7, 16, 0, 0, 8402, 8403, 7, 13, 0, 0, 8403, 8404, + 7, 24, 0, 0, 8404, 8405, 7, 19, 0, 0, 8405, 8406, 7, 9, 0, 0, 8406, 1626, + 1, 0, 0, 0, 8407, 8408, 7, 9, 0, 0, 8408, 8409, 7, 22, 0, 0, 8409, 8410, + 7, 18, 0, 0, 8410, 8411, 7, 9, 0, 0, 8411, 8412, 7, 16, 0, 0, 8412, 8413, + 7, 13, 0, 0, 8413, 1628, 1, 0, 0, 0, 8414, 8415, 7, 16, 0, 0, 8415, 8416, + 7, 19, 0, 0, 8416, 8417, 5, 95, 0, 0, 8417, 8418, 7, 5, 0, 0, 8418, 8419, + 7, 9, 0, 0, 8419, 8420, 7, 14, 0, 0, 8420, 8421, 7, 17, 0, 0, 8421, 8422, + 7, 17, 0, 0, 8422, 1630, 1, 0, 0, 0, 8423, 8424, 7, 16, 0, 0, 8424, 8425, + 7, 19, 0, 0, 8425, 8426, 5, 95, 0, 0, 8426, 8427, 7, 20, 0, 0, 8427, 8428, + 7, 10, 0, 0, 8428, 8429, 7, 26, 0, 0, 8429, 1632, 1, 0, 0, 0, 8430, 8431, + 7, 16, 0, 0, 8431, 8432, 7, 13, 0, 0, 8432, 8433, 7, 5, 0, 0, 8433, 8434, + 7, 7, 0, 0, 8434, 8435, 7, 9, 0, 0, 8435, 8436, 7, 6, 0, 0, 8436, 8437, + 7, 5, 0, 0, 8437, 8438, 7, 16, 0, 0, 8438, 8439, 7, 10, 0, 0, 8439, 1634, + 1, 0, 0, 0, 8440, 8441, 7, 22, 0, 0, 8441, 8442, 7, 7, 0, 0, 8442, 8443, + 7, 17, 0, 0, 8443, 8444, 7, 9, 0, 0, 8444, 8445, 7, 16, 0, 0, 8445, 8446, + 7, 13, 0, 0, 8446, 1636, 1, 0, 0, 0, 8447, 8448, 7, 5, 0, 0, 8448, 8449, + 7, 23, 0, 0, 8449, 8450, 7, 10, 0, 0, 8450, 1638, 1, 0, 0, 0, 8451, 8452, + 7, 14, 0, 0, 8452, 8453, 7, 6, 0, 0, 8453, 8454, 7, 19, 0, 0, 8454, 8455, + 7, 14, 0, 0, 8455, 8456, 7, 21, 0, 0, 8456, 8457, 5, 95, 0, 0, 8457, 8458, + 7, 16, 0, 0, 8458, 8459, 7, 17, 0, 0, 8459, 8460, 7, 15, 0, 0, 8460, 8461, + 7, 10, 0, 0, 8461, 8462, 7, 9, 0, 0, 8462, 8463, 7, 16, 0, 0, 8463, 8464, + 7, 5, 0, 0, 8464, 8465, 7, 15, 0, 0, 8465, 8466, 7, 24, 0, 0, 8466, 1640, + 1, 0, 0, 0, 8467, 8468, 7, 12, 0, 0, 8468, 8469, 7, 5, 0, 0, 8469, 8470, + 7, 16, 0, 0, 8470, 8471, 7, 10, 0, 0, 8471, 8472, 5, 95, 0, 0, 8472, 8473, + 7, 18, 0, 0, 8473, 8474, 7, 17, 0, 0, 8474, 8475, 7, 7, 0, 0, 8475, 1642, + 1, 0, 0, 0, 8476, 8477, 7, 12, 0, 0, 8477, 8478, 7, 5, 0, 0, 8478, 8479, + 7, 16, 0, 0, 8479, 8480, 7, 10, 0, 0, 8480, 8481, 5, 95, 0, 0, 8481, 8482, + 7, 24, 0, 0, 8482, 8483, 7, 5, 0, 0, 8483, 8484, 7, 13, 0, 0, 8484, 8485, + 7, 16, 0, 0, 8485, 1644, 1, 0, 0, 0, 8486, 8487, 7, 12, 0, 0, 8487, 8488, + 7, 5, 0, 0, 8488, 8489, 7, 16, 0, 0, 8489, 8490, 7, 10, 0, 0, 8490, 8491, + 5, 95, 0, 0, 8491, 8492, 7, 16, 0, 0, 8492, 8493, 7, 13, 0, 0, 8493, 8494, + 7, 22, 0, 0, 8494, 8495, 7, 7, 0, 0, 8495, 8496, 7, 14, 0, 0, 8496, 1646, + 1, 0, 0, 0, 8497, 8498, 7, 17, 0, 0, 8498, 8499, 7, 9, 0, 0, 8499, 8500, + 7, 25, 0, 0, 8500, 8501, 7, 17, 0, 0, 8501, 8502, 7, 7, 0, 0, 8502, 8503, + 7, 17, 0, 0, 8503, 8504, 7, 16, 0, 0, 8504, 8505, 7, 10, 0, 0, 8505, 1648, + 1, 0, 0, 0, 8506, 8507, 7, 30, 0, 0, 8507, 8508, 7, 22, 0, 0, 8508, 8509, + 7, 9, 0, 0, 8509, 8510, 7, 16, 0, 0, 8510, 8511, 7, 17, 0, 0, 8511, 8512, + 7, 25, 0, 0, 8512, 8513, 7, 8, 0, 0, 8513, 8514, 5, 95, 0, 0, 8514, 8515, + 7, 12, 0, 0, 8515, 8516, 7, 5, 0, 0, 8516, 8517, 7, 8, 0, 0, 8517, 8518, + 7, 9, 0, 0, 8518, 1650, 1, 0, 0, 0, 8519, 8520, 7, 30, 0, 0, 8520, 8521, + 7, 22, 0, 0, 8521, 8522, 7, 9, 0, 0, 8522, 8523, 7, 16, 0, 0, 8523, 8524, + 7, 17, 0, 0, 8524, 8525, 7, 25, 0, 0, 8525, 8526, 7, 8, 0, 0, 8526, 8527, + 5, 95, 0, 0, 8527, 8528, 7, 20, 0, 0, 8528, 8529, 7, 19, 0, 0, 8529, 8530, + 7, 22, 0, 0, 8530, 8531, 7, 13, 0, 0, 8531, 8532, 7, 9, 0, 0, 8532, 1652, + 1, 0, 0, 0, 8533, 8534, 7, 30, 0, 0, 8534, 8535, 7, 22, 0, 0, 8535, 8536, + 7, 9, 0, 0, 8536, 8537, 7, 16, 0, 0, 8537, 8538, 7, 17, 0, 0, 8538, 8539, + 7, 25, 0, 0, 8539, 8540, 7, 8, 0, 0, 8540, 8541, 5, 95, 0, 0, 8541, 8542, + 7, 17, 0, 0, 8542, 8543, 7, 7, 0, 0, 8543, 8544, 7, 16, 0, 0, 8544, 8545, + 7, 10, 0, 0, 8545, 8546, 7, 13, 0, 0, 8546, 8547, 7, 27, 0, 0, 8547, 8548, + 7, 5, 0, 0, 8548, 8549, 7, 6, 0, 0, 8549, 1654, 1, 0, 0, 0, 8550, 8551, + 7, 15, 0, 0, 8551, 8552, 7, 5, 0, 0, 8552, 8553, 7, 21, 0, 0, 8553, 8554, + 7, 10, 0, 0, 8554, 8555, 5, 95, 0, 0, 8555, 8556, 7, 12, 0, 0, 8556, 8557, + 7, 5, 0, 0, 8557, 8558, 7, 16, 0, 0, 8558, 8559, 7, 10, 0, 0, 8559, 1656, + 1, 0, 0, 0, 8560, 8561, 7, 15, 0, 0, 8561, 8562, 7, 5, 0, 0, 8562, 8563, + 7, 21, 0, 0, 8563, 8564, 7, 10, 0, 0, 8564, 8565, 5, 95, 0, 0, 8565, 8566, + 7, 17, 0, 0, 8566, 8567, 7, 7, 0, 0, 8567, 8568, 7, 16, 0, 0, 8568, 8569, + 7, 10, 0, 0, 8569, 8570, 7, 13, 0, 0, 8570, 8571, 7, 27, 0, 0, 8571, 8572, + 7, 5, 0, 0, 8572, 8573, 7, 6, 0, 0, 8573, 1658, 1, 0, 0, 0, 8574, 8575, + 7, 15, 0, 0, 8575, 8576, 7, 5, 0, 0, 8576, 8577, 7, 21, 0, 0, 8577, 8578, + 7, 10, 0, 0, 8578, 8579, 5, 95, 0, 0, 8579, 8580, 7, 16, 0, 0, 8580, 8581, + 7, 17, 0, 0, 8581, 8582, 7, 15, 0, 0, 8582, 8583, 7, 10, 0, 0, 8583, 1660, + 1, 0, 0, 0, 8584, 8585, 7, 15, 0, 0, 8585, 8586, 7, 5, 0, 0, 8586, 8587, + 7, 21, 0, 0, 8587, 8588, 7, 10, 0, 0, 8588, 8589, 5, 95, 0, 0, 8589, 8590, + 7, 16, 0, 0, 8590, 8591, 7, 17, 0, 0, 8591, 8592, 7, 15, 0, 0, 8592, 8593, + 7, 10, 0, 0, 8593, 8594, 7, 9, 0, 0, 8594, 8595, 7, 16, 0, 0, 8595, 8596, + 7, 5, 0, 0, 8596, 8597, 7, 15, 0, 0, 8597, 8598, 7, 24, 0, 0, 8598, 1662, + 1, 0, 0, 0, 8599, 8600, 7, 15, 0, 0, 8600, 8601, 7, 5, 0, 0, 8601, 8602, + 7, 21, 0, 0, 8602, 8603, 7, 10, 0, 0, 8603, 8604, 5, 95, 0, 0, 8604, 8605, + 7, 16, 0, 0, 8605, 8606, 7, 17, 0, 0, 8606, 8607, 7, 15, 0, 0, 8607, 8608, + 7, 10, 0, 0, 8608, 8609, 7, 9, 0, 0, 8609, 8610, 7, 16, 0, 0, 8610, 8611, + 7, 5, 0, 0, 8611, 8612, 7, 15, 0, 0, 8612, 8613, 7, 24, 0, 0, 8613, 8614, + 7, 16, 0, 0, 8614, 8615, 7, 11, 0, 0, 8615, 1664, 1, 0, 0, 0, 8616, 8617, + 7, 7, 0, 0, 8617, 8618, 7, 19, 0, 0, 8618, 8619, 7, 29, 0, 0, 8619, 1666, + 1, 0, 0, 0, 8620, 8621, 7, 9, 0, 0, 8621, 8622, 7, 16, 0, 0, 8622, 8623, + 7, 5, 0, 0, 8623, 8624, 7, 16, 0, 0, 8624, 8625, 7, 10, 0, 0, 8625, 8626, + 7, 15, 0, 0, 8626, 8627, 7, 10, 0, 0, 8627, 8628, 7, 7, 0, 0, 8628, 8629, + 7, 16, 0, 0, 8629, 8630, 5, 95, 0, 0, 8630, 8631, 7, 16, 0, 0, 8631, 8632, + 7, 17, 0, 0, 8632, 8633, 7, 15, 0, 0, 8633, 8634, 7, 10, 0, 0, 8634, 8635, + 7, 9, 0, 0, 8635, 8636, 7, 16, 0, 0, 8636, 8637, 7, 5, 0, 0, 8637, 8638, + 7, 15, 0, 0, 8638, 8639, 7, 24, 0, 0, 8639, 1668, 1, 0, 0, 0, 8640, 8641, + 7, 16, 0, 0, 8641, 8642, 7, 17, 0, 0, 8642, 8643, 7, 15, 0, 0, 8643, 8644, + 7, 10, 0, 0, 8644, 8645, 7, 19, 0, 0, 8645, 8646, 7, 25, 0, 0, 8646, 8647, + 7, 12, 0, 0, 8647, 8648, 7, 5, 0, 0, 8648, 8649, 7, 8, 0, 0, 8649, 1670, + 1, 0, 0, 0, 8650, 8651, 7, 16, 0, 0, 8651, 8652, 7, 13, 0, 0, 8652, 8653, + 7, 5, 0, 0, 8653, 8654, 7, 7, 0, 0, 8654, 8655, 7, 9, 0, 0, 8655, 8656, + 7, 5, 0, 0, 8656, 8657, 7, 14, 0, 0, 8657, 8658, 7, 16, 0, 0, 8658, 8659, + 7, 17, 0, 0, 8659, 8660, 7, 19, 0, 0, 8660, 8661, 7, 7, 0, 0, 8661, 8662, + 5, 95, 0, 0, 8662, 8663, 7, 16, 0, 0, 8663, 8664, 7, 17, 0, 0, 8664, 8665, + 7, 15, 0, 0, 8665, 8666, 7, 10, 0, 0, 8666, 8667, 7, 9, 0, 0, 8667, 8668, + 7, 16, 0, 0, 8668, 8669, 7, 5, 0, 0, 8669, 8670, 7, 15, 0, 0, 8670, 8671, + 7, 24, 0, 0, 8671, 1672, 1, 0, 0, 0, 8672, 8673, 7, 16, 0, 0, 8673, 8674, + 7, 19, 0, 0, 8674, 8675, 5, 95, 0, 0, 8675, 8676, 7, 16, 0, 0, 8676, 8677, + 7, 17, 0, 0, 8677, 8678, 7, 15, 0, 0, 8678, 8679, 7, 10, 0, 0, 8679, 8680, + 7, 9, 0, 0, 8680, 8681, 7, 16, 0, 0, 8681, 8682, 7, 5, 0, 0, 8682, 8683, + 7, 15, 0, 0, 8683, 8684, 7, 24, 0, 0, 8684, 1674, 1, 0, 0, 0, 8685, 8686, + 7, 16, 0, 0, 8686, 8687, 7, 19, 0, 0, 8687, 8688, 5, 95, 0, 0, 8688, 8689, + 7, 14, 0, 0, 8689, 8690, 7, 20, 0, 0, 8690, 8691, 7, 5, 0, 0, 8691, 8692, + 7, 13, 0, 0, 8692, 1676, 1, 0, 0, 0, 8693, 8694, 7, 16, 0, 0, 8694, 8695, + 7, 19, 0, 0, 8695, 8696, 5, 95, 0, 0, 8696, 8697, 7, 12, 0, 0, 8697, 8698, + 7, 5, 0, 0, 8698, 8699, 7, 16, 0, 0, 8699, 8700, 7, 10, 0, 0, 8700, 1678, + 1, 0, 0, 0, 8701, 8702, 7, 16, 0, 0, 8702, 8703, 7, 19, 0, 0, 8703, 8704, + 5, 95, 0, 0, 8704, 8705, 7, 7, 0, 0, 8705, 8706, 7, 22, 0, 0, 8706, 8707, + 7, 15, 0, 0, 8707, 8708, 7, 18, 0, 0, 8708, 8709, 7, 10, 0, 0, 8709, 8710, + 7, 13, 0, 0, 8710, 1680, 1, 0, 0, 0, 8711, 8712, 7, 10, 0, 0, 8712, 8713, + 7, 7, 0, 0, 8713, 8714, 7, 14, 0, 0, 8714, 8715, 7, 19, 0, 0, 8715, 8716, + 7, 12, 0, 0, 8716, 8717, 7, 10, 0, 0, 8717, 1682, 1, 0, 0, 0, 8718, 8719, + 7, 12, 0, 0, 8719, 8720, 7, 17, 0, 0, 8720, 8721, 7, 9, 0, 0, 8721, 8722, + 7, 16, 0, 0, 8722, 8723, 7, 21, 0, 0, 8723, 8724, 7, 10, 0, 0, 8724, 8725, + 7, 8, 0, 0, 8725, 1684, 1, 0, 0, 0, 8726, 8727, 7, 9, 0, 0, 8727, 8728, + 7, 19, 0, 0, 8728, 8729, 7, 13, 0, 0, 8729, 8730, 7, 16, 0, 0, 8730, 8731, + 7, 21, 0, 0, 8731, 8732, 7, 10, 0, 0, 8732, 8733, 7, 8, 0, 0, 8733, 1686, + 1, 0, 0, 0, 8734, 8735, 7, 12, 0, 0, 8735, 8736, 7, 17, 0, 0, 8736, 8737, + 7, 9, 0, 0, 8737, 8738, 7, 16, 0, 0, 8738, 8739, 7, 9, 0, 0, 8739, 8740, + 7, 16, 0, 0, 8740, 8741, 7, 8, 0, 0, 8741, 8742, 7, 6, 0, 0, 8742, 8743, + 7, 10, 0, 0, 8743, 1688, 1, 0, 0, 0, 8744, 8745, 7, 18, 0, 0, 8745, 8746, + 7, 5, 0, 0, 8746, 8747, 7, 14, 0, 0, 8747, 8748, 7, 21, 0, 0, 8748, 8749, + 7, 22, 0, 0, 8749, 8750, 7, 24, 0, 0, 8750, 1690, 1, 0, 0, 0, 8751, 8752, + 7, 14, 0, 0, 8752, 8753, 7, 19, 0, 0, 8753, 8754, 7, 15, 0, 0, 8754, 8755, + 7, 24, 0, 0, 8755, 8756, 7, 19, 0, 0, 8756, 8757, 7, 22, 0, 0, 8757, 8758, + 7, 7, 0, 0, 8758, 8759, 7, 12, 0, 0, 8759, 1692, 1, 0, 0, 0, 8760, 8761, + 7, 17, 0, 0, 8761, 8762, 7, 7, 0, 0, 8762, 8763, 7, 16, 0, 0, 8763, 8764, + 7, 10, 0, 0, 8764, 8765, 7, 13, 0, 0, 8765, 8766, 7, 6, 0, 0, 8766, 8767, + 7, 10, 0, 0, 8767, 8768, 7, 5, 0, 0, 8768, 8769, 7, 27, 0, 0, 8769, 8770, + 7, 10, 0, 0, 8770, 8771, 7, 12, 0, 0, 8771, 1694, 1, 0, 0, 0, 8772, 8773, + 7, 10, 0, 0, 8773, 8774, 7, 27, 0, 0, 8774, 8775, 7, 10, 0, 0, 8775, 8776, + 7, 7, 0, 0, 8776, 1696, 1, 0, 0, 0, 8777, 8778, 7, 14, 0, 0, 8778, 8779, + 7, 5, 0, 0, 8779, 8780, 7, 9, 0, 0, 8780, 8781, 7, 10, 0, 0, 8781, 8782, + 5, 95, 0, 0, 8782, 8783, 7, 9, 0, 0, 8783, 8784, 7, 10, 0, 0, 8784, 8785, + 7, 7, 0, 0, 8785, 8786, 7, 9, 0, 0, 8786, 8787, 7, 17, 0, 0, 8787, 8788, + 7, 16, 0, 0, 8788, 8789, 7, 17, 0, 0, 8789, 8790, 7, 27, 0, 0, 8790, 8791, + 7, 10, 0, 0, 8791, 1698, 1, 0, 0, 0, 8792, 8793, 7, 28, 0, 0, 8793, 8794, + 7, 22, 0, 0, 8794, 8795, 7, 19, 0, 0, 8795, 8796, 7, 16, 0, 0, 8796, 8797, + 7, 5, 0, 0, 8797, 1700, 1, 0, 0, 0, 8798, 8799, 7, 16, 0, 0, 8799, 8800, + 7, 18, 0, 0, 8800, 1702, 1, 0, 0, 0, 8801, 8802, 7, 18, 0, 0, 8802, 8803, + 7, 19, 0, 0, 8803, 8804, 7, 19, 0, 0, 8804, 8805, 7, 9, 0, 0, 8805, 8806, + 7, 16, 0, 0, 8806, 1704, 1, 0, 0, 0, 8807, 8808, 7, 13, 0, 0, 8808, 8809, + 7, 10, 0, 0, 8809, 8810, 7, 14, 0, 0, 8810, 8811, 7, 6, 0, 0, 8811, 8812, + 7, 22, 0, 0, 8812, 8813, 7, 9, 0, 0, 8813, 8814, 7, 16, 0, 0, 8814, 8815, + 7, 10, 0, 0, 8815, 8816, 7, 13, 0, 0, 8816, 1706, 1, 0, 0, 0, 8817, 8818, + 7, 9, 0, 0, 8818, 8819, 7, 19, 0, 0, 8819, 8820, 7, 13, 0, 0, 8820, 8821, + 7, 16, 0, 0, 8821, 1708, 1, 0, 0, 0, 8822, 8823, 7, 24, 0, 0, 8823, 8824, + 7, 10, 0, 0, 8824, 8825, 7, 13, 0, 0, 8825, 8826, 7, 14, 0, 0, 8826, 8827, + 7, 10, 0, 0, 8827, 8828, 7, 7, 0, 0, 8828, 8829, 7, 16, 0, 0, 8829, 1710, + 1, 0, 0, 0, 8830, 8831, 7, 14, 0, 0, 8831, 8832, 7, 5, 0, 0, 8832, 8833, + 7, 9, 0, 0, 8833, 8834, 7, 10, 0, 0, 8834, 8835, 5, 95, 0, 0, 8835, 8836, + 7, 17, 0, 0, 8836, 8837, 7, 7, 0, 0, 8837, 8838, 7, 9, 0, 0, 8838, 8839, + 7, 10, 0, 0, 8839, 8840, 7, 7, 0, 0, 8840, 8841, 7, 9, 0, 0, 8841, 8842, + 7, 17, 0, 0, 8842, 8843, 7, 16, 0, 0, 8843, 8844, 7, 17, 0, 0, 8844, 8845, + 7, 27, 0, 0, 8845, 8846, 7, 10, 0, 0, 8846, 1712, 1, 0, 0, 0, 8847, 8851, + 3, 1719, 857, 0, 8848, 8850, 3, 1721, 858, 0, 8849, 8848, 1, 0, 0, 0, 8850, + 8853, 1, 0, 0, 0, 8851, 8849, 1, 0, 0, 0, 8851, 8852, 1, 0, 0, 0, 8852, + 1714, 1, 0, 0, 0, 8853, 8851, 1, 0, 0, 0, 8854, 8855, 5, 35, 0, 0, 8855, + 8856, 3, 1713, 854, 0, 8856, 1716, 1, 0, 0, 0, 8857, 8858, 3, 1713, 854, + 0, 8858, 8859, 5, 58, 0, 0, 8859, 8860, 3, 1713, 854, 0, 8860, 1718, 1, + 0, 0, 0, 8861, 8868, 7, 31, 0, 0, 8862, 8863, 7, 32, 0, 0, 8863, 8868, + 4, 857, 6, 0, 8864, 8865, 7, 33, 0, 0, 8865, 8866, 7, 34, 0, 0, 8866, 8868, + 4, 857, 7, 0, 8867, 8861, 1, 0, 0, 0, 8867, 8862, 1, 0, 0, 0, 8867, 8864, + 1, 0, 0, 0, 8868, 1720, 1, 0, 0, 0, 8869, 8872, 3, 1723, 859, 0, 8870, + 8872, 5, 36, 0, 0, 8871, 8869, 1, 0, 0, 0, 8871, 8870, 1, 0, 0, 0, 8872, + 1722, 1, 0, 0, 0, 8873, 8876, 3, 1719, 857, 0, 8874, 8876, 7, 0, 0, 0, + 8875, 8873, 1, 0, 0, 0, 8875, 8874, 1, 0, 0, 0, 8876, 1724, 1, 0, 0, 0, + 8877, 8878, 3, 1727, 861, 0, 8878, 8879, 5, 34, 0, 0, 8879, 1726, 1, 0, + 0, 0, 8880, 8886, 5, 34, 0, 0, 8881, 8882, 5, 34, 0, 0, 8882, 8885, 5, + 34, 0, 0, 8883, 8885, 8, 35, 0, 0, 8884, 8881, 1, 0, 0, 0, 8884, 8883, + 1, 0, 0, 0, 8885, 8888, 1, 0, 0, 0, 8886, 8884, 1, 0, 0, 0, 8886, 8887, + 1, 0, 0, 0, 8887, 1728, 1, 0, 0, 0, 8888, 8886, 1, 0, 0, 0, 8889, 8890, + 3, 1731, 863, 0, 8890, 8891, 5, 34, 0, 0, 8891, 1730, 1, 0, 0, 0, 8892, + 8898, 5, 34, 0, 0, 8893, 8894, 5, 34, 0, 0, 8894, 8897, 5, 34, 0, 0, 8895, + 8897, 8, 36, 0, 0, 8896, 8893, 1, 0, 0, 0, 8896, 8895, 1, 0, 0, 0, 8897, + 8900, 1, 0, 0, 0, 8898, 8896, 1, 0, 0, 0, 8898, 8899, 1, 0, 0, 0, 8899, + 1732, 1, 0, 0, 0, 8900, 8898, 1, 0, 0, 0, 8901, 8902, 7, 22, 0, 0, 8902, + 8903, 5, 38, 0, 0, 8903, 8904, 3, 1725, 860, 0, 8904, 1734, 1, 0, 0, 0, + 8905, 8906, 7, 22, 0, 0, 8906, 8907, 5, 38, 0, 0, 8907, 8908, 3, 1727, + 861, 0, 8908, 1736, 1, 0, 0, 0, 8909, 8910, 7, 22, 0, 0, 8910, 8911, 5, + 38, 0, 0, 8911, 8912, 3, 1729, 862, 0, 8912, 1738, 1, 0, 0, 0, 8913, 8914, + 7, 22, 0, 0, 8914, 8915, 5, 38, 0, 0, 8915, 8916, 3, 1731, 863, 0, 8916, + 1740, 1, 0, 0, 0, 8917, 8918, 3, 1743, 869, 0, 8918, 8919, 5, 39, 0, 0, + 8919, 1742, 1, 0, 0, 0, 8920, 8926, 5, 39, 0, 0, 8921, 8922, 5, 39, 0, + 0, 8922, 8925, 5, 39, 0, 0, 8923, 8925, 8, 37, 0, 0, 8924, 8921, 1, 0, + 0, 0, 8924, 8923, 1, 0, 0, 0, 8925, 8928, 1, 0, 0, 0, 8926, 8924, 1, 0, + 0, 0, 8926, 8927, 1, 0, 0, 0, 8927, 1744, 1, 0, 0, 0, 8928, 8926, 1, 0, + 0, 0, 8929, 8930, 7, 10, 0, 0, 8930, 8931, 5, 39, 0, 0, 8931, 8932, 1, + 0, 0, 0, 8932, 8933, 6, 870, 2, 0, 8933, 8934, 6, 870, 3, 0, 8934, 1746, + 1, 0, 0, 0, 8935, 8936, 3, 1749, 872, 0, 8936, 8937, 5, 39, 0, 0, 8937, + 1748, 1, 0, 0, 0, 8938, 8939, 7, 22, 0, 0, 8939, 8940, 5, 38, 0, 0, 8940, + 8941, 3, 1743, 869, 0, 8941, 1750, 1, 0, 0, 0, 8942, 8944, 5, 36, 0, 0, + 8943, 8945, 3, 1753, 874, 0, 8944, 8943, 1, 0, 0, 0, 8944, 8945, 1, 0, + 0, 0, 8945, 8946, 1, 0, 0, 0, 8946, 8947, 5, 36, 0, 0, 8947, 8948, 6, 873, + 4, 0, 8948, 8949, 1, 0, 0, 0, 8949, 8950, 6, 873, 5, 0, 8950, 1752, 1, + 0, 0, 0, 8951, 8955, 3, 1719, 857, 0, 8952, 8954, 3, 1723, 859, 0, 8953, + 8952, 1, 0, 0, 0, 8954, 8957, 1, 0, 0, 0, 8955, 8953, 1, 0, 0, 0, 8955, + 8956, 1, 0, 0, 0, 8956, 1754, 1, 0, 0, 0, 8957, 8955, 1, 0, 0, 0, 8958, + 8959, 3, 1757, 876, 0, 8959, 8960, 5, 39, 0, 0, 8960, 1756, 1, 0, 0, 0, + 8961, 8962, 7, 18, 0, 0, 8962, 8966, 5, 39, 0, 0, 8963, 8965, 7, 38, 0, + 0, 8964, 8963, 1, 0, 0, 0, 8965, 8968, 1, 0, 0, 0, 8966, 8964, 1, 0, 0, + 0, 8966, 8967, 1, 0, 0, 0, 8967, 1758, 1, 0, 0, 0, 8968, 8966, 1, 0, 0, + 0, 8969, 8970, 3, 1761, 878, 0, 8970, 8971, 5, 39, 0, 0, 8971, 1760, 1, + 0, 0, 0, 8972, 8973, 7, 18, 0, 0, 8973, 8974, 3, 1743, 869, 0, 8974, 1762, + 1, 0, 0, 0, 8975, 8976, 3, 1765, 880, 0, 8976, 8977, 5, 39, 0, 0, 8977, + 1764, 1, 0, 0, 0, 8978, 8979, 7, 26, 0, 0, 8979, 8983, 5, 39, 0, 0, 8980, + 8982, 7, 39, 0, 0, 8981, 8980, 1, 0, 0, 0, 8982, 8985, 1, 0, 0, 0, 8983, + 8981, 1, 0, 0, 0, 8983, 8984, 1, 0, 0, 0, 8984, 1766, 1, 0, 0, 0, 8985, + 8983, 1, 0, 0, 0, 8986, 8987, 3, 1769, 882, 0, 8987, 8988, 5, 39, 0, 0, + 8988, 1768, 1, 0, 0, 0, 8989, 8990, 7, 26, 0, 0, 8990, 8991, 3, 1743, 869, + 0, 8991, 1770, 1, 0, 0, 0, 8992, 8993, 3, 1777, 886, 0, 8993, 1772, 1, + 0, 0, 0, 8994, 8995, 3, 1777, 886, 0, 8995, 8996, 5, 46, 0, 0, 8996, 8997, + 5, 46, 0, 0, 8997, 8998, 1, 0, 0, 0, 8998, 8999, 6, 884, 6, 0, 8999, 1774, + 1, 0, 0, 0, 9000, 9001, 3, 1777, 886, 0, 9001, 9003, 5, 46, 0, 0, 9002, + 9004, 3, 1777, 886, 0, 9003, 9002, 1, 0, 0, 0, 9003, 9004, 1, 0, 0, 0, + 9004, 9010, 1, 0, 0, 0, 9005, 9007, 7, 10, 0, 0, 9006, 9008, 7, 1, 0, 0, + 9007, 9006, 1, 0, 0, 0, 9007, 9008, 1, 0, 0, 0, 9008, 9009, 1, 0, 0, 0, + 9009, 9011, 3, 1777, 886, 0, 9010, 9005, 1, 0, 0, 0, 9010, 9011, 1, 0, + 0, 0, 9011, 9029, 1, 0, 0, 0, 9012, 9013, 5, 46, 0, 0, 9013, 9019, 3, 1777, + 886, 0, 9014, 9016, 7, 10, 0, 0, 9015, 9017, 7, 1, 0, 0, 9016, 9015, 1, + 0, 0, 0, 9016, 9017, 1, 0, 0, 0, 9017, 9018, 1, 0, 0, 0, 9018, 9020, 3, + 1777, 886, 0, 9019, 9014, 1, 0, 0, 0, 9019, 9020, 1, 0, 0, 0, 9020, 9029, + 1, 0, 0, 0, 9021, 9022, 3, 1777, 886, 0, 9022, 9024, 7, 10, 0, 0, 9023, + 9025, 7, 1, 0, 0, 9024, 9023, 1, 0, 0, 0, 9024, 9025, 1, 0, 0, 0, 9025, + 9026, 1, 0, 0, 0, 9026, 9027, 3, 1777, 886, 0, 9027, 9029, 1, 0, 0, 0, + 9028, 9000, 1, 0, 0, 0, 9028, 9012, 1, 0, 0, 0, 9028, 9021, 1, 0, 0, 0, + 9029, 1776, 1, 0, 0, 0, 9030, 9032, 7, 0, 0, 0, 9031, 9030, 1, 0, 0, 0, + 9032, 9033, 1, 0, 0, 0, 9033, 9031, 1, 0, 0, 0, 9033, 9034, 1, 0, 0, 0, + 9034, 1778, 1, 0, 0, 0, 9035, 9036, 5, 58, 0, 0, 9036, 9040, 7, 40, 0, + 0, 9037, 9039, 7, 41, 0, 0, 9038, 9037, 1, 0, 0, 0, 9039, 9042, 1, 0, 0, + 0, 9040, 9038, 1, 0, 0, 0, 9040, 9041, 1, 0, 0, 0, 9041, 1780, 1, 0, 0, + 0, 9042, 9040, 1, 0, 0, 0, 9043, 9044, 5, 58, 0, 0, 9044, 9045, 5, 34, + 0, 0, 9045, 9053, 1, 0, 0, 0, 9046, 9047, 5, 92, 0, 0, 9047, 9052, 9, 0, + 0, 0, 9048, 9049, 5, 34, 0, 0, 9049, 9052, 5, 34, 0, 0, 9050, 9052, 8, + 42, 0, 0, 9051, 9046, 1, 0, 0, 0, 9051, 9048, 1, 0, 0, 0, 9051, 9050, 1, + 0, 0, 0, 9052, 9055, 1, 0, 0, 0, 9053, 9051, 1, 0, 0, 0, 9053, 9054, 1, + 0, 0, 0, 9054, 9056, 1, 0, 0, 0, 9055, 9053, 1, 0, 0, 0, 9056, 9057, 5, + 34, 0, 0, 9057, 1782, 1, 0, 0, 0, 9058, 9059, 7, 43, 0, 0, 9059, 9060, + 1, 0, 0, 0, 9060, 9061, 6, 889, 7, 0, 9061, 1784, 1, 0, 0, 0, 9062, 9064, + 5, 13, 0, 0, 9063, 9065, 5, 10, 0, 0, 9064, 9063, 1, 0, 0, 0, 9064, 9065, + 1, 0, 0, 0, 9065, 9068, 1, 0, 0, 0, 9066, 9068, 5, 10, 0, 0, 9067, 9062, + 1, 0, 0, 0, 9067, 9066, 1, 0, 0, 0, 9068, 9069, 1, 0, 0, 0, 9069, 9070, + 6, 890, 7, 0, 9070, 1786, 1, 0, 0, 0, 9071, 9072, 5, 45, 0, 0, 9072, 9073, + 5, 45, 0, 0, 9073, 9077, 1, 0, 0, 0, 9074, 9076, 8, 44, 0, 0, 9075, 9074, + 1, 0, 0, 0, 9076, 9079, 1, 0, 0, 0, 9077, 9075, 1, 0, 0, 0, 9077, 9078, + 1, 0, 0, 0, 9078, 9080, 1, 0, 0, 0, 9079, 9077, 1, 0, 0, 0, 9080, 9081, + 6, 891, 7, 0, 9081, 1788, 1, 0, 0, 0, 9082, 9083, 5, 47, 0, 0, 9083, 9084, + 5, 42, 0, 0, 9084, 9107, 1, 0, 0, 0, 9085, 9087, 5, 47, 0, 0, 9086, 9085, + 1, 0, 0, 0, 9087, 9090, 1, 0, 0, 0, 9088, 9086, 1, 0, 0, 0, 9088, 9089, + 1, 0, 0, 0, 9089, 9091, 1, 0, 0, 0, 9090, 9088, 1, 0, 0, 0, 9091, 9106, + 3, 1789, 892, 0, 9092, 9106, 8, 45, 0, 0, 9093, 9095, 5, 47, 0, 0, 9094, + 9093, 1, 0, 0, 0, 9095, 9096, 1, 0, 0, 0, 9096, 9094, 1, 0, 0, 0, 9096, + 9097, 1, 0, 0, 0, 9097, 9098, 1, 0, 0, 0, 9098, 9106, 8, 45, 0, 0, 9099, + 9101, 5, 42, 0, 0, 9100, 9099, 1, 0, 0, 0, 9101, 9102, 1, 0, 0, 0, 9102, + 9100, 1, 0, 0, 0, 9102, 9103, 1, 0, 0, 0, 9103, 9104, 1, 0, 0, 0, 9104, + 9106, 8, 45, 0, 0, 9105, 9088, 1, 0, 0, 0, 9105, 9092, 1, 0, 0, 0, 9105, + 9094, 1, 0, 0, 0, 9105, 9100, 1, 0, 0, 0, 9106, 9109, 1, 0, 0, 0, 9107, + 9105, 1, 0, 0, 0, 9107, 9108, 1, 0, 0, 0, 9108, 9113, 1, 0, 0, 0, 9109, + 9107, 1, 0, 0, 0, 9110, 9112, 5, 42, 0, 0, 9111, 9110, 1, 0, 0, 0, 9112, + 9115, 1, 0, 0, 0, 9113, 9111, 1, 0, 0, 0, 9113, 9114, 1, 0, 0, 0, 9114, + 9116, 1, 0, 0, 0, 9115, 9113, 1, 0, 0, 0, 9116, 9117, 5, 42, 0, 0, 9117, + 9118, 5, 47, 0, 0, 9118, 9119, 1, 0, 0, 0, 9119, 9120, 6, 892, 7, 0, 9120, + 1790, 1, 0, 0, 0, 9121, 9122, 5, 47, 0, 0, 9122, 9123, 5, 42, 0, 0, 9123, + 9148, 1, 0, 0, 0, 9124, 9126, 5, 47, 0, 0, 9125, 9124, 1, 0, 0, 0, 9126, + 9129, 1, 0, 0, 0, 9127, 9125, 1, 0, 0, 0, 9127, 9128, 1, 0, 0, 0, 9128, + 9130, 1, 0, 0, 0, 9129, 9127, 1, 0, 0, 0, 9130, 9147, 3, 1789, 892, 0, + 9131, 9147, 8, 45, 0, 0, 9132, 9134, 5, 47, 0, 0, 9133, 9132, 1, 0, 0, + 0, 9134, 9135, 1, 0, 0, 0, 9135, 9133, 1, 0, 0, 0, 9135, 9136, 1, 0, 0, + 0, 9136, 9137, 1, 0, 0, 0, 9137, 9145, 8, 45, 0, 0, 9138, 9140, 5, 42, + 0, 0, 9139, 9138, 1, 0, 0, 0, 9140, 9141, 1, 0, 0, 0, 9141, 9139, 1, 0, + 0, 0, 9141, 9142, 1, 0, 0, 0, 9142, 9143, 1, 0, 0, 0, 9143, 9145, 8, 45, + 0, 0, 9144, 9133, 1, 0, 0, 0, 9144, 9139, 1, 0, 0, 0, 9145, 9147, 1, 0, + 0, 0, 9146, 9127, 1, 0, 0, 0, 9146, 9131, 1, 0, 0, 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, 9168, 1, 0, 0, 0, 9150, 9148, 1, 0, 0, 0, 9151, 9153, 5, 47, + 0, 0, 9152, 9151, 1, 0, 0, 0, 9153, 9154, 1, 0, 0, 0, 9154, 9152, 1, 0, + 0, 0, 9154, 9155, 1, 0, 0, 0, 9155, 9169, 1, 0, 0, 0, 9156, 9158, 5, 42, + 0, 0, 9157, 9156, 1, 0, 0, 0, 9158, 9159, 1, 0, 0, 0, 9159, 9157, 1, 0, + 0, 0, 9159, 9160, 1, 0, 0, 0, 9160, 9169, 1, 0, 0, 0, 9161, 9163, 5, 47, + 0, 0, 9162, 9161, 1, 0, 0, 0, 9163, 9166, 1, 0, 0, 0, 9164, 9162, 1, 0, + 0, 0, 9164, 9165, 1, 0, 0, 0, 9165, 9167, 1, 0, 0, 0, 9166, 9164, 1, 0, + 0, 0, 9167, 9169, 3, 1791, 893, 0, 9168, 9152, 1, 0, 0, 0, 9168, 9157, + 1, 0, 0, 0, 9168, 9164, 1, 0, 0, 0, 9168, 9169, 1, 0, 0, 0, 9169, 9170, + 1, 0, 0, 0, 9170, 9171, 6, 893, 8, 0, 9171, 1792, 1, 0, 0, 0, 9172, 9184, + 5, 92, 0, 0, 9173, 9183, 8, 46, 0, 0, 9174, 9178, 5, 34, 0, 0, 9175, 9177, + 8, 47, 0, 0, 9176, 9175, 1, 0, 0, 0, 9177, 9180, 1, 0, 0, 0, 9178, 9176, + 1, 0, 0, 0, 9178, 9179, 1, 0, 0, 0, 9179, 9181, 1, 0, 0, 0, 9180, 9178, + 1, 0, 0, 0, 9181, 9183, 5, 34, 0, 0, 9182, 9173, 1, 0, 0, 0, 9182, 9174, + 1, 0, 0, 0, 9183, 9186, 1, 0, 0, 0, 9184, 9182, 1, 0, 0, 0, 9184, 9185, + 1, 0, 0, 0, 9185, 9194, 1, 0, 0, 0, 9186, 9184, 1, 0, 0, 0, 9187, 9191, + 5, 34, 0, 0, 9188, 9190, 8, 47, 0, 0, 9189, 9188, 1, 0, 0, 0, 9190, 9193, + 1, 0, 0, 0, 9191, 9189, 1, 0, 0, 0, 9191, 9192, 1, 0, 0, 0, 9192, 9195, + 1, 0, 0, 0, 9193, 9191, 1, 0, 0, 0, 9194, 9187, 1, 0, 0, 0, 9194, 9195, + 1, 0, 0, 0, 9195, 1794, 1, 0, 0, 0, 9196, 9197, 5, 92, 0, 0, 9197, 9198, + 5, 92, 0, 0, 9198, 1796, 1, 0, 0, 0, 9199, 9200, 9, 0, 0, 0, 9200, 1798, + 1, 0, 0, 0, 9201, 9202, 3, 1803, 899, 0, 9202, 9203, 5, 39, 0, 0, 9203, + 9204, 1, 0, 0, 0, 9204, 9205, 6, 897, 9, 0, 9205, 1800, 1, 0, 0, 0, 9206, + 9208, 3, 1803, 899, 0, 9207, 9209, 5, 92, 0, 0, 9208, 9207, 1, 0, 0, 0, + 9208, 9209, 1, 0, 0, 0, 9209, 9210, 1, 0, 0, 0, 9210, 9211, 5, 0, 0, 1, + 9211, 1802, 1, 0, 0, 0, 9212, 9213, 5, 39, 0, 0, 9213, 9236, 5, 39, 0, + 0, 9214, 9232, 5, 92, 0, 0, 9215, 9216, 5, 120, 0, 0, 9216, 9233, 7, 39, + 0, 0, 9217, 9218, 5, 117, 0, 0, 9218, 9219, 7, 39, 0, 0, 9219, 9220, 7, + 39, 0, 0, 9220, 9221, 7, 39, 0, 0, 9221, 9233, 7, 39, 0, 0, 9222, 9223, + 5, 85, 0, 0, 9223, 9224, 7, 39, 0, 0, 9224, 9225, 7, 39, 0, 0, 9225, 9226, + 7, 39, 0, 0, 9226, 9227, 7, 39, 0, 0, 9227, 9228, 7, 39, 0, 0, 9228, 9229, + 7, 39, 0, 0, 9229, 9230, 7, 39, 0, 0, 9230, 9233, 7, 39, 0, 0, 9231, 9233, + 8, 48, 0, 0, 9232, 9215, 1, 0, 0, 0, 9232, 9217, 1, 0, 0, 0, 9232, 9222, + 1, 0, 0, 0, 9232, 9231, 1, 0, 0, 0, 9233, 9236, 1, 0, 0, 0, 9234, 9236, + 8, 49, 0, 0, 9235, 9212, 1, 0, 0, 0, 9235, 9214, 1, 0, 0, 0, 9235, 9234, + 1, 0, 0, 0, 9236, 9239, 1, 0, 0, 0, 9237, 9235, 1, 0, 0, 0, 9237, 9238, + 1, 0, 0, 0, 9238, 1804, 1, 0, 0, 0, 9239, 9237, 1, 0, 0, 0, 9240, 9241, + 3, 1809, 902, 0, 9241, 9242, 5, 39, 0, 0, 9242, 9243, 1, 0, 0, 0, 9243, + 9244, 6, 900, 9, 0, 9244, 1806, 1, 0, 0, 0, 9245, 9247, 3, 1809, 902, 0, + 9246, 9248, 5, 92, 0, 0, 9247, 9246, 1, 0, 0, 0, 9247, 9248, 1, 0, 0, 0, + 9248, 9249, 1, 0, 0, 0, 9249, 9250, 5, 0, 0, 1, 9250, 1808, 1, 0, 0, 0, + 9251, 9252, 5, 39, 0, 0, 9252, 9257, 5, 39, 0, 0, 9253, 9254, 5, 92, 0, + 0, 9254, 9257, 9, 0, 0, 0, 9255, 9257, 8, 49, 0, 0, 9256, 9251, 1, 0, 0, + 0, 9256, 9253, 1, 0, 0, 0, 9256, 9255, 1, 0, 0, 0, 9257, 9260, 1, 0, 0, + 0, 9258, 9256, 1, 0, 0, 0, 9258, 9259, 1, 0, 0, 0, 9259, 1810, 1, 0, 0, + 0, 9260, 9258, 1, 0, 0, 0, 9261, 9262, 3, 1783, 889, 0, 9262, 9263, 1, + 0, 0, 0, 9263, 9264, 6, 903, 10, 0, 9264, 9265, 6, 903, 7, 0, 9265, 1812, + 1, 0, 0, 0, 9266, 9267, 3, 1785, 890, 0, 9267, 9268, 1, 0, 0, 0, 9268, + 9269, 6, 904, 11, 0, 9269, 9270, 6, 904, 7, 0, 9270, 9271, 6, 904, 12, + 0, 9271, 1814, 1, 0, 0, 0, 9272, 9273, 6, 905, 13, 0, 9273, 9274, 1, 0, + 0, 0, 9274, 9275, 6, 905, 14, 0, 9275, 9276, 6, 905, 15, 0, 9276, 1816, + 1, 0, 0, 0, 9277, 9278, 3, 1783, 889, 0, 9278, 9279, 1, 0, 0, 0, 9279, + 9280, 6, 906, 10, 0, 9280, 9281, 6, 906, 7, 0, 9281, 1818, 1, 0, 0, 0, + 9282, 9283, 3, 1785, 890, 0, 9283, 9284, 1, 0, 0, 0, 9284, 9285, 6, 907, + 11, 0, 9285, 9286, 6, 907, 7, 0, 9286, 1820, 1, 0, 0, 0, 9287, 9288, 5, + 39, 0, 0, 9288, 9289, 1, 0, 0, 0, 9289, 9290, 6, 908, 2, 0, 9290, 9291, + 6, 908, 16, 0, 9291, 1822, 1, 0, 0, 0, 9292, 9293, 6, 909, 17, 0, 9293, + 9294, 1, 0, 0, 0, 9294, 9295, 6, 909, 14, 0, 9295, 9296, 6, 909, 15, 0, + 9296, 1824, 1, 0, 0, 0, 9297, 9299, 8, 50, 0, 0, 9298, 9297, 1, 0, 0, 0, + 9299, 9300, 1, 0, 0, 0, 9300, 9298, 1, 0, 0, 0, 9300, 9301, 1, 0, 0, 0, + 9301, 9310, 1, 0, 0, 0, 9302, 9306, 5, 36, 0, 0, 9303, 9305, 8, 50, 0, + 0, 9304, 9303, 1, 0, 0, 0, 9305, 9308, 1, 0, 0, 0, 9306, 9304, 1, 0, 0, + 0, 9306, 9307, 1, 0, 0, 0, 9307, 9310, 1, 0, 0, 0, 9308, 9306, 1, 0, 0, + 0, 9309, 9298, 1, 0, 0, 0, 9309, 9302, 1, 0, 0, 0, 9310, 1826, 1, 0, 0, + 0, 9311, 9313, 5, 36, 0, 0, 9312, 9314, 3, 1753, 874, 0, 9313, 9312, 1, + 0, 0, 0, 9313, 9314, 1, 0, 0, 0, 9314, 9315, 1, 0, 0, 0, 9315, 9316, 5, + 36, 0, 0, 9316, 9317, 1, 0, 0, 0, 9317, 9318, 4, 911, 8, 0, 9318, 9319, + 6, 911, 18, 0, 9319, 9320, 1, 0, 0, 0, 9320, 9321, 6, 911, 15, 0, 9321, + 1828, 1, 0, 0, 0, 77, 0, 1, 2, 3, 4, 1896, 1902, 1904, 1909, 1913, 1915, + 1918, 1927, 1929, 1934, 1939, 1941, 8851, 8867, 8871, 8875, 8884, 8886, + 8896, 8898, 8924, 8926, 8944, 8955, 8966, 8983, 9003, 9007, 9010, 9016, + 9019, 9024, 9028, 9033, 9040, 9051, 9053, 9064, 9067, 9077, 9088, 9096, + 9102, 9105, 9107, 9113, 9127, 9135, 9141, 9144, 9146, 9148, 9154, 9159, + 9164, 9168, 9178, 9182, 9184, 9191, 9194, 9208, 9232, 9235, 9237, 9247, + 9256, 9258, 9300, 9306, 9309, 9313, 19, 1, 28, 0, 7, 29, 0, 3, 0, 0, 5, + 1, 0, 1, 873, 1, 5, 4, 0, 1, 884, 2, 0, 1, 0, 1, 893, 3, 2, 2, 0, 7, 880, + 0, 7, 881, 0, 2, 3, 0, 1, 905, 4, 6, 0, 0, 4, 0, 0, 2, 1, 0, 1, 909, 5, + 1, 911, 6, + } + 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) + } +} + +// RedshiftLexerInit initializes any static state used to implement RedshiftLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewRedshiftLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func RedshiftLexerInit() { + staticData := &RedshiftLexerLexerStaticData + staticData.once.Do(redshiftlexerLexerInit) +} + +// NewRedshiftLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewRedshiftLexer(input antlr.CharStream) *RedshiftLexer { + RedshiftLexerInit() + l := new(RedshiftLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &RedshiftLexerLexerStaticData + 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 = "RedshiftLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// RedshiftLexer tokens. +const ( + RedshiftLexerDollar = 1 + RedshiftLexerOPEN_PAREN = 2 + RedshiftLexerCLOSE_PAREN = 3 + RedshiftLexerOPEN_BRACKET = 4 + RedshiftLexerCLOSE_BRACKET = 5 + RedshiftLexerCOMMA = 6 + RedshiftLexerSEMI = 7 + RedshiftLexerCOLON = 8 + RedshiftLexerSTAR = 9 + RedshiftLexerEQUAL = 10 + RedshiftLexerDOT = 11 + RedshiftLexerPLUS = 12 + RedshiftLexerMINUS = 13 + RedshiftLexerSLASH = 14 + RedshiftLexerCARET = 15 + RedshiftLexerLT = 16 + RedshiftLexerGT = 17 + RedshiftLexerLESS_LESS = 18 + RedshiftLexerGREATER_GREATER = 19 + RedshiftLexerCOLON_EQUALS = 20 + RedshiftLexerLESS_EQUALS = 21 + RedshiftLexerEQUALS_GREATER = 22 + RedshiftLexerGREATER_EQUALS = 23 + RedshiftLexerDOT_DOT = 24 + RedshiftLexerNOT_EQUALS = 25 + RedshiftLexerTYPECAST = 26 + RedshiftLexerPERCENT = 27 + RedshiftLexerPARAM = 28 + RedshiftLexerOperator = 29 + RedshiftLexerALL = 30 + RedshiftLexerANALYSE = 31 + RedshiftLexerANALYZE = 32 + RedshiftLexerAND = 33 + RedshiftLexerANY = 34 + RedshiftLexerARRAY = 35 + RedshiftLexerAS = 36 + RedshiftLexerASC = 37 + RedshiftLexerASYMMETRIC = 38 + RedshiftLexerBOTH = 39 + RedshiftLexerCASE = 40 + RedshiftLexerCAST = 41 + RedshiftLexerCHECK = 42 + RedshiftLexerCOLLATE = 43 + RedshiftLexerCOLUMN = 44 + RedshiftLexerCONSTRAINT = 45 + RedshiftLexerCREATE = 46 + RedshiftLexerCURRENT_CATALOG = 47 + RedshiftLexerCURRENT_DATE = 48 + RedshiftLexerCURRENT_ROLE = 49 + RedshiftLexerCURRENT_TIME = 50 + RedshiftLexerCURRENT_TIMESTAMP = 51 + RedshiftLexerCURRENT_USER = 52 + RedshiftLexerDEFAULT = 53 + RedshiftLexerDEFERRABLE = 54 + RedshiftLexerDESC = 55 + RedshiftLexerDISTINCT = 56 + RedshiftLexerDO = 57 + RedshiftLexerELSE = 58 + RedshiftLexerEXCEPT = 59 + RedshiftLexerFALSE_P = 60 + RedshiftLexerFETCH = 61 + RedshiftLexerFOR = 62 + RedshiftLexerFOREIGN = 63 + RedshiftLexerFROM = 64 + RedshiftLexerGRANT = 65 + RedshiftLexerGROUP_P = 66 + RedshiftLexerHAVING = 67 + RedshiftLexerIN_P = 68 + RedshiftLexerINITIALLY = 69 + RedshiftLexerINTERSECT = 70 + RedshiftLexerINTO = 71 + RedshiftLexerLATERAL_P = 72 + RedshiftLexerLEADING = 73 + RedshiftLexerLIMIT = 74 + RedshiftLexerLOCALTIME = 75 + RedshiftLexerLOCALTIMESTAMP = 76 + RedshiftLexerNOT = 77 + RedshiftLexerNULL_P = 78 + RedshiftLexerOFFSET = 79 + RedshiftLexerON = 80 + RedshiftLexerONLY = 81 + RedshiftLexerOR = 82 + RedshiftLexerORDER = 83 + RedshiftLexerPLACING = 84 + RedshiftLexerPRIMARY = 85 + RedshiftLexerPUBLIC = 86 + RedshiftLexerREFERENCES = 87 + RedshiftLexerRETURNING = 88 + RedshiftLexerSELECT = 89 + RedshiftLexerSESSION_USER = 90 + RedshiftLexerSOME = 91 + RedshiftLexerSYMMETRIC = 92 + RedshiftLexerTABLE = 93 + RedshiftLexerTHEN = 94 + RedshiftLexerTO = 95 + RedshiftLexerTRAILING = 96 + RedshiftLexerTRUE_P = 97 + RedshiftLexerUNION = 98 + RedshiftLexerUNIQUE = 99 + RedshiftLexerUSER = 100 + RedshiftLexerUSING = 101 + RedshiftLexerVARIADIC = 102 + RedshiftLexerWHEN = 103 + RedshiftLexerWHERE = 104 + RedshiftLexerWINDOW = 105 + RedshiftLexerWITH = 106 + RedshiftLexerAUTHORIZATION = 107 + RedshiftLexerBINARY = 108 + RedshiftLexerBINDING = 109 + RedshiftLexerCOLLATION = 110 + RedshiftLexerCONCURRENTLY = 111 + RedshiftLexerCROSS = 112 + RedshiftLexerCURRENT_SCHEMA = 113 + RedshiftLexerFREEZE = 114 + RedshiftLexerFULL = 115 + RedshiftLexerILIKE = 116 + RedshiftLexerINNER_P = 117 + RedshiftLexerIS = 118 + RedshiftLexerISNULL = 119 + RedshiftLexerJOIN = 120 + RedshiftLexerLEFT = 121 + RedshiftLexerLIKE = 122 + RedshiftLexerNATURAL = 123 + RedshiftLexerNOTNULL = 124 + RedshiftLexerOUTER_P = 125 + RedshiftLexerOVER = 126 + RedshiftLexerOVERLAPS = 127 + RedshiftLexerRIGHT = 128 + RedshiftLexerSIMILAR = 129 + RedshiftLexerVERBOSE = 130 + RedshiftLexerABORT_P = 131 + RedshiftLexerABSOLUTE_P = 132 + RedshiftLexerACCESS = 133 + RedshiftLexerACTION = 134 + RedshiftLexerADD_P = 135 + RedshiftLexerADMIN = 136 + RedshiftLexerAFTER = 137 + RedshiftLexerAGGREGATE = 138 + RedshiftLexerALSO = 139 + RedshiftLexerALTER = 140 + RedshiftLexerALWAYS = 141 + RedshiftLexerASSERTION = 142 + RedshiftLexerASSIGNMENT = 143 + RedshiftLexerAT = 144 + RedshiftLexerATTRIBUTE = 145 + RedshiftLexerBACKWARD = 146 + RedshiftLexerBEFORE = 147 + RedshiftLexerBEGIN_P = 148 + RedshiftLexerBY = 149 + RedshiftLexerCACHE = 150 + RedshiftLexerCALLED = 151 + RedshiftLexerCASCADE = 152 + RedshiftLexerCASCADED = 153 + RedshiftLexerCATALOG = 154 + RedshiftLexerCHAIN = 155 + RedshiftLexerCHARACTERISTICS = 156 + RedshiftLexerCHECKPOINT = 157 + RedshiftLexerCLASS = 158 + RedshiftLexerCLOSE = 159 + RedshiftLexerCLUSTER = 160 + RedshiftLexerCOMMENT = 161 + RedshiftLexerCOMMENTS = 162 + RedshiftLexerCOMMIT = 163 + RedshiftLexerCOMMITTED = 164 + RedshiftLexerCONFIGURATION = 165 + RedshiftLexerCONNECTION = 166 + RedshiftLexerCONSTRAINTS = 167 + RedshiftLexerCONTENT_P = 168 + RedshiftLexerCONTINUE_P = 169 + RedshiftLexerCONVERSION_P = 170 + RedshiftLexerCOPY = 171 + RedshiftLexerCOST = 172 + RedshiftLexerCSV = 173 + RedshiftLexerJSON = 174 + RedshiftLexerCURSOR = 175 + RedshiftLexerCYCLE = 176 + RedshiftLexerDATA_P = 177 + RedshiftLexerDATA_CATALOG = 178 + RedshiftLexerDATABASE = 179 + RedshiftLexerDAY_P = 180 + RedshiftLexerDEALLOCATE = 181 + RedshiftLexerDECLARE = 182 + RedshiftLexerDEFAULTS = 183 + RedshiftLexerDEFERRED = 184 + RedshiftLexerDEFINER = 185 + RedshiftLexerDELETE_P = 186 + RedshiftLexerDELIMITER = 187 + RedshiftLexerDELIMITERS = 188 + RedshiftLexerDICTIONARY = 189 + RedshiftLexerDISABLE_P = 190 + RedshiftLexerDISCARD = 191 + RedshiftLexerDOCUMENT_P = 192 + RedshiftLexerDOMAIN_P = 193 + RedshiftLexerDOUBLE_P = 194 + RedshiftLexerDROP = 195 + RedshiftLexerEACH = 196 + RedshiftLexerENABLE_P = 197 + RedshiftLexerENCODING = 198 + RedshiftLexerENCRYPTED = 199 + RedshiftLexerENUM_P = 200 + RedshiftLexerESCAPE = 201 + RedshiftLexerEVENT = 202 + RedshiftLexerEXCLUDE = 203 + RedshiftLexerEXCLUDING = 204 + RedshiftLexerEXCLUSIVE = 205 + RedshiftLexerEXECUTE = 206 + RedshiftLexerEXPLAIN = 207 + RedshiftLexerEXTENSION = 208 + RedshiftLexerEXTERNAL = 209 + RedshiftLexerFAMILY = 210 + RedshiftLexerFIRST_P = 211 + RedshiftLexerFOLLOWING = 212 + RedshiftLexerFORCE = 213 + RedshiftLexerFORWARD = 214 + RedshiftLexerFUNCTION = 215 + RedshiftLexerFUNCTIONS = 216 + RedshiftLexerGLOBAL = 217 + RedshiftLexerGRANTED = 218 + RedshiftLexerHANDLER = 219 + RedshiftLexerHEADER_P = 220 + RedshiftLexerHOLD = 221 + RedshiftLexerHOUR_P = 222 + RedshiftLexerIDENTITY_P = 223 + RedshiftLexerIF_P = 224 + RedshiftLexerIMMEDIATE = 225 + RedshiftLexerIMMUTABLE = 226 + RedshiftLexerIMPLICIT_P = 227 + RedshiftLexerINCLUDING = 228 + RedshiftLexerINCREMENT = 229 + RedshiftLexerINDEX = 230 + RedshiftLexerINDEXES = 231 + RedshiftLexerINHERIT = 232 + RedshiftLexerINHERITS = 233 + RedshiftLexerINLINE_P = 234 + RedshiftLexerINSENSITIVE = 235 + RedshiftLexerINSERT = 236 + RedshiftLexerINSTEAD = 237 + RedshiftLexerINVOKER = 238 + RedshiftLexerISOLATION = 239 + RedshiftLexerKEY = 240 + RedshiftLexerLABEL = 241 + RedshiftLexerLANGUAGE = 242 + RedshiftLexerLARGE_P = 243 + RedshiftLexerLAST_P = 244 + RedshiftLexerLEAKPROOF = 245 + RedshiftLexerLEVEL = 246 + RedshiftLexerLISTEN = 247 + RedshiftLexerLOAD = 248 + RedshiftLexerLOCAL = 249 + RedshiftLexerLOCATION = 250 + RedshiftLexerLOCK_P = 251 + RedshiftLexerMAPPING = 252 + RedshiftLexerMATCH = 253 + RedshiftLexerMATCHED = 254 + RedshiftLexerMATERIALIZED = 255 + RedshiftLexerMAXVALUE = 256 + RedshiftLexerMERGE = 257 + RedshiftLexerMINUTE_P = 258 + RedshiftLexerMINVALUE = 259 + RedshiftLexerMODE = 260 + RedshiftLexerMONTH_P = 261 + RedshiftLexerMOVE = 262 + RedshiftLexerNAME_P = 263 + RedshiftLexerNAMES = 264 + RedshiftLexerNEXT = 265 + RedshiftLexerNO = 266 + RedshiftLexerNOTHING = 267 + RedshiftLexerNOTIFY = 268 + RedshiftLexerNOWAIT = 269 + RedshiftLexerNULLS_P = 270 + RedshiftLexerOBJECT_P = 271 + RedshiftLexerOF = 272 + RedshiftLexerOFF = 273 + RedshiftLexerOIDS = 274 + RedshiftLexerOPERATOR = 275 + RedshiftLexerOPTION = 276 + RedshiftLexerOPTIONS = 277 + RedshiftLexerOWNED = 278 + RedshiftLexerOWNER = 279 + RedshiftLexerPARSER = 280 + RedshiftLexerPARTIAL = 281 + RedshiftLexerPARTITION = 282 + RedshiftLexerPASSING = 283 + RedshiftLexerPASSWORD = 284 + RedshiftLexerPLANS = 285 + RedshiftLexerPRECEDING = 286 + RedshiftLexerPREDICATE = 287 + RedshiftLexerPREPARE = 288 + RedshiftLexerPREPARED = 289 + RedshiftLexerPRESERVE = 290 + RedshiftLexerPRIOR = 291 + RedshiftLexerPRIVILEGES = 292 + RedshiftLexerPROCEDURAL = 293 + RedshiftLexerPROCEDURE = 294 + RedshiftLexerPROGRAM = 295 + RedshiftLexerQUOTE = 296 + RedshiftLexerRANGE = 297 + RedshiftLexerREAD = 298 + RedshiftLexerREASSIGN = 299 + RedshiftLexerRECHECK = 300 + RedshiftLexerRECURSIVE = 301 + RedshiftLexerREF = 302 + RedshiftLexerREFRESH = 303 + RedshiftLexerREINDEX = 304 + RedshiftLexerRELATIVE_P = 305 + RedshiftLexerRELEASE = 306 + RedshiftLexerRENAME = 307 + RedshiftLexerREPEATABLE = 308 + RedshiftLexerREPLACE = 309 + RedshiftLexerREPLICA = 310 + RedshiftLexerRESET = 311 + RedshiftLexerRESTART = 312 + RedshiftLexerRESTRICT = 313 + RedshiftLexerRETURNS = 314 + RedshiftLexerREVOKE = 315 + RedshiftLexerROLE = 316 + RedshiftLexerROLLBACK = 317 + RedshiftLexerROWS = 318 + RedshiftLexerRULE = 319 + RedshiftLexerSAVEPOINT = 320 + RedshiftLexerSCHEMA = 321 + RedshiftLexerSCROLL = 322 + RedshiftLexerSEARCH = 323 + RedshiftLexerSECOND_P = 324 + RedshiftLexerSECURITY = 325 + RedshiftLexerSEQUENCE = 326 + RedshiftLexerSEQUENCES = 327 + RedshiftLexerSERIALIZABLE = 328 + RedshiftLexerSERVER = 329 + RedshiftLexerSESSION = 330 + RedshiftLexerSET = 331 + RedshiftLexerSHARE = 332 + RedshiftLexerSHOW = 333 + RedshiftLexerSIMPLE = 334 + RedshiftLexerSNAPSHOT = 335 + RedshiftLexerSTABLE = 336 + RedshiftLexerSTANDALONE_P = 337 + RedshiftLexerSTART = 338 + RedshiftLexerSTATEMENT = 339 + RedshiftLexerSTATISTICS = 340 + RedshiftLexerSTDIN = 341 + RedshiftLexerSTDOUT = 342 + RedshiftLexerSTORAGE = 343 + RedshiftLexerSTRICT_P = 344 + RedshiftLexerSTRIP_P = 345 + RedshiftLexerSYSID = 346 + RedshiftLexerSYSTEM_P = 347 + RedshiftLexerTABLES = 348 + RedshiftLexerTABLESPACE = 349 + RedshiftLexerTEMP = 350 + RedshiftLexerTEMPLATE = 351 + RedshiftLexerTEMPORARY = 352 + RedshiftLexerTEXT_P = 353 + RedshiftLexerTRANSACTION = 354 + RedshiftLexerTRIGGER = 355 + RedshiftLexerTRUNCATE = 356 + RedshiftLexerTRUSTED = 357 + RedshiftLexerTYPE_P = 358 + RedshiftLexerTYPES_P = 359 + RedshiftLexerUNBOUNDED = 360 + RedshiftLexerUNCOMMITTED = 361 + RedshiftLexerUNENCRYPTED = 362 + RedshiftLexerUNKNOWN = 363 + RedshiftLexerUNLISTEN = 364 + RedshiftLexerUNLOGGED = 365 + RedshiftLexerUNTIL = 366 + RedshiftLexerUPDATE = 367 + RedshiftLexerVACUUM = 368 + RedshiftLexerVALID = 369 + RedshiftLexerVALIDATE = 370 + RedshiftLexerVALIDATOR = 371 + RedshiftLexerVARYING = 372 + RedshiftLexerVERSION_P = 373 + RedshiftLexerVIEW = 374 + RedshiftLexerVOLATILE = 375 + RedshiftLexerWHITESPACE_P = 376 + RedshiftLexerWITHOUT = 377 + RedshiftLexerWORK = 378 + RedshiftLexerWRAPPER = 379 + RedshiftLexerWRITE = 380 + RedshiftLexerXML_P = 381 + RedshiftLexerYEAR_P = 382 + RedshiftLexerYES_P = 383 + RedshiftLexerZONE = 384 + RedshiftLexerQUALIFY = 385 + RedshiftLexerCONNECT = 386 + RedshiftLexerTOP = 387 + RedshiftLexerVARBYTE = 388 + RedshiftLexerVARBINARY = 389 + RedshiftLexerCONJUNCTION = 390 + RedshiftLexerDEFINITION = 391 + RedshiftLexerDATASHARE = 392 + RedshiftLexerFILE = 393 + RedshiftLexerPUBLICACCESSIBLE = 394 + RedshiftLexerINCLUDENEW = 395 + RedshiftLexerIAM_ROLE = 396 + RedshiftLexerCATALOG_ROLE = 397 + RedshiftLexerCATALOG_ID = 398 + RedshiftLexerHIVE = 399 + RedshiftLexerMETASTORE = 400 + RedshiftLexerURI = 401 + RedshiftLexerPOSTGRES = 402 + RedshiftLexerMYSQL = 403 + RedshiftLexerSECRET_ARN = 404 + RedshiftLexerKINESIS = 405 + RedshiftLexerKAFKA = 406 + RedshiftLexerMSK = 407 + RedshiftLexerAUTHENTICATION = 408 + RedshiftLexerAUTHENTICATION_ARN = 409 + RedshiftLexerSESSION_TOKEN = 410 + RedshiftLexerMTLS = 411 + RedshiftLexerMASKING = 412 + RedshiftLexerRLS = 413 + RedshiftLexerIDENTITY = 414 + RedshiftLexerPROVIDER = 415 + RedshiftLexerPROTECTED = 416 + RedshiftLexerMODEL = 417 + RedshiftLexerTARGET = 418 + RedshiftLexerSAGEMAKER = 419 + RedshiftLexerAUTO = 420 + RedshiftLexerMODEL_TYPE = 421 + RedshiftLexerPROBLEM_TYPE = 422 + RedshiftLexerOBJECTIVE = 423 + RedshiftLexerPREPROCESSORS = 424 + RedshiftLexerHYPERPARAMETERS = 425 + RedshiftLexerXGBOOST = 426 + RedshiftLexerMLP = 427 + RedshiftLexerLINEAR_LEARNER = 428 + RedshiftLexerKMEANS = 429 + RedshiftLexerFORECAST = 430 + RedshiftLexerREGRESSION = 431 + RedshiftLexerBINARY_CLASSIFICATION = 432 + RedshiftLexerMULTICLASS_CLASSIFICATION = 433 + RedshiftLexerS3_BUCKET = 434 + RedshiftLexerTAGS = 435 + RedshiftLexerKMS_KEY_ID = 436 + RedshiftLexerS3_GARBAGE_COLLECT = 437 + RedshiftLexerMAX_CELLS = 438 + RedshiftLexerMAX_RUNTIME = 439 + RedshiftLexerHORIZON = 440 + RedshiftLexerFREQUENCY = 441 + RedshiftLexerPERCENTILES = 442 + RedshiftLexerMAX_BATCH_ROWS = 443 + RedshiftLexerUNLOAD = 444 + RedshiftLexerMANIFEST = 445 + RedshiftLexerADDQUOTES = 446 + RedshiftLexerALLOWOVERWRITE = 447 + RedshiftLexerCLEANPATH = 448 + RedshiftLexerMAXFILESIZE = 449 + RedshiftLexerROWGROUPSIZE = 450 + RedshiftLexerBZIP2 = 451 + RedshiftLexerGZIP = 452 + RedshiftLexerZSTD = 453 + RedshiftLexerDATABASES = 454 + RedshiftLexerDATASHARES = 455 + RedshiftLexerGRANTS = 456 + RedshiftLexerUSE = 457 + RedshiftLexerCANCEL = 458 + RedshiftLexerSESSION_AUTHORIZATION = 459 + RedshiftLexerSESSION_CHARACTERISTICS = 460 + RedshiftLexerCOMPRESSION = 461 + RedshiftLexerLIBRARY = 462 + RedshiftLexerAPPEND = 463 + RedshiftLexerMB = 464 + RedshiftLexerGB = 465 + RedshiftLexerACCOUNT = 466 + RedshiftLexerNAMESPACE = 467 + RedshiftLexerDESCRIBE = 468 + RedshiftLexerNONATOMIC = 469 + RedshiftLexerMANAGEDBY = 470 + RedshiftLexerADX = 471 + RedshiftLexerREMOVE = 472 + RedshiftLexerDUPLICATES = 473 + RedshiftLexerBEDROCK = 474 + RedshiftLexerMODEL_ID = 475 + RedshiftLexerPROMPT = 476 + RedshiftLexerSUFFIX = 477 + RedshiftLexerREQUEST_TYPE = 478 + RedshiftLexerRESPONSE_TYPE = 479 + RedshiftLexerRAW = 480 + RedshiftLexerUNIFIED = 481 + RedshiftLexerSUPER = 482 + RedshiftLexerCI = 483 + RedshiftLexerCS = 484 + RedshiftLexerPLPYTHONU = 485 + RedshiftLexerFILLTARGET = 486 + RedshiftLexerIGNOREEXTRA = 487 + RedshiftLexerCREATEUSER = 488 + RedshiftLexerNOCREATEUSER = 489 + RedshiftLexerREGION = 490 + RedshiftLexerPORT = 491 + RedshiftLexerREDSHIFT = 492 + RedshiftLexerIAM = 493 + RedshiftLexerCREATEDB = 494 + RedshiftLexerNOCREATEDB = 495 + RedshiftLexerRESTRICTED = 496 + RedshiftLexerUNLIMITED = 497 + RedshiftLexerEXTERNALID = 498 + RedshiftLexerTIMEOUT = 499 + RedshiftLexerSYSLOG = 500 + RedshiftLexerCREDENTIALS = 501 + RedshiftLexerUNRESTRICTED = 502 + RedshiftLexerPARAMETERS = 503 + RedshiftLexerAPPLICATION_ARN = 504 + RedshiftLexerAUTO_CREATE_ROLES = 505 + RedshiftLexerCOMPROWS = 506 + RedshiftLexerPROVIDER_URL = 507 + RedshiftLexerPROVIDER_URL_PORT = 508 + RedshiftLexerATTRIBUTE_MAP = 509 + RedshiftLexerPROVIDER_ARN = 510 + RedshiftLexerASSUME_ROLE_ARN = 511 + RedshiftLexerPROPERTIES = 512 + RedshiftLexerAVRO = 513 + RedshiftLexerRCFILE = 514 + RedshiftLexerSEQUENCEFILE = 515 + RedshiftLexerTEXTFILE = 516 + RedshiftLexerORC = 517 + RedshiftLexerION = 518 + RedshiftLexerLAMBDA = 519 + RedshiftLexerFIXEDWIDTH = 520 + RedshiftLexerPARQUET = 521 + RedshiftLexerLZOP = 522 + RedshiftLexerREMOVEQUOTES = 523 + RedshiftLexerTRUNCATECOLUMNS = 524 + RedshiftLexerFILLRECORD = 525 + RedshiftLexerBLANKSASNULL = 526 + RedshiftLexerEMPTYASNULL = 527 + RedshiftLexerMAXERROR = 528 + RedshiftLexerDATEFORMAT = 529 + RedshiftLexerTIMEFORMAT = 530 + RedshiftLexerACCEPTINVCHARS = 531 + RedshiftLexerACCEPTANYDATE = 532 + RedshiftLexerIGNOREHEADER = 533 + RedshiftLexerIGNOREBLANKLINES = 534 + RedshiftLexerCOMPUPDATE = 535 + RedshiftLexerSTATUPDATE = 536 + RedshiftLexerEXPLICIT_IDS = 537 + RedshiftLexerREADRATIO = 538 + RedshiftLexerROUNDEC = 539 + RedshiftLexerTRIMBLANKS = 540 + RedshiftLexerPRESET = 541 + RedshiftLexerACCESS_KEY_ID = 542 + RedshiftLexerSECRET_ACCESS_KEY = 543 + RedshiftLexerSESSION_TOKEN_KW = 544 + RedshiftLexerHEADER = 545 + RedshiftLexerSETTINGS = 546 + RedshiftLexerFUNCTION_NAME = 547 + RedshiftLexerATOMIC_P = 548 + RedshiftLexerBETWEEN = 549 + RedshiftLexerBIGINT = 550 + RedshiftLexerBIT = 551 + RedshiftLexerBOOLEAN_P = 552 + RedshiftLexerCHAR_P = 553 + RedshiftLexerCHARACTER = 554 + RedshiftLexerCOALESCE = 555 + RedshiftLexerDEC = 556 + RedshiftLexerDECIMAL_P = 557 + RedshiftLexerEXISTS = 558 + RedshiftLexerEXTRACT = 559 + RedshiftLexerFLOAT_P = 560 + RedshiftLexerGREATEST = 561 + RedshiftLexerINOUT = 562 + RedshiftLexerINT_P = 563 + RedshiftLexerINTEGER = 564 + RedshiftLexerINTERVAL = 565 + RedshiftLexerLEAST = 566 + RedshiftLexerNATIONAL = 567 + RedshiftLexerNCHAR = 568 + RedshiftLexerNONE = 569 + RedshiftLexerNULLIF = 570 + RedshiftLexerNUMERIC = 571 + RedshiftLexerOVERLAY = 572 + RedshiftLexerPARAMETER = 573 + RedshiftLexerPOSITION = 574 + RedshiftLexerPRECISION = 575 + RedshiftLexerREAL = 576 + RedshiftLexerROW = 577 + RedshiftLexerSETOF = 578 + RedshiftLexerSMALLINT = 579 + RedshiftLexerSUBSTRING = 580 + RedshiftLexerTIME = 581 + RedshiftLexerTIMESTAMP = 582 + RedshiftLexerTREAT = 583 + RedshiftLexerTRIM = 584 + RedshiftLexerVALUES = 585 + RedshiftLexerVARCHAR = 586 + RedshiftLexerXMLATTRIBUTES = 587 + RedshiftLexerXMLCOMMENT = 588 + RedshiftLexerXMLAGG = 589 + RedshiftLexerXML_IS_WELL_FORMED = 590 + RedshiftLexerXML_IS_WELL_FORMED_DOCUMENT = 591 + RedshiftLexerXML_IS_WELL_FORMED_CONTENT = 592 + RedshiftLexerXPATH = 593 + RedshiftLexerXPATH_EXISTS = 594 + RedshiftLexerXMLCONCAT = 595 + RedshiftLexerXMLELEMENT = 596 + RedshiftLexerXMLEXISTS = 597 + RedshiftLexerXMLFOREST = 598 + RedshiftLexerXMLPARSE = 599 + RedshiftLexerXMLPI = 600 + RedshiftLexerXMLROOT = 601 + RedshiftLexerXMLSERIALIZE = 602 + RedshiftLexerCALL = 603 + RedshiftLexerCURRENT_P = 604 + RedshiftLexerATTACH = 605 + RedshiftLexerDETACH = 606 + RedshiftLexerEXPRESSION = 607 + RedshiftLexerGENERATED = 608 + RedshiftLexerLOGGED = 609 + RedshiftLexerSTORED = 610 + RedshiftLexerSERDE = 611 + RedshiftLexerSERDEPROPERTIES = 612 + RedshiftLexerINPUTFORMAT = 613 + RedshiftLexerOUTPUTFORMAT = 614 + RedshiftLexerFIELDS = 615 + RedshiftLexerCOLLECTION = 616 + RedshiftLexerITEMS = 617 + RedshiftLexerTERMINATED = 618 + RedshiftLexerESCAPED = 619 + RedshiftLexerDEFINED = 620 + RedshiftLexerLINES = 621 + RedshiftLexerKEYS = 622 + RedshiftLexerPARTITIONED = 623 + RedshiftLexerSTRUCT = 624 + RedshiftLexerMAP = 625 + RedshiftLexerSTRING = 626 + RedshiftLexerDELIMITED = 627 + RedshiftLexerUSAGE = 628 + RedshiftLexerIGNORE = 629 + RedshiftLexerLANGUAGES = 630 + RedshiftLexerJOB = 631 + RedshiftLexerJOBS = 632 + RedshiftLexerVIA = 633 + RedshiftLexerASSUMEROLE = 634 + RedshiftLexerRETRY_TIMEOUT = 635 + RedshiftLexerMAX_BATCH_SIZE = 636 + RedshiftLexerMAX_PAYLOAD_IN_MB = 637 + RedshiftLexerKB = 638 + RedshiftLexerINCLUDE = 639 + RedshiftLexerROUTINE = 640 + RedshiftLexerTRANSFORM = 641 + RedshiftLexerIMPORT_P = 642 + RedshiftLexerPOLICY = 643 + RedshiftLexerPRIORITY = 644 + RedshiftLexerMETHOD = 645 + RedshiftLexerREFERENCING = 646 + RedshiftLexerNEW = 647 + RedshiftLexerOLD = 648 + RedshiftLexerVALUE_P = 649 + RedshiftLexerSUBSCRIPTION = 650 + RedshiftLexerPUBLICATION = 651 + RedshiftLexerOUT_P = 652 + RedshiftLexerEND_P = 653 + RedshiftLexerROUTINES = 654 + RedshiftLexerSCHEMAS = 655 + RedshiftLexerPROCEDURES = 656 + RedshiftLexerINPUT_P = 657 + RedshiftLexerSUPPORT = 658 + RedshiftLexerPARALLEL = 659 + RedshiftLexerSQL_P = 660 + RedshiftLexerDEPENDS = 661 + RedshiftLexerOVERRIDING = 662 + RedshiftLexerCONFLICT = 663 + RedshiftLexerSKIP_P = 664 + RedshiftLexerLOCKED = 665 + RedshiftLexerTIES = 666 + RedshiftLexerROLLUP = 667 + RedshiftLexerCUBE = 668 + RedshiftLexerGROUPING = 669 + RedshiftLexerSETS = 670 + RedshiftLexerTABLESAMPLE = 671 + RedshiftLexerORDINALITY = 672 + RedshiftLexerXMLTABLE = 673 + RedshiftLexerCOLUMNS = 674 + RedshiftLexerXMLNAMESPACES = 675 + RedshiftLexerROWTYPE = 676 + RedshiftLexerNORMALIZED = 677 + RedshiftLexerWITHIN = 678 + RedshiftLexerFILTER = 679 + RedshiftLexerGROUPS = 680 + RedshiftLexerOTHERS = 681 + RedshiftLexerNFC = 682 + RedshiftLexerNFD = 683 + RedshiftLexerNFKC = 684 + RedshiftLexerNFKD = 685 + RedshiftLexerUESCAPE = 686 + RedshiftLexerVIEWS = 687 + RedshiftLexerNORMALIZE = 688 + RedshiftLexerDUMP = 689 + RedshiftLexerPRINT_STRICT_PARAMS = 690 + RedshiftLexerVARIABLE_CONFLICT = 691 + RedshiftLexerERROR = 692 + RedshiftLexerUSE_VARIABLE = 693 + RedshiftLexerUSE_COLUMN = 694 + RedshiftLexerALIAS = 695 + RedshiftLexerCONSTANT = 696 + RedshiftLexerPERFORM = 697 + RedshiftLexerGET = 698 + RedshiftLexerDIAGNOSTICS = 699 + RedshiftLexerSTACKED = 700 + RedshiftLexerELSIF = 701 + RedshiftLexerWHILE = 702 + RedshiftLexerREVERSE = 703 + RedshiftLexerFOREACH = 704 + RedshiftLexerSLICE = 705 + RedshiftLexerEXIT = 706 + RedshiftLexerRETURN = 707 + RedshiftLexerQUERY = 708 + RedshiftLexerRAISE = 709 + RedshiftLexerSQLSTATE = 710 + RedshiftLexerDEBUG = 711 + RedshiftLexerLOG = 712 + RedshiftLexerINFO = 713 + RedshiftLexerNOTICE = 714 + RedshiftLexerWARNING = 715 + RedshiftLexerEXCEPTION = 716 + RedshiftLexerASSERT = 717 + RedshiftLexerLOOP = 718 + RedshiftLexerOPEN = 719 + RedshiftLexerABS = 720 + RedshiftLexerCBRT = 721 + RedshiftLexerCEIL = 722 + RedshiftLexerCEILING = 723 + RedshiftLexerDEGREES = 724 + RedshiftLexerDIV = 725 + RedshiftLexerEXP = 726 + RedshiftLexerFACTORIAL = 727 + RedshiftLexerFLOOR = 728 + RedshiftLexerGCD = 729 + RedshiftLexerLCM = 730 + RedshiftLexerLN = 731 + RedshiftLexerLOG10 = 732 + RedshiftLexerMIN_SCALE = 733 + RedshiftLexerMOD = 734 + RedshiftLexerPI = 735 + RedshiftLexerPOWER = 736 + RedshiftLexerRADIANS = 737 + RedshiftLexerROUND = 738 + RedshiftLexerSCALE = 739 + RedshiftLexerSIGN = 740 + RedshiftLexerSQRT = 741 + RedshiftLexerTRIM_SCALE = 742 + RedshiftLexerTRUNC = 743 + RedshiftLexerWIDTH_BUCKET = 744 + RedshiftLexerRANDOM = 745 + RedshiftLexerSETSEED = 746 + RedshiftLexerACOS = 747 + RedshiftLexerACOSD = 748 + RedshiftLexerASIN = 749 + RedshiftLexerASIND = 750 + RedshiftLexerATAN = 751 + RedshiftLexerATAND = 752 + RedshiftLexerATAN2 = 753 + RedshiftLexerATAN2D = 754 + RedshiftLexerCOS = 755 + RedshiftLexerCOSD = 756 + RedshiftLexerCOT = 757 + RedshiftLexerCOTD = 758 + RedshiftLexerSIN = 759 + RedshiftLexerSIND = 760 + RedshiftLexerTAN = 761 + RedshiftLexerTAND = 762 + RedshiftLexerSINH = 763 + RedshiftLexerCOSH = 764 + RedshiftLexerTANH = 765 + RedshiftLexerASINH = 766 + RedshiftLexerACOSH = 767 + RedshiftLexerATANH = 768 + RedshiftLexerBIT_LENGTH = 769 + RedshiftLexerCHAR_LENGTH = 770 + RedshiftLexerCHARACTER_LENGTH = 771 + RedshiftLexerLOWER = 772 + RedshiftLexerOCTET_LENGTH = 773 + RedshiftLexerUPPER = 774 + RedshiftLexerASCII = 775 + RedshiftLexerBTRIM = 776 + RedshiftLexerCHR = 777 + RedshiftLexerCONCAT = 778 + RedshiftLexerCONCAT_WS = 779 + RedshiftLexerFORMAT = 780 + RedshiftLexerINITCAP = 781 + RedshiftLexerLENGTH = 782 + RedshiftLexerLPAD = 783 + RedshiftLexerLTRIM = 784 + RedshiftLexerMD5 = 785 + RedshiftLexerPARSE_IDENT = 786 + RedshiftLexerPG_CLIENT_ENCODING = 787 + RedshiftLexerQUOTE_IDENT = 788 + RedshiftLexerQUOTE_LITERAL = 789 + RedshiftLexerQUOTE_NULLABLE = 790 + RedshiftLexerREGEXP_COUNT = 791 + RedshiftLexerREGEXP_INSTR = 792 + RedshiftLexerREGEXP_LIKE = 793 + RedshiftLexerREGEXP_MATCH = 794 + RedshiftLexerREGEXP_MATCHES = 795 + RedshiftLexerREGEXP_REPLACE = 796 + RedshiftLexerREGEXP_SPLIT_TO_ARRAY = 797 + RedshiftLexerREGEXP_SPLIT_TO_TABLE = 798 + RedshiftLexerREGEXP_SUBSTR = 799 + RedshiftLexerREPEAT = 800 + RedshiftLexerRPAD = 801 + RedshiftLexerRTRIM = 802 + RedshiftLexerSPLIT_PART = 803 + RedshiftLexerSTARTS_WITH = 804 + RedshiftLexerSTRING_TO_ARRAY = 805 + RedshiftLexerSTRING_TO_TABLE = 806 + RedshiftLexerSTRPOS = 807 + RedshiftLexerSUBSTR = 808 + RedshiftLexerTO_ASCII = 809 + RedshiftLexerTO_HEX = 810 + RedshiftLexerTRANSLATE = 811 + RedshiftLexerUNISTR = 812 + RedshiftLexerAGE = 813 + RedshiftLexerCLOCK_TIMESTAMP = 814 + RedshiftLexerDATE_BIN = 815 + RedshiftLexerDATE_PART = 816 + RedshiftLexerDATE_TRUNC = 817 + RedshiftLexerISFINITE = 818 + RedshiftLexerJUSTIFY_DAYS = 819 + RedshiftLexerJUSTIFY_HOURS = 820 + RedshiftLexerJUSTIFY_INTERVAL = 821 + RedshiftLexerMAKE_DATE = 822 + RedshiftLexerMAKE_INTERVAL = 823 + RedshiftLexerMAKE_TIME = 824 + RedshiftLexerMAKE_TIMESTAMP = 825 + RedshiftLexerMAKE_TIMESTAMPTZ = 826 + RedshiftLexerNOW = 827 + RedshiftLexerSTATEMENT_TIMESTAMP = 828 + RedshiftLexerTIMEOFDAY = 829 + RedshiftLexerTRANSACTION_TIMESTAMP = 830 + RedshiftLexerTO_TIMESTAMP = 831 + RedshiftLexerTO_CHAR = 832 + RedshiftLexerTO_DATE = 833 + RedshiftLexerTO_NUMBER = 834 + RedshiftLexerENCODE = 835 + RedshiftLexerDISTKEY = 836 + RedshiftLexerSORTKEY = 837 + RedshiftLexerDISTSTYLE = 838 + RedshiftLexerBACKUP = 839 + RedshiftLexerCOMPOUND = 840 + RedshiftLexerINTERLEAVED = 841 + RedshiftLexerEVEN = 842 + RedshiftLexerCASE_SENSITIVE = 843 + RedshiftLexerQUOTA = 844 + RedshiftLexerTB = 845 + RedshiftLexerBOOST = 846 + RedshiftLexerRECLUSTER = 847 + RedshiftLexerSORT = 848 + RedshiftLexerPERCENT_WORD = 849 + RedshiftLexerCASE_INSENSITIVE = 850 + RedshiftLexerIdentifier = 851 + RedshiftLexerTemporaryIdentifier = 852 + RedshiftLexerNamespaceUser = 853 + RedshiftLexerQuotedIdentifier = 854 + RedshiftLexerUnterminatedQuotedIdentifier = 855 + RedshiftLexerInvalidQuotedIdentifier = 856 + RedshiftLexerInvalidUnterminatedQuotedIdentifier = 857 + RedshiftLexerUnicodeQuotedIdentifier = 858 + RedshiftLexerUnterminatedUnicodeQuotedIdentifier = 859 + RedshiftLexerInvalidUnicodeQuotedIdentifier = 860 + RedshiftLexerInvalidUnterminatedUnicodeQuotedIdentifier = 861 + RedshiftLexerStringConstant = 862 + RedshiftLexerUnterminatedStringConstant = 863 + RedshiftLexerUnicodeEscapeStringConstant = 864 + RedshiftLexerUnterminatedUnicodeEscapeStringConstant = 865 + RedshiftLexerBeginDollarStringConstant = 866 + RedshiftLexerBinaryStringConstant = 867 + RedshiftLexerUnterminatedBinaryStringConstant = 868 + RedshiftLexerInvalidBinaryStringConstant = 869 + RedshiftLexerInvalidUnterminatedBinaryStringConstant = 870 + RedshiftLexerHexadecimalStringConstant = 871 + RedshiftLexerUnterminatedHexadecimalStringConstant = 872 + RedshiftLexerInvalidHexadecimalStringConstant = 873 + RedshiftLexerInvalidUnterminatedHexadecimalStringConstant = 874 + RedshiftLexerIntegral = 875 + RedshiftLexerNumericFail = 876 + RedshiftLexerNumeric = 877 + RedshiftLexerPLSQLVARIABLENAME = 878 + RedshiftLexerPLSQLIDENTIFIER = 879 + RedshiftLexerWhitespace = 880 + RedshiftLexerNewline = 881 + RedshiftLexerLineComment = 882 + RedshiftLexerBlockComment = 883 + RedshiftLexerUnterminatedBlockComment = 884 + RedshiftLexerMetaCommand = 885 + RedshiftLexerEndMetaCommand = 886 + RedshiftLexerErrorCharacter = 887 + RedshiftLexerEscapeStringConstant = 888 + RedshiftLexerUnterminatedEscapeStringConstant = 889 + RedshiftLexerInvalidEscapeStringConstant = 890 + RedshiftLexerInvalidUnterminatedEscapeStringConstant = 891 + RedshiftLexerAfterEscapeStringConstantMode_NotContinued = 892 + RedshiftLexerAfterEscapeStringConstantWithNewlineMode_NotContinued = 893 + RedshiftLexerDollarText = 894 + RedshiftLexerEndDollarStringConstant = 895 + RedshiftLexerAfterEscapeStringConstantWithNewlineMode_Continued = 896 +) + +// RedshiftLexer modes. +const ( + RedshiftLexerEscapeStringConstantMode = iota + 1 + RedshiftLexerAfterEscapeStringConstantMode + RedshiftLexerAfterEscapeStringConstantWithNewlineMode + RedshiftLexerDollarQuotedStringMode +) + +/* This field stores the tags which are used to detect the end of a dollar-quoted string literal. + */ + +func (l *RedshiftLexer) Action(localctx antlr.RuleContext, ruleIndex, actionIndex int) { + switch ruleIndex { + case 28: + l.Operator_Action(localctx, actionIndex) + + case 873: + l.BeginDollarStringConstant_Action(localctx, actionIndex) + + case 884: + l.NumericFail_Action(localctx, actionIndex) + + case 893: + l.UnterminatedBlockComment_Action(localctx, actionIndex) + + case 905: + l.AfterEscapeStringConstantMode_NotContinued_Action(localctx, actionIndex) + + case 909: + l.AfterEscapeStringConstantWithNewlineMode_NotContinued_Action(localctx, actionIndex) + + case 911: + l.EndDollarStringConstant_Action(localctx, actionIndex) + + default: + panic("No registered action for: " + fmt.Sprint(ruleIndex)) + } +} + +func (l *RedshiftLexer) Operator_Action(localctx antlr.RuleContext, actionIndex int) { + switch actionIndex { + case 0: + + l.HandleLessLessGreaterGreater() + + default: + panic("No registered action for: " + fmt.Sprint(actionIndex)) + } +} +func (l *RedshiftLexer) BeginDollarStringConstant_Action(localctx antlr.RuleContext, actionIndex int) { + switch actionIndex { + case 1: + l.pushTag() + + default: + panic("No registered action for: " + fmt.Sprint(actionIndex)) + } +} +func (l *RedshiftLexer) NumericFail_Action(localctx antlr.RuleContext, actionIndex int) { + switch actionIndex { + case 2: + l.HandleNumericFail() + + default: + panic("No registered action for: " + fmt.Sprint(actionIndex)) + } +} +func (l *RedshiftLexer) UnterminatedBlockComment_Action(localctx antlr.RuleContext, actionIndex int) { + switch actionIndex { + case 3: + + l.UnterminatedBlockCommentDebugAssert() + + default: + panic("No registered action for: " + fmt.Sprint(actionIndex)) + } +} +func (l *RedshiftLexer) AfterEscapeStringConstantMode_NotContinued_Action(localctx antlr.RuleContext, actionIndex int) { + switch actionIndex { + case 4: + + default: + panic("No registered action for: " + fmt.Sprint(actionIndex)) + } +} +func (l *RedshiftLexer) AfterEscapeStringConstantWithNewlineMode_NotContinued_Action(localctx antlr.RuleContext, actionIndex int) { + switch actionIndex { + case 5: + + default: + panic("No registered action for: " + fmt.Sprint(actionIndex)) + } +} +func (l *RedshiftLexer) EndDollarStringConstant_Action(localctx antlr.RuleContext, actionIndex int) { + switch actionIndex { + case 6: + l.popTag() + + default: + panic("No registered action for: " + fmt.Sprint(actionIndex)) + } +} + +func (l *RedshiftLexer) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 28: + return l.Operator_Sempred(localctx, predIndex) + + case 29: + return l.OperatorEndingWithPlusMinus_Sempred(localctx, predIndex) + + case 857: + return l.IdentifierStartChar_Sempred(localctx, predIndex) + + case 911: + return l.EndDollarStringConstant_Sempred(localctx, predIndex) + + default: + panic("No registered predicate for: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *RedshiftLexer) Operator_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.checkLA('-') + + case 1: + return p.checkLA('*') + + case 2: + return p.checkLA('*') + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *RedshiftLexer) OperatorEndingWithPlusMinus_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 3: + return p.checkLA('-') + + case 4: + return p.checkLA('*') + + case 5: + return p.checkLA('-') + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *RedshiftLexer) IdentifierStartChar_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 6: + return p.charIsLetter() + + case 7: + return p.CheckIfUtf32Letter() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *RedshiftLexer) EndDollarStringConstant_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 8: + return p.isTag() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/redshift/redshift_lexer_base.go b/redshift/redshift_lexer_base.go new file mode 100644 index 0000000..1de1ddc --- /dev/null +++ b/redshift/redshift_lexer_base.go @@ -0,0 +1,455 @@ +package redshift + +import ( + "strings" + "unicode" + + "github.com/antlr4-go/antlr/v4" +) + +type RedshiftLexerBase struct { + *antlr.BaseLexer + + stack StringStack + reservedKeywordMap map[string]bool +} + +func (receiver *RedshiftLexerBase) pushTag() { + receiver.stack.Push(receiver.GetText()) +} + +func (receiver *RedshiftLexerBase) isTag() bool { + if receiver.stack.IsEmpty() { + return false + } + return receiver.GetText() == receiver.stack.PeekOrEmpty() +} + +func (receiver *RedshiftLexerBase) popTag() { + _, _ = receiver.stack.Pop() +} + +func (receiver *RedshiftLexerBase) checkLA(c int) bool { + return receiver.GetInputStream().LA(1) != c +} + +func (receiver *RedshiftLexerBase) charIsLetter() bool { + c := receiver.GetInputStream().LA(-1) + return unicode.IsLetter(rune(c)) +} + +func (receiver *RedshiftLexerBase) HandleNumericFail() { + index := receiver.GetInputStream().Index() - 2 + receiver.GetInputStream().Seek(index) + receiver.SetType(RedshiftLexerIntegral) +} + +func (receiver *RedshiftLexerBase) HandleLessLessGreaterGreater() { + if receiver.GetText() == "<<" { + receiver.SetType(RedshiftLexerLESS_LESS) + } + if receiver.GetText() == ">>" { + receiver.SetType(RedshiftLexerGREATER_GREATER) + } +} + +func (receiver *RedshiftLexerBase) UnterminatedBlockCommentDebugAssert() { + //Debug.Assert(InputStream.LA(1) == -1 /*EOF*/); +} + +func (receiver *RedshiftLexerBase) CheckIfUtf32Letter() bool { + codePoint := receiver.GetInputStream().LA(-2)<<8 + receiver.GetInputStream().LA(-1) + var c []rune + if codePoint < 0x10000 { + c = []rune{rune(codePoint)} + } else { + codePoint -= 0x10000 + c = []rune{ + (rune)(codePoint/0x400 + 0xd800), + (rune)(codePoint%0x400 + 0xdc00), + } + } + return unicode.IsLetter(c[0]) +} + +func (receiver *RedshiftLexerBase) IsIdentifier(tokenType int) bool { + if tokenType == antlr.TokenEOF { + return false + } + + switch tokenType { + case RedshiftLexerIdentifier, + RedshiftLexerQuotedIdentifier, + RedshiftLexerUnicodeQuotedIdentifier, + RedshiftLexerPLSQLVARIABLENAME, + RedshiftLexerPLSQLIDENTIFIER, + RedshiftLexerUnterminatedQuotedIdentifier: + return true + case RedshiftLexerABORT_P, // Unreserved Keywords + RedshiftLexerABSOLUTE_P, + RedshiftLexerACCESS, + RedshiftLexerACTION, + RedshiftLexerADD_P, + RedshiftLexerADMIN, + RedshiftLexerAFTER, + RedshiftLexerAGGREGATE, + RedshiftLexerALSO, + RedshiftLexerALTER, + RedshiftLexerALWAYS, + RedshiftLexerASSERTION, + RedshiftLexerASSIGNMENT, + RedshiftLexerAT, + RedshiftLexerATOMIC_P, + RedshiftLexerATTACH, + RedshiftLexerATTRIBUTE, + RedshiftLexerBACKWARD, + RedshiftLexerBEFORE, + RedshiftLexerBEGIN_P, + RedshiftLexerBY, + RedshiftLexerCACHE, + RedshiftLexerCALL, + RedshiftLexerCALLED, + RedshiftLexerCASCADE, + RedshiftLexerCASCADED, + RedshiftLexerCATALOG, + RedshiftLexerCHAIN, + RedshiftLexerCHARACTERISTICS, + RedshiftLexerCHECKPOINT, + RedshiftLexerCLASS, + RedshiftLexerCLOSE, + RedshiftLexerCLUSTER, + RedshiftLexerCOLUMNS, + RedshiftLexerCOMMENT, + RedshiftLexerCOMMENTS, + RedshiftLexerCOMMIT, + RedshiftLexerCOMMITTED, + RedshiftLexerCONFIGURATION, + RedshiftLexerCONFLICT, + RedshiftLexerCONNECTION, + RedshiftLexerCONSTRAINTS, + RedshiftLexerCONTENT_P, + RedshiftLexerCONTINUE_P, + RedshiftLexerCONVERSION_P, + RedshiftLexerCOPY, + RedshiftLexerCOST, + RedshiftLexerCSV, + RedshiftLexerCUBE, + RedshiftLexerCURRENT_P, + RedshiftLexerCURSOR, + RedshiftLexerCYCLE, + RedshiftLexerDATA_P, + RedshiftLexerDATABASE, + RedshiftLexerDAY_P, + RedshiftLexerDEALLOCATE, + RedshiftLexerDECLARE, + RedshiftLexerDEFAULTS, + RedshiftLexerDEFERRED, + RedshiftLexerDEFINER, + RedshiftLexerDELETE_P, + RedshiftLexerDELIMITER, + RedshiftLexerDELIMITERS, + RedshiftLexerDEPENDS, + RedshiftLexerDETACH, + RedshiftLexerDICTIONARY, + RedshiftLexerDISABLE_P, + RedshiftLexerDISCARD, + RedshiftLexerDOCUMENT_P, + RedshiftLexerDOMAIN_P, + RedshiftLexerDOUBLE_P, + RedshiftLexerDROP, + RedshiftLexerEACH, + RedshiftLexerENABLE_P, + RedshiftLexerENCODING, + RedshiftLexerENCRYPTED, + RedshiftLexerENUM_P, + RedshiftLexerESCAPE, + RedshiftLexerEVENT, + RedshiftLexerEXCLUDE, + RedshiftLexerEXCLUDING, + RedshiftLexerEXCLUSIVE, + RedshiftLexerEXECUTE, + RedshiftLexerEXPLAIN, + RedshiftLexerEXPRESSION, + RedshiftLexerEXTENSION, + RedshiftLexerEXTERNAL, + RedshiftLexerFAMILY, + RedshiftLexerFILTER, + RedshiftLexerFIRST_P, + RedshiftLexerFOLLOWING, + RedshiftLexerFORCE, + RedshiftLexerFORWARD, + RedshiftLexerFUNCTION, + RedshiftLexerFUNCTIONS, + RedshiftLexerGENERATED, + RedshiftLexerGLOBAL, + RedshiftLexerGRANTED, + RedshiftLexerGROUPS, + RedshiftLexerHANDLER, + RedshiftLexerHEADER_P, + RedshiftLexerHOLD, + RedshiftLexerHOUR_P, + RedshiftLexerIDENTITY_P, + RedshiftLexerIF_P, + RedshiftLexerIMMEDIATE, + RedshiftLexerIMMUTABLE, + RedshiftLexerIMPLICIT_P, + RedshiftLexerIMPORT_P, + RedshiftLexerINCLUDE, + RedshiftLexerINCLUDING, + RedshiftLexerINCREMENT, + RedshiftLexerINDEX, + RedshiftLexerINDEXES, + RedshiftLexerINHERIT, + RedshiftLexerINHERITS, + RedshiftLexerINLINE_P, + RedshiftLexerINPUT_P, + RedshiftLexerINSENSITIVE, + RedshiftLexerINSERT, + RedshiftLexerINSTEAD, + RedshiftLexerINVOKER, + RedshiftLexerISOLATION, + RedshiftLexerKEY, + RedshiftLexerLABEL, + RedshiftLexerLANGUAGE, + RedshiftLexerLARGE_P, + RedshiftLexerLAST_P, + RedshiftLexerLEAKPROOF, + RedshiftLexerLEVEL, + RedshiftLexerLISTEN, + RedshiftLexerLOAD, + RedshiftLexerLOCAL, + RedshiftLexerLOCATION, + RedshiftLexerLOCK_P, + RedshiftLexerLOCKED, + RedshiftLexerLOGGED, + RedshiftLexerMAPPING, + RedshiftLexerMATCH, + RedshiftLexerMATERIALIZED, + RedshiftLexerMAXVALUE, + RedshiftLexerMETHOD, + RedshiftLexerMINUTE_P, + RedshiftLexerMINVALUE, + RedshiftLexerMODE, + RedshiftLexerMONTH_P, + RedshiftLexerMOVE, + RedshiftLexerNAME_P, + RedshiftLexerNAMES, + RedshiftLexerNEW, + RedshiftLexerNEXT, + RedshiftLexerNFC, + RedshiftLexerNFD, + RedshiftLexerNFKC, + RedshiftLexerNFKD, + RedshiftLexerNO, + RedshiftLexerNORMALIZED, + RedshiftLexerNOTHING, + RedshiftLexerNOTIFY, + RedshiftLexerNOWAIT, + RedshiftLexerNULLS_P, + RedshiftLexerOBJECT_P, + RedshiftLexerOF, + RedshiftLexerOFF, + RedshiftLexerOIDS, + RedshiftLexerOLD, + RedshiftLexerOPERATOR, + RedshiftLexerOPTION, + RedshiftLexerOPTIONS, + RedshiftLexerORDINALITY, + RedshiftLexerOTHERS, + RedshiftLexerOVER, + RedshiftLexerOVERRIDING, + RedshiftLexerOWNED, + RedshiftLexerOWNER, + RedshiftLexerPARALLEL, + RedshiftLexerPARSER, + RedshiftLexerPARTIAL, + RedshiftLexerPARTITION, + RedshiftLexerPASSING, + RedshiftLexerPASSWORD, + RedshiftLexerPLANS, + RedshiftLexerPOLICY, + RedshiftLexerPRECEDING, + RedshiftLexerPREPARE, + RedshiftLexerPREPARED, + RedshiftLexerPRESERVE, + RedshiftLexerPRIOR, + RedshiftLexerPRIVILEGES, + RedshiftLexerPROCEDURAL, + RedshiftLexerPROCEDURE, + RedshiftLexerPROCEDURES, + RedshiftLexerPROGRAM, + RedshiftLexerPUBLICATION, + RedshiftLexerQUOTE, + RedshiftLexerRANGE, + RedshiftLexerREAD, + RedshiftLexerREASSIGN, + RedshiftLexerRECHECK, + RedshiftLexerRECURSIVE, + RedshiftLexerREF, + RedshiftLexerREFERENCING, + RedshiftLexerREFRESH, + RedshiftLexerREINDEX, + RedshiftLexerRELATIVE_P, + RedshiftLexerRELEASE, + RedshiftLexerRENAME, + RedshiftLexerREPEATABLE, + RedshiftLexerREPLICA, + RedshiftLexerRESET, + RedshiftLexerRESTART, + RedshiftLexerRESTRICT, + RedshiftLexerRETURNS, + RedshiftLexerREVOKE, + RedshiftLexerROLE, + RedshiftLexerROLLBACK, + RedshiftLexerROLLUP, + RedshiftLexerROUTINE, + RedshiftLexerROUTINES, + RedshiftLexerROWS, + RedshiftLexerRULE, + RedshiftLexerSAVEPOINT, + RedshiftLexerSCHEMA, + RedshiftLexerSCHEMAS, + RedshiftLexerSCROLL, + RedshiftLexerSEARCH, + RedshiftLexerSECOND_P, + RedshiftLexerSECURITY, + RedshiftLexerSEQUENCE, + RedshiftLexerSEQUENCES, + RedshiftLexerSERIALIZABLE, + RedshiftLexerSERVER, + RedshiftLexerSESSION, + RedshiftLexerSET, + RedshiftLexerSETS, + RedshiftLexerSHARE, + RedshiftLexerSHOW, + RedshiftLexerSIMPLE, + RedshiftLexerSKIP_P, + RedshiftLexerSNAPSHOT, + RedshiftLexerSQL_P, + RedshiftLexerSTABLE, + RedshiftLexerSTANDALONE_P, + RedshiftLexerSTART, + RedshiftLexerSTATEMENT, + RedshiftLexerSTATISTICS, + RedshiftLexerSTDIN, + RedshiftLexerSTDOUT, + RedshiftLexerSTORAGE, + RedshiftLexerSTORED, + RedshiftLexerSTRICT_P, + RedshiftLexerSTRIP_P, + RedshiftLexerSUBSCRIPTION, + RedshiftLexerSUPPORT, + RedshiftLexerSYSID, + RedshiftLexerSYSTEM_P, + RedshiftLexerTABLES, + RedshiftLexerTABLESPACE, + RedshiftLexerTEMP, + RedshiftLexerTEMPLATE, + RedshiftLexerTEMPORARY, + RedshiftLexerTEXT_P, + RedshiftLexerTIES, + RedshiftLexerTRANSACTION, + RedshiftLexerTRANSFORM, + RedshiftLexerTRIGGER, + RedshiftLexerTRUNCATE, + RedshiftLexerTRUSTED, + RedshiftLexerTYPE_P, + RedshiftLexerTYPES_P, + RedshiftLexerUESCAPE, + RedshiftLexerUNBOUNDED, + RedshiftLexerUNCOMMITTED, + RedshiftLexerUNENCRYPTED, + RedshiftLexerUNKNOWN, + RedshiftLexerUNLISTEN, + RedshiftLexerUNLOGGED, + RedshiftLexerUNTIL, + RedshiftLexerUPDATE, + RedshiftLexerVACUUM, + RedshiftLexerVALID, + RedshiftLexerVALIDATE, + RedshiftLexerVALIDATOR, + RedshiftLexerVALUE_P, + RedshiftLexerVARYING, + RedshiftLexerVERSION_P, + RedshiftLexerVIEW, + RedshiftLexerVIEWS, + RedshiftLexerVOLATILE, + RedshiftLexerWHITESPACE_P, + RedshiftLexerWITHIN, + RedshiftLexerWITHOUT, + RedshiftLexerWORK, + RedshiftLexerWRAPPER, + RedshiftLexerWRITE, + RedshiftLexerXML_P, + RedshiftLexerYEAR_P, + RedshiftLexerYES_P, + RedshiftLexerZONE: + return true + case RedshiftLexerALIAS, // plsql unreserved keywords + RedshiftLexerAND, + RedshiftLexerARRAY, + RedshiftLexerASSERT, + RedshiftLexerCOLLATE, + RedshiftLexerCOLUMN, + RedshiftLexerCONSTANT, + RedshiftLexerCONSTRAINT, + RedshiftLexerDEBUG, + RedshiftLexerDEFAULT, + RedshiftLexerDIAGNOSTICS, + RedshiftLexerDO, + RedshiftLexerDUMP, + RedshiftLexerELSIF, + RedshiftLexerERROR, + RedshiftLexerEXCEPTION, + RedshiftLexerEXIT, + RedshiftLexerFETCH, + RedshiftLexerGET, + RedshiftLexerINFO, + RedshiftLexerIS, + RedshiftLexerNOTICE, + RedshiftLexerOPEN, + RedshiftLexerPERFORM, + RedshiftLexerPRINT_STRICT_PARAMS, + RedshiftLexerQUERY, + RedshiftLexerRAISE, + RedshiftLexerRETURN, + RedshiftLexerSLICE, + RedshiftLexerSQLSTATE, + RedshiftLexerSTACKED, + RedshiftLexerTABLE, + RedshiftLexerUSE_COLUMN, + RedshiftLexerUSE_VARIABLE, + RedshiftLexerVARIABLE_CONFLICT, + RedshiftLexerWARNING, + RedshiftLexerOUTER_P: + return true + } + + symbol := receiver.GetSymbolicNames()[tokenType] + symbol = strings.TrimSuffix(symbol, "_SYMBOL") + if len(symbol) > 0 && !receiver.IsReservedKeyword(symbol) { + return true + } + return false +} + +func (receiver *RedshiftLexerBase) IsReservedKeyword(s string) bool { + receiver.initReservedKeywordMap() + + _, exists := receiver.reservedKeywordMap[s] + return exists +} + +func (receiver *RedshiftLexerBase) initReservedKeywordMap() { + if receiver.reservedKeywordMap != nil { + return + } + + receiver.reservedKeywordMap = make(map[string]bool) + + for _, keyword := range Keywords { + if keyword.Reserved { + receiver.reservedKeywordMap[keyword.Keyword] = true + } + } +} diff --git a/redshift/redshift_parse_error.go b/redshift/redshift_parse_error.go new file mode 100644 index 0000000..4996cb8 --- /dev/null +++ b/redshift/redshift_parse_error.go @@ -0,0 +1,9 @@ +package redshift + +type RedshiftParseError struct { + Number int + Offset int + Line int + Column int + Message string +} diff --git a/redshift/redshift_parser.go b/redshift/redshift_parser.go new file mode 100644 index 0000000..0779d47 --- /dev/null +++ b/redshift/redshift_parser.go @@ -0,0 +1,259370 @@ +// Code generated from RedshiftParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package redshift // RedshiftParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type RedshiftParser struct { + RedshiftParserBase +} + +var RedshiftParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func redshiftparserParserInit() { + staticData := &RedshiftParserParserStaticData + staticData.LiteralNames = []string{ + "", "'$'", "'('", "')'", "'['", "']'", "','", "';'", "':'", "'*'", "'='", + "'.'", "'+'", "'-'", "'/'", "'^'", "'<'", "'>'", "'<<'", "'>>'", "':='", + "'<='", "'=>'", "'>='", "'..'", "'<>'", "'::'", "'%'", "", "", "'ALL'", + "'ANALYSE'", "'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", "'AS'", "'ASC'", + "'ASYMMETRIC'", "'BOTH'", "'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", + "'COLUMN'", "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", "'CURRENT_DATE'", + "'CURRENT_ROLE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", + "'DEFAULT'", "'DEFERRABLE'", "'DESC'", "'DISTINCT'", "'DO'", "'ELSE'", + "'EXCEPT'", "'FALSE'", "'FETCH'", "'FOR'", "'FOREIGN'", "'FROM'", "'GRANT'", + "'GROUP'", "'HAVING'", "'IN'", "'INITIALLY'", "'INTERSECT'", "'INTO'", + "'LATERAL'", "'LEADING'", "'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'", + "'NOT'", "'NULL'", "'OFFSET'", "'ON'", "'ONLY'", "'OR'", "'ORDER'", + "'PLACING'", "'PRIMARY'", "'PUBLIC'", "'REFERENCES'", "'RETURNING'", + "'SELECT'", "'SESSION_USER'", "'SOME'", "'SYMMETRIC'", "'TABLE'", "'THEN'", + "'TO'", "'TRAILING'", "'TRUE'", "'UNION'", "'UNIQUE'", "'USER'", "'USING'", + "'VARIADIC'", "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'AUTHORIZATION'", + "'BINARY'", "'BINDING'", "'COLLATION'", "'CONCURRENTLY'", "'CROSS'", + "'CURRENT_SCHEMA'", "'FREEZE'", "'FULL'", "'ILIKE'", "'INNER'", "'IS'", + "'ISNULL'", "'JOIN'", "'LEFT'", "'LIKE'", "'NATURAL'", "'NOTNULL'", + "'OUTER'", "'OVER'", "'OVERLAPS'", "'RIGHT'", "'SIMILAR'", "'VERBOSE'", + "'ABORT'", "'ABSOLUTE'", "'ACCESS'", "'ACTION'", "'ADD'", "'ADMIN'", + "'AFTER'", "'AGGREGATE'", "'ALSO'", "'ALTER'", "'ALWAYS'", "'ASSERTION'", + "'ASSIGNMENT'", "'AT'", "'ATTRIBUTE'", "'BACKWARD'", "'BEFORE'", "'BEGIN'", + "'BY'", "'CACHE'", "'CALLED'", "'CASCADE'", "'CASCADED'", "'CATALOG'", + "'CHAIN'", "'CHARACTERISTICS'", "'CHECKPOINT'", "'CLASS'", "'CLOSE'", + "'CLUSTER'", "'COMMENT'", "'COMMENTS'", "'COMMIT'", "'COMMITTED'", "'CONFIGURATION'", + "'CONNECTION'", "'CONSTRAINTS'", "'CONTENT'", "'CONTINUE'", "'CONVERSION'", + "'COPY'", "'COST'", "'CSV'", "'JSON'", "'CURSOR'", "'CYCLE'", "'DATA'", + "'DATA_CATALOG'", "'DATABASE'", "'DAY'", "'DEALLOCATE'", "'DECLARE'", + "'DEFAULTS'", "'DEFERRED'", "'DEFINER'", "'DELETE'", "'DELIMITER'", + "'DELIMITERS'", "'DICTIONARY'", "'DISABLE'", "'DISCARD'", "'DOCUMENT'", + "'DOMAIN'", "'DOUBLE'", "'DROP'", "'EACH'", "'ENABLE'", "'ENCODING'", + "'ENCRYPTED'", "'ENUM'", "'ESCAPE'", "'EVENT'", "'EXCLUDE'", "'EXCLUDING'", + "'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", "'EXTENSION'", "'EXTERNAL'", + "'FAMILY'", "'FIRST'", "'FOLLOWING'", "'FORCE'", "'FORWARD'", "'FUNCTION'", + "'FUNCTIONS'", "'GLOBAL'", "'GRANTED'", "'HANDLER'", "", "'HOLD'", "'HOUR'", + "", "'IF'", "'IMMEDIATE'", "'IMMUTABLE'", "'IMPLICIT'", "'INCLUDING'", + "'INCREMENT'", "'INDEX'", "'INDEXES'", "'INHERIT'", "'INHERITS'", "'INLINE'", + "'INSENSITIVE'", "'INSERT'", "'INSTEAD'", "'INVOKER'", "'ISOLATION'", + "'KEY'", "'LABEL'", "'LANGUAGE'", "'LARGE'", "'LAST'", "'LEAKPROOF'", + "'LEVEL'", "'LISTEN'", "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", + "'MAPPING'", "'MATCH'", "'MATCHED'", "'MATERIALIZED'", "'MAXVALUE'", + "'MERGE'", "'MINUTE'", "'MINVALUE'", "'MODE'", "'MONTH'", "'MOVE'", + "'NAME'", "'NAMES'", "'NEXT'", "'NO'", "'NOTHING'", "'NOTIFY'", "'NOWAIT'", + "'NULLS'", "'OBJECT'", "'OF'", "'OFF'", "'OIDS'", "'OPERATOR'", "'OPTION'", + "'OPTIONS'", "'OWNED'", "'OWNER'", "'PARSER'", "'PARTIAL'", "'PARTITION'", + "'PASSING'", "'PASSWORD'", "'PLANS'", "'PRECEDING'", "'PREDICATE'", + "'PREPARE'", "'PREPARED'", "'PRESERVE'", "'PRIOR'", "'PRIVILEGES'", + "'PROCEDURAL'", "'PROCEDURE'", "'PROGRAM'", "'QUOTE'", "'RANGE'", "'READ'", + "'REASSIGN'", "'RECHECK'", "'RECURSIVE'", "'REF'", "'REFRESH'", "'REINDEX'", + "'RELATIVE'", "'RELEASE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", + "'REPLICA'", "'RESET'", "'RESTART'", "'RESTRICT'", "'RETURNS'", "'REVOKE'", + "'ROLE'", "'ROLLBACK'", "'ROWS'", "'RULE'", "'SAVEPOINT'", "'SCHEMA'", + "'SCROLL'", "'SEARCH'", "'SECOND'", "'SECURITY'", "'SEQUENCE'", "'SEQUENCES'", + "'SERIALIZABLE'", "'SERVER'", "", "'SET'", "'SHARE'", "'SHOW'", "'SIMPLE'", + "'SNAPSHOT'", "'STABLE'", "'STANDALONE'", "'START'", "'STATEMENT'", + "'STATISTICS'", "'STDIN'", "'STDOUT'", "'STORAGE'", "'STRICT'", "'STRIP'", + "'SYSID'", "'SYSTEM'", "'TABLES'", "'TABLESPACE'", "'TEMP'", "'TEMPLATE'", + "'TEMPORARY'", "'TEXT'", "'TRANSACTION'", "'TRIGGER'", "'TRUNCATE'", + "'TRUSTED'", "'TYPE'", "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNENCRYPTED'", + "'UNKNOWN'", "'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", "'UPDATE'", "'VACUUM'", + "'VALID'", "'VALIDATE'", "'VALIDATOR'", "'VARYING'", "'VERSION'", "'VIEW'", + "'VOLATILE'", "'WHITESPACE'", "'WITHOUT'", "'WORK'", "'WRAPPER'", "'WRITE'", + "'XML'", "'YEAR'", "'YES'", "'ZONE'", "'QUALIFY'", "'CONNECT'", "'TOP'", + "'VARBYTE'", "'VARBINARY'", "'CONJUNCTION'", "'DEFINITION'", "'DATASHARE'", + "'FILE'", "'PUBLICACCESSIBLE'", "'INCLUDENEW'", "'IAM_ROLE'", "'CATALOG_ROLE'", + "'CATALOG_ID'", "'HIVE'", "'METASTORE'", "'URI'", "'POSTGRES'", "'MYSQL'", + "'SECRET_ARN'", "'KINESIS'", "'KAFKA'", "'MSK'", "'AUTHENTICATION'", + "'AUTHENTICATION_ARN'", "", "'MTLS'", "'MASKING'", "'RLS'", "", "'PROVIDER'", + "'PROTECTED'", "'MODEL'", "'TARGET'", "'SAGEMAKER'", "'AUTO'", "'MODEL_TYPE'", + "'PROBLEM_TYPE'", "'OBJECTIVE'", "'PREPROCESSORS'", "'HYPERPARAMETERS'", + "'XGBOOST'", "'MLP'", "'LINEAR_LEARNER'", "'KMEANS'", "'FORECAST'", + "'REGRESSION'", "'BINARY_CLASSIFICATION'", "'MULTICLASS_CLASSIFICATION'", + "'S3_BUCKET'", "'TAGS'", "'KMS_KEY_ID'", "'S3_GARBAGE_COLLECT'", "'MAX_CELLS'", + "'MAX_RUNTIME'", "'HORIZON'", "'FREQUENCY'", "'PERCENTILES'", "'MAX_BATCH_ROWS'", + "'UNLOAD'", "'MANIFEST'", "'ADDQUOTES'", "'ALLOWOVERWRITE'", "'CLEANPATH'", + "'MAXFILESIZE'", "'ROWGROUPSIZE'", "'BZIP2'", "'GZIP'", "'ZSTD'", "'DATABASES'", + "'DATASHARES'", "'GRANTS'", "'USE'", "'CANCEL'", "'SESSION_AUTHORIZATION'", + "'SESSION_CHARACTERISTICS'", "'COMPRESSION'", "'LIBRARY'", "'APPEND'", + "'MB'", "'GB'", "'ACCOUNT'", "'NAMESPACE'", "'DESCRIBE'", "'NONATOMIC'", + "'MANAGEDBY'", "'ADX'", "'REMOVE'", "'DUPLICATES'", "'BEDROCK'", "'MODEL_ID'", + "'PROMPT'", "'SUFFIX'", "'REQUEST_TYPE'", "'RESPONSE_TYPE'", "'RAW'", + "'UNIFIED'", "'SUPER'", "'CI'", "'CS'", "'PLPYTHONU'", "'FILLTARGET'", + "'IGNOREEXTRA'", "'CREATEUSER'", "'NOCREATEUSER'", "'REGION'", "'PORT'", + "'REDSHIFT'", "'IAM'", "'CREATEDB'", "'NOCREATEDB'", "'RESTRICTED'", + "'UNLIMITED'", "'EXTERNALID'", "'TIMEOUT'", "'SYSLOG'", "'CREDENTIALS'", + "'UNRESTRICTED'", "'PARAMETERS'", "'APPLICATION_ARN'", "'AUTO_CREATE_ROLES'", + "'COMPROWS'", "'PROVIDER_URL'", "'PROVIDER_URL_PORT'", "'ATTRIBUTE_MAP'", + "'PROVIDER_ARN'", "'ASSUME_ROLE_ARN'", "'PROPERTIES'", "'AVRO'", "'RCFILE'", + "'SEQUENCEFILE'", "'TEXTFILE'", "'ORC'", "'ION'", "'LAMBDA'", "'FIXEDWIDTH'", + "'PARQUET'", "'LZOP'", "'REMOVEQUOTES'", "'TRUNCATECOLUMNS'", "'FILLRECORD'", + "'BLANKSASNULL'", "'EMPTYASNULL'", "'MAXERROR'", "'DATEFORMAT'", "'TIMEFORMAT'", + "'ACCEPTINVCHARS'", "'ACCEPTANYDATE'", "'IGNOREHEADER'", "'IGNOREBLANKLINES'", + "'COMPUPDATE'", "'STATUPDATE'", "'EXPLICIT_IDS'", "'READRATIO'", "'ROUNDEC'", + "'TRIMBLANKS'", "'PRESET'", "'ACCESS_KEY_ID'", "'SECRET_ACCESS_KEY'", + "'SESSION_TOKEN'", "", "'SETTINGS'", "'FUNCTION_NAME'", "'ATOMIC'", + "'BETWEEN'", "'BIGINT'", "'BIT'", "'BOOLEAN'", "'CHAR'", "'CHARACTER'", + "'COALESCE'", "'DEC'", "'DECIMAL'", "'EXISTS'", "'EXTRACT'", "'FLOAT'", + "'GREATEST'", "'INOUT'", "'INT'", "'INTEGER'", "'INTERVAL'", "'LEAST'", + "'NATIONAL'", "'NCHAR'", "'NONE'", "'NULLIF'", "'NUMERIC'", "'OVERLAY'", + "'PARAMETER'", "'POSITION'", "'PRECISION'", "'REAL'", "'ROW'", "'SETOF'", + "'SMALLINT'", "'SUBSTRING'", "'TIME'", "'TIMESTAMP'", "'TREAT'", "'TRIM'", + "'VALUES'", "'VARCHAR'", "'XMLATTRIBUTES'", "'XMLCOMMENT'", "'XMLAGG'", + "'XML_IS_WELL_FORMED'", "'XML_IS_WELL_FORMED_DOCUMENT'", "'XML_IS_WELL_FORMED_CONTENT'", + "'XPATH'", "'XPATH_EXISTS'", "'XMLCONCAT'", "'XMLELEMENT'", "'XMLEXISTS'", + "'XMLFOREST'", "'XMLPARSE'", "'XMLPI'", "'XMLROOT'", "'XMLSERIALIZE'", + "'CALL'", "'CURRENT'", "'ATTACH'", "'DETACH'", "'EXPRESSION'", "'GENERATED'", + "'LOGGED'", "'STORED'", "'SERDE'", "'SERDEPROPERTIES'", "'INPUTFORMAT'", + "'OUTPUTFORMAT'", "'FIELDS'", "'COLLECTION'", "'ITEMS'", "'TERMINATED'", + "'ESCAPED'", "'DEFINED'", "'LINES'", "'KEYS'", "'PARTITIONED'", "'STRUCT'", + "'MAP'", "'STRING'", "'DELIMITED'", "'USAGE'", "'IGNORE'", "'LANGUAGES'", + "'JOB'", "'JOBS'", "'VIA'", "'ASSUMEROLE'", "'RETRY_TIMEOUT'", "'MAX_BATCH_SIZE'", + "'MAX_PAYLOAD_IN_MB'", "'KB'", "'INCLUDE'", "'ROUTINE'", "'TRANSFORM'", + "'IMPORT'", "'POLICY'", "'PRIORITY'", "'METHOD'", "'REFERENCING'", "'NEW'", + "'OLD'", "'VALUE'", "'SUBSCRIPTION'", "'PUBLICATION'", "'OUT'", "'END'", + "'ROUTINES'", "'SCHEMAS'", "'PROCEDURES'", "'INPUT'", "'SUPPORT'", "'PARALLEL'", + "'SQL'", "'DEPENDS'", "'OVERRIDING'", "'CONFLICT'", "'SKIP'", "'LOCKED'", + "'TIES'", "'ROLLUP'", "'CUBE'", "'GROUPING'", "'SETS'", "'TABLESAMPLE'", + "'ORDINALITY'", "'XMLTABLE'", "'COLUMNS'", "'XMLNAMESPACES'", "'ROWTYPE'", + "'NORMALIZED'", "'WITHIN'", "'FILTER'", "'GROUPS'", "'OTHERS'", "'NFC'", + "'NFD'", "'NFKC'", "'NFKD'", "'UESCAPE'", "'VIEWS'", "'NORMALIZE'", + "'DUMP'", "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", "'ERROR'", + "'USE_VARIABLE'", "'USE_COLUMN'", "'ALIAS'", "'CONSTANT'", "'PERFORM'", + "'GET'", "'DIAGNOSTICS'", "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", + "'FOREACH'", "'SLICE'", "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", + "'SQLSTATE'", "'DEBUG'", "'LOG'", "'INFO'", "'NOTICE'", "'WARNING'", + "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", "'ABS'", "'CBRT'", "'CEIL'", + "'CEILING'", "'DEGREES'", "'DIV'", "'EXP'", "'FACTORIAL'", "'FLOOR'", + "'GCD'", "'LCM'", "'LN'", "'LOG10'", "'MIN_SCALE'", "'MOD'", "'PI'", + "'POWER'", "'RADIANS'", "'ROUND'", "'SCALE'", "'SIGN'", "'SQRT'", "'TRIM_SCALE'", + "'TRUNC'", "'WIDTH_BUCKET'", "'RANDOM'", "'SETSEED'", "'ACOS'", "'ACOSD'", + "'ASIN'", "'ASIND'", "'ATAN'", "'ATAND'", "'ATAN2'", "'ATAN2D'", "'COS'", + "'COSD'", "'COT'", "'COTD'", "'SIN'", "'SIND'", "'TAN'", "'TAND'", "'SINH'", + "'COSH'", "'TANH'", "'ASINH'", "'ACOSH'", "'ATANH'", "'BIT_LENGTH'", + "'CHAR_LENGTH'", "'CHARACTER_LENGTH'", "'LOWER'", "'OCTET_LENGTH'", + "'UPPER'", "'ASCII'", "'BTRIM'", "'CHR'", "'CONCAT'", "'CONCAT_WS'", + "'FORMAT'", "'INITCAP'", "'LENGTH'", "'LPAD'", "'LTRIM'", "'MD5'", "'PARSE_IDENT'", + "'PG_CLIENT_ENCODING'", "'QUOTE_IDENT'", "'QUOTE_LITERAL'", "'QUOTE_NULLABLE'", + "'REGEXP_COUNT'", "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_MATCH'", + "'REGEXP_MATCHES'", "'REGEXP_REPLACE'", "'REGEXP_SPLIT_TO_ARRAY'", "'REGEXP_SPLIT_TO_TABLE'", + "'REGEXP_SUBSTR'", "'REPEAT'", "'RPAD'", "'RTRIM'", "'SPLIT_PART'", + "'STARTS_WITH'", "'STRING_TO_ARRAY'", "'STRING_TO_TABLE'", "'STRPOS'", + "'SUBSTR'", "'TO_ASCII'", "'TO_HEX'", "'TRANSLATE'", "'UNISTR'", "'AGE'", + "'CLOCK_TIMESTAMP'", "'DATE_BIN'", "'DATE_PART'", "'DATE_TRUNC'", "'ISFINITE'", + "'JUSTIFY_DAYS'", "'JUSTIFY_HOURS'", "'JUSTIFY_INTERVAL'", "'MAKE_DATE'", + "'MAKE_INTERVAL'", "'MAKE_TIME'", "'MAKE_TIMESTAMP'", "'MAKE_TIMESTAMPTZ'", + "'NOW'", "'STATEMENT_TIMESTAMP'", "'TIMEOFDAY'", "'TRANSACTION_TIMESTAMP'", + "'TO_TIMESTAMP'", "'TO_CHAR'", "'TO_DATE'", "'TO_NUMBER'", "'ENCODE'", + "'DISTKEY'", "'SORTKEY'", "'DISTSTYLE'", "'BACKUP'", "'COMPOUND'", "'INTERLEAVED'", + "'EVEN'", "'CASE_SENSITIVE'", "'QUOTA'", "'TB'", "'BOOST'", "'RECLUSTER'", + "'SORT'", "'PERCENT'", "'CASE_INSENSITIVE'", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "'\\\\'", "", "", "", + "", "", "", "", "", "", "'''", + } + staticData.SymbolicNames = []string{ + "", "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", "CLOSE_BRACKET", + "COMMA", "SEMI", "COLON", "STAR", "EQUAL", "DOT", "PLUS", "MINUS", "SLASH", + "CARET", "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS", + "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", "DOT_DOT", "NOT_EQUALS", + "TYPECAST", "PERCENT", "PARAM", "Operator", "ALL", "ANALYSE", "ANALYZE", + "AND", "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", "CASE", "CAST", + "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", "CREATE", "CURRENT_CATALOG", + "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP", + "CURRENT_USER", "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", "ELSE", + "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", "FROM", "GRANT", "GROUP_P", + "HAVING", "IN_P", "INITIALLY", "INTERSECT", "INTO", "LATERAL_P", "LEADING", + "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", "ON", + "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", "PUBLIC", "REFERENCES", + "RETURNING", "SELECT", "SESSION_USER", "SOME", "SYMMETRIC", "TABLE", + "THEN", "TO", "TRAILING", "TRUE_P", "UNION", "UNIQUE", "USER", "USING", + "VARIADIC", "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", "BINARY", + "BINDING", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", "FREEZE", + "FULL", "ILIKE", "INNER_P", "IS", "ISNULL", "JOIN", "LEFT", "LIKE", + "NATURAL", "NOTNULL", "OUTER_P", "OVER", "OVERLAPS", "RIGHT", "SIMILAR", + "VERBOSE", "ABORT_P", "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", "ADMIN", + "AFTER", "AGGREGATE", "ALSO", "ALTER", "ALWAYS", "ASSERTION", "ASSIGNMENT", + "AT", "ATTRIBUTE", "BACKWARD", "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", + "CASCADE", "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", "CHECKPOINT", + "CLASS", "CLOSE", "CLUSTER", "COMMENT", "COMMENTS", "COMMIT", "COMMITTED", + "CONFIGURATION", "CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", + "CONVERSION_P", "COPY", "COST", "CSV", "JSON", "CURSOR", "CYCLE", "DATA_P", + "DATA_CATALOG", "DATABASE", "DAY_P", "DEALLOCATE", "DECLARE", "DEFAULTS", + "DEFERRED", "DEFINER", "DELETE_P", "DELIMITER", "DELIMITERS", "DICTIONARY", + "DISABLE_P", "DISCARD", "DOCUMENT_P", "DOMAIN_P", "DOUBLE_P", "DROP", + "EACH", "ENABLE_P", "ENCODING", "ENCRYPTED", "ENUM_P", "ESCAPE", "EVENT", + "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXPLAIN", "EXTENSION", + "EXTERNAL", "FAMILY", "FIRST_P", "FOLLOWING", "FORCE", "FORWARD", "FUNCTION", + "FUNCTIONS", "GLOBAL", "GRANTED", "HANDLER", "HEADER_P", "HOLD", "HOUR_P", + "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", "IMPLICIT_P", "INCLUDING", + "INCREMENT", "INDEX", "INDEXES", "INHERIT", "INHERITS", "INLINE_P", + "INSENSITIVE", "INSERT", "INSTEAD", "INVOKER", "ISOLATION", "KEY", "LABEL", + "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", "LEVEL", "LISTEN", "LOAD", + "LOCAL", "LOCATION", "LOCK_P", "MAPPING", "MATCH", "MATCHED", "MATERIALIZED", + "MAXVALUE", "MERGE", "MINUTE_P", "MINVALUE", "MODE", "MONTH_P", "MOVE", + "NAME_P", "NAMES", "NEXT", "NO", "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", + "OBJECT_P", "OF", "OFF", "OIDS", "OPERATOR", "OPTION", "OPTIONS", "OWNED", + "OWNER", "PARSER", "PARTIAL", "PARTITION", "PASSING", "PASSWORD", "PLANS", + "PRECEDING", "PREDICATE", "PREPARE", "PREPARED", "PRESERVE", "PRIOR", + "PRIVILEGES", "PROCEDURAL", "PROCEDURE", "PROGRAM", "QUOTE", "RANGE", + "READ", "REASSIGN", "RECHECK", "RECURSIVE", "REF", "REFRESH", "REINDEX", + "RELATIVE_P", "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", + "RESET", "RESTART", "RESTRICT", "RETURNS", "REVOKE", "ROLE", "ROLLBACK", + "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", "SEARCH", "SECOND_P", + "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", "SERVER", "SESSION", + "SET", "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", "STABLE", "STANDALONE_P", + "START", "STATEMENT", "STATISTICS", "STDIN", "STDOUT", "STORAGE", "STRICT_P", + "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE", "TEMP", "TEMPLATE", + "TEMPORARY", "TEXT_P", "TRANSACTION", "TRIGGER", "TRUNCATE", "TRUSTED", + "TYPE_P", "TYPES_P", "UNBOUNDED", "UNCOMMITTED", "UNENCRYPTED", "UNKNOWN", + "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", "VACUUM", "VALID", "VALIDATE", + "VALIDATOR", "VARYING", "VERSION_P", "VIEW", "VOLATILE", "WHITESPACE_P", + "WITHOUT", "WORK", "WRAPPER", "WRITE", "XML_P", "YEAR_P", "YES_P", "ZONE", + "QUALIFY", "CONNECT", "TOP", "VARBYTE", "VARBINARY", "CONJUNCTION", + "DEFINITION", "DATASHARE", "FILE", "PUBLICACCESSIBLE", "INCLUDENEW", + "IAM_ROLE", "CATALOG_ROLE", "CATALOG_ID", "HIVE", "METASTORE", "URI", + "POSTGRES", "MYSQL", "SECRET_ARN", "KINESIS", "KAFKA", "MSK", "AUTHENTICATION", + "AUTHENTICATION_ARN", "SESSION_TOKEN", "MTLS", "MASKING", "RLS", "IDENTITY", + "PROVIDER", "PROTECTED", "MODEL", "TARGET", "SAGEMAKER", "AUTO", "MODEL_TYPE", + "PROBLEM_TYPE", "OBJECTIVE", "PREPROCESSORS", "HYPERPARAMETERS", "XGBOOST", + "MLP", "LINEAR_LEARNER", "KMEANS", "FORECAST", "REGRESSION", "BINARY_CLASSIFICATION", + "MULTICLASS_CLASSIFICATION", "S3_BUCKET", "TAGS", "KMS_KEY_ID", "S3_GARBAGE_COLLECT", + "MAX_CELLS", "MAX_RUNTIME", "HORIZON", "FREQUENCY", "PERCENTILES", "MAX_BATCH_ROWS", + "UNLOAD", "MANIFEST", "ADDQUOTES", "ALLOWOVERWRITE", "CLEANPATH", "MAXFILESIZE", + "ROWGROUPSIZE", "BZIP2", "GZIP", "ZSTD", "DATABASES", "DATASHARES", + "GRANTS", "USE", "CANCEL", "SESSION_AUTHORIZATION", "SESSION_CHARACTERISTICS", + "COMPRESSION", "LIBRARY", "APPEND", "MB", "GB", "ACCOUNT", "NAMESPACE", + "DESCRIBE", "NONATOMIC", "MANAGEDBY", "ADX", "REMOVE", "DUPLICATES", + "BEDROCK", "MODEL_ID", "PROMPT", "SUFFIX", "REQUEST_TYPE", "RESPONSE_TYPE", + "RAW", "UNIFIED", "SUPER", "CI", "CS", "PLPYTHONU", "FILLTARGET", "IGNOREEXTRA", + "CREATEUSER", "NOCREATEUSER", "REGION", "PORT", "REDSHIFT", "IAM", "CREATEDB", + "NOCREATEDB", "RESTRICTED", "UNLIMITED", "EXTERNALID", "TIMEOUT", "SYSLOG", + "CREDENTIALS", "UNRESTRICTED", "PARAMETERS", "APPLICATION_ARN", "AUTO_CREATE_ROLES", + "COMPROWS", "PROVIDER_URL", "PROVIDER_URL_PORT", "ATTRIBUTE_MAP", "PROVIDER_ARN", + "ASSUME_ROLE_ARN", "PROPERTIES", "AVRO", "RCFILE", "SEQUENCEFILE", "TEXTFILE", + "ORC", "ION", "LAMBDA", "FIXEDWIDTH", "PARQUET", "LZOP", "REMOVEQUOTES", + "TRUNCATECOLUMNS", "FILLRECORD", "BLANKSASNULL", "EMPTYASNULL", "MAXERROR", + "DATEFORMAT", "TIMEFORMAT", "ACCEPTINVCHARS", "ACCEPTANYDATE", "IGNOREHEADER", + "IGNOREBLANKLINES", "COMPUPDATE", "STATUPDATE", "EXPLICIT_IDS", "READRATIO", + "ROUNDEC", "TRIMBLANKS", "PRESET", "ACCESS_KEY_ID", "SECRET_ACCESS_KEY", + "SESSION_TOKEN_KW", "HEADER", "SETTINGS", "FUNCTION_NAME", "ATOMIC_P", + "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", "CHARACTER", "COALESCE", + "DEC", "DECIMAL_P", "EXISTS", "EXTRACT", "FLOAT_P", "GREATEST", "INOUT", + "INT_P", "INTEGER", "INTERVAL", "LEAST", "NATIONAL", "NCHAR", "NONE", + "NULLIF", "NUMERIC", "OVERLAY", "PARAMETER", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", "XMLATTRIBUTES", "XMLCOMMENT", + "XMLAGG", "XML_IS_WELL_FORMED", "XML_IS_WELL_FORMED_DOCUMENT", "XML_IS_WELL_FORMED_CONTENT", + "XPATH", "XPATH_EXISTS", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", "XMLFOREST", + "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", "CALL", "CURRENT_P", + "ATTACH", "DETACH", "EXPRESSION", "GENERATED", "LOGGED", "STORED", "SERDE", + "SERDEPROPERTIES", "INPUTFORMAT", "OUTPUTFORMAT", "FIELDS", "COLLECTION", + "ITEMS", "TERMINATED", "ESCAPED", "DEFINED", "LINES", "KEYS", "PARTITIONED", + "STRUCT", "MAP", "STRING", "DELIMITED", "USAGE", "IGNORE", "LANGUAGES", + "JOB", "JOBS", "VIA", "ASSUMEROLE", "RETRY_TIMEOUT", "MAX_BATCH_SIZE", + "MAX_PAYLOAD_IN_MB", "KB", "INCLUDE", "ROUTINE", "TRANSFORM", "IMPORT_P", + "POLICY", "PRIORITY", "METHOD", "REFERENCING", "NEW", "OLD", "VALUE_P", + "SUBSCRIPTION", "PUBLICATION", "OUT_P", "END_P", "ROUTINES", "SCHEMAS", + "PROCEDURES", "INPUT_P", "SUPPORT", "PARALLEL", "SQL_P", "DEPENDS", + "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", "ROLLUP", "CUBE", + "GROUPING", "SETS", "TABLESAMPLE", "ORDINALITY", "XMLTABLE", "COLUMNS", + "XMLNAMESPACES", "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", "GROUPS", + "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", "VIEWS", "NORMALIZE", + "DUMP", "PRINT_STRICT_PARAMS", "VARIABLE_CONFLICT", "ERROR", "USE_VARIABLE", + "USE_COLUMN", "ALIAS", "CONSTANT", "PERFORM", "GET", "DIAGNOSTICS", + "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", "SLICE", "EXIT", + "RETURN", "QUERY", "RAISE", "SQLSTATE", "DEBUG", "LOG", "INFO", "NOTICE", + "WARNING", "EXCEPTION", "ASSERT", "LOOP", "OPEN", "ABS", "CBRT", "CEIL", + "CEILING", "DEGREES", "DIV", "EXP", "FACTORIAL", "FLOOR", "GCD", "LCM", + "LN", "LOG10", "MIN_SCALE", "MOD", "PI", "POWER", "RADIANS", "ROUND", + "SCALE", "SIGN", "SQRT", "TRIM_SCALE", "TRUNC", "WIDTH_BUCKET", "RANDOM", + "SETSEED", "ACOS", "ACOSD", "ASIN", "ASIND", "ATAN", "ATAND", "ATAN2", + "ATAN2D", "COS", "COSD", "COT", "COTD", "SIN", "SIND", "TAN", "TAND", + "SINH", "COSH", "TANH", "ASINH", "ACOSH", "ATANH", "BIT_LENGTH", "CHAR_LENGTH", + "CHARACTER_LENGTH", "LOWER", "OCTET_LENGTH", "UPPER", "ASCII", "BTRIM", + "CHR", "CONCAT", "CONCAT_WS", "FORMAT", "INITCAP", "LENGTH", "LPAD", + "LTRIM", "MD5", "PARSE_IDENT", "PG_CLIENT_ENCODING", "QUOTE_IDENT", + "QUOTE_LITERAL", "QUOTE_NULLABLE", "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE", + "REGEXP_MATCH", "REGEXP_MATCHES", "REGEXP_REPLACE", "REGEXP_SPLIT_TO_ARRAY", + "REGEXP_SPLIT_TO_TABLE", "REGEXP_SUBSTR", "REPEAT", "RPAD", "RTRIM", + "SPLIT_PART", "STARTS_WITH", "STRING_TO_ARRAY", "STRING_TO_TABLE", "STRPOS", + "SUBSTR", "TO_ASCII", "TO_HEX", "TRANSLATE", "UNISTR", "AGE", "CLOCK_TIMESTAMP", + "DATE_BIN", "DATE_PART", "DATE_TRUNC", "ISFINITE", "JUSTIFY_DAYS", "JUSTIFY_HOURS", + "JUSTIFY_INTERVAL", "MAKE_DATE", "MAKE_INTERVAL", "MAKE_TIME", "MAKE_TIMESTAMP", + "MAKE_TIMESTAMPTZ", "NOW", "STATEMENT_TIMESTAMP", "TIMEOFDAY", "TRANSACTION_TIMESTAMP", + "TO_TIMESTAMP", "TO_CHAR", "TO_DATE", "TO_NUMBER", "ENCODE", "DISTKEY", + "SORTKEY", "DISTSTYLE", "BACKUP", "COMPOUND", "INTERLEAVED", "EVEN", + "CASE_SENSITIVE", "QUOTA", "TB", "BOOST", "RECLUSTER", "SORT", "PERCENT_WORD", + "CASE_INSENSITIVE", "Identifier", "TemporaryIdentifier", "NamespaceUser", + "QuotedIdentifier", "UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", + "InvalidUnterminatedQuotedIdentifier", "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", + "InvalidUnicodeQuotedIdentifier", "InvalidUnterminatedUnicodeQuotedIdentifier", + "StringConstant", "UnterminatedStringConstant", "UnicodeEscapeStringConstant", + "UnterminatedUnicodeEscapeStringConstant", "BeginDollarStringConstant", + "BinaryStringConstant", "UnterminatedBinaryStringConstant", "InvalidBinaryStringConstant", + "InvalidUnterminatedBinaryStringConstant", "HexadecimalStringConstant", + "UnterminatedHexadecimalStringConstant", "InvalidHexadecimalStringConstant", + "InvalidUnterminatedHexadecimalStringConstant", "Integral", "NumericFail", + "Numeric", "PLSQLVARIABLENAME", "PLSQLIDENTIFIER", "Whitespace", "Newline", + "LineComment", "BlockComment", "UnterminatedBlockComment", "MetaCommand", + "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant", "UnterminatedEscapeStringConstant", + "InvalidEscapeStringConstant", "InvalidUnterminatedEscapeStringConstant", + "AfterEscapeStringConstantMode_NotContinued", "AfterEscapeStringConstantWithNewlineMode_NotContinued", + "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued", + } + staticData.RuleNames = []string{ + "root", "plsqlroot", "stmtblock", "stmtmulti", "stmt", "plsqlconsolecommand", + "callstmt", "createrolestmt", "opt_with", "optrolelist", "alteroptrolelist", + "alteroptroleelem", "createoptroleelem", "createuserstmt", "alterrolestmt", + "alterroleaction", "opt_in_database", "alterrolesetstmt", "alterschemastmt", + "droprolestmt", "dropuserstmt", "dropgroupstmt", "creategroupstmt", + "altergroupstmt", "add_drop", "createschemastmt", "opt_auth_clause", + "opt_quota", "optschemaeltlist", "schema_stmt", "variablesetstmt", "set_rest", + "generic_set", "set_rest_more", "var_name", "var_list", "var_value", + "iso_level", "opt_boolean_or_string", "zone_value", "opt_encoding", + "nonreservedword_or_sconst", "variableresetstmt", "reset_rest", "generic_reset", + "setresetclause", "functionsetresetclause", "variableshowstmt", "constraintssetstmt", + "constraints_set_list", "constraints_set_mode", "checkpointstmt", "discardstmt", + "altertablestmt", "alter_table_cmds", "table_constraint", "partition_cmd", + "index_partition_cmd", "alter_table_cmd", "alter_column_default", "opt_drop_behavior", + "opt_collate_clause", "alter_using", "replica_identity", "reloptions", + "opt_reloptions", "reloption_list", "reloption_elem", "alter_identity_column_option_list", + "alter_identity_column_option", "partitionboundspec", "hash_partbound_elem", + "hash_partbound", "altercompositetypestmt", "alter_type_cmds", "alter_type_cmd", + "closeportalstmt", "copystmt", "redshift_copy_authorization", "redshift_copy_format", + "redshift_copy_parameter", "copy_param_name", "copy_param_value", "copy_from", + "opt_program", "copy_file_name", "copy_options", "copy_opt_list", "copy_opt_item", + "opt_binary", "copy_delimiter", "opt_using", "copy_generic_opt_list", + "copy_generic_opt_elem", "copy_generic_opt_arg", "copy_generic_opt_arg_list", + "copy_generic_opt_arg_list_item", "createstmt", "opt_table_attributes", + "opttemp", "opttableelementlist", "opttypedtableelementlist", "tableelementlist", + "typedtableelementlist", "tableelement", "typedtableelement", "columnDef", + "rs_colattributes", "rs_colattribute", "columnOptions", "colquallist", + "colconstraint", "colconstraintelem", "opt_unique_null_treatment", "generated_when", + "constraintattr", "tablelikeclause", "tablelikeoptionlist", "tablelikeoption", + "tableconstraint", "constraintelem", "opt_no_inherit", "opt_column_list", + "columnlist", "columnElem", "opt_c_include", "key_match", "exclusionconstraintlist", + "exclusionconstraintelem", "exclusionwhereclause", "key_actions", "key_update", + "key_delete", "key_action", "optinherit", "optpartitionspec", "partitionspec", + "part_params", "part_elem", "table_access_method_clause", "optwith", + "oncommitoption", "opttablespace", "optredshifttableoptions", "redshifttableoption", + "sortkeyclause", "sortkeyclausetype", "optconstablespace", "existingindex", + "createstatsstmt", "alterstatsstmt", "createasstmt", "create_as_target", + "opt_backup_clause_table_attributes", "table_attributes", "opt_backup_clause", + "opt_with_data", "creatematviewstmt", "opt_auto_refresh", "refreshmatviewstmt", + "createseqstmt", "alterseqstmt", "optseqoptlist", "optparenthesizedseqoptlist", + "seqoptlist", "seqoptelem", "opt_by", "numericonly", "numericonly_list", + "createplangstmt", "opt_trusted", "handler_name", "opt_inline_handler", + "validator_clause", "opt_validator", "opt_procedural", "createtablespacestmt", + "opttablespaceowner", "droptablespacestmt", "createextensionstmt", "create_extension_opt_list", + "create_extension_opt_item", "alterextensionstmt", "alter_extension_opt_list", + "alter_extension_opt_item", "alterextensioncontentsstmt", "createfdwstmt", + "fdw_option", "fdw_options", "opt_fdw_options", "alterfdwstmt", "create_generic_options", + "generic_option_list", "alter_generic_options", "alter_generic_option_list", + "alter_generic_option_elem", "generic_option_elem", "generic_option_name", + "generic_option_arg", "createforeignserverstmt", "opt_type", "foreign_server_version", + "opt_foreign_server_version", "alterforeignserverstmt", "createforeigntablestmt", + "importforeignschemastmt", "import_qualification_type", "import_qualification", + "createusermappingstmt", "auth_ident", "dropusermappingstmt", "alterusermappingstmt", + "createpolicystmt", "alterpolicystmt", "rowsecurityoptionalexpr", "rowsecurityoptionalwithcheck", + "rowsecuritydefaulttorole", "rowsecurityoptionaltorole", "rowsecuritydefaultpermissive", + "rowsecuritydefaultforcmd", "row_security_cmd", "createamstmt", "am_type", + "createtrigstmt", "triggeractiontime", "triggerevents", "triggeroneevent", + "triggerreferencing", "triggertransitions", "triggertransition", "transitionoldornew", + "transitionrowortable", "transitionrelname", "triggerforspec", "triggerforopteach", + "triggerfortype", "triggerwhen", "function_or_procedure", "triggerfuncargs", + "triggerfuncarg", "optconstrfromtable", "constraintattributespec", "constraintattributeElem", + "createeventtrigstmt", "event_trigger_when_list", "event_trigger_when_item", + "event_trigger_value_list", "altereventtrigstmt", "enable_trigger", + "createassertionstmt", "definestmt", "definition", "def_list", "def_elem", + "def_arg", "old_aggr_definition", "old_aggr_list", "old_aggr_elem", + "opt_enum_val_list", "enum_val_list", "alterenumstmt", "opt_if_not_exists", + "createopclassstmt", "opclass_item_list", "opclass_item", "opt_default", + "opt_opfamily", "opclass_purpose", "opt_recheck", "createopfamilystmt", + "alteropfamilystmt", "opclass_drop_list", "opclass_drop", "dropopclassstmt", + "dropopfamilystmt", "dropownedstmt", "reassignownedstmt", "dropstmt", + "object_type_any_name", "object_type_name", "drop_type_name", "object_type_name_on_any_name", + "any_name_list", "any_name", "attrs", "type_name_list", "truncatestmt", + "opt_restart_seqs", "commentstmt", "comment_text", "seclabelstmt", "opt_provider", + "security_label", "fetchstmt", "fetch_args", "grantstmt", "grant_permissions_for_rls_lookup_tables", + "grant_explain_permissions_for_row_level_security_policy_filters", "grant_machine_learning_permissions", + "grant_role_permissions", "grant_role_permission_target_list", "grant_role_permission_target_list_item", + "system_permissions", "system_permissions_item", "opt_with_admin_option", + "grant_scoped_permissions", "grant_scoped_schemas_permissions", "grant_scoped_tables_permissions", + "grant_scoped_functions_permissions", "grant_scoped_procedures_permissions", + "grant_scoped_languages_permissions", "grant_scoped_copy_jobs_permissions", + "grantee_list_without_public", "grantee_without_public", "grant_datashare_permissions", + "grant_spectrum_integration_permissions", "grant_spectrum_integration_external_schema_permissions", + "spectrum_integration_external_schema_permission_list", "spectrum_integration_external_schema_permission", + "grant_spectrum_integration_external_table_permissions", "spectrum_integration_external_table_permission", + "spectrum_integration_external_table_permission_list", "grant_spectrum_integration_extenral_column_permissions", + "iamrolelist_or_public", "iamrolelist", "grant_assume_role_permissions", + "grant_assume_role_for_list", "grant_assume_role_for_item", "grant_assume_role_target", + "grant_column_level_permissions", "column_privilege_target", "column_privilege_list", + "column_all_privilege", "column_select_update_privilege", "common_grant", + "copy_job_privilege_list", "copy_job_privilege", "copy_job_target", + "copy_job_name", "language_privilege_list", "grant_language_target", + "grant_procedure_target", "procedure_privilege_list", "procedure_privilege", + "function_privilege_list", "function_privilege", "grant_function_target", + "grant_schema_target", "revoke_schema_target", "schema_privilege_list", + "schema_privilege", "database_privilege_list", "database_privilege", + "grant_database_target", "grant_table_target", "revoke_table_target", + "all_tables_in_schema_list", "all_privileges", "grantee_list", "grantee", + "opt_with_grant_option", "table_privilege", "table_privilege_list", + "revokestmt", "revoke_permissions_for_rls_lookup_tables", "revoke_explain_permissions_for_row_level_security_policy_filters", + "revoke_machine_learning_permissions", "revoke_role_permissions", "revoke_scoped_permissions", + "revoke_scoped_schemas_permissions", "revoke_scoped_tables_permissions", + "revoke_scoped_functions_permissions", "revoke_scoped_procedures_permissions", + "revoke_scoped_languages_permissions", "revoke_scoped_copy_jobs_permissions", + "revoke_datashare_permissions", "revoke_spectrum_integration_permissions", + "revoke_spectrum_integration_external_schema_permissions", "revoke_spectrum_integration_external_table_permissions", + "revoke_spectrum_integration_extenral_column_permissions", "revoke_assume_role_permissions", + "revoke_column_level_permissions", "common_revoke", "privileges", "privilege_list", + "privilege", "privilege_target", "parameter_name_list", "parameter_name", + "opt_grant_grant_option", "grantrolestmt", "revokerolestmt", "opt_grant_admin_option", + "opt_granted_by", "alterdefaultprivilegesstmt", "defacloptionlist", + "defacloption", "defaclaction", "defacl_privilege_target", "indexstmt", + "opt_unique", "opt_concurrently", "opt_index_name", "access_method_clause", + "index_params", "index_elem_options", "index_elem", "opt_include", "index_including_params", + "opt_collate", "opt_class", "opt_asc_desc", "opt_nulls_order", "createfunctionstmt", + "createprocedurestmt", "opt_nonatomic", "opt_or_replace", "func_py_args_or_sql_args", + "func_py_args_or_sql_args_list", "func_args", "func_args_list", "function_with_argtypes_list", + "function_with_argtypes", "func_args_with_defaults", "func_args_with_defaults_list", + "func_arg", "arg_class", "param_name", "func_return", "func_type", "func_arg_with_default", + "aggr_arg", "aggr_args", "aggr_args_list", "aggregate_with_argtypes", + "aggregate_with_argtypes_list", "createfunc_opt_list", "common_func_opt_item", + "createfunc_opt_item", "func_as", "transform_type_list", "opt_definition", + "table_func_column", "table_func_column_list", "alterfunctionstmt", + "alterprocedurestmt", "alterfunc_opt_list", "opt_restrict", "removefuncstmt", + "removeaggrstmt", "removeoperstmt", "oper_argtypes", "any_operator", + "operator_with_argtypes_list", "operator_with_argtypes", "dostmt", "dostmt_opt_list", + "dostmt_opt_item", "createcaststmt", "cast_context", "dropcaststmt", + "opt_if_exists", "createtransformstmt", "transform_element_list", "droptransformstmt", + "reindexstmt", "reindex_target_type", "reindex_target_multitable", "reindex_option_list", + "reindex_option_elem", "altertblspcstmt", "renamestmt", "opt_column", + "opt_set_data", "alterobjectdependsstmt", "opt_no", "alterobjectschemastmt", + "alteroperatorstmt", "operator_def_list", "operator_def_elem", "operator_def_arg", + "altertypestmt", "alterownerstmt", "createpublicationstmt", "pub_obj_list", + "publication_obj_spec", "opt_where_clause", "alterpublicationstmt", + "createsubscriptionstmt", "publication_name_list", "publication_name_item", + "altersubscriptionstmt", "dropsubscriptionstmt", "rulestmt", "ruleactionlist", + "ruleactionmulti", "ruleactionstmt", "ruleactionstmtOrEmpty", "event", + "opt_instead", "notifystmt", "notify_payload", "listenstmt", "unlistenstmt", + "transactionstmt", "opt_transaction", "transaction_mode_item", "transaction_mode_list", + "transaction_mode_list_or_empty", "opt_transaction_chain", "viewstmt", + "with_no_schema_binding", "opt_check_option", "loadstmt", "alterdatasharestmt", + "alterdatashare_action", "alterdatashare_add_drop", "alterdatashare_objects", + "datashare_table_list", "datashare_table_name", "table_name", "temporary_table_name", + "datashare_function_list", "datashare_function", "datashare_function_name", + "createdatasharestmt", "createdatashareoptions", "createdatashareoption", + "setpublicaccessibleoption", "managedbyoption", "descdatasharestmt", + "dropdatasharestmt", "alterexternalschemastmt", "altexternalschemaopts", + "alterexternalviewstmt", "createexternalschemastmt", "fromdatacatalogclause", + "dropschemastmt", "implicitdatacatalogclause", "fromhivemetastoreclause", + "frompostgresclause", "frommysqlclause", "fromkinesisclause", "fromkafkaclause", + "frommskclause", "fromredshiftclause", "iamrolevalue", "catalogrolevalue", + "authenticationvalue", "createexternalfunctionstmt", "external_func_params", + "paramlist", "param_spec", "createexternalmodelstmt", "createexternaltablestmt", + "extern_column_list", "extern_column_def", "extern_typename", "extern_table_format", + "row_format_spec", "serde_properties_list", "serde_property", "external_format_spec", + "table_properties_list", "table_property", "createexternalviewstmt", + "dropexternalviewstmt", "alteridentityproviderstmt", "alteridprovideropts", + "altermaskingpolicystmt", "altermaterializedviewstmt", "altmaskingpolicyopts", + "altmaskingpolicyargs", "altmaskingpolicyarg", "alterrlspolicystmt", + "attachmaskingpolicystmt", "attachpolicycollist", "attachpolicycolumn", + "attachpolicytargets", "attachpolicytarget", "attachrlspolicystmt", + "table_name_list", "createidentityproviderstmt", "createidprovideropts", + "groupfilter", "createlibrarystmt", "createlibraryopts", "createmaskingpolicystmt", + "inputcolumnlist", "inputcolumn", "maskingexpression", "createmodelstmt", + "createmodelfromclause", "iamrolespec", "sagemakerspec", "modeltypespec", + "problemtypespec", "problemtype", "objectivespec", "hyperparametersspec", + "hyperparameterslist", "hyperparameteritem", "settingsclause", "settingsitem", + "datatypelist", "datatype", "createrlspolicystmt", "descidentityproviderstmt", + "detachmaskingpolicystmt", "detachrlspolicystmt", "role_or_user_or_public_list", + "role_or_user_or_public", "rlspolicyname", "dropidentityproviderstmt", + "droplibrarystmt", "dropmaskingpolicystmt", "dropmodelstmt", "droprlspolicystmt", + "altertableappendstmt", "appendoptions", "alteruserstmt", "alteruseropts", + "analyzecompressionstmt", "cancelstmt", "closestmt", "insertexternaltablestmt", + "select_or_values", "selectintostmt", "setsessionauthorizationstmt", + "setsessioncharacteristicsstmt", "showcolumnsstmt", "showdatabasesstmt", + "showdbsopts", "showdatasharesstmt", "showexternaltablestmt", "showgrantsstmt", + "grantobject", "grantprincipal", "showmodelstmt", "showprocedurestmt", + "showschemasstmt", "showtablestmt", "showtablesstmt", "showviewstmt", + "unloadstmt", "iamroleclause", "unloadoptions", "formatoption", "partitionbyoption", + "manifestoption", "headeroption", "delimiteroption", "fixedwidthoption", + "encryptedoption", "kmskeyoption", "compressionoption", "addquotesoption", + "nullasoption", "escapeoption", "allowoverwriteoption", "cleanpathoption", + "paralleloption", "maxfilesizeoption", "rowgroupsizeoption", "sizeunit", + "regionoption", "extensionoption", "usestmt", "createdbstmt", "createdb_opt_list", + "createdb_opt_items", "createdb_opt_item", "createdb_opt_name", "opt_equal", + "alterdatabasestmt", "alterdatabasesetstmt", "dropdbstmt", "drop_option_list", + "drop_option", "altercollationstmt", "altersystemstmt", "createdomainstmt", + "alterdomainstmt", "opt_as", "altertsdictionarystmt", "altertsconfigurationstmt", + "any_with", "createconversionstmt", "clusterstmt", "cluster_index_specification", + "vacuumstmt", "vacuum_option", "analyzestmt", "vac_analyze_option_list", + "analyze_keyword", "vac_analyze_option_elem", "vac_analyze_option_name", + "vac_analyze_option_arg", "opt_analyze", "opt_verbose", "opt_full", + "opt_freeze", "opt_name_list", "vacuum_relation", "vacuum_relation_list", + "opt_vacuum_relation_list", "explainstmt", "explainablestmt", "explain_option_list", + "explain_option_elem", "explain_option_name", "explain_option_arg", + "preparestmt", "prep_type_clause", "preparablestmt", "executestmt", + "execute_param_clause", "deallocatestmt", "insertstmt", "insert_target", + "insert_rest", "override_kind", "insert_column_list", "insert_column_item", + "opt_on_conflict", "opt_conf_expr", "returning_clause", "mergestmt", + "merge_when_clause", "merge_insert_clause", "merge_update_clause", "merge_delete_clause", + "deletestmt", "using_clause", "lockstmt", "opt_lock", "lock_type", "opt_nowait", + "opt_nowait_or_skip", "updatestmt", "set_clause_list", "set_clause", + "set_target", "set_target_list", "declarecursorstmt", "cursor_name", + "cursor_options", "opt_hold", "selectstmt", "select_with_parens", "select_no_parens", + "select_clause", "simple_select_intersect", "simple_select_pramary", + "exclude_clause", "qualify_clause", "start_with_clause", "with_clause", + "cte_list", "common_table_expr", "opt_materialized", "opt_with_clause", + "into_clause", "opt_top_clause", "opt_strict", "opttempTableName", "opt_table", + "all_or_distinct", "distinct_clause", "opt_all_clause", "opt_sort_clause", + "sort_clause", "sortby_list", "sortby", "select_limit", "opt_select_limit", + "limit_clause", "offset_clause", "select_limit_value", "select_offset_value", + "select_fetch_first_value", "i_or_f_const", "row_or_rows", "first_or_next", + "group_clause", "group_by_list", "group_by_item", "empty_grouping_set", + "rollup_clause", "cube_clause", "grouping_sets_clause", "having_clause", + "for_locking_clause", "opt_for_locking_clause", "for_locking_items", + "for_locking_item", "for_locking_strength", "locked_rels_list", "values_clause", + "from_clause", "from_list", "table_ref", "joined_table", "alias_clause", + "opt_alias_clause", "table_alias_clause", "func_alias_clause", "join_type", + "join_qual", "relation_expr", "relation_expr_list", "relation_expr_opt_alias", + "tablesample_clause", "opt_repeatable_clause", "func_table", "rowsfrom_item", + "rowsfrom_list", "opt_col_def_list", "opt_ordinality", "where_clause", + "where_or_current_clause", "opttablefuncelementlist", "tablefuncelementlist", + "tablefuncelement", "xmltable", "xmltable_column_list", "xmltable_column_el", + "xmltable_column_option_list", "xmltable_column_option_el", "xml_namespace_list", + "xml_namespace_el", "typename", "opt_array_bounds", "simpletypename", + "varbyte", "json_type", "consttypename", "generictype", "opt_type_modifiers", + "numeric", "opt_float", "bit", "constbit", "bitwithlength", "bitwithoutlength", + "character", "constcharacter", "character_c", "opt_varying", "constdatetime", + "constinterval", "opt_timezone", "opt_interval", "interval_second", + "opt_escape", "a_expr", "a_expr_qual", "a_expr_lessless", "a_expr_or", + "a_expr_and", "a_expr_between", "a_expr_in", "a_expr_unary_not", "a_expr_isnull", + "a_expr_is_not", "a_expr_compare", "a_expr_prior_or_level", "a_expr_like", + "a_expr_qual_op", "a_expr_unary_qualop", "a_expr_add", "a_expr_mul", + "a_expr_caret", "a_expr_unary_sign", "a_expr_at_time_zone", "a_expr_collate", + "a_expr_typecast", "b_expr", "c_expr", "plsqlvariablename", "func_application", + "func_expr", "func_expr_windowless", "func_expr_common_subexpr", "xml_root_version", + "opt_xml_root_standalone", "xml_attributes", "xml_attribute_list", "xml_attribute_el", + "document_or_content", "xml_whitespace_option", "xmlexists_argument", + "xml_passing_mech", "within_group_clause", "filter_clause", "window_clause", + "window_definition_list", "window_definition", "over_clause", "window_specification", + "opt_existing_window_name", "opt_partition_clause", "opt_frame_clause", + "frame_extent", "frame_bound", "opt_window_exclusion_clause", "row", + "explicit_row", "implicit_row", "sub_type", "all_op", "mathop", "qual_op", + "qual_all_op", "subquery_Op", "expr_list", "func_arg_list", "func_arg_expr", + "type_list", "array_expr", "array_expr_list", "extract_list", "extract_arg", + "unicode_normal_form", "overlay_list", "position_list", "substr_list", + "trim_list", "in_expr", "case_expr", "when_clause_list", "when_clause", + "case_default", "case_arg", "columnref", "indirection_el", "opt_slice_bound", + "indirection", "opt_indirection", "opt_target_list", "target_list", + "target_el", "target_alias", "qualified_name_list", "qualified_name", + "name_list", "name", "attr_name", "file_name", "func_name", "aexprconst", + "xconst", "bconst", "fconst", "iconst", "sconst", "anysconst", "opt_uescape", + "signediconst", "roleid", "rolespec", "role_list", "colid", "table_alias", + "type_function_name", "nonreservedword", "collabel", "identifier", "plsqlidentifier", + "unreserved_keyword", "col_name_keyword", "type_func_name_keyword", + "reserved_keyword", "builtin_function_name", "pl_function", "comp_options", + "comp_option", "sharp", "option_value", "opt_semi", "pl_block", "decl_sect", + "decl_start", "decl_stmts", "label_decl", "decl_stmt", "decl_statement", + "opt_scrollable", "decl_cursor_query", "decl_cursor_args", "decl_cursor_arglist", + "decl_cursor_arg", "decl_is_for", "decl_aliasitem", "decl_varname", + "decl_const", "decl_datatype", "decl_collate", "decl_notnull", "decl_defval", + "decl_defkey", "assign_operator", "proc_sect", "proc_stmt", "stmt_perform", + "stmt_call", "opt_expr_list", "stmt_assign", "stmt_getdiag", "getdiag_area_opt", + "getdiag_list", "getdiag_list_item", "getdiag_item", "getdiag_target", + "assign_var", "stmt_if", "stmt_elsifs", "stmt_else", "stmt_case", "opt_expr_until_when", + "case_when_list", "case_when", "opt_case_else", "stmt_loop", "stmt_while", + "stmt_for", "for_control", "opt_for_using_expression", "opt_cursor_parameters", + "opt_reverse", "opt_by_expression", "for_variable", "stmt_foreach_a", + "foreach_slice", "stmt_exit", "exit_type", "stmt_return", "opt_return_result", + "stmt_raise", "opt_stmt_raise_level", "opt_raise_list", "opt_raise_using", + "opt_raise_using_elem", "opt_raise_using_elem_list", "stmt_assert", + "opt_stmt_assert_message", "loop_body", "stmt_execsql", "stmt_dynexecute", + "opt_execute_using", "opt_execute_using_list", "opt_execute_into", "stmt_open", + "opt_open_bound_list_item", "opt_open_bound_list", "opt_open_using", + "opt_scroll_option", "opt_scroll_option_no", "stmt_fetch", "into_target", + "opt_cursor_from", "opt_fetch_direction", "stmt_move", "stmt_close", + "stmt_null", "stmt_commit", "stmt_rollback", "plsql_opt_transaction_chain", + "stmt_set", "cursor_variable", "exception_sect", "proc_exceptions", + "proc_exception", "proc_conditions", "proc_condition", "opt_block_label", + "opt_loop_label", "opt_label", "opt_exitcond", "any_identifier", "plsql_unreserved_keyword", + "sql_expression", "expr_until_then", "expr_until_semi", "expr_until_rightbracket", + "expr_until_loop", "make_execsql_stmt", "opt_returning_clause_into", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 896, 15082, 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, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 3, 3, 2186, + 8, 3, 5, 3, 2188, 8, 3, 10, 3, 12, 3, 2191, 9, 3, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, + 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, + 4, 2376, 8, 4, 1, 5, 1, 5, 3, 5, 2380, 8, 5, 1, 6, 1, 6, 1, 6, 1, 7, 1, + 7, 1, 7, 1, 7, 3, 7, 2389, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 5, 9, 2396, + 8, 9, 10, 9, 12, 9, 2399, 9, 9, 1, 10, 1, 10, 1, 10, 5, 10, 2404, 8, 10, + 10, 10, 12, 10, 2407, 9, 10, 1, 10, 5, 10, 2410, 8, 10, 10, 10, 12, 10, + 2413, 9, 10, 3, 10, 2415, 8, 10, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2421, + 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2431, + 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2441, + 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, + 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2461, + 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 2468, 8, 11, 1, 12, 1, + 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 2480, + 8, 12, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 2486, 8, 13, 1, 13, 1, 13, 1, + 14, 1, 14, 1, 14, 1, 14, 3, 14, 2494, 8, 14, 1, 14, 1, 14, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 2507, 8, 15, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 3, 17, 2516, 8, 17, 1, 17, + 1, 17, 3, 17, 2520, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 3, 18, 2530, 8, 18, 1, 18, 3, 18, 2533, 8, 18, 1, 19, 1, 19, + 1, 19, 1, 19, 3, 19, 2539, 8, 19, 1, 20, 1, 20, 1, 20, 3, 20, 2544, 8, + 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, + 3, 22, 2556, 8, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, + 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 3, 25, 2572, 8, 25, 1, 25, + 1, 25, 3, 25, 2576, 8, 25, 1, 25, 3, 25, 2579, 8, 25, 1, 25, 3, 25, 2582, + 8, 25, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 2588, 8, 25, 1, 25, 3, 25, 2591, + 8, 25, 3, 25, 2593, 8, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 3, + 27, 2601, 8, 27, 1, 27, 3, 27, 2604, 8, 27, 1, 27, 3, 27, 2607, 8, 27, + 1, 28, 4, 28, 2610, 8, 28, 11, 28, 12, 28, 2611, 1, 29, 1, 29, 1, 29, 1, + 29, 1, 29, 1, 29, 3, 29, 2620, 8, 29, 1, 30, 1, 30, 3, 30, 2624, 8, 30, + 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 3, + 31, 2636, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, + 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, + 33, 2656, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, + 1, 33, 1, 33, 1, 33, 3, 33, 2669, 8, 33, 1, 34, 1, 34, 1, 34, 5, 34, 2674, + 8, 34, 10, 34, 12, 34, 2677, 9, 34, 1, 35, 1, 35, 1, 35, 5, 35, 2682, 8, + 35, 10, 35, 12, 35, 2685, 9, 35, 1, 36, 1, 36, 3, 36, 2689, 8, 36, 1, 37, + 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 2696, 8, 37, 1, 38, 1, 38, 1, 38, 1, + 38, 3, 38, 2702, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 2709, + 8, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 3, + 39, 2720, 8, 39, 1, 40, 1, 40, 3, 40, 2724, 8, 40, 1, 41, 1, 41, 3, 41, + 2728, 8, 41, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, + 43, 1, 43, 1, 43, 3, 43, 2741, 8, 43, 1, 44, 1, 44, 3, 44, 2745, 8, 44, + 1, 45, 1, 45, 1, 45, 3, 45, 2750, 8, 45, 1, 46, 1, 46, 1, 46, 3, 46, 2755, + 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, + 47, 1, 47, 1, 47, 1, 47, 3, 47, 2770, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, + 1, 48, 1, 49, 1, 49, 3, 49, 2779, 8, 49, 1, 50, 1, 50, 1, 51, 1, 51, 1, + 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 5, 53, 2794, + 8, 53, 10, 53, 12, 53, 2797, 9, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 3, 54, 2805, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2850, 8, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 3, 54, 2868, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, + 54, 2874, 8, 54, 1, 54, 1, 54, 3, 54, 2878, 8, 54, 1, 54, 3, 54, 2881, + 8, 54, 1, 54, 3, 54, 2884, 8, 54, 1, 54, 1, 54, 3, 54, 2888, 8, 54, 1, + 54, 1, 54, 3, 54, 2892, 8, 54, 1, 54, 1, 54, 3, 54, 2896, 8, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2905, 8, 54, 1, 54, 1, + 54, 3, 54, 2909, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 3, 54, 2919, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 2946, 8, + 54, 10, 54, 12, 54, 2949, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 3, 54, 2958, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 2971, 8, 54, 10, 54, 12, 54, + 2974, 9, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 2992, 8, 54, + 10, 54, 12, 54, 2995, 9, 54, 1, 54, 1, 54, 3, 54, 2999, 8, 54, 1, 55, 1, + 55, 3, 55, 3003, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, + 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, + 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 3027, 8, 55, 1, 56, 1, 56, 1, 56, + 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 3037, 8, 56, 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, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3061, + 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3068, 8, 58, 1, 58, 1, + 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3077, 8, 58, 1, 58, 1, 58, + 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3086, 8, 58, 1, 58, 1, 58, 1, + 58, 1, 58, 1, 58, 1, 58, 3, 58, 3094, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, + 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3104, 8, 58, 1, 58, 1, 58, 1, 58, 1, + 58, 1, 58, 1, 58, 1, 58, 3, 58, 3113, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, + 1, 58, 1, 58, 1, 58, 3, 58, 3122, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, + 58, 1, 58, 3, 58, 3130, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, + 3, 58, 3138, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, + 58, 3147, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, + 3156, 8, 58, 1, 58, 1, 58, 3, 58, 3160, 8, 58, 1, 58, 1, 58, 1, 58, 1, + 58, 1, 58, 3, 58, 3167, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, + 3, 58, 3175, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, + 58, 3, 58, 3185, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3191, 8, 58, + 1, 58, 1, 58, 3, 58, 3195, 8, 58, 1, 58, 1, 58, 3, 58, 3199, 8, 58, 1, + 58, 1, 58, 3, 58, 3203, 8, 58, 1, 58, 1, 58, 3, 58, 3207, 8, 58, 1, 58, + 1, 58, 1, 58, 3, 58, 3212, 8, 58, 1, 58, 3, 58, 3215, 8, 58, 1, 58, 1, + 58, 3, 58, 3219, 8, 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, 58, 1, 58, 1, 58, 1, 58, 1, + 58, 1, 58, 3, 58, 3240, 8, 58, 1, 58, 1, 58, 1, 58, 1, 58, 3, 58, 3246, + 8, 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, 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, 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, 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, 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, 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, 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, 3, 58, 3345, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, + 1, 59, 3, 59, 3352, 8, 59, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 62, 1, + 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 3368, 8, 63, + 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 5, + 66, 3380, 8, 66, 10, 66, 12, 66, 3383, 9, 66, 1, 67, 1, 67, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 67, 3, 67, 3392, 8, 67, 3, 67, 3394, 8, 67, 1, 68, 4, + 68, 3397, 8, 68, 11, 68, 12, 68, 3398, 1, 69, 1, 69, 3, 69, 3403, 8, 69, + 1, 69, 3, 69, 3406, 8, 69, 1, 69, 1, 69, 1, 69, 1, 69, 3, 69, 3412, 8, + 69, 3, 69, 3414, 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, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 3442, + 8, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 5, 72, 3450, 8, 72, 10, + 72, 12, 72, 3453, 9, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, + 1, 74, 5, 74, 3463, 8, 74, 10, 74, 12, 74, 3466, 9, 74, 1, 75, 1, 75, 1, + 75, 1, 75, 3, 75, 3472, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 3478, + 8, 75, 1, 75, 1, 75, 3, 75, 3482, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, + 75, 3488, 8, 75, 1, 75, 1, 75, 1, 75, 3, 75, 3493, 8, 75, 1, 75, 3, 75, + 3496, 8, 75, 3, 75, 3498, 8, 75, 1, 76, 1, 76, 1, 76, 3, 76, 3503, 8, 76, + 1, 77, 1, 77, 3, 77, 3507, 8, 77, 1, 77, 1, 77, 3, 77, 3511, 8, 77, 1, + 77, 1, 77, 3, 77, 3515, 8, 77, 1, 77, 1, 77, 3, 77, 3519, 8, 77, 1, 77, + 3, 77, 3522, 8, 77, 1, 77, 1, 77, 3, 77, 3526, 8, 77, 1, 77, 1, 77, 1, + 77, 1, 77, 1, 77, 1, 77, 3, 77, 3534, 8, 77, 1, 77, 1, 77, 3, 77, 3538, + 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 3545, 8, 77, 1, 77, 1, + 77, 1, 77, 1, 77, 3, 77, 3551, 8, 77, 1, 77, 5, 77, 3554, 8, 77, 10, 77, + 12, 77, 3557, 9, 77, 3, 77, 3559, 8, 77, 1, 78, 1, 78, 1, 78, 3, 78, 3564, + 8, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 3, 78, 3574, + 8, 78, 3, 78, 3576, 8, 78, 1, 79, 3, 79, 3579, 8, 79, 1, 79, 3, 79, 3582, + 8, 79, 1, 79, 1, 79, 3, 79, 3586, 8, 79, 1, 80, 1, 80, 3, 80, 3590, 8, + 80, 1, 80, 3, 80, 3593, 8, 80, 1, 81, 1, 81, 3, 81, 3597, 8, 81, 1, 82, + 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, + 82, 3610, 8, 82, 1, 83, 1, 83, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 3, 85, + 3619, 8, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 86, 3, 86, 3626, 8, 86, 1, + 87, 5, 87, 3629, 8, 87, 10, 87, 12, 87, 3632, 9, 87, 1, 88, 1, 88, 1, 88, + 1, 88, 3, 88, 3638, 8, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3643, 8, 88, 1, + 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3650, 8, 88, 1, 88, 1, 88, 1, 88, + 3, 88, 3655, 8, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, + 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, 3673, + 8, 88, 1, 89, 1, 89, 1, 90, 3, 90, 3678, 8, 90, 1, 90, 1, 90, 1, 90, 1, + 91, 1, 91, 1, 92, 1, 92, 1, 92, 5, 92, 3688, 8, 92, 10, 92, 12, 92, 3691, + 9, 92, 1, 93, 1, 93, 3, 93, 3695, 8, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, + 94, 1, 94, 1, 94, 3, 94, 3704, 8, 94, 1, 95, 1, 95, 1, 95, 5, 95, 3709, + 8, 95, 10, 95, 12, 95, 3712, 9, 95, 1, 96, 1, 96, 1, 97, 1, 97, 3, 97, + 3718, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3724, 8, 97, 1, 97, 1, + 97, 1, 97, 3, 97, 3729, 8, 97, 1, 97, 1, 97, 3, 97, 3733, 8, 97, 1, 97, + 5, 97, 3736, 8, 97, 10, 97, 12, 97, 3739, 9, 97, 1, 98, 1, 98, 1, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3749, 8, 98, 1, 98, 1, 98, 1, 98, + 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3758, 8, 98, 1, 99, 3, 99, 3761, 8, + 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, + 1, 102, 1, 102, 5, 102, 3774, 8, 102, 10, 102, 12, 102, 3777, 9, 102, 1, + 103, 1, 103, 1, 103, 5, 103, 3782, 8, 103, 10, 103, 12, 103, 3785, 9, 103, + 1, 104, 1, 104, 1, 104, 3, 104, 3790, 8, 104, 1, 105, 1, 105, 3, 105, 3794, + 8, 105, 1, 106, 1, 106, 1, 106, 3, 106, 3799, 8, 106, 1, 106, 3, 106, 3802, + 8, 106, 1, 107, 4, 107, 3805, 8, 107, 11, 107, 12, 107, 3806, 1, 108, 1, + 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, + 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, + 108, 3828, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, + 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, + 3845, 8, 108, 3, 108, 3847, 8, 108, 1, 109, 1, 109, 1, 109, 3, 109, 3852, + 8, 109, 1, 109, 1, 109, 1, 110, 5, 110, 3857, 8, 110, 10, 110, 12, 110, + 3860, 9, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 3, 111, 3870, 8, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, + 3877, 8, 112, 1, 112, 3, 112, 3880, 8, 112, 1, 112, 3, 112, 3883, 8, 112, + 1, 112, 1, 112, 1, 112, 3, 112, 3888, 8, 112, 1, 112, 3, 112, 3891, 8, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3898, 8, 112, 1, 112, + 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3907, 8, 112, 1, + 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 3914, 8, 112, 1, 112, 1, 112, + 1, 112, 3, 112, 3919, 8, 112, 1, 112, 3, 112, 3922, 8, 112, 1, 112, 3, + 112, 3925, 8, 112, 3, 112, 3927, 8, 112, 1, 113, 1, 113, 3, 113, 3931, + 8, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 3, 114, 3938, 8, 114, 1, + 115, 1, 115, 1, 115, 1, 115, 1, 115, 3, 115, 3945, 8, 115, 1, 116, 1, 116, + 1, 116, 1, 116, 1, 117, 1, 117, 5, 117, 3953, 8, 117, 10, 117, 12, 117, + 3956, 9, 117, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, + 119, 3965, 8, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 3, 120, 3975, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3981, + 8, 120, 1, 120, 3, 120, 3984, 8, 120, 1, 120, 3, 120, 3987, 8, 120, 1, + 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 3994, 8, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4002, 8, 120, 1, 120, 3, 120, 4005, + 8, 120, 1, 120, 3, 120, 4008, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, + 120, 3, 120, 4015, 8, 120, 1, 120, 1, 120, 3, 120, 4019, 8, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 3, 120, 4025, 8, 120, 1, 120, 3, 120, 4028, 8, + 120, 1, 120, 3, 120, 4031, 8, 120, 1, 120, 3, 120, 4034, 8, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, + 3, 120, 4046, 8, 120, 1, 120, 3, 120, 4049, 8, 120, 1, 120, 3, 120, 4052, + 8, 120, 1, 120, 1, 120, 3, 120, 4056, 8, 120, 1, 121, 1, 121, 1, 121, 1, + 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 5, 123, 4068, 8, 123, + 10, 123, 12, 123, 4071, 9, 123, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 5, 127, + 4086, 8, 127, 10, 127, 12, 127, 4089, 9, 127, 1, 128, 1, 128, 1, 128, 1, + 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 4099, 8, 128, 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, 3, 130, 4114, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, + 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, + 133, 1, 133, 3, 133, 4131, 8, 133, 3, 133, 4133, 8, 133, 1, 134, 1, 134, + 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1, 136, + 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, 137, 5, 137, 4152, 8, 137, 10, + 137, 12, 137, 4155, 9, 137, 1, 138, 1, 138, 3, 138, 4159, 8, 138, 1, 138, + 3, 138, 4162, 8, 138, 1, 138, 1, 138, 3, 138, 4166, 8, 138, 1, 138, 3, + 138, 4169, 8, 138, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, 4175, 8, 138, + 1, 138, 3, 138, 4178, 8, 138, 3, 138, 4180, 8, 138, 1, 139, 1, 139, 1, + 139, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4189, 8, 140, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4198, 8, 141, 1, 142, 1, + 142, 1, 142, 1, 143, 4, 143, 4204, 8, 143, 11, 143, 12, 143, 4205, 1, 144, + 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, + 1, 144, 1, 144, 3, 144, 4220, 8, 144, 1, 145, 3, 145, 4223, 8, 145, 1, + 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, + 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, + 149, 1, 149, 1, 149, 3, 149, 4246, 8, 149, 1, 149, 1, 149, 3, 149, 4250, + 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, + 1, 150, 3, 150, 4261, 8, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, + 151, 1, 151, 3, 151, 4270, 8, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, + 1, 152, 1, 152, 3, 152, 4279, 8, 152, 1, 152, 3, 152, 4282, 8, 152, 1, + 153, 1, 153, 5, 153, 4286, 8, 153, 10, 153, 12, 153, 4289, 9, 153, 1, 153, + 4, 153, 4292, 8, 153, 11, 153, 12, 153, 4293, 1, 153, 3, 153, 4297, 8, + 153, 1, 153, 5, 153, 4300, 8, 153, 10, 153, 12, 153, 4303, 9, 153, 3, 153, + 4305, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, + 154, 3, 154, 4315, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, + 4322, 8, 154, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 3, + 156, 4331, 8, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 3, 157, 4338, + 8, 157, 1, 157, 5, 157, 4341, 8, 157, 10, 157, 12, 157, 4344, 9, 157, 1, + 157, 3, 157, 4347, 8, 157, 1, 157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 4360, 8, 159, 1, 159, 1, + 159, 3, 159, 4364, 8, 159, 1, 159, 3, 159, 4367, 8, 159, 1, 160, 1, 160, + 3, 160, 4371, 8, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 4377, 8, + 160, 1, 160, 1, 160, 3, 160, 4381, 8, 160, 1, 161, 1, 161, 1, 161, 1, 161, + 3, 161, 4387, 8, 161, 1, 161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 163, 1, + 163, 1, 163, 1, 163, 1, 164, 4, 164, 4399, 8, 164, 11, 164, 12, 164, 4400, + 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4410, 8, + 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, + 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4428, + 8, 165, 1, 165, 1, 165, 1, 165, 3, 165, 4433, 8, 165, 1, 165, 3, 165, 4436, + 8, 165, 1, 165, 3, 165, 4439, 8, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, + 167, 1, 167, 1, 167, 1, 167, 3, 167, 4449, 8, 167, 1, 168, 1, 168, 1, 168, + 5, 168, 4454, 8, 168, 10, 168, 12, 168, 4457, 9, 168, 1, 169, 1, 169, 3, + 169, 4461, 8, 169, 1, 169, 3, 169, 4464, 8, 169, 1, 169, 3, 169, 4467, + 8, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 4474, 8, 169, 1, + 169, 3, 169, 4477, 8, 169, 3, 169, 4479, 8, 169, 1, 170, 1, 170, 1, 171, + 1, 171, 3, 171, 4485, 8, 171, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, + 173, 1, 173, 3, 173, 4494, 8, 173, 1, 174, 1, 174, 1, 175, 1, 175, 1, 176, + 1, 176, 1, 176, 1, 176, 3, 176, 4504, 8, 176, 1, 176, 1, 176, 1, 176, 3, + 176, 4509, 8, 176, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, + 3, 178, 4518, 8, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, + 179, 3, 179, 4527, 8, 179, 1, 179, 1, 179, 3, 179, 4531, 8, 179, 1, 179, + 1, 179, 1, 180, 5, 180, 4536, 8, 180, 10, 180, 12, 180, 4539, 9, 180, 1, + 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 3, 181, 4548, 8, 181, + 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 183, 5, 183, 4557, 8, + 183, 10, 183, 12, 183, 4560, 9, 183, 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, 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, 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, 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, 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, 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, 185, 1, 185, 3, 185, 4669, 8, 185, 1, 186, 1, 186, 1, 186, + 1, 186, 1, 186, 1, 186, 3, 186, 4677, 8, 186, 1, 186, 3, 186, 4680, 8, + 186, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 187, 3, + 187, 4690, 8, 187, 1, 188, 4, 188, 4693, 8, 188, 11, 188, 12, 188, 4694, + 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, + 4705, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, + 190, 1, 190, 3, 190, 4716, 8, 190, 1, 191, 1, 191, 1, 191, 1, 191, 1, 191, + 1, 192, 1, 192, 1, 192, 5, 192, 4726, 8, 192, 10, 192, 12, 192, 4729, 9, + 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 5, + 194, 4739, 8, 194, 10, 194, 12, 194, 4742, 9, 194, 1, 195, 1, 195, 1, 195, + 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 4751, 8, 195, 1, 196, 1, 196, 1, + 196, 1, 197, 1, 197, 1, 198, 1, 198, 1, 199, 1, 199, 1, 199, 1, 199, 3, + 199, 4764, 8, 199, 1, 199, 3, 199, 4767, 8, 199, 1, 199, 1, 199, 1, 199, + 1, 199, 1, 199, 3, 199, 4774, 8, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 3, 199, 4783, 8, 199, 1, 199, 3, 199, 4786, 8, 199, + 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 3, 199, 4793, 8, 199, 3, 199, 4795, + 8, 199, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 3, 201, 4803, 8, + 201, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, + 203, 4813, 8, 203, 3, 203, 4815, 8, 203, 1, 204, 1, 204, 1, 204, 1, 204, + 1, 204, 1, 204, 3, 204, 4823, 8, 204, 1, 204, 1, 204, 3, 204, 4827, 8, + 204, 1, 204, 1, 204, 1, 204, 3, 204, 4832, 8, 204, 1, 204, 1, 204, 1, 204, + 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4843, 8, 204, 1, + 204, 1, 204, 3, 204, 4847, 8, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4852, + 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, + 3, 204, 4862, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 3, 204, 4868, 8, + 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, + 204, 1, 204, 1, 204, 3, 204, 4881, 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, + 3, 204, 4887, 8, 204, 3, 204, 4889, 8, 204, 1, 205, 1, 205, 1, 205, 1, + 205, 1, 205, 3, 205, 4896, 8, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, + 1, 205, 3, 205, 4904, 8, 205, 1, 206, 1, 206, 1, 206, 3, 206, 4909, 8, + 206, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, 208, 4924, 8, 208, 1, 208, 1, 208, + 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, + 3, 208, 4937, 8, 208, 3, 208, 4939, 8, 208, 1, 209, 1, 209, 3, 209, 4943, + 8, 209, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, + 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, + 1, 210, 3, 210, 4963, 8, 210, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, + 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, + 212, 3, 212, 4980, 8, 212, 1, 212, 3, 212, 4983, 8, 212, 1, 212, 3, 212, + 4986, 8, 212, 1, 212, 3, 212, 4989, 8, 212, 1, 212, 3, 212, 4992, 8, 212, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 5000, 8, 213, 1, + 213, 3, 213, 5003, 8, 213, 1, 213, 3, 213, 5006, 8, 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, 217, 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, + 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, + 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 223, 1, 223, + 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5052, 8, 223, 1, + 223, 3, 223, 5055, 8, 223, 1, 223, 3, 223, 5058, 8, 223, 1, 223, 1, 223, + 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, + 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5076, 8, 223, 1, 223, 1, + 223, 1, 223, 1, 223, 1, 223, 3, 223, 5083, 8, 223, 1, 223, 1, 223, 1, 223, + 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5092, 8, 223, 1, 224, 1, 224, 1, + 224, 1, 224, 3, 224, 5098, 8, 224, 1, 225, 1, 225, 1, 225, 5, 225, 5103, + 8, 225, 10, 225, 12, 225, 5106, 9, 225, 1, 226, 1, 226, 1, 226, 1, 226, + 1, 226, 1, 226, 1, 226, 3, 226, 5115, 8, 226, 1, 227, 1, 227, 1, 227, 1, + 228, 4, 228, 5121, 8, 228, 11, 228, 12, 228, 5122, 1, 229, 1, 229, 1, 229, + 3, 229, 5128, 8, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 231, 1, 231, 1, + 232, 1, 232, 1, 233, 1, 233, 3, 233, 5140, 8, 233, 1, 233, 1, 233, 1, 234, + 1, 234, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, + 1, 237, 1, 238, 1, 238, 3, 238, 5157, 8, 238, 1, 238, 1, 238, 5, 238, 5161, + 8, 238, 10, 238, 12, 238, 5164, 9, 238, 1, 239, 1, 239, 1, 239, 1, 239, + 3, 239, 5170, 8, 239, 1, 240, 1, 240, 1, 240, 1, 241, 5, 241, 5176, 8, + 241, 10, 241, 12, 241, 5179, 9, 241, 1, 242, 1, 242, 1, 242, 1, 242, 1, + 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 3, 242, 5192, 8, 242, + 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, + 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, + 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, + 5220, 8, 243, 1, 244, 1, 244, 1, 244, 5, 244, 5225, 8, 244, 10, 244, 12, + 244, 5228, 9, 244, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 246, + 1, 246, 1, 246, 5, 246, 5239, 8, 246, 10, 246, 12, 246, 5242, 9, 246, 1, + 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 1, 248, 1, 248, 1, + 248, 1, 248, 1, 248, 3, 248, 5256, 8, 248, 1, 249, 1, 249, 1, 249, 1, 249, + 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 250, 1, 250, 3, 250, 5269, 8, + 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5278, + 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5303, 8, 250, 1, + 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 3, + 250, 5314, 8, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, 250, + 1, 250, 1, 250, 1, 250, 1, 250, 3, 250, 5381, 8, 250, 1, 251, 1, 251, 1, + 251, 1, 251, 1, 252, 1, 252, 1, 252, 5, 252, 5390, 8, 252, 10, 252, 12, + 252, 5393, 9, 252, 1, 253, 1, 253, 1, 253, 3, 253, 5398, 8, 253, 1, 254, + 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 3, 254, 5406, 8, 254, 1, 255, 1, + 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 5, 256, 5415, 8, 256, 10, + 256, 12, 256, 5418, 9, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 258, 1, + 258, 1, 259, 1, 259, 1, 259, 5, 259, 5429, 8, 259, 10, 259, 12, 259, 5432, + 9, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, 260, 5440, 8, + 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, + 260, 5450, 8, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, + 1, 260, 1, 260, 1, 260, 3, 260, 5462, 8, 260, 1, 260, 1, 260, 1, 260, 1, + 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, + 260, 3, 260, 5477, 8, 260, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, + 1, 262, 1, 262, 1, 262, 3, 262, 5488, 8, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 3, 262, 5496, 8, 262, 1, 262, 1, 262, 1, 262, 1, 263, + 1, 263, 1, 263, 5, 263, 5504, 8, 263, 10, 263, 12, 263, 5507, 9, 263, 1, + 264, 1, 264, 1, 264, 1, 264, 3, 264, 5513, 8, 264, 1, 264, 3, 264, 5516, + 8, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 5522, 8, 264, 1, 264, 3, + 264, 5525, 8, 264, 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, 264, 3, 264, 5540, 8, 264, 1, + 265, 1, 265, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, + 267, 1, 267, 3, 267, 5553, 8, 267, 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, 270, 1, 270, 1, 270, 3, 270, 5582, 8, 270, 1, 271, 1, 271, 1, + 271, 5, 271, 5587, 8, 271, 10, 271, 12, 271, 5590, 9, 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, 3, 272, 5604, 8, 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, + 273, 1, 273, 3, 273, 5613, 8, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, + 1, 273, 1, 273, 1, 273, 1, 273, 3, 273, 5624, 8, 273, 3, 273, 5626, 8, + 273, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 5635, + 8, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, + 1, 274, 3, 274, 5646, 8, 274, 3, 274, 5648, 8, 274, 1, 275, 1, 275, 1, + 275, 1, 275, 1, 275, 3, 275, 5655, 8, 275, 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, + 3, 277, 5670, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5676, 8, + 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5684, 8, 277, + 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5690, 8, 277, 1, 277, 1, 277, 1, + 277, 1, 277, 1, 277, 1, 277, 3, 277, 5698, 8, 277, 1, 277, 1, 277, 1, 277, + 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5708, 8, 277, 1, 277, 1, + 277, 1, 277, 1, 277, 3, 277, 5714, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, + 1, 277, 1, 277, 3, 277, 5722, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, + 277, 5728, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, + 5736, 8, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5743, 8, + 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 5752, + 8, 277, 3, 277, 5754, 8, 277, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, + 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, + 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 3, + 278, 5779, 8, 278, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 3, 279, + 5787, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, + 280, 1, 280, 3, 280, 5798, 8, 280, 1, 280, 1, 280, 1, 280, 3, 280, 5803, + 8, 280, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 5, 282, 5810, 8, 282, 10, + 282, 12, 282, 5813, 9, 282, 1, 283, 1, 283, 3, 283, 5817, 8, 283, 1, 284, + 1, 284, 4, 284, 5821, 8, 284, 11, 284, 12, 284, 5822, 1, 285, 1, 285, 1, + 285, 5, 285, 5828, 8, 285, 10, 285, 12, 285, 5831, 9, 285, 1, 286, 1, 286, + 3, 286, 5835, 8, 286, 1, 286, 1, 286, 3, 286, 5839, 8, 286, 1, 286, 3, + 286, 5842, 8, 286, 1, 287, 1, 287, 1, 287, 1, 287, 3, 287, 5848, 8, 287, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, + 1, 288, 1, 288, 1, 288, 3, 288, 5997, 8, 288, 1, 289, 1, 289, 3, 289, 6001, + 8, 289, 1, 290, 1, 290, 1, 290, 3, 290, 6006, 8, 290, 1, 290, 1, 290, 1, + 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6017, 8, 290, + 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, + 3, 290, 6028, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, + 290, 1, 290, 1, 290, 3, 290, 6039, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, + 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6050, 8, 290, 1, 290, 1, + 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6061, + 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, + 1, 290, 3, 290, 6072, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, + 290, 1, 290, 1, 290, 1, 290, 3, 290, 6083, 8, 290, 1, 290, 1, 290, 1, 290, + 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 3, 290, 6095, 8, + 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, + 290, 3, 290, 6106, 8, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, + 3, 290, 6114, 8, 290, 1, 291, 1, 291, 1, 291, 1, 292, 1, 292, 3, 292, 6121, + 8, 292, 1, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, + 1, 294, 1, 294, 1, 294, 1, 294, 3, 294, 6135, 8, 294, 1, 294, 1, 294, 1, + 294, 1, 294, 3, 294, 6141, 8, 294, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 3, 295, 6153, 8, 295, 1, 296, 1, + 296, 1, 296, 1, 296, 3, 296, 6159, 8, 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, 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, 3, 298, 6187, 8, 298, 1, 299, 1, 299, 1, + 299, 1, 299, 1, 299, 1, 299, 5, 299, 6195, 8, 299, 10, 299, 12, 299, 6198, + 9, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, + 1, 299, 3, 299, 6209, 8, 299, 1, 300, 1, 300, 1, 300, 5, 300, 6214, 8, + 300, 10, 300, 12, 300, 6217, 9, 300, 1, 301, 1, 301, 3, 301, 6221, 8, 301, + 1, 301, 1, 301, 3, 301, 6225, 8, 301, 1, 302, 1, 302, 1, 302, 5, 302, 6230, + 8, 302, 10, 302, 12, 302, 6233, 9, 302, 1, 302, 3, 302, 6236, 8, 302, 1, + 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, + 303, 1, 303, 3, 303, 6249, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 1, 303, 1, 303, 3, 303, 6259, 8, 303, 1, 303, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 303, 3, 303, 6267, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 3, 303, 6274, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, + 303, 1, 303, 1, 303, 1, 303, 3, 303, 6294, 8, 303, 1, 304, 1, 304, 1, 304, + 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 6306, 8, + 305, 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, 3, 307, 6327, 8, 307, 1, 307, 1, 307, 3, 307, 6331, 8, 307, + 1, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, + 1, 308, 1, 308, 1, 308, 3, 308, 6345, 8, 308, 1, 308, 1, 308, 3, 308, 6349, + 8, 308, 1, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, + 1, 309, 1, 309, 1, 309, 1, 309, 3, 309, 6363, 8, 309, 1, 309, 1, 309, 3, + 309, 6367, 8, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, 1, 310, 1, 310, + 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, + 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 3, 311, 6392, 8, + 311, 1, 311, 1, 311, 3, 311, 6396, 8, 311, 1, 311, 1, 311, 1, 311, 1, 312, + 1, 312, 1, 312, 5, 312, 6404, 8, 312, 10, 312, 12, 312, 6407, 9, 312, 1, + 313, 1, 313, 3, 313, 6411, 8, 313, 1, 313, 1, 313, 3, 313, 6415, 8, 313, + 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, + 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, + 1, 314, 1, 314, 1, 314, 3, 314, 6438, 8, 314, 3, 314, 6440, 8, 314, 1, + 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 3, 314, 6449, 8, 314, + 1, 314, 1, 314, 1, 314, 3, 314, 6454, 8, 314, 1, 315, 1, 315, 1, 315, 3, + 315, 6459, 8, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, + 1, 316, 1, 316, 3, 316, 6470, 8, 316, 1, 317, 1, 317, 1, 317, 5, 317, 6475, + 8, 317, 10, 317, 12, 317, 6478, 9, 317, 1, 317, 3, 317, 6481, 8, 317, 1, + 318, 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, + 319, 1, 319, 3, 319, 6494, 8, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, + 1, 320, 3, 320, 6502, 8, 320, 1, 321, 1, 321, 1, 321, 5, 321, 6507, 8, + 321, 10, 321, 12, 321, 6510, 9, 321, 1, 322, 1, 322, 1, 322, 3, 322, 6515, + 8, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, + 1, 322, 1, 322, 3, 322, 6527, 8, 322, 1, 323, 1, 323, 3, 323, 6531, 8, + 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 5, 324, 6538, 8, 324, 10, + 324, 12, 324, 6541, 9, 324, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, + 325, 1, 325, 1, 325, 1, 326, 1, 326, 1, 326, 5, 326, 6554, 8, 326, 10, + 326, 12, 326, 6557, 9, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, + 327, 1, 327, 3, 327, 6566, 8, 327, 1, 328, 1, 328, 1, 328, 5, 328, 6571, + 8, 328, 10, 328, 12, 328, 6574, 9, 328, 1, 328, 1, 328, 3, 328, 6578, 8, + 328, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 3, + 330, 6588, 8, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 5, 331, 6595, + 8, 331, 10, 331, 12, 331, 6598, 9, 331, 1, 331, 1, 331, 1, 331, 5, 331, + 6603, 8, 331, 10, 331, 12, 331, 6606, 9, 331, 3, 331, 6608, 8, 331, 1, + 332, 1, 332, 3, 332, 6612, 8, 332, 1, 332, 1, 332, 3, 332, 6616, 8, 332, + 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 3, 333, 6623, 8, 333, 1, 333, 1, + 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 6676, 8, 334, 1, 335, 1, 335, + 1, 335, 5, 335, 6681, 8, 335, 10, 335, 12, 335, 6684, 9, 335, 1, 335, 3, + 335, 6687, 8, 335, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, + 5, 337, 6696, 8, 337, 10, 337, 12, 337, 6699, 9, 337, 1, 338, 1, 338, 1, + 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 341, 1, 341, 1, 341, 1, 341, 5, + 341, 6712, 8, 341, 10, 341, 12, 341, 6715, 9, 341, 1, 341, 1, 341, 1, 341, + 1, 341, 1, 341, 3, 341, 6722, 8, 341, 1, 342, 1, 342, 3, 342, 6726, 8, + 342, 1, 343, 1, 343, 3, 343, 6730, 8, 343, 1, 344, 1, 344, 3, 344, 6734, + 8, 344, 1, 345, 1, 345, 3, 345, 6738, 8, 345, 1, 346, 1, 346, 1, 346, 1, + 346, 5, 346, 6744, 8, 346, 10, 346, 12, 346, 6747, 9, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 3, 346, 6754, 8, 346, 1, 347, 1, 347, 1, 347, 1, + 347, 5, 347, 6760, 8, 347, 10, 347, 12, 347, 6763, 9, 347, 1, 348, 1, 348, + 1, 348, 3, 348, 6768, 8, 348, 1, 348, 1, 348, 1, 348, 5, 348, 6773, 8, + 348, 10, 348, 12, 348, 6776, 9, 348, 1, 349, 1, 349, 1, 349, 5, 349, 6781, + 8, 349, 10, 349, 12, 349, 6784, 9, 349, 1, 349, 3, 349, 6787, 8, 349, 1, + 350, 1, 350, 1, 351, 1, 351, 1, 351, 5, 351, 6794, 8, 351, 10, 351, 12, + 351, 6797, 9, 351, 1, 351, 3, 351, 6800, 8, 351, 1, 352, 1, 352, 1, 353, + 1, 353, 1, 353, 1, 353, 5, 353, 6808, 8, 353, 10, 353, 12, 353, 6811, 9, + 353, 1, 354, 3, 354, 6814, 8, 354, 1, 354, 1, 354, 3, 354, 6818, 8, 354, + 1, 355, 3, 355, 6821, 8, 355, 1, 355, 1, 355, 3, 355, 6825, 8, 355, 1, + 355, 1, 355, 3, 355, 6829, 8, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, + 1, 356, 1, 357, 1, 357, 3, 357, 6839, 8, 357, 1, 358, 1, 358, 1, 358, 5, + 358, 6844, 8, 358, 10, 358, 12, 358, 6847, 9, 358, 1, 359, 1, 359, 3, 359, + 6851, 8, 359, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 3, 359, 6858, 8, + 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 362, 1, 362, 1, + 362, 5, 362, 6869, 8, 362, 10, 362, 12, 362, 6872, 9, 362, 1, 362, 3, 362, + 6875, 8, 362, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, 363, 1, + 363, 1, 363, 1, 363, 3, 363, 6887, 8, 363, 1, 364, 1, 364, 1, 364, 1, 364, + 3, 364, 6893, 8, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 3, + 364, 6901, 8, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, + 3, 365, 6910, 8, 365, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 3, + 366, 6918, 8, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, 1, 366, + 1, 366, 3, 366, 6928, 8, 366, 3, 366, 6930, 8, 366, 1, 367, 1, 367, 1, + 367, 1, 367, 1, 367, 1, 367, 5, 367, 6938, 8, 367, 10, 367, 12, 367, 6941, + 9, 367, 1, 367, 1, 367, 1, 367, 3, 367, 6946, 8, 367, 1, 367, 1, 367, 1, + 367, 1, 367, 1, 367, 1, 367, 3, 367, 6954, 8, 367, 1, 367, 1, 367, 1, 367, + 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 5, 367, 6965, 8, 367, 10, + 367, 12, 367, 6968, 9, 367, 1, 367, 1, 367, 1, 367, 3, 367, 6973, 8, 367, + 3, 367, 6975, 8, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 3, + 368, 6983, 8, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, + 1, 369, 1, 369, 1, 369, 3, 369, 6995, 8, 369, 1, 370, 1, 370, 1, 370, 1, + 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 7006, 8, 370, 1, 370, + 1, 370, 3, 370, 7010, 8, 370, 1, 370, 1, 370, 1, 370, 3, 370, 7015, 8, + 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, + 371, 3, 371, 7026, 8, 371, 1, 371, 1, 371, 3, 371, 7030, 8, 371, 1, 371, + 1, 371, 1, 371, 3, 371, 7035, 8, 371, 1, 372, 1, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7046, 8, 372, 1, 372, 1, 372, + 3, 372, 7050, 8, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7055, 8, 372, 1, + 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, + 373, 3, 373, 7067, 8, 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 7079, 8, 374, 1, 374, 1, 374, 3, + 374, 7083, 8, 374, 1, 374, 1, 374, 1, 374, 3, 374, 7088, 8, 374, 1, 375, + 1, 375, 1, 375, 1, 375, 3, 375, 7094, 8, 375, 1, 375, 1, 375, 1, 375, 1, + 375, 1, 375, 1, 375, 1, 375, 3, 375, 7103, 8, 375, 1, 375, 1, 375, 1, 375, + 1, 375, 3, 375, 7109, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, + 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7122, 8, 375, 3, 375, + 7124, 8, 375, 1, 375, 3, 375, 7127, 8, 375, 1, 375, 1, 375, 1, 375, 1, + 375, 3, 375, 7133, 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, + 3, 375, 7141, 8, 375, 1, 375, 1, 375, 1, 375, 3, 375, 7146, 8, 375, 3, + 375, 7148, 8, 375, 1, 376, 1, 376, 1, 376, 3, 376, 7153, 8, 376, 1, 377, + 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 3, 377, + 7164, 8, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, + 378, 1, 378, 3, 378, 7175, 8, 378, 1, 379, 1, 379, 1, 379, 3, 379, 7180, + 8, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, + 1, 379, 1, 379, 3, 379, 7192, 8, 379, 1, 380, 1, 380, 1, 380, 1, 380, 1, + 380, 1, 380, 1, 380, 1, 380, 3, 380, 7202, 8, 380, 1, 381, 1, 381, 1, 381, + 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 7211, 8, 381, 1, 381, 1, 381, 1, + 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 7223, + 8, 381, 3, 381, 7225, 8, 381, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7231, + 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7239, 8, + 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7245, 8, 382, 1, 382, 1, 382, + 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7253, 8, 382, 1, 382, 1, 382, 1, + 382, 1, 382, 3, 382, 7259, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, + 1, 382, 3, 382, 7267, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7273, + 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7281, 8, + 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7287, 8, 382, 1, 382, 1, 382, + 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7295, 8, 382, 1, 382, 1, 382, 1, + 382, 1, 382, 3, 382, 7301, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, + 1, 382, 3, 382, 7309, 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7315, + 8, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 3, 382, 7323, 8, + 382, 3, 382, 7325, 8, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 3, 383, 7342, 8, 383, 1, 384, 1, 384, 1, 384, 5, 384, 7347, 8, 384, 10, + 384, 12, 384, 7350, 9, 384, 1, 385, 1, 385, 3, 385, 7354, 8, 385, 1, 385, + 1, 385, 3, 385, 7358, 8, 385, 1, 385, 1, 385, 3, 385, 7362, 8, 385, 1, + 385, 1, 385, 1, 385, 1, 385, 3, 385, 7368, 8, 385, 3, 385, 7370, 8, 385, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 3, 386, 7432, 8, 386, 1, + 387, 1, 387, 1, 387, 5, 387, 7437, 8, 387, 10, 387, 12, 387, 7440, 9, 387, + 1, 388, 1, 388, 1, 388, 3, 388, 7445, 8, 388, 1, 389, 1, 389, 1, 389, 1, + 389, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 3, 390, 7456, 8, 390, 1, 390, + 3, 390, 7459, 8, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 3, 391, 7466, + 8, 391, 1, 391, 3, 391, 7469, 8, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, + 391, 1, 391, 1, 391, 1, 391, 3, 391, 7479, 8, 391, 1, 391, 3, 391, 7482, + 8, 391, 3, 391, 7484, 8, 391, 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, + 393, 1, 393, 1, 393, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, + 395, 5, 395, 7501, 8, 395, 10, 395, 12, 395, 7504, 9, 395, 1, 396, 1, 396, + 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 3, 396, 7515, 8, + 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, 7524, + 8, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, 397, + 7533, 8, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 1, + 397, 1, 397, 1, 397, 3, 397, 7545, 8, 397, 3, 397, 7547, 8, 397, 1, 398, + 1, 398, 1, 399, 1, 399, 3, 399, 7553, 8, 399, 1, 399, 1, 399, 3, 399, 7557, + 8, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7562, 8, 399, 1, 399, 3, 399, 7565, + 8, 399, 1, 399, 1, 399, 1, 399, 3, 399, 7570, 8, 399, 1, 399, 1, 399, 1, + 399, 1, 399, 3, 399, 7576, 8, 399, 1, 399, 3, 399, 7579, 8, 399, 1, 399, + 3, 399, 7582, 8, 399, 1, 399, 3, 399, 7585, 8, 399, 1, 399, 3, 399, 7588, + 8, 399, 1, 400, 1, 400, 1, 401, 1, 401, 1, 402, 1, 402, 1, 403, 1, 403, + 1, 403, 1, 404, 1, 404, 1, 404, 5, 404, 7602, 8, 404, 10, 404, 12, 404, + 7605, 9, 404, 1, 405, 3, 405, 7608, 8, 405, 1, 405, 3, 405, 7611, 8, 405, + 1, 405, 3, 405, 7614, 8, 405, 1, 405, 3, 405, 7617, 8, 405, 1, 405, 3, + 405, 7620, 8, 405, 1, 405, 1, 405, 1, 405, 3, 405, 7625, 8, 405, 1, 405, + 3, 405, 7628, 8, 405, 3, 405, 7630, 8, 405, 1, 406, 1, 406, 1, 406, 1, + 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 3, 406, 7643, + 8, 406, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, + 5, 408, 7653, 8, 408, 10, 408, 12, 408, 7656, 9, 408, 1, 409, 1, 409, 1, + 409, 1, 410, 1, 410, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, 3, + 412, 7669, 8, 412, 1, 413, 1, 413, 3, 413, 7673, 8, 413, 1, 413, 1, 413, + 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 3, 413, + 7685, 8, 413, 3, 413, 7687, 8, 413, 1, 413, 1, 413, 1, 413, 1, 414, 1, + 414, 3, 414, 7694, 8, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, + 1, 414, 1, 414, 1, 414, 1, 414, 3, 414, 7706, 8, 414, 3, 414, 7708, 8, + 414, 1, 414, 3, 414, 7711, 8, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 416, + 1, 416, 1, 416, 1, 417, 1, 417, 3, 417, 7722, 8, 417, 1, 417, 1, 417, 1, + 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 5, 418, 7732, 8, 418, 10, + 418, 12, 418, 7735, 9, 418, 1, 418, 1, 418, 1, 418, 5, 418, 7740, 8, 418, + 10, 418, 12, 418, 7743, 9, 418, 3, 418, 7745, 8, 418, 1, 419, 1, 419, 3, + 419, 7749, 8, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 5, 420, 7756, + 8, 420, 10, 420, 12, 420, 7759, 9, 420, 1, 421, 1, 421, 1, 421, 5, 421, + 7764, 8, 421, 10, 421, 12, 421, 7767, 9, 421, 1, 422, 1, 422, 1, 422, 1, + 422, 1, 422, 1, 422, 3, 422, 7775, 8, 422, 3, 422, 7777, 8, 422, 1, 423, + 1, 423, 3, 423, 7781, 8, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, 5, + 424, 7788, 8, 424, 10, 424, 12, 424, 7791, 9, 424, 1, 425, 1, 425, 3, 425, + 7795, 8, 425, 1, 425, 1, 425, 1, 425, 1, 425, 3, 425, 7801, 8, 425, 1, + 425, 1, 425, 1, 425, 3, 425, 7806, 8, 425, 1, 426, 1, 426, 1, 427, 1, 427, + 1, 427, 1, 427, 3, 427, 7814, 8, 427, 1, 428, 1, 428, 1, 429, 1, 429, 3, + 429, 7820, 8, 429, 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 7826, 8, 429, + 1, 429, 1, 429, 1, 429, 1, 429, 3, 429, 7832, 8, 429, 1, 430, 1, 430, 1, + 430, 3, 430, 7837, 8, 430, 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, 3, 432, 7852, 8, + 432, 1, 432, 1, 432, 1, 433, 1, 433, 1, 433, 5, 433, 7859, 8, 433, 10, + 433, 12, 433, 7862, 9, 433, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, 1, + 435, 5, 435, 7870, 8, 435, 10, 435, 12, 435, 7873, 9, 435, 1, 436, 4, 436, + 7876, 8, 436, 11, 436, 12, 436, 7877, 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, 437, 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, 437, 1, 437, 1, 437, 1, 437, 1, + 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 3, 437, 7917, 8, 437, 1, 438, + 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, + 1, 438, 1, 438, 1, 438, 3, 438, 7932, 8, 438, 1, 439, 1, 439, 1, 439, 1, + 439, 1, 439, 3, 439, 7939, 8, 439, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, + 1, 440, 1, 440, 5, 440, 7948, 8, 440, 10, 440, 12, 440, 7951, 9, 440, 1, + 441, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 5, + 443, 7962, 8, 443, 10, 443, 12, 443, 7965, 9, 443, 1, 444, 1, 444, 1, 444, + 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 3, 444, 7977, 8, + 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 1, + 445, 1, 445, 3, 445, 7989, 8, 445, 1, 446, 4, 446, 7992, 8, 446, 11, 446, + 12, 446, 7993, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, + 8002, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8010, + 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8016, 8, 448, 1, 448, 1, + 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 8024, 8, 448, 1, 448, 1, 448, + 1, 448, 1, 448, 3, 448, 8030, 8, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, + 448, 1, 448, 3, 448, 8038, 8, 448, 3, 448, 8040, 8, 448, 1, 449, 1, 449, + 1, 449, 1, 449, 3, 449, 8046, 8, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, + 449, 1, 449, 3, 449, 8054, 8, 449, 3, 449, 8056, 8, 449, 1, 450, 1, 450, + 1, 450, 1, 450, 3, 450, 8062, 8, 450, 1, 450, 1, 450, 1, 450, 1, 450, 1, + 450, 1, 450, 3, 450, 8070, 8, 450, 3, 450, 8072, 8, 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, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 3, 451, 8096, 8, 451, 1, 452, 1, 452, 1, 452, 5, 452, 8101, + 8, 452, 10, 452, 12, 452, 8104, 9, 452, 1, 452, 1, 452, 1, 453, 1, 453, + 1, 453, 5, 453, 8111, 8, 453, 10, 453, 12, 453, 8114, 9, 453, 1, 454, 1, + 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 456, 4, 456, 8123, 8, 456, 11, + 456, 12, 456, 8124, 1, 457, 1, 457, 1, 457, 3, 457, 8130, 8, 457, 1, 458, + 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, + 1, 458, 3, 458, 8143, 8, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, + 458, 1, 458, 1, 458, 1, 458, 1, 458, 3, 458, 8155, 8, 458, 1, 458, 1, 458, + 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 3, 458, + 8167, 8, 458, 3, 458, 8169, 8, 458, 1, 459, 1, 459, 1, 459, 1, 459, 3, + 459, 8175, 8, 459, 1, 460, 1, 460, 1, 460, 3, 460, 8180, 8, 460, 1, 460, + 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 3, 460, 8188, 8, 460, 1, 461, 1, + 461, 1, 461, 1, 462, 1, 462, 3, 462, 8195, 8, 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, 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, 3, 463, 8240, 8, 463, 1, 464, 1, 464, 1, + 464, 3, 464, 8245, 8, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, + 8252, 8, 464, 1, 465, 1, 465, 1, 465, 3, 465, 8257, 8, 465, 1, 465, 1, + 465, 1, 465, 1, 465, 1, 465, 3, 465, 8264, 8, 465, 1, 465, 1, 465, 1, 465, + 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 3, 465, 8274, 8, 465, 1, 465, 1, + 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 3, 465, 8284, 8, 465, + 1, 465, 1, 465, 3, 465, 8288, 8, 465, 1, 466, 1, 466, 1, 467, 1, 467, 1, + 468, 1, 468, 1, 468, 5, 468, 8297, 8, 468, 10, 468, 12, 468, 8300, 9, 468, + 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, 3, 470, 8316, 8, 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, 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, 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, 3, 471, 8387, 8, 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, 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, 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, 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, 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, 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, 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, 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, 471, 1, 471, 3, 471, 8582, 8, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, + 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8595, 8, 471, + 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, + 3, 471, 8606, 8, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, + 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, 8619, 8, 471, 1, 471, 1, 471, + 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 3, 471, + 8631, 8, 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, 3, 471, 8645, 8, 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, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, + 1, 471, 3, 471, 8677, 8, 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, 3, 471, 8691, 8, 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, 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, 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, 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, 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, 3, 471, 8803, 8, 471, 3, 471, 8805, 8, 471, 1, 472, 1, + 472, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8816, + 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, + 1, 474, 3, 474, 8827, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, + 474, 1, 474, 1, 474, 1, 474, 3, 474, 8838, 8, 474, 1, 474, 1, 474, 1, 474, + 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, + 8851, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, + 474, 1, 474, 1, 474, 3, 474, 8863, 8, 474, 1, 474, 1, 474, 1, 474, 1, 474, + 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 3, 474, 8874, 8, 474, 1, 474, 1, + 474, 1, 474, 1, 474, 1, 474, 3, 474, 8881, 8, 474, 1, 475, 1, 475, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, + 3, 476, 9102, 8, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 1, 477, 1, 478, 1, 478, 1, 478, 5, 478, 9115, 8, 478, 10, 478, 12, + 478, 9118, 9, 478, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 479, 3, 479, 9128, 8, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 3, + 480, 9135, 8, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, + 1, 481, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, + 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, + 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, + 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, + 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, + 3, 482, 9189, 8, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 3, 482, 9330, 8, 482, + 1, 483, 1, 483, 1, 483, 1, 483, 3, 483, 9336, 8, 483, 1, 483, 1, 483, 1, + 483, 1, 483, 1, 483, 1, 483, 1, 483, 3, 483, 9345, 8, 483, 1, 483, 1, 483, + 1, 483, 1, 483, 1, 483, 1, 483, 3, 483, 9353, 8, 483, 3, 483, 9355, 8, + 483, 1, 484, 1, 484, 1, 484, 5, 484, 9360, 8, 484, 10, 484, 12, 484, 9363, + 9, 484, 1, 485, 1, 485, 1, 485, 3, 485, 9368, 8, 485, 1, 485, 3, 485, 9371, + 8, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 3, 485, 9378, 8, 485, 1, + 485, 1, 485, 3, 485, 9382, 8, 485, 1, 485, 3, 485, 9385, 8, 485, 1, 485, + 1, 485, 1, 485, 3, 485, 9390, 8, 485, 1, 485, 3, 485, 9393, 8, 485, 1, + 485, 1, 485, 3, 485, 9397, 8, 485, 1, 485, 3, 485, 9400, 8, 485, 1, 485, + 3, 485, 9403, 8, 485, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 487, 1, + 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, + 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, + 487, 1, 487, 1, 487, 1, 487, 1, 487, 3, 487, 9434, 8, 487, 1, 488, 1, 488, + 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 3, 488, 9444, 8, 488, 1, + 489, 1, 489, 1, 489, 5, 489, 9449, 8, 489, 10, 489, 12, 489, 9452, 9, 489, + 1, 490, 1, 490, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, + 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, + 1, 491, 1, 491, 3, 491, 9474, 8, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, + 491, 1, 491, 1, 491, 3, 491, 9483, 8, 491, 1, 491, 1, 491, 1, 491, 1, 491, + 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, + 1, 491, 1, 491, 1, 491, 3, 491, 9501, 8, 491, 1, 492, 1, 492, 1, 492, 1, + 492, 3, 492, 9507, 8, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, + 3, 492, 9515, 8, 492, 3, 492, 9517, 8, 492, 1, 493, 1, 493, 3, 493, 9521, + 8, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, + 3, 493, 9531, 8, 493, 1, 493, 1, 493, 3, 493, 9535, 8, 493, 1, 493, 1, + 493, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 3, 494, 9545, 8, 494, + 1, 495, 3, 495, 9548, 8, 495, 1, 495, 1, 495, 3, 495, 9552, 8, 495, 5, + 495, 9554, 8, 495, 10, 495, 12, 495, 9557, 9, 495, 1, 496, 1, 496, 1, 496, + 1, 496, 1, 496, 3, 496, 9564, 8, 496, 1, 497, 1, 497, 1, 498, 1, 498, 1, + 499, 1, 499, 1, 500, 1, 500, 1, 500, 3, 500, 9575, 8, 500, 1, 501, 1, 501, + 1, 501, 1, 502, 1, 502, 1, 502, 1, 503, 1, 503, 1, 503, 1, 503, 3, 503, + 9587, 8, 503, 1, 504, 1, 504, 3, 504, 9591, 8, 504, 1, 504, 3, 504, 9594, + 8, 504, 1, 504, 1, 504, 3, 504, 9598, 8, 504, 1, 504, 3, 504, 9601, 8, + 504, 1, 504, 1, 504, 1, 504, 3, 504, 9606, 8, 504, 1, 504, 1, 504, 3, 504, + 9610, 8, 504, 1, 504, 3, 504, 9613, 8, 504, 1, 504, 1, 504, 3, 504, 9617, + 8, 504, 1, 504, 3, 504, 9620, 8, 504, 1, 504, 1, 504, 3, 504, 9624, 8, + 504, 1, 504, 3, 504, 9627, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, + 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 9638, 8, 504, 1, 504, 1, 504, 1, + 504, 1, 504, 1, 504, 3, 504, 9645, 8, 504, 1, 504, 1, 504, 1, 504, 1, 504, + 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 9658, 8, + 504, 1, 505, 1, 505, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, 506, 1, + 506, 1, 506, 1, 506, 1, 506, 3, 506, 9672, 8, 506, 1, 507, 1, 507, 3, 507, + 9676, 8, 507, 1, 507, 5, 507, 9679, 8, 507, 10, 507, 12, 507, 9682, 9, + 507, 1, 508, 1, 508, 1, 509, 1, 509, 3, 509, 9688, 8, 509, 1, 509, 1, 509, + 1, 510, 1, 510, 1, 510, 3, 510, 9695, 8, 510, 1, 510, 3, 510, 9698, 8, + 510, 1, 510, 1, 510, 1, 510, 3, 510, 9703, 8, 510, 1, 510, 3, 510, 9706, + 8, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 3, 510, + 9715, 8, 510, 3, 510, 9717, 8, 510, 1, 510, 1, 510, 1, 510, 3, 510, 9722, + 8, 510, 1, 510, 3, 510, 9725, 8, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, + 511, 1, 512, 1, 512, 3, 512, 9734, 8, 512, 1, 512, 1, 512, 1, 512, 1, 513, + 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, + 1, 515, 1, 515, 1, 515, 1, 515, 3, 515, 9753, 8, 515, 1, 515, 1, 515, 1, + 515, 1, 515, 3, 515, 9759, 8, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, + 3, 515, 9766, 8, 515, 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, + 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, + 517, 1, 517, 1, 517, 3, 517, 9786, 8, 517, 1, 518, 1, 518, 1, 518, 5, 518, + 9791, 8, 518, 10, 518, 12, 518, 9794, 9, 518, 1, 519, 1, 519, 1, 519, 3, + 519, 9799, 8, 519, 1, 520, 1, 520, 3, 520, 9803, 8, 520, 1, 521, 1, 521, + 1, 522, 1, 522, 1, 522, 5, 522, 9810, 8, 522, 10, 522, 12, 522, 9813, 9, + 522, 1, 523, 1, 523, 1, 523, 1, 524, 1, 524, 1, 524, 3, 524, 9821, 8, 524, + 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, 9827, 8, 525, 1, 526, 1, 526, 1, + 526, 5, 526, 9832, 8, 526, 10, 526, 12, 526, 9835, 9, 526, 1, 527, 1, 527, + 3, 527, 9839, 8, 527, 1, 528, 3, 528, 9842, 8, 528, 1, 528, 1, 528, 3, + 528, 9846, 8, 528, 1, 528, 3, 528, 9849, 8, 528, 1, 529, 1, 529, 1, 529, + 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 9860, 8, 530, 1, + 530, 1, 530, 3, 530, 9864, 8, 530, 1, 531, 1, 531, 1, 531, 3, 531, 9869, + 8, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 4, 532, + 9878, 8, 532, 11, 532, 12, 532, 9879, 1, 533, 1, 533, 1, 533, 1, 533, 1, + 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 9892, 8, 533, 1, 533, + 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 9902, 8, + 533, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 3, 534, 9909, 8, 534, 1, 534, + 1, 534, 1, 534, 1, 534, 3, 534, 9915, 8, 534, 1, 535, 1, 535, 1, 535, 1, + 535, 3, 535, 9921, 8, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, + 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 9933, 8, 535, 1, 536, 1, 536, 1, + 536, 1, 536, 3, 536, 9939, 8, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, + 1, 536, 1, 536, 1, 536, 3, 536, 9949, 8, 536, 1, 536, 1, 536, 1, 536, 1, + 536, 3, 536, 9955, 8, 536, 1, 536, 1, 536, 3, 536, 9959, 8, 536, 1, 537, + 1, 537, 1, 537, 3, 537, 9964, 8, 537, 1, 537, 1, 537, 1, 537, 5, 537, 9969, + 8, 537, 10, 537, 12, 537, 9972, 9, 537, 1, 537, 1, 537, 1, 537, 3, 537, + 9977, 8, 537, 1, 537, 3, 537, 9980, 8, 537, 1, 538, 1, 538, 1, 538, 1, + 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 3, 538, 9991, 8, 538, 1, 538, + 1, 538, 1, 538, 1, 538, 3, 538, 9997, 8, 538, 1, 538, 1, 538, 3, 538, 10001, + 8, 538, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, + 1, 539, 3, 539, 10012, 8, 539, 1, 539, 1, 539, 1, 539, 1, 540, 1, 540, + 1, 540, 1, 540, 1, 540, 1, 540, 3, 540, 10023, 8, 540, 1, 540, 1, 540, + 1, 540, 1, 540, 3, 540, 10029, 8, 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, + 3, 541, 10044, 8, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 541, 1, 542, + 1, 542, 1, 542, 1, 542, 1, 542, 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, + 1, 543, 3, 543, 10062, 8, 543, 1, 543, 1, 543, 3, 543, 10066, 8, 543, 1, + 543, 1, 543, 3, 543, 10070, 8, 543, 1, 544, 1, 544, 1, 544, 1, 544, 1, + 544, 1, 544, 3, 544, 10078, 8, 544, 1, 544, 1, 544, 3, 544, 10082, 8, 544, + 1, 544, 1, 544, 3, 544, 10086, 8, 544, 1, 545, 1, 545, 1, 545, 1, 545, + 1, 545, 1, 545, 3, 545, 10094, 8, 545, 1, 545, 1, 545, 1, 545, 3, 545, + 10099, 8, 545, 1, 545, 1, 545, 3, 545, 10103, 8, 545, 1, 546, 1, 546, 1, + 546, 3, 546, 10108, 8, 546, 1, 547, 1, 547, 3, 547, 10112, 8, 547, 1, 548, + 1, 548, 1, 549, 1, 549, 1, 549, 3, 549, 10119, 8, 549, 1, 549, 1, 549, + 1, 549, 1, 549, 1, 549, 3, 549, 10126, 8, 549, 1, 549, 1, 549, 1, 549, + 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 3, 549, 10138, + 8, 549, 1, 549, 1, 549, 3, 549, 10142, 8, 549, 1, 549, 1, 549, 1, 549, + 3, 549, 10147, 8, 549, 3, 549, 10149, 8, 549, 1, 550, 1, 550, 1, 550, 5, + 550, 10154, 8, 550, 10, 550, 12, 550, 10157, 9, 550, 1, 551, 1, 551, 1, + 551, 5, 551, 10162, 8, 551, 10, 551, 12, 551, 10165, 9, 551, 1, 551, 3, + 551, 10168, 8, 551, 1, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, + 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 10181, 8, 553, 1, 553, 1, + 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 10190, 8, 553, 1, + 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, + 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 10207, 8, 553, 1, + 554, 1, 554, 1, 554, 1, 554, 3, 554, 10213, 8, 554, 1, 554, 1, 554, 1, + 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 3, 554, 10225, + 8, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, + 1, 554, 3, 554, 10236, 8, 554, 1, 555, 1, 555, 1, 555, 5, 555, 10241, 8, + 555, 10, 555, 12, 555, 10244, 9, 555, 1, 556, 1, 556, 1, 556, 1, 557, 1, + 557, 3, 557, 10251, 8, 557, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, + 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, + 558, 3, 558, 10268, 8, 558, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, + 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10280, 8, 559, 3, 559, 10282, + 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10289, 8, 559, + 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10296, 8, 559, 1, 559, + 1, 559, 1, 559, 1, 559, 3, 559, 10302, 8, 559, 1, 559, 1, 559, 1, 559, + 1, 559, 3, 559, 10308, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, + 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 3, 559, 10320, 8, 559, 3, 559, + 10322, 8, 559, 1, 560, 1, 560, 1, 560, 5, 560, 10327, 8, 560, 10, 560, + 12, 560, 10330, 9, 560, 1, 561, 1, 561, 1, 561, 1, 561, 1, 562, 1, 562, + 1, 563, 1, 563, 1, 563, 5, 563, 10341, 8, 563, 10, 563, 12, 563, 10344, + 9, 563, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, 3, 565, + 10353, 8, 565, 1, 565, 1, 565, 3, 565, 10357, 8, 565, 1, 565, 1, 565, 1, + 565, 1, 565, 1, 565, 3, 565, 10364, 8, 565, 1, 565, 1, 565, 1, 565, 1, + 565, 3, 565, 10370, 8, 565, 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, + 566, 1, 566, 3, 566, 10379, 8, 566, 1, 566, 1, 566, 3, 566, 10383, 8, 566, + 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 4, 567, 10390, 8, 567, 11, 567, + 12, 567, 10391, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, + 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 3, 568, 10406, 8, 568, 1, 568, + 3, 568, 10409, 8, 568, 1, 568, 1, 568, 3, 568, 10413, 8, 568, 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, 3, 570, 10439, 8, 570, 1, 570, 1, + 570, 3, 570, 10443, 8, 570, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, 5, + 570, 10450, 8, 570, 10, 570, 12, 570, 10453, 9, 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, 3, 570, 10467, 8, 570, 1, 570, 1, 570, 3, 570, 10471, 8, 570, 3, 570, + 10473, 8, 570, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, + 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, + 3, 571, 10491, 8, 571, 1, 572, 1, 572, 1, 572, 5, 572, 10496, 8, 572, 10, + 572, 12, 572, 10499, 9, 572, 1, 573, 1, 573, 1, 573, 1, 574, 1, 574, 1, + 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 575, 1, 575, 1, + 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, + 575, 1, 575, 1, 575, 3, 575, 10527, 8, 575, 1, 575, 1, 575, 1, 575, 1, + 575, 3, 575, 10533, 8, 575, 1, 576, 1, 576, 1, 576, 5, 576, 10538, 8, 576, + 10, 576, 12, 576, 10541, 9, 576, 1, 577, 1, 577, 1, 578, 1, 578, 1, 578, + 5, 578, 10548, 8, 578, 10, 578, 12, 578, 10551, 9, 578, 1, 579, 1, 579, + 1, 579, 3, 579, 10556, 8, 579, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, + 1, 580, 3, 580, 10564, 8, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 581, + 1, 581, 1, 581, 5, 581, 10573, 8, 581, 10, 581, 12, 581, 10576, 9, 581, + 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 1, 582, 3, 582, 10585, + 8, 582, 1, 582, 5, 582, 10588, 8, 582, 10, 582, 12, 582, 10591, 9, 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, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, + 1, 583, 3, 583, 10612, 8, 583, 1, 583, 1, 583, 1, 583, 3, 583, 10617, 8, + 583, 3, 583, 10619, 8, 583, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, + 584, 1, 584, 1, 584, 3, 584, 10629, 8, 584, 1, 585, 1, 585, 1, 585, 3, + 585, 10634, 8, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, + 585, 5, 585, 10643, 8, 585, 10, 585, 12, 585, 10646, 9, 585, 1, 586, 1, + 586, 1, 586, 1, 586, 3, 586, 10652, 8, 586, 1, 586, 1, 586, 1, 586, 1, + 586, 1, 586, 3, 586, 10659, 8, 586, 3, 586, 10661, 8, 586, 1, 587, 1, 587, + 1, 587, 1, 587, 3, 587, 10667, 8, 587, 1, 587, 1, 587, 1, 587, 1, 587, + 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, 1, 588, 1, 588, 1, 588, + 5, 588, 10682, 8, 588, 10, 588, 12, 588, 10685, 9, 588, 1, 589, 1, 589, + 1, 589, 1, 590, 1, 590, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, + 1, 591, 3, 591, 10699, 8, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, + 1, 591, 3, 591, 10707, 8, 591, 1, 591, 1, 591, 3, 591, 10711, 8, 591, 1, + 591, 1, 591, 3, 591, 10715, 8, 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, + 591, 10721, 8, 591, 1, 591, 1, 591, 3, 591, 10725, 8, 591, 1, 591, 1, 591, + 3, 591, 10729, 8, 591, 1, 591, 1, 591, 3, 591, 10733, 8, 591, 1, 591, 1, + 591, 3, 591, 10737, 8, 591, 1, 591, 1, 591, 3, 591, 10741, 8, 591, 1, 591, + 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 10748, 8, 591, 1, 592, 1, 592, + 1, 592, 1, 592, 1, 592, 1, 592, 3, 592, 10756, 8, 592, 1, 593, 1, 593, + 3, 593, 10760, 8, 593, 1, 594, 1, 594, 1, 594, 3, 594, 10765, 8, 594, 1, + 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 597, 1, 597, 1, 598, 1, + 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, + 599, 3, 599, 10786, 8, 599, 1, 600, 1, 600, 1, 600, 5, 600, 10791, 8, 600, + 10, 600, 12, 600, 10794, 9, 600, 1, 601, 1, 601, 1, 601, 1, 602, 1, 602, + 1, 602, 5, 602, 10802, 8, 602, 10, 602, 12, 602, 10805, 9, 602, 1, 603, + 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, + 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, + 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, + 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 10841, 8, 603, + 1, 604, 1, 604, 1, 604, 5, 604, 10846, 8, 604, 10, 604, 12, 604, 10849, + 9, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 3, 605, + 10858, 8, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, + 1, 606, 1, 606, 1, 606, 3, 606, 10870, 8, 606, 3, 606, 10872, 8, 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, 608, 1, 608, 1, 608, 1, + 608, 1, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, + 609, 3, 609, 10902, 8, 609, 1, 609, 1, 609, 1, 609, 1, 609, 1, 610, 1, + 610, 1, 610, 5, 610, 10911, 8, 610, 10, 610, 12, 610, 10914, 9, 610, 1, + 611, 1, 611, 1, 611, 1, 611, 3, 611, 10920, 8, 611, 1, 612, 1, 612, 1, + 613, 1, 613, 1, 613, 1, 613, 3, 613, 10928, 8, 613, 1, 613, 1, 613, 3, + 613, 10932, 8, 613, 1, 614, 1, 614, 1, 614, 3, 614, 10937, 8, 614, 1, 614, + 1, 614, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 10945, 8, 615, 1, 615, + 1, 615, 1, 616, 1, 616, 1, 616, 3, 616, 10952, 8, 616, 1, 616, 1, 616, + 1, 617, 1, 617, 1, 617, 1, 617, 3, 617, 10960, 8, 617, 1, 617, 1, 617, + 3, 617, 10964, 8, 617, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, + 1, 618, 5, 618, 10973, 8, 618, 10, 618, 12, 618, 10976, 9, 618, 1, 619, + 1, 619, 1, 620, 1, 620, 1, 620, 1, 620, 3, 620, 10984, 8, 620, 1, 620, + 4, 620, 10987, 8, 620, 11, 620, 12, 620, 10988, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 3, 621, 11001, + 8, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 621, 3, 621, 11013, 8, 621, 1, 621, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 621, 3, 621, 11030, 8, 621, 1, 622, 1, 622, 1, 622, 1, 622, + 1, 622, 1, 622, 1, 622, 3, 622, 11039, 8, 622, 3, 622, 11041, 8, 622, 1, + 622, 1, 622, 3, 622, 11045, 8, 622, 1, 623, 1, 623, 1, 623, 3, 623, 11050, + 8, 623, 1, 623, 3, 623, 11053, 8, 623, 1, 624, 1, 624, 1, 624, 1, 625, + 1, 625, 1, 625, 1, 625, 1, 625, 1, 626, 1, 626, 3, 626, 11065, 8, 626, + 1, 627, 1, 627, 3, 627, 11069, 8, 627, 1, 627, 1, 627, 1, 627, 1, 627, + 3, 627, 11075, 8, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, + 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 3, 628, 11088, 8, 628, 1, 629, + 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 630, 1, 630, 1, 630, + 1, 630, 3, 630, 11101, 8, 630, 1, 630, 1, 630, 1, 630, 3, 630, 11106, 8, + 630, 1, 630, 1, 630, 3, 630, 11110, 8, 630, 1, 631, 1, 631, 1, 631, 1, + 631, 1, 631, 3, 631, 11117, 8, 631, 1, 631, 5, 631, 11120, 8, 631, 10, + 631, 12, 631, 11123, 9, 631, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, + 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 5, 632, 11136, 8, 632, 10, + 632, 12, 632, 11139, 9, 632, 1, 632, 1, 632, 1, 632, 1, 632, 3, 632, 11145, + 8, 632, 3, 632, 11147, 8, 632, 1, 633, 1, 633, 1, 633, 1, 633, 3, 633, + 11153, 8, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 3, 634, 11160, 8, + 634, 1, 635, 1, 635, 1, 635, 1, 635, 3, 635, 11166, 8, 635, 1, 635, 1, + 635, 3, 635, 11170, 8, 635, 1, 635, 1, 635, 3, 635, 11174, 8, 635, 1, 635, + 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 3, 635, 11183, 8, 635, + 3, 635, 11185, 8, 635, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 3, 636, + 11192, 8, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 3, 636, 11199, 8, + 636, 1, 636, 3, 636, 11202, 8, 636, 3, 636, 11204, 8, 636, 1, 637, 1, 637, + 1, 637, 3, 637, 11209, 8, 637, 1, 638, 1, 638, 1, 638, 1, 638, 3, 638, + 11215, 8, 638, 1, 639, 1, 639, 1, 639, 1, 639, 3, 639, 11221, 8, 639, 1, + 640, 1, 640, 1, 640, 1, 640, 1, 640, 3, 640, 11228, 8, 640, 1, 640, 1, + 640, 3, 640, 11232, 8, 640, 1, 640, 1, 640, 3, 640, 11236, 8, 640, 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, 3, 642, 11251, 8, 642, 1, 642, 1, 642, 3, 642, + 11255, 8, 642, 1, 643, 1, 643, 1, 643, 1, 643, 1, 644, 1, 644, 1, 644, + 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 5, 644, 11269, 8, 644, 10, 644, + 12, 644, 11272, 9, 644, 1, 645, 1, 645, 1, 645, 3, 645, 11277, 8, 645, + 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, + 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, + 1, 646, 3, 646, 11298, 8, 646, 1, 647, 1, 647, 1, 647, 1, 648, 1, 648, + 1, 648, 1, 648, 1, 648, 1, 648, 3, 648, 11309, 8, 648, 1, 649, 1, 649, + 3, 649, 11313, 8, 649, 1, 650, 1, 650, 1, 651, 1, 651, 3, 651, 11319, 8, + 651, 1, 651, 1, 651, 1, 652, 1, 652, 1, 652, 1, 653, 1, 653, 3, 653, 11328, + 8, 653, 1, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 656, 1, 656, 1, 657, + 1, 657, 1, 657, 1, 657, 1, 658, 1, 658, 1, 659, 1, 659, 1, 660, 1, 660, + 1, 661, 1, 661, 1, 661, 1, 662, 1, 662, 3, 662, 11352, 8, 662, 1, 662, + 1, 662, 3, 662, 11356, 8, 662, 1, 663, 1, 663, 3, 663, 11360, 8, 663, 1, + 663, 1, 663, 3, 663, 11364, 8, 663, 1, 664, 1, 664, 1, 665, 1, 665, 3, + 665, 11370, 8, 665, 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 1, 667, 1, + 667, 1, 667, 1, 668, 1, 668, 1, 668, 1, 668, 3, 668, 11384, 8, 668, 1, + 668, 3, 668, 11387, 8, 668, 1, 669, 1, 669, 1, 670, 4, 670, 11392, 8, 670, + 11, 670, 12, 670, 11393, 1, 671, 1, 671, 3, 671, 11398, 8, 671, 1, 671, + 1, 671, 1, 671, 1, 671, 3, 671, 11404, 8, 671, 1, 671, 1, 671, 1, 671, + 1, 671, 1, 671, 3, 671, 11411, 8, 671, 1, 672, 1, 672, 1, 672, 1, 672, + 1, 672, 1, 672, 1, 672, 1, 672, 3, 672, 11421, 8, 672, 1, 673, 1, 673, + 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 3, 674, 11430, 8, 674, 1, 674, + 3, 674, 11433, 8, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, + 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 1, 674, 3, 674, 11447, 8, 674, + 3, 674, 11449, 8, 674, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 676, + 1, 676, 1, 676, 1, 676, 1, 677, 1, 677, 1, 677, 5, 677, 11463, 8, 677, + 10, 677, 12, 677, 11466, 9, 677, 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, 3, 681, 11485, 8, 681, 1, 681, 1, 681, 1, 681, + 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, + 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 3, 682, 11506, + 8, 682, 1, 682, 1, 682, 3, 682, 11510, 8, 682, 1, 682, 1, 682, 1, 682, + 3, 682, 11515, 8, 682, 1, 683, 1, 683, 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, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 3, 685, 11598, 8, 685, 1, 686, 1, 686, 1, 687, + 1, 687, 3, 687, 11604, 8, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, + 1, 687, 1, 687, 1, 687, 1, 687, 1, 688, 1, 688, 3, 688, 11617, 8, 688, + 1, 688, 1, 688, 3, 688, 11621, 8, 688, 1, 688, 1, 688, 3, 688, 11625, 8, + 688, 1, 688, 1, 688, 3, 688, 11629, 8, 688, 1, 688, 1, 688, 1, 688, 1, + 688, 3, 688, 11635, 8, 688, 1, 689, 1, 689, 1, 689, 1, 690, 1, 690, 3, + 690, 11642, 8, 690, 1, 690, 3, 690, 11645, 8, 690, 1, 690, 3, 690, 11648, + 8, 690, 1, 690, 3, 690, 11651, 8, 690, 1, 690, 3, 690, 11654, 8, 690, 1, + 690, 1, 690, 1, 690, 1, 690, 1, 690, 3, 690, 11661, 8, 690, 1, 690, 1, + 690, 3, 690, 11665, 8, 690, 1, 690, 3, 690, 11668, 8, 690, 1, 690, 1, 690, + 1, 690, 1, 690, 3, 690, 11674, 8, 690, 1, 690, 3, 690, 11677, 8, 690, 3, + 690, 11679, 8, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, + 691, 3, 691, 11688, 8, 691, 1, 692, 1, 692, 3, 692, 11692, 8, 692, 1, 692, + 1, 692, 1, 692, 1, 692, 1, 692, 3, 692, 11699, 8, 692, 3, 692, 11701, 8, + 692, 1, 692, 1, 692, 1, 692, 1, 692, 3, 692, 11707, 8, 692, 1, 693, 1, + 693, 1, 693, 5, 693, 11712, 8, 693, 10, 693, 12, 693, 11715, 9, 693, 1, + 694, 1, 694, 1, 695, 1, 695, 3, 695, 11721, 8, 695, 1, 696, 1, 696, 3, + 696, 11725, 8, 696, 1, 697, 1, 697, 3, 697, 11729, 8, 697, 1, 698, 1, 698, + 1, 699, 1, 699, 1, 700, 1, 700, 1, 701, 1, 701, 1, 702, 1, 702, 1, 702, + 1, 702, 1, 703, 1, 703, 3, 703, 11745, 8, 703, 1, 704, 1, 704, 1, 704, + 5, 704, 11750, 8, 704, 10, 704, 12, 704, 11753, 9, 704, 1, 705, 1, 705, + 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 3, 706, 11762, 8, 706, 1, 706, + 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, + 1, 706, 3, 706, 11775, 8, 706, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, + 1, 707, 1, 707, 1, 707, 1, 707, 3, 707, 11786, 8, 707, 1, 708, 1, 708, + 1, 708, 5, 708, 11791, 8, 708, 10, 708, 12, 708, 11794, 9, 708, 1, 709, + 1, 709, 3, 709, 11798, 8, 709, 1, 710, 1, 710, 3, 710, 11802, 8, 710, 1, + 711, 1, 711, 3, 711, 11806, 8, 711, 1, 712, 1, 712, 1, 712, 3, 712, 11811, + 8, 712, 1, 712, 1, 712, 1, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 714, + 1, 714, 1, 714, 1, 714, 1, 714, 3, 714, 11825, 8, 714, 1, 715, 1, 715, + 1, 715, 3, 715, 11830, 8, 715, 1, 715, 1, 715, 3, 715, 11834, 8, 715, 1, + 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 3, 715, 11842, 8, 715, 1, + 715, 3, 715, 11845, 8, 715, 1, 715, 1, 715, 3, 715, 11849, 8, 715, 1, 715, + 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 1, 715, 3, 715, + 11860, 8, 715, 1, 715, 3, 715, 11863, 8, 715, 3, 715, 11865, 8, 715, 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, 717, 3, 717, 11881, 8, 717, 1, 718, 3, + 718, 11884, 8, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 3, 718, 11891, + 8, 718, 1, 718, 3, 718, 11894, 8, 718, 1, 719, 1, 719, 1, 719, 3, 719, + 11899, 8, 719, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, + 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 3, 720, 11914, 8, 720, + 1, 720, 1, 720, 1, 720, 1, 720, 3, 720, 11920, 8, 720, 1, 721, 1, 721, + 1, 722, 1, 722, 1, 722, 5, 722, 11927, 8, 722, 10, 722, 12, 722, 11930, + 9, 722, 1, 723, 1, 723, 1, 723, 1, 724, 1, 724, 1, 724, 3, 724, 11938, + 8, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 3, 724, 11945, 8, 724, + 1, 724, 3, 724, 11948, 8, 724, 1, 725, 1, 725, 1, 725, 1, 725, 3, 725, + 11954, 8, 725, 1, 725, 1, 725, 1, 725, 3, 725, 11959, 8, 725, 1, 726, 1, + 726, 1, 726, 1, 727, 3, 727, 11965, 8, 727, 1, 727, 1, 727, 1, 727, 3, + 727, 11970, 8, 727, 1, 727, 1, 727, 3, 727, 11974, 8, 727, 1, 727, 1, 727, + 1, 727, 3, 727, 11979, 8, 727, 1, 727, 3, 727, 11982, 8, 727, 1, 727, 1, + 727, 1, 727, 4, 727, 11987, 8, 727, 11, 727, 12, 727, 11988, 1, 727, 1, + 727, 3, 727, 11993, 8, 727, 1, 728, 1, 728, 1, 728, 3, 728, 11998, 8, 728, + 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 3, 729, 12005, 8, 729, 1, 729, + 3, 729, 12008, 8, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 3, 729, + 12015, 8, 729, 1, 729, 1, 729, 1, 730, 1, 730, 1, 730, 1, 730, 3, 730, + 12023, 8, 730, 1, 730, 3, 730, 12026, 8, 730, 1, 730, 1, 730, 1, 730, 1, + 730, 1, 731, 1, 731, 1, 731, 1, 731, 3, 731, 12036, 8, 731, 1, 731, 3, + 731, 12039, 8, 731, 1, 731, 1, 731, 1, 732, 3, 732, 12044, 8, 732, 1, 732, + 1, 732, 3, 732, 12048, 8, 732, 1, 732, 1, 732, 3, 732, 12052, 8, 732, 1, + 732, 3, 732, 12055, 8, 732, 1, 732, 3, 732, 12058, 8, 732, 1, 733, 1, 733, + 1, 733, 1, 734, 1, 734, 3, 734, 12065, 8, 734, 1, 734, 1, 734, 3, 734, + 12069, 8, 734, 1, 734, 3, 734, 12072, 8, 734, 1, 735, 1, 735, 1, 735, 1, + 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, + 736, 3, 736, 12087, 8, 736, 1, 736, 3, 736, 12090, 8, 736, 1, 737, 1, 737, + 1, 738, 1, 738, 1, 738, 3, 738, 12097, 8, 738, 1, 739, 3, 739, 12100, 8, + 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 3, 739, 12107, 8, 739, 1, + 739, 3, 739, 12110, 8, 739, 1, 739, 3, 739, 12113, 8, 739, 1, 740, 1, 740, + 1, 740, 5, 740, 12118, 8, 740, 10, 740, 12, 740, 12121, 9, 740, 1, 741, + 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, + 3, 741, 12133, 8, 741, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 1, 743, + 5, 743, 12141, 8, 743, 10, 743, 12, 743, 12144, 9, 743, 1, 744, 1, 744, + 1, 744, 1, 744, 1, 744, 3, 744, 12151, 8, 744, 1, 744, 1, 744, 1, 744, + 1, 745, 1, 745, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 5, 746, 12163, + 8, 746, 10, 746, 12, 746, 12166, 9, 746, 1, 747, 1, 747, 1, 747, 1, 747, + 3, 747, 12172, 8, 747, 1, 748, 1, 748, 3, 748, 12176, 8, 748, 1, 749, 1, + 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 3, 749, 12186, 8, + 749, 1, 750, 1, 750, 3, 750, 12190, 8, 750, 1, 750, 1, 750, 3, 750, 12194, + 8, 750, 1, 750, 1, 750, 3, 750, 12198, 8, 750, 3, 750, 12200, 8, 750, 1, + 750, 1, 750, 1, 750, 3, 750, 12205, 8, 750, 1, 750, 1, 750, 3, 750, 12209, + 8, 750, 1, 750, 1, 750, 3, 750, 12213, 8, 750, 3, 750, 12215, 8, 750, 3, + 750, 12217, 8, 750, 1, 751, 1, 751, 1, 751, 3, 751, 12222, 8, 751, 1, 751, + 5, 751, 12225, 8, 751, 10, 751, 12, 751, 12228, 9, 751, 1, 752, 1, 752, + 1, 752, 3, 752, 12233, 8, 752, 1, 752, 5, 752, 12236, 8, 752, 10, 752, + 12, 752, 12239, 9, 752, 1, 753, 1, 753, 3, 753, 12243, 8, 753, 1, 753, + 3, 753, 12246, 8, 753, 1, 753, 3, 753, 12249, 8, 753, 1, 753, 3, 753, 12252, + 8, 753, 1, 753, 3, 753, 12255, 8, 753, 1, 753, 1, 753, 1, 753, 1, 753, + 3, 753, 12261, 8, 753, 1, 753, 3, 753, 12264, 8, 753, 1, 753, 3, 753, 12267, + 8, 753, 1, 753, 3, 753, 12270, 8, 753, 1, 753, 3, 753, 12273, 8, 753, 1, + 753, 3, 753, 12276, 8, 753, 1, 753, 3, 753, 12279, 8, 753, 1, 753, 3, 753, + 12282, 8, 753, 1, 753, 3, 753, 12285, 8, 753, 1, 753, 3, 753, 12288, 8, + 753, 1, 753, 1, 753, 1, 753, 1, 753, 3, 753, 12294, 8, 753, 1, 754, 1, + 754, 1, 754, 1, 754, 1, 754, 1, 755, 1, 755, 1, 755, 1, 756, 1, 756, 1, + 756, 3, 756, 12307, 8, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 757, 1, + 757, 3, 757, 12315, 8, 757, 1, 757, 1, 757, 1, 758, 1, 758, 1, 758, 5, + 758, 12322, 8, 758, 10, 758, 12, 758, 12325, 9, 758, 1, 759, 1, 759, 3, + 759, 12329, 8, 759, 1, 759, 1, 759, 3, 759, 12333, 8, 759, 1, 759, 1, 759, + 1, 759, 1, 759, 1, 760, 1, 760, 1, 760, 3, 760, 12342, 8, 760, 1, 761, + 1, 761, 1, 762, 1, 762, 3, 762, 12348, 8, 762, 1, 762, 1, 762, 3, 762, + 12352, 8, 762, 1, 763, 1, 763, 1, 763, 1, 764, 1, 764, 1, 765, 3, 765, + 12360, 8, 765, 1, 765, 1, 765, 3, 765, 12364, 8, 765, 1, 765, 1, 765, 1, + 765, 3, 765, 12369, 8, 765, 1, 765, 1, 765, 1, 765, 1, 765, 3, 765, 12375, + 8, 765, 1, 766, 1, 766, 1, 767, 1, 767, 1, 768, 1, 768, 1, 768, 1, 768, + 1, 768, 1, 768, 3, 768, 12387, 8, 768, 1, 769, 1, 769, 1, 770, 1, 770, + 1, 771, 1, 771, 1, 771, 1, 771, 1, 772, 1, 772, 1, 772, 5, 772, 12400, + 8, 772, 10, 772, 12, 772, 12403, 9, 772, 1, 773, 1, 773, 1, 773, 1, 773, + 3, 773, 12409, 8, 773, 3, 773, 12411, 8, 773, 1, 773, 3, 773, 12414, 8, + 773, 1, 774, 1, 774, 3, 774, 12418, 8, 774, 1, 774, 1, 774, 3, 774, 12422, + 8, 774, 3, 774, 12424, 8, 774, 1, 775, 1, 775, 1, 776, 1, 776, 1, 776, + 1, 776, 3, 776, 12432, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, 1, 776, + 1, 776, 1, 776, 3, 776, 12441, 8, 776, 1, 776, 1, 776, 1, 776, 1, 776, + 3, 776, 12447, 8, 776, 3, 776, 12449, 8, 776, 3, 776, 12451, 8, 776, 1, + 777, 1, 777, 1, 777, 1, 777, 1, 777, 3, 777, 12458, 8, 777, 1, 778, 1, + 778, 3, 778, 12462, 8, 778, 1, 779, 1, 779, 1, 780, 1, 780, 1, 780, 1, + 780, 1, 780, 3, 780, 12471, 8, 780, 1, 781, 1, 781, 3, 781, 12475, 8, 781, + 1, 782, 1, 782, 1, 783, 1, 783, 1, 784, 1, 784, 1, 784, 1, 784, 1, 785, + 1, 785, 1, 785, 5, 785, 12488, 8, 785, 10, 785, 12, 785, 12491, 9, 785, + 1, 785, 3, 785, 12494, 8, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, + 3, 786, 12501, 8, 786, 1, 787, 1, 787, 1, 787, 1, 788, 1, 788, 1, 788, + 1, 788, 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, + 1, 790, 1, 790, 1, 790, 1, 790, 1, 791, 1, 791, 1, 791, 1, 792, 1, 792, + 1, 792, 1, 792, 3, 792, 12529, 8, 792, 1, 793, 1, 793, 1, 794, 4, 794, + 12534, 8, 794, 11, 794, 12, 794, 12535, 1, 795, 1, 795, 3, 795, 12540, + 8, 795, 1, 795, 3, 795, 12543, 8, 795, 1, 796, 1, 796, 1, 796, 3, 796, + 12548, 8, 796, 1, 796, 1, 796, 3, 796, 12552, 8, 796, 1, 796, 3, 796, 12555, + 8, 796, 1, 797, 1, 797, 1, 797, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, + 1, 798, 1, 798, 1, 798, 1, 798, 5, 798, 12569, 8, 798, 10, 798, 12, 798, + 12572, 9, 798, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 5, 800, + 12580, 8, 800, 10, 800, 12, 800, 12583, 9, 800, 1, 801, 1, 801, 3, 801, + 12587, 8, 801, 1, 801, 3, 801, 12590, 8, 801, 1, 801, 1, 801, 3, 801, 12594, + 8, 801, 1, 801, 1, 801, 3, 801, 12598, 8, 801, 1, 801, 1, 801, 3, 801, + 12602, 8, 801, 1, 801, 1, 801, 1, 801, 3, 801, 12607, 8, 801, 1, 801, 1, + 801, 3, 801, 12611, 8, 801, 1, 801, 1, 801, 3, 801, 12615, 8, 801, 3, 801, + 12617, 8, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, 1, 801, + 3, 801, 12626, 8, 801, 1, 801, 1, 801, 1, 801, 3, 801, 12631, 8, 801, 1, + 801, 1, 801, 1, 801, 1, 801, 3, 801, 12637, 8, 801, 1, 801, 1, 801, 3, + 801, 12641, 8, 801, 3, 801, 12643, 8, 801, 1, 801, 5, 801, 12646, 8, 801, + 10, 801, 12, 801, 12649, 9, 801, 1, 802, 3, 802, 12652, 8, 802, 1, 802, + 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 3, 802, + 12663, 8, 802, 1, 802, 1, 802, 3, 802, 12667, 8, 802, 1, 803, 3, 803, 12670, + 8, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 3, 803, 12677, 8, 803, + 1, 804, 1, 804, 1, 805, 3, 805, 12682, 8, 805, 1, 805, 1, 805, 1, 805, + 1, 805, 1, 805, 3, 805, 12689, 8, 805, 1, 806, 1, 806, 1, 806, 3, 806, + 12694, 8, 806, 1, 806, 3, 806, 12697, 8, 806, 1, 806, 1, 806, 1, 806, 1, + 806, 3, 806, 12703, 8, 806, 1, 807, 1, 807, 3, 807, 12707, 8, 807, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 1, 808, 3, 808, 12716, 8, 808, + 1, 809, 1, 809, 3, 809, 12720, 8, 809, 1, 809, 1, 809, 1, 809, 1, 809, + 1, 809, 1, 809, 3, 809, 12728, 8, 809, 3, 809, 12730, 8, 809, 1, 810, 1, + 810, 1, 810, 5, 810, 12735, 8, 810, 10, 810, 12, 810, 12738, 9, 810, 1, + 811, 1, 811, 3, 811, 12742, 8, 811, 1, 811, 3, 811, 12745, 8, 811, 1, 812, + 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 3, 812, 12753, 8, 812, 1, 813, + 1, 813, 1, 813, 1, 813, 1, 813, 1, 814, 1, 814, 3, 814, 12762, 8, 814, + 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 3, 814, 12770, 8, 814, + 3, 814, 12772, 8, 814, 1, 815, 1, 815, 3, 815, 12776, 8, 815, 1, 816, 1, + 816, 1, 816, 5, 816, 12781, 8, 816, 10, 816, 12, 816, 12784, 9, 816, 1, + 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 819, 1, + 819, 1, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 3, 820, 12802, 8, + 820, 1, 821, 1, 821, 1, 822, 1, 822, 1, 822, 5, 822, 12809, 8, 822, 10, + 822, 12, 822, 12812, 9, 822, 1, 823, 1, 823, 1, 823, 3, 823, 12817, 8, + 823, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, + 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 3, + 824, 12836, 8, 824, 1, 824, 1, 824, 1, 825, 1, 825, 1, 825, 5, 825, 12843, + 8, 825, 10, 825, 12, 825, 12846, 9, 825, 1, 826, 1, 826, 1, 826, 3, 826, + 12851, 8, 826, 1, 826, 1, 826, 3, 826, 12855, 8, 826, 1, 827, 4, 827, 12858, + 8, 827, 11, 827, 12, 827, 12859, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, + 1, 828, 1, 828, 1, 828, 3, 828, 12870, 8, 828, 1, 829, 1, 829, 1, 829, + 5, 829, 12875, 8, 829, 10, 829, 12, 829, 12878, 9, 829, 1, 830, 1, 830, + 1, 830, 1, 830, 1, 830, 1, 830, 3, 830, 12886, 8, 830, 1, 831, 3, 831, + 12889, 8, 831, 1, 831, 1, 831, 3, 831, 12893, 8, 831, 1, 831, 1, 831, 1, + 831, 1, 831, 1, 831, 3, 831, 12900, 8, 831, 3, 831, 12902, 8, 831, 1, 831, + 1, 831, 1, 831, 1, 831, 1, 831, 3, 831, 12909, 8, 831, 1, 832, 1, 832, + 3, 832, 12913, 8, 832, 1, 832, 4, 832, 12916, 8, 832, 11, 832, 12, 832, + 12917, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, + 3, 833, 12928, 8, 833, 1, 833, 1, 833, 1, 833, 1, 833, 3, 833, 12934, 8, + 833, 1, 833, 3, 833, 12937, 8, 833, 1, 834, 1, 834, 1, 834, 1, 834, 3, + 834, 12943, 8, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 835, 1, 835, 1, + 836, 1, 836, 1, 836, 1, 836, 3, 836, 12955, 8, 836, 1, 837, 1, 837, 1, + 837, 1, 837, 3, 837, 12961, 8, 837, 1, 837, 3, 837, 12964, 8, 837, 1, 837, + 3, 837, 12967, 8, 837, 1, 838, 1, 838, 1, 838, 1, 838, 1, 839, 1, 839, + 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 3, 839, 12980, 8, 839, 1, 839, + 1, 839, 1, 839, 1, 839, 3, 839, 12986, 8, 839, 1, 839, 1, 839, 3, 839, + 12990, 8, 839, 1, 839, 1, 839, 3, 839, 12994, 8, 839, 1, 839, 3, 839, 12997, + 8, 839, 1, 840, 1, 840, 1, 840, 1, 840, 1, 841, 1, 841, 3, 841, 13005, + 8, 841, 1, 842, 1, 842, 3, 842, 13009, 8, 842, 1, 843, 1, 843, 3, 843, + 13013, 8, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 844, 1, 844, 3, 844, + 13021, 8, 844, 1, 845, 1, 845, 1, 845, 1, 845, 3, 845, 13027, 8, 845, 1, + 845, 1, 845, 3, 845, 13031, 8, 845, 1, 846, 1, 846, 1, 846, 1, 846, 3, + 846, 13037, 8, 846, 1, 846, 1, 846, 3, 846, 13041, 8, 846, 1, 847, 1, 847, + 3, 847, 13045, 8, 847, 1, 847, 1, 847, 1, 847, 1, 847, 3, 847, 13051, 8, + 847, 3, 847, 13053, 8, 847, 1, 848, 1, 848, 1, 849, 1, 849, 1, 849, 1, + 849, 1, 849, 3, 849, 13062, 8, 849, 1, 849, 3, 849, 13065, 8, 849, 1, 850, + 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 3, 851, 13075, + 8, 851, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, + 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 3, 852, 13091, 8, 852, + 1, 852, 1, 852, 1, 852, 1, 852, 3, 852, 13097, 8, 852, 1, 852, 1, 852, + 1, 852, 3, 852, 13102, 8, 852, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, + 3, 853, 13109, 8, 853, 1, 854, 1, 854, 1, 854, 1, 855, 1, 855, 1, 856, + 1, 856, 3, 856, 13118, 8, 856, 1, 857, 1, 857, 1, 857, 5, 857, 13123, 8, + 857, 10, 857, 12, 857, 13126, 9, 857, 1, 858, 1, 858, 1, 858, 5, 858, 13131, + 8, 858, 10, 858, 12, 858, 13134, 9, 858, 1, 859, 1, 859, 1, 859, 5, 859, + 13139, 8, 859, 10, 859, 12, 859, 13142, 9, 859, 1, 860, 1, 860, 3, 860, + 13146, 8, 860, 1, 860, 1, 860, 3, 860, 13150, 8, 860, 1, 860, 1, 860, 1, + 860, 1, 860, 3, 860, 13156, 8, 860, 1, 861, 1, 861, 3, 861, 13160, 8, 861, + 1, 861, 1, 861, 3, 861, 13164, 8, 861, 1, 862, 3, 862, 13167, 8, 862, 1, + 862, 1, 862, 1, 863, 1, 863, 3, 863, 13173, 8, 863, 1, 864, 1, 864, 1, + 864, 3, 864, 13178, 8, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, + 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 3, + 864, 13194, 8, 864, 1, 864, 3, 864, 13197, 8, 864, 3, 864, 13199, 8, 864, + 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, + 1, 865, 3, 865, 13211, 8, 865, 3, 865, 13213, 8, 865, 1, 866, 3, 866, 13216, + 8, 866, 1, 866, 1, 866, 1, 867, 1, 867, 3, 867, 13222, 8, 867, 1, 867, + 1, 867, 1, 867, 1, 867, 3, 867, 13228, 8, 867, 1, 867, 1, 867, 3, 867, + 13232, 8, 867, 3, 867, 13234, 8, 867, 1, 868, 1, 868, 1, 868, 1, 868, 5, + 868, 13240, 8, 868, 10, 868, 12, 868, 13243, 9, 868, 1, 869, 3, 869, 13246, + 8, 869, 1, 869, 1, 869, 1, 870, 1, 870, 1, 870, 5, 870, 13253, 8, 870, + 10, 870, 12, 870, 13256, 9, 870, 1, 871, 1, 871, 1, 871, 5, 871, 13261, + 8, 871, 10, 871, 12, 871, 13264, 9, 871, 1, 872, 1, 872, 1, 872, 3, 872, + 13269, 8, 872, 1, 873, 3, 873, 13272, 8, 873, 1, 873, 1, 873, 1, 874, 1, + 874, 1, 874, 1, 874, 1, 874, 3, 874, 13281, 8, 874, 1, 875, 1, 875, 1, + 875, 3, 875, 13286, 8, 875, 1, 876, 1, 876, 1, 876, 5, 876, 13291, 8, 876, + 10, 876, 12, 876, 13294, 9, 876, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, + 1, 877, 1, 877, 3, 877, 13303, 8, 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, 1, 877, 1, 877, + 1, 877, 1, 877, 3, 877, 13329, 8, 877, 1, 877, 1, 877, 1, 877, 1, 877, + 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 3, 877, 13340, 8, 877, 5, 877, + 13342, 8, 877, 10, 877, 12, 877, 13345, 9, 877, 1, 878, 1, 878, 1, 878, + 1, 878, 1, 878, 3, 878, 13352, 8, 878, 1, 878, 1, 878, 1, 878, 1, 878, + 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, + 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 3, 878, + 13375, 8, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 3, 878, + 13383, 8, 878, 1, 879, 1, 879, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, + 1, 880, 3, 880, 13393, 8, 880, 1, 880, 3, 880, 13396, 8, 880, 1, 880, 1, + 880, 1, 880, 3, 880, 13401, 8, 880, 1, 880, 1, 880, 1, 880, 3, 880, 13406, + 8, 880, 1, 880, 1, 880, 3, 880, 13410, 8, 880, 1, 880, 1, 880, 1, 881, + 1, 881, 3, 881, 13416, 8, 881, 1, 881, 3, 881, 13419, 8, 881, 1, 881, 3, + 881, 13422, 8, 881, 1, 881, 3, 881, 13425, 8, 881, 1, 882, 1, 882, 3, 882, + 13429, 8, 882, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13443, 8, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13450, 8, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 3, 883, 13457, 8, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 3, 883, 13464, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 3, 883, 13482, 8, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 3, 883, 13490, 8, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13502, + 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, + 13520, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 3, 883, 13559, 8, 883, 3, 883, 13561, 8, 883, 1, + 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, + 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, + 883, 13581, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, + 883, 1, 883, 3, 883, 13591, 8, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, + 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, 883, 13602, 8, 883, 1, 883, 1, + 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 3, + 883, 13614, 8, 883, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 3, 884, 13621, + 8, 884, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, + 1, 885, 1, 885, 3, 885, 13633, 8, 885, 1, 886, 1, 886, 1, 886, 1, 886, + 1, 886, 1, 887, 1, 887, 1, 887, 5, 887, 13643, 8, 887, 10, 887, 12, 887, + 13646, 9, 887, 1, 888, 1, 888, 1, 888, 3, 888, 13651, 8, 888, 1, 889, 1, + 889, 1, 890, 1, 890, 1, 890, 1, 890, 3, 890, 13659, 8, 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, 3, 891, 13676, 8, 891, 1, 892, 1, + 892, 1, 892, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 894, 1, + 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 895, 1, 895, 1, 895, 1, 896, 1, + 896, 1, 896, 5, 896, 13699, 8, 896, 10, 896, 12, 896, 13702, 9, 896, 1, + 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 1, 898, 3, 898, 13711, 8, + 898, 1, 899, 1, 899, 3, 899, 13715, 8, 899, 1, 899, 3, 899, 13718, 8, 899, + 1, 899, 3, 899, 13721, 8, 899, 1, 899, 3, 899, 13724, 8, 899, 1, 899, 1, + 899, 1, 900, 1, 900, 1, 901, 1, 901, 1, 901, 1, 901, 1, 902, 1, 902, 1, + 902, 3, 902, 13737, 8, 902, 1, 902, 1, 902, 1, 902, 3, 902, 13742, 8, 902, + 1, 902, 1, 902, 1, 902, 3, 902, 13747, 8, 902, 3, 902, 13749, 8, 902, 1, + 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 3, 903, 13757, 8, 903, 1, + 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 3, 904, 13766, 8, + 904, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 3, 905, 13775, + 8, 905, 1, 906, 1, 906, 1, 906, 3, 906, 13780, 8, 906, 1, 906, 1, 906, + 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 3, 906, 13789, 8, 906, 1, 907, + 1, 907, 1, 907, 3, 907, 13794, 8, 907, 1, 907, 1, 907, 1, 908, 1, 908, + 1, 908, 1, 908, 1, 908, 1, 908, 1, 909, 1, 909, 1, 910, 1, 910, 3, 910, + 13808, 8, 910, 1, 911, 1, 911, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, + 1, 912, 3, 912, 13818, 8, 912, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, + 1, 913, 3, 913, 13826, 8, 913, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, + 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 3, 914, 13840, + 8, 914, 1, 915, 1, 915, 1, 915, 5, 915, 13845, 8, 915, 10, 915, 12, 915, + 13848, 9, 915, 1, 916, 1, 916, 1, 916, 5, 916, 13853, 8, 916, 10, 916, + 12, 916, 13856, 9, 916, 1, 917, 1, 917, 1, 917, 1, 917, 1, 917, 3, 917, + 13863, 8, 917, 1, 918, 1, 918, 1, 918, 5, 918, 13868, 8, 918, 10, 918, + 12, 918, 13871, 9, 918, 1, 919, 1, 919, 1, 919, 3, 919, 13876, 8, 919, + 1, 919, 1, 919, 1, 920, 1, 920, 1, 920, 5, 920, 13883, 8, 920, 10, 920, + 12, 920, 13886, 9, 920, 1, 921, 1, 921, 1, 921, 1, 921, 1, 922, 1, 922, + 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 3, 922, 13900, 8, 922, + 1, 923, 1, 923, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, 1, 924, + 3, 924, 13911, 8, 924, 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, 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, 3, 926, 13944, + 8, 926, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 3, 927, + 13953, 8, 927, 1, 928, 1, 928, 1, 928, 1, 928, 1, 928, 3, 928, 13960, 8, + 928, 1, 929, 1, 929, 3, 929, 13964, 8, 929, 1, 929, 1, 929, 3, 929, 13968, + 8, 929, 1, 929, 1, 929, 1, 930, 4, 930, 13973, 8, 930, 11, 930, 12, 930, + 13974, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 932, 1, 932, 1, 932, + 1, 933, 1, 933, 1, 934, 1, 934, 3, 934, 13989, 8, 934, 1, 935, 1, 935, + 1, 935, 3, 935, 13994, 8, 935, 1, 935, 1, 935, 1, 935, 3, 935, 13999, 8, + 935, 1, 935, 1, 935, 3, 935, 14003, 8, 935, 3, 935, 14005, 8, 935, 1, 935, + 3, 935, 14008, 8, 935, 1, 936, 1, 936, 1, 937, 4, 937, 14013, 8, 937, 11, + 937, 12, 937, 14014, 1, 938, 5, 938, 14018, 8, 938, 10, 938, 12, 938, 14021, + 9, 938, 1, 939, 1, 939, 1, 940, 1, 940, 1, 940, 5, 940, 14028, 8, 940, + 10, 940, 12, 940, 14031, 9, 940, 1, 941, 1, 941, 3, 941, 14035, 8, 941, + 1, 941, 3, 941, 14038, 8, 941, 1, 942, 1, 942, 1, 942, 3, 942, 14043, 8, + 942, 1, 943, 1, 943, 1, 943, 5, 943, 14048, 8, 943, 10, 943, 12, 943, 14051, + 9, 943, 1, 944, 1, 944, 3, 944, 14055, 8, 944, 1, 945, 1, 945, 1, 945, + 5, 945, 14060, 8, 945, 10, 945, 12, 945, 14063, 9, 945, 1, 946, 1, 946, + 1, 947, 1, 947, 1, 948, 1, 948, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, + 1, 949, 1, 949, 3, 949, 14078, 8, 949, 1, 950, 1, 950, 1, 950, 1, 950, + 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 3, 950, 14090, 8, 950, + 1, 950, 1, 950, 1, 950, 3, 950, 14095, 8, 950, 1, 950, 1, 950, 1, 950, + 1, 950, 1, 950, 1, 950, 3, 950, 14103, 8, 950, 1, 950, 1, 950, 1, 950, + 1, 950, 1, 950, 3, 950, 14110, 8, 950, 1, 950, 1, 950, 1, 950, 3, 950, + 14115, 8, 950, 1, 951, 1, 951, 1, 952, 1, 952, 1, 953, 1, 953, 1, 954, + 1, 954, 1, 955, 1, 955, 3, 955, 14127, 8, 955, 1, 956, 1, 956, 1, 956, + 1, 956, 5, 956, 14133, 8, 956, 10, 956, 12, 956, 14136, 9, 956, 1, 956, + 1, 956, 3, 956, 14140, 8, 956, 1, 957, 1, 957, 1, 957, 1, 958, 1, 958, + 1, 958, 1, 958, 1, 958, 3, 958, 14150, 8, 958, 1, 959, 1, 959, 1, 960, + 1, 960, 1, 960, 1, 960, 3, 960, 14158, 8, 960, 1, 961, 1, 961, 1, 961, + 5, 961, 14163, 8, 961, 10, 961, 12, 961, 14166, 9, 961, 1, 962, 1, 962, + 1, 962, 1, 962, 1, 962, 1, 962, 3, 962, 14174, 8, 962, 1, 963, 1, 963, + 1, 963, 1, 963, 3, 963, 14180, 8, 963, 1, 964, 1, 964, 1, 964, 1, 964, + 3, 964, 14186, 8, 964, 1, 965, 1, 965, 1, 965, 1, 965, 3, 965, 14192, 8, + 965, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 3, 966, 14200, 8, + 966, 1, 967, 1, 967, 3, 967, 14204, 8, 967, 1, 967, 1, 967, 1, 967, 1, + 967, 1, 967, 3, 967, 14211, 8, 967, 1, 968, 1, 968, 1, 969, 1, 969, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, + 970, 3, 970, 14308, 8, 970, 1, 971, 1, 971, 1, 972, 1, 972, 1, 973, 1, + 973, 1, 974, 1, 974, 1, 974, 3, 974, 14319, 8, 974, 1, 975, 5, 975, 14322, + 8, 975, 10, 975, 12, 975, 14325, 9, 975, 1, 976, 1, 976, 1, 976, 1, 976, + 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, + 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 3, 976, 14347, + 8, 976, 1, 977, 1, 977, 1, 978, 1, 978, 1, 978, 1, 978, 3, 978, 14355, + 8, 978, 1, 979, 1, 979, 1, 980, 1, 980, 1, 980, 1, 980, 3, 980, 14363, + 8, 980, 1, 980, 1, 980, 3, 980, 14367, 8, 980, 1, 981, 3, 981, 14370, 8, + 981, 1, 981, 1, 981, 3, 981, 14374, 8, 981, 3, 981, 14376, 8, 981, 1, 982, + 1, 982, 1, 983, 4, 983, 14381, 8, 983, 11, 983, 12, 983, 14382, 1, 984, + 1, 984, 1, 984, 1, 984, 1, 985, 1, 985, 1, 985, 3, 985, 14392, 8, 985, + 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 3, 986, 14399, 8, 986, 1, 986, + 1, 986, 3, 986, 14403, 8, 986, 1, 986, 3, 986, 14406, 8, 986, 1, 986, 3, + 986, 14409, 8, 986, 1, 986, 3, 986, 14412, 8, 986, 1, 986, 1, 986, 3, 986, + 14416, 8, 986, 1, 986, 1, 986, 1, 986, 3, 986, 14421, 8, 986, 1, 986, 1, + 986, 1, 987, 1, 987, 1, 987, 3, 987, 14428, 8, 987, 1, 988, 1, 988, 1, + 989, 1, 989, 1, 989, 1, 989, 1, 990, 1, 990, 1, 990, 5, 990, 14439, 8, + 990, 10, 990, 12, 990, 14442, 9, 990, 1, 991, 1, 991, 1, 991, 1, 992, 1, + 992, 1, 993, 1, 993, 3, 993, 14451, 8, 993, 1, 994, 1, 994, 1, 995, 1, + 995, 1, 996, 1, 996, 1, 997, 1, 997, 1, 997, 1, 998, 1, 998, 1, 998, 1, + 999, 1, 999, 1, 999, 1, 1000, 1, 1000, 3, 1000, 14470, 8, 1000, 1, 1001, + 1, 1001, 1, 1002, 5, 1002, 14475, 8, 1002, 10, 1002, 12, 1002, 14478, 9, + 1002, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, + 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, + 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, + 1003, 1, 1003, 1, 1003, 1, 1003, 3, 1003, 14507, 8, 1003, 1, 1004, 1, 1004, + 1, 1004, 1, 1004, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 14517, 8, + 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 3, + 1005, 14526, 8, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 14531, 8, 1005, + 1, 1006, 1, 1006, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1008, + 1, 1008, 3, 1008, 14542, 8, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, + 1009, 1, 1009, 1, 1010, 1, 1010, 1, 1010, 5, 1010, 14553, 8, 1010, 10, + 1010, 12, 1010, 14556, 9, 1010, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, + 1012, 1, 1012, 1, 1013, 1, 1013, 1, 1014, 1, 1014, 3, 1014, 14568, 8, 1014, + 1, 1014, 1, 1014, 1, 1014, 1, 1014, 5, 1014, 14574, 8, 1014, 10, 1014, + 12, 1014, 14577, 9, 1014, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, + 1, 1015, 3, 1015, 14585, 8, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, + 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 5, 1016, 14596, 8, 1016, 10, + 1016, 12, 1016, 14599, 9, 1016, 1, 1017, 1, 1017, 1, 1017, 1, 1018, 1, + 1018, 3, 1018, 14606, 8, 1018, 1, 1018, 1, 1018, 3, 1018, 14610, 8, 1018, + 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1019, 1, 1019, 1, 1020, 4, 1020, + 14619, 8, 1020, 11, 1020, 12, 1020, 14620, 1, 1021, 1, 1021, 1, 1021, 1, + 1021, 1, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1023, 3, 1023, 14632, 8, 1023, + 1, 1023, 1, 1023, 1, 1024, 3, 1024, 14637, 8, 1024, 1, 1024, 1, 1024, 1, + 1024, 1, 1024, 1, 1025, 3, 1025, 14644, 8, 1025, 1, 1025, 1, 1025, 1, 1025, + 1, 1025, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 14654, 8, 1026, 1, + 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 14661, 8, 1026, 1, 1026, + 3, 1026, 14664, 8, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 14670, + 8, 1026, 3, 1026, 14672, 8, 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1028, 1, + 1028, 1, 1028, 1, 1028, 5, 1028, 14681, 8, 1028, 10, 1028, 12, 1028, 14684, + 9, 1028, 1, 1028, 1, 1028, 1, 1029, 1, 1029, 1, 1030, 1, 1030, 1, 1030, + 1, 1031, 1, 1031, 1, 1032, 3, 1032, 14696, 8, 1032, 1, 1032, 1, 1032, 1, + 1032, 3, 1032, 14701, 8, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, + 1, 1033, 1, 1033, 1, 1033, 1, 1034, 1, 1034, 3, 1034, 14713, 8, 1034, 1, + 1034, 3, 1034, 14716, 8, 1034, 1, 1034, 1, 1034, 1, 1035, 1, 1035, 1, 1036, + 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 1, 1036, 3, 1036, 14729, 8, + 1036, 1, 1036, 3, 1036, 14732, 8, 1036, 1, 1036, 3, 1036, 14735, 8, 1036, + 3, 1036, 14737, 8, 1036, 1, 1036, 1, 1036, 1, 1037, 1, 1037, 1, 1038, 1, + 1038, 3, 1038, 14745, 8, 1038, 1, 1038, 1, 1038, 3, 1038, 14749, 8, 1038, + 1, 1038, 3, 1038, 14752, 8, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 3, + 1038, 14758, 8, 1038, 1, 1038, 1, 1038, 3, 1038, 14762, 8, 1038, 1, 1038, + 1, 1038, 1, 1038, 1, 1038, 3, 1038, 14768, 8, 1038, 1, 1038, 1, 1038, 1, + 1038, 3, 1038, 14773, 8, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 3, 1038, + 14779, 8, 1038, 1, 1038, 3, 1038, 14782, 8, 1038, 1, 1038, 1, 1038, 3, + 1038, 14786, 8, 1038, 1, 1039, 1, 1039, 1, 1040, 1, 1040, 4, 1040, 14792, + 8, 1040, 11, 1040, 12, 1040, 14793, 1, 1041, 1, 1041, 1, 1041, 1, 1042, + 1, 1042, 1, 1042, 1, 1042, 1, 1043, 1, 1043, 1, 1043, 5, 1043, 14806, 8, + 1043, 10, 1043, 12, 1043, 14809, 9, 1043, 1, 1044, 1, 1044, 1, 1044, 3, + 1044, 14814, 8, 1044, 1, 1044, 1, 1044, 1, 1045, 1, 1045, 1, 1045, 1, 1046, + 1, 1046, 1, 1046, 1, 1046, 1, 1046, 3, 1046, 14826, 8, 1046, 1, 1046, 1, + 1046, 1, 1047, 1, 1047, 1, 1047, 1, 1048, 1, 1048, 1, 1048, 3, 1048, 14836, + 8, 1048, 1, 1048, 3, 1048, 14839, 8, 1048, 1, 1048, 3, 1048, 14842, 8, + 1048, 1, 1048, 3, 1048, 14845, 8, 1048, 1, 1048, 3, 1048, 14848, 8, 1048, + 1, 1048, 1, 1048, 1, 1049, 1, 1049, 1, 1049, 1, 1050, 1, 1050, 1, 1050, + 5, 1050, 14858, 8, 1050, 10, 1050, 12, 1050, 14861, 9, 1050, 1, 1051, 1, + 1051, 3, 1051, 14865, 8, 1051, 1, 1051, 1, 1051, 1, 1052, 1, 1052, 1, 1052, + 3, 1052, 14872, 8, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 3, + 1052, 14879, 8, 1052, 3, 1052, 14881, 8, 1052, 1, 1052, 1, 1052, 1, 1052, + 1, 1052, 1, 1052, 3, 1052, 14888, 8, 1052, 3, 1052, 14890, 8, 1052, 1, + 1052, 1, 1052, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 3, 1053, 14899, + 8, 1053, 1, 1054, 1, 1054, 1, 1054, 5, 1054, 14904, 8, 1054, 10, 1054, + 12, 1054, 14907, 9, 1054, 1, 1055, 1, 1055, 1, 1055, 1, 1056, 3, 1056, + 14913, 8, 1056, 1, 1056, 1, 1056, 1, 1057, 1, 1057, 1, 1058, 1, 1058, 3, + 1058, 14921, 8, 1058, 1, 1058, 3, 1058, 14924, 8, 1058, 1, 1058, 1, 1058, + 1, 1058, 1, 1058, 1, 1058, 1, 1059, 1, 1059, 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, 3, 1061, 14948, 8, 1061, 3, 1061, 14950, + 8, 1061, 1, 1062, 1, 1062, 3, 1062, 14954, 8, 1062, 1, 1062, 1, 1062, 1, + 1062, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1064, 1, 1064, 1, 1064, 1, + 1065, 1, 1065, 3, 1065, 14968, 8, 1065, 1, 1065, 1, 1065, 1, 1066, 1, 1066, + 3, 1066, 14974, 8, 1066, 1, 1066, 1, 1066, 1, 1067, 1, 1067, 3, 1067, 14980, + 8, 1067, 1, 1067, 1, 1067, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1068, 1, 1068, 1, 1068, 3, 1068, 14993, 8, 1068, 1, 1068, 3, + 1068, 14996, 8, 1068, 1, 1069, 1, 1069, 3, 1069, 15000, 8, 1069, 1, 1070, + 1, 1070, 1, 1070, 1, 1071, 4, 1071, 15006, 8, 1071, 11, 1071, 12, 1071, + 15007, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1073, 1, 1073, 1, + 1073, 5, 1073, 15018, 8, 1073, 10, 1073, 12, 1073, 15021, 9, 1073, 1, 1074, + 1, 1074, 1, 1074, 3, 1074, 15026, 8, 1074, 1, 1075, 1, 1075, 1, 1076, 1, + 1076, 1, 1077, 1, 1077, 1, 1078, 1, 1078, 1, 1078, 1, 1079, 1, 1079, 3, + 1079, 15039, 8, 1079, 1, 1080, 1, 1080, 1, 1081, 3, 1081, 15044, 8, 1081, + 1, 1081, 3, 1081, 15047, 8, 1081, 1, 1081, 3, 1081, 15050, 8, 1081, 1, + 1081, 3, 1081, 15053, 8, 1081, 1, 1081, 3, 1081, 15056, 8, 1081, 1, 1081, + 3, 1081, 15059, 8, 1081, 1, 1081, 3, 1081, 15062, 8, 1081, 1, 1082, 1, + 1082, 1, 1083, 1, 1083, 1, 1084, 1, 1084, 1, 1085, 1, 1085, 1, 1086, 1, + 1086, 3, 1086, 15074, 8, 1086, 1, 1087, 1, 1087, 3, 1087, 15078, 8, 1087, + 1, 1087, 1, 1087, 1, 1087, 0, 1, 1754, 1088, 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, 0, 113, 2, 0, 199, 199, 362, 362, 2, 0, 496, 496, + 502, 502, 2, 0, 10, 10, 95, 95, 2, 0, 66, 66, 316, 316, 2, 0, 100, 100, + 316, 316, 2, 0, 464, 465, 845, 845, 2, 0, 213, 213, 313, 313, 2, 0, 135, + 135, 195, 195, 2, 0, 249, 249, 330, 330, 2, 0, 164, 164, 361, 361, 2, 0, + 184, 184, 225, 225, 5, 0, 30, 30, 285, 285, 327, 327, 350, 350, 352, 352, + 2, 0, 152, 152, 313, 313, 3, 0, 483, 484, 843, 843, 850, 850, 2, 0, 80, + 80, 273, 273, 2, 0, 33, 33, 82, 82, 1, 0, 486, 487, 4, 0, 173, 174, 513, + 513, 517, 517, 521, 521, 2, 0, 64, 64, 95, 95, 4, 0, 30, 30, 240, 240, + 420, 420, 842, 842, 1, 0, 840, 841, 2, 0, 350, 350, 352, 352, 2, 0, 843, + 843, 850, 850, 2, 0, 204, 204, 228, 228, 9, 0, 30, 30, 162, 162, 167, 167, + 183, 183, 223, 223, 231, 231, 340, 340, 343, 343, 608, 608, 3, 0, 115, + 115, 281, 281, 334, 334, 2, 0, 53, 53, 78, 78, 2, 0, 266, 266, 383, 383, + 3, 0, 176, 176, 256, 256, 259, 259, 5, 0, 30, 30, 89, 89, 186, 186, 236, + 236, 367, 367, 2, 0, 93, 93, 230, 230, 1, 0, 647, 648, 2, 0, 93, 93, 577, + 577, 2, 0, 339, 339, 577, 577, 2, 0, 215, 215, 294, 294, 3, 0, 319, 319, + 355, 355, 643, 643, 2, 0, 207, 207, 629, 629, 3, 0, 46, 46, 140, 140, 195, + 195, 2, 0, 46, 46, 195, 195, 2, 0, 140, 140, 332, 332, 2, 0, 89, 89, 367, + 367, 2, 0, 140, 140, 195, 195, 4, 0, 46, 46, 140, 140, 195, 195, 628, 628, + 5, 0, 46, 46, 140, 140, 350, 350, 352, 352, 628, 628, 8, 0, 87, 87, 89, + 89, 140, 140, 186, 186, 195, 195, 236, 236, 356, 356, 367, 367, 5, 0, 216, + 216, 327, 327, 348, 348, 359, 359, 654, 656, 2, 0, 37, 37, 55, 55, 3, 0, + 226, 226, 336, 336, 375, 375, 3, 0, 68, 68, 562, 562, 652, 652, 2, 0, 10, + 10, 53, 53, 5, 0, 93, 93, 179, 179, 230, 230, 321, 321, 347, 347, 3, 0, + 179, 179, 321, 321, 347, 347, 3, 0, 111, 111, 130, 130, 349, 349, 4, 0, + 89, 89, 186, 186, 236, 236, 367, 367, 2, 0, 139, 139, 237, 237, 2, 0, 354, + 354, 378, 378, 2, 0, 153, 153, 249, 249, 2, 0, 135, 135, 472, 472, 2, 0, + 60, 60, 97, 97, 2, 0, 55, 55, 468, 468, 3, 0, 411, 411, 493, 493, 569, + 569, 2, 0, 464, 464, 638, 638, 3, 0, 174, 174, 513, 518, 521, 521, 2, 0, + 203, 203, 639, 639, 2, 0, 420, 420, 569, 569, 1, 0, 426, 430, 1, 0, 431, + 433, 1, 0, 480, 481, 2, 0, 482, 482, 586, 586, 1, 0, 31, 32, 2, 0, 173, + 174, 521, 521, 1, 0, 451, 453, 1, 0, 464, 465, 2, 0, 328, 328, 335, 335, + 2, 0, 311, 311, 331, 331, 2, 0, 100, 100, 347, 347, 2, 0, 205, 205, 332, + 332, 2, 0, 59, 59, 98, 98, 2, 0, 217, 217, 249, 249, 2, 0, 30, 30, 56, + 56, 2, 0, 318, 318, 577, 577, 2, 0, 211, 211, 265, 265, 4, 0, 115, 115, + 117, 117, 121, 121, 128, 128, 2, 0, 358, 358, 676, 676, 2, 0, 553, 554, + 568, 568, 1, 0, 553, 554, 1, 0, 581, 582, 1, 0, 18, 19, 2, 0, 119, 119, + 124, 124, 5, 0, 10, 10, 16, 17, 21, 21, 23, 23, 25, 25, 2, 0, 246, 246, + 291, 291, 1, 0, 12, 13, 3, 0, 9, 9, 14, 14, 27, 27, 3, 0, 39, 39, 73, 73, + 96, 96, 2, 0, 168, 168, 192, 192, 2, 0, 302, 302, 649, 649, 2, 0, 212, + 212, 286, 286, 3, 0, 30, 30, 34, 34, 91, 91, 6, 0, 9, 10, 12, 17, 21, 21, + 23, 23, 25, 25, 27, 27, 2, 0, 20, 20, 22, 22, 1, 0, 682, 685, 19, 0, 86, + 86, 126, 126, 131, 173, 175, 177, 179, 253, 255, 256, 258, 286, 288, 308, + 310, 384, 391, 392, 394, 548, 573, 573, 603, 610, 639, 651, 654, 668, 670, + 670, 672, 672, 674, 674, 677, 687, 6, 0, 107, 108, 110, 120, 122, 125, + 127, 127, 129, 130, 671, 671, 5, 0, 30, 52, 54, 70, 72, 85, 87, 106, 653, + 653, 6, 0, 52, 52, 309, 309, 588, 594, 703, 703, 712, 712, 720, 834, 2, + 0, 62, 62, 118, 118, 2, 0, 10, 10, 20, 20, 2, 0, 604, 604, 700, 700, 2, + 0, 169, 169, 706, 706, 1, 0, 711, 716, 2, 0, 64, 64, 68, 68, 2, 0, 146, + 146, 214, 214, 36, 0, 33, 33, 35, 35, 43, 45, 53, 53, 57, 57, 61, 61, 93, + 93, 118, 118, 125, 125, 132, 132, 146, 146, 155, 155, 159, 159, 163, 163, + 169, 169, 175, 175, 211, 211, 214, 214, 236, 236, 244, 244, 262, 262, 265, + 266, 276, 276, 291, 291, 305, 305, 311, 311, 317, 317, 321, 322, 331, 331, + 358, 358, 603, 604, 676, 676, 689, 701, 705, 711, 713, 717, 719, 719, 16714, + 0, 2176, 1, 0, 0, 0, 2, 2179, 1, 0, 0, 0, 4, 2181, 1, 0, 0, 0, 6, 2189, + 1, 0, 0, 0, 8, 2375, 1, 0, 0, 0, 10, 2377, 1, 0, 0, 0, 12, 2381, 1, 0, + 0, 0, 14, 2384, 1, 0, 0, 0, 16, 2392, 1, 0, 0, 0, 18, 2397, 1, 0, 0, 0, + 20, 2414, 1, 0, 0, 0, 22, 2467, 1, 0, 0, 0, 24, 2479, 1, 0, 0, 0, 26, 2481, + 1, 0, 0, 0, 28, 2489, 1, 0, 0, 0, 30, 2506, 1, 0, 0, 0, 32, 2508, 1, 0, + 0, 0, 34, 2512, 1, 0, 0, 0, 36, 2523, 1, 0, 0, 0, 38, 2534, 1, 0, 0, 0, + 40, 2540, 1, 0, 0, 0, 42, 2547, 1, 0, 0, 0, 44, 2551, 1, 0, 0, 0, 46, 2559, + 1, 0, 0, 0, 48, 2566, 1, 0, 0, 0, 50, 2592, 1, 0, 0, 0, 52, 2594, 1, 0, + 0, 0, 54, 2597, 1, 0, 0, 0, 56, 2609, 1, 0, 0, 0, 58, 2619, 1, 0, 0, 0, + 60, 2621, 1, 0, 0, 0, 62, 2635, 1, 0, 0, 0, 64, 2637, 1, 0, 0, 0, 66, 2668, + 1, 0, 0, 0, 68, 2670, 1, 0, 0, 0, 70, 2678, 1, 0, 0, 0, 72, 2688, 1, 0, + 0, 0, 74, 2695, 1, 0, 0, 0, 76, 2701, 1, 0, 0, 0, 78, 2719, 1, 0, 0, 0, + 80, 2723, 1, 0, 0, 0, 82, 2727, 1, 0, 0, 0, 84, 2729, 1, 0, 0, 0, 86, 2740, + 1, 0, 0, 0, 88, 2744, 1, 0, 0, 0, 90, 2749, 1, 0, 0, 0, 92, 2754, 1, 0, + 0, 0, 94, 2756, 1, 0, 0, 0, 96, 2771, 1, 0, 0, 0, 98, 2778, 1, 0, 0, 0, + 100, 2780, 1, 0, 0, 0, 102, 2782, 1, 0, 0, 0, 104, 2784, 1, 0, 0, 0, 106, + 2787, 1, 0, 0, 0, 108, 2998, 1, 0, 0, 0, 110, 3002, 1, 0, 0, 0, 112, 3036, + 1, 0, 0, 0, 114, 3038, 1, 0, 0, 0, 116, 3344, 1, 0, 0, 0, 118, 3351, 1, + 0, 0, 0, 120, 3353, 1, 0, 0, 0, 122, 3355, 1, 0, 0, 0, 124, 3358, 1, 0, + 0, 0, 126, 3367, 1, 0, 0, 0, 128, 3369, 1, 0, 0, 0, 130, 3373, 1, 0, 0, + 0, 132, 3376, 1, 0, 0, 0, 134, 3384, 1, 0, 0, 0, 136, 3396, 1, 0, 0, 0, + 138, 3413, 1, 0, 0, 0, 140, 3441, 1, 0, 0, 0, 142, 3443, 1, 0, 0, 0, 144, + 3446, 1, 0, 0, 0, 146, 3454, 1, 0, 0, 0, 148, 3459, 1, 0, 0, 0, 150, 3497, + 1, 0, 0, 0, 152, 3499, 1, 0, 0, 0, 154, 3558, 1, 0, 0, 0, 156, 3575, 1, + 0, 0, 0, 158, 3578, 1, 0, 0, 0, 160, 3587, 1, 0, 0, 0, 162, 3596, 1, 0, + 0, 0, 164, 3609, 1, 0, 0, 0, 166, 3611, 1, 0, 0, 0, 168, 3613, 1, 0, 0, + 0, 170, 3618, 1, 0, 0, 0, 172, 3625, 1, 0, 0, 0, 174, 3630, 1, 0, 0, 0, + 176, 3672, 1, 0, 0, 0, 178, 3674, 1, 0, 0, 0, 180, 3677, 1, 0, 0, 0, 182, + 3682, 1, 0, 0, 0, 184, 3684, 1, 0, 0, 0, 186, 3692, 1, 0, 0, 0, 188, 3703, + 1, 0, 0, 0, 190, 3705, 1, 0, 0, 0, 192, 3713, 1, 0, 0, 0, 194, 3715, 1, + 0, 0, 0, 196, 3757, 1, 0, 0, 0, 198, 3760, 1, 0, 0, 0, 200, 3764, 1, 0, + 0, 0, 202, 3766, 1, 0, 0, 0, 204, 3770, 1, 0, 0, 0, 206, 3778, 1, 0, 0, + 0, 208, 3789, 1, 0, 0, 0, 210, 3793, 1, 0, 0, 0, 212, 3795, 1, 0, 0, 0, + 214, 3804, 1, 0, 0, 0, 216, 3846, 1, 0, 0, 0, 218, 3848, 1, 0, 0, 0, 220, + 3858, 1, 0, 0, 0, 222, 3869, 1, 0, 0, 0, 224, 3926, 1, 0, 0, 0, 226, 3928, + 1, 0, 0, 0, 228, 3937, 1, 0, 0, 0, 230, 3944, 1, 0, 0, 0, 232, 3946, 1, + 0, 0, 0, 234, 3954, 1, 0, 0, 0, 236, 3957, 1, 0, 0, 0, 238, 3964, 1, 0, + 0, 0, 240, 4055, 1, 0, 0, 0, 242, 4057, 1, 0, 0, 0, 244, 4060, 1, 0, 0, + 0, 246, 4064, 1, 0, 0, 0, 248, 4072, 1, 0, 0, 0, 250, 4074, 1, 0, 0, 0, + 252, 4079, 1, 0, 0, 0, 254, 4082, 1, 0, 0, 0, 256, 4090, 1, 0, 0, 0, 258, + 4100, 1, 0, 0, 0, 260, 4113, 1, 0, 0, 0, 262, 4115, 1, 0, 0, 0, 264, 4119, + 1, 0, 0, 0, 266, 4132, 1, 0, 0, 0, 268, 4134, 1, 0, 0, 0, 270, 4139, 1, + 0, 0, 0, 272, 4141, 1, 0, 0, 0, 274, 4148, 1, 0, 0, 0, 276, 4179, 1, 0, + 0, 0, 278, 4181, 1, 0, 0, 0, 280, 4188, 1, 0, 0, 0, 282, 4190, 1, 0, 0, + 0, 284, 4199, 1, 0, 0, 0, 286, 4203, 1, 0, 0, 0, 288, 4219, 1, 0, 0, 0, + 290, 4222, 1, 0, 0, 0, 292, 4229, 1, 0, 0, 0, 294, 4231, 1, 0, 0, 0, 296, + 4236, 1, 0, 0, 0, 298, 4240, 1, 0, 0, 0, 300, 4256, 1, 0, 0, 0, 302, 4267, + 1, 0, 0, 0, 304, 4276, 1, 0, 0, 0, 306, 4304, 1, 0, 0, 0, 308, 4321, 1, + 0, 0, 0, 310, 4323, 1, 0, 0, 0, 312, 4326, 1, 0, 0, 0, 314, 4332, 1, 0, + 0, 0, 316, 4351, 1, 0, 0, 0, 318, 4355, 1, 0, 0, 0, 320, 4368, 1, 0, 0, + 0, 322, 4382, 1, 0, 0, 0, 324, 4391, 1, 0, 0, 0, 326, 4393, 1, 0, 0, 0, + 328, 4398, 1, 0, 0, 0, 330, 4438, 1, 0, 0, 0, 332, 4440, 1, 0, 0, 0, 334, + 4448, 1, 0, 0, 0, 336, 4450, 1, 0, 0, 0, 338, 4458, 1, 0, 0, 0, 340, 4480, + 1, 0, 0, 0, 342, 4482, 1, 0, 0, 0, 344, 4486, 1, 0, 0, 0, 346, 4493, 1, + 0, 0, 0, 348, 4495, 1, 0, 0, 0, 350, 4497, 1, 0, 0, 0, 352, 4499, 1, 0, + 0, 0, 354, 4510, 1, 0, 0, 0, 356, 4513, 1, 0, 0, 0, 358, 4521, 1, 0, 0, + 0, 360, 4537, 1, 0, 0, 0, 362, 4547, 1, 0, 0, 0, 364, 4549, 1, 0, 0, 0, + 366, 4558, 1, 0, 0, 0, 368, 4561, 1, 0, 0, 0, 370, 4668, 1, 0, 0, 0, 372, + 4670, 1, 0, 0, 0, 374, 4689, 1, 0, 0, 0, 376, 4692, 1, 0, 0, 0, 378, 4696, + 1, 0, 0, 0, 380, 4715, 1, 0, 0, 0, 382, 4717, 1, 0, 0, 0, 384, 4722, 1, + 0, 0, 0, 386, 4730, 1, 0, 0, 0, 388, 4735, 1, 0, 0, 0, 390, 4750, 1, 0, + 0, 0, 392, 4752, 1, 0, 0, 0, 394, 4755, 1, 0, 0, 0, 396, 4757, 1, 0, 0, + 0, 398, 4794, 1, 0, 0, 0, 400, 4796, 1, 0, 0, 0, 402, 4799, 1, 0, 0, 0, + 404, 4804, 1, 0, 0, 0, 406, 4806, 1, 0, 0, 0, 408, 4888, 1, 0, 0, 0, 410, + 4890, 1, 0, 0, 0, 412, 4908, 1, 0, 0, 0, 414, 4910, 1, 0, 0, 0, 416, 4938, + 1, 0, 0, 0, 418, 4942, 1, 0, 0, 0, 420, 4962, 1, 0, 0, 0, 422, 4964, 1, + 0, 0, 0, 424, 4973, 1, 0, 0, 0, 426, 4993, 1, 0, 0, 0, 428, 5007, 1, 0, + 0, 0, 430, 5012, 1, 0, 0, 0, 432, 5018, 1, 0, 0, 0, 434, 5021, 1, 0, 0, + 0, 436, 5024, 1, 0, 0, 0, 438, 5027, 1, 0, 0, 0, 440, 5030, 1, 0, 0, 0, + 442, 5032, 1, 0, 0, 0, 444, 5041, 1, 0, 0, 0, 446, 5091, 1, 0, 0, 0, 448, + 5097, 1, 0, 0, 0, 450, 5099, 1, 0, 0, 0, 452, 5114, 1, 0, 0, 0, 454, 5116, + 1, 0, 0, 0, 456, 5120, 1, 0, 0, 0, 458, 5124, 1, 0, 0, 0, 460, 5131, 1, + 0, 0, 0, 462, 5133, 1, 0, 0, 0, 464, 5135, 1, 0, 0, 0, 466, 5137, 1, 0, + 0, 0, 468, 5143, 1, 0, 0, 0, 470, 5145, 1, 0, 0, 0, 472, 5147, 1, 0, 0, + 0, 474, 5152, 1, 0, 0, 0, 476, 5156, 1, 0, 0, 0, 478, 5169, 1, 0, 0, 0, + 480, 5171, 1, 0, 0, 0, 482, 5177, 1, 0, 0, 0, 484, 5191, 1, 0, 0, 0, 486, + 5219, 1, 0, 0, 0, 488, 5221, 1, 0, 0, 0, 490, 5229, 1, 0, 0, 0, 492, 5235, + 1, 0, 0, 0, 494, 5243, 1, 0, 0, 0, 496, 5255, 1, 0, 0, 0, 498, 5257, 1, + 0, 0, 0, 500, 5380, 1, 0, 0, 0, 502, 5382, 1, 0, 0, 0, 504, 5386, 1, 0, + 0, 0, 506, 5394, 1, 0, 0, 0, 508, 5405, 1, 0, 0, 0, 510, 5407, 1, 0, 0, + 0, 512, 5411, 1, 0, 0, 0, 514, 5419, 1, 0, 0, 0, 516, 5423, 1, 0, 0, 0, + 518, 5425, 1, 0, 0, 0, 520, 5476, 1, 0, 0, 0, 522, 5478, 1, 0, 0, 0, 524, + 5482, 1, 0, 0, 0, 526, 5500, 1, 0, 0, 0, 528, 5539, 1, 0, 0, 0, 530, 5541, + 1, 0, 0, 0, 532, 5543, 1, 0, 0, 0, 534, 5552, 1, 0, 0, 0, 536, 5554, 1, + 0, 0, 0, 538, 5556, 1, 0, 0, 0, 540, 5581, 1, 0, 0, 0, 542, 5583, 1, 0, + 0, 0, 544, 5603, 1, 0, 0, 0, 546, 5625, 1, 0, 0, 0, 548, 5647, 1, 0, 0, + 0, 550, 5649, 1, 0, 0, 0, 552, 5656, 1, 0, 0, 0, 554, 5753, 1, 0, 0, 0, + 556, 5778, 1, 0, 0, 0, 558, 5786, 1, 0, 0, 0, 560, 5802, 1, 0, 0, 0, 562, + 5804, 1, 0, 0, 0, 564, 5806, 1, 0, 0, 0, 566, 5814, 1, 0, 0, 0, 568, 5820, + 1, 0, 0, 0, 570, 5824, 1, 0, 0, 0, 572, 5832, 1, 0, 0, 0, 574, 5847, 1, + 0, 0, 0, 576, 5996, 1, 0, 0, 0, 578, 6000, 1, 0, 0, 0, 580, 6113, 1, 0, + 0, 0, 582, 6115, 1, 0, 0, 0, 584, 6120, 1, 0, 0, 0, 586, 6122, 1, 0, 0, + 0, 588, 6140, 1, 0, 0, 0, 590, 6152, 1, 0, 0, 0, 592, 6154, 1, 0, 0, 0, + 594, 6166, 1, 0, 0, 0, 596, 6186, 1, 0, 0, 0, 598, 6208, 1, 0, 0, 0, 600, + 6210, 1, 0, 0, 0, 602, 6224, 1, 0, 0, 0, 604, 6235, 1, 0, 0, 0, 606, 6293, + 1, 0, 0, 0, 608, 6295, 1, 0, 0, 0, 610, 6305, 1, 0, 0, 0, 612, 6307, 1, + 0, 0, 0, 614, 6317, 1, 0, 0, 0, 616, 6335, 1, 0, 0, 0, 618, 6353, 1, 0, + 0, 0, 620, 6371, 1, 0, 0, 0, 622, 6381, 1, 0, 0, 0, 624, 6400, 1, 0, 0, + 0, 626, 6414, 1, 0, 0, 0, 628, 6453, 1, 0, 0, 0, 630, 6458, 1, 0, 0, 0, + 632, 6460, 1, 0, 0, 0, 634, 6480, 1, 0, 0, 0, 636, 6482, 1, 0, 0, 0, 638, + 6484, 1, 0, 0, 0, 640, 6501, 1, 0, 0, 0, 642, 6503, 1, 0, 0, 0, 644, 6511, + 1, 0, 0, 0, 646, 6530, 1, 0, 0, 0, 648, 6532, 1, 0, 0, 0, 650, 6542, 1, + 0, 0, 0, 652, 6550, 1, 0, 0, 0, 654, 6565, 1, 0, 0, 0, 656, 6577, 1, 0, + 0, 0, 658, 6579, 1, 0, 0, 0, 660, 6587, 1, 0, 0, 0, 662, 6607, 1, 0, 0, + 0, 664, 6609, 1, 0, 0, 0, 666, 6619, 1, 0, 0, 0, 668, 6675, 1, 0, 0, 0, + 670, 6686, 1, 0, 0, 0, 672, 6688, 1, 0, 0, 0, 674, 6690, 1, 0, 0, 0, 676, + 6700, 1, 0, 0, 0, 678, 6702, 1, 0, 0, 0, 680, 6704, 1, 0, 0, 0, 682, 6721, + 1, 0, 0, 0, 684, 6725, 1, 0, 0, 0, 686, 6729, 1, 0, 0, 0, 688, 6733, 1, + 0, 0, 0, 690, 6737, 1, 0, 0, 0, 692, 6753, 1, 0, 0, 0, 694, 6755, 1, 0, + 0, 0, 696, 6764, 1, 0, 0, 0, 698, 6786, 1, 0, 0, 0, 700, 6788, 1, 0, 0, + 0, 702, 6799, 1, 0, 0, 0, 704, 6801, 1, 0, 0, 0, 706, 6803, 1, 0, 0, 0, + 708, 6817, 1, 0, 0, 0, 710, 6828, 1, 0, 0, 0, 712, 6830, 1, 0, 0, 0, 714, + 6836, 1, 0, 0, 0, 716, 6840, 1, 0, 0, 0, 718, 6857, 1, 0, 0, 0, 720, 6859, + 1, 0, 0, 0, 722, 6863, 1, 0, 0, 0, 724, 6874, 1, 0, 0, 0, 726, 6886, 1, + 0, 0, 0, 728, 6888, 1, 0, 0, 0, 730, 6902, 1, 0, 0, 0, 732, 6929, 1, 0, + 0, 0, 734, 6974, 1, 0, 0, 0, 736, 6982, 1, 0, 0, 0, 738, 6984, 1, 0, 0, + 0, 740, 6996, 1, 0, 0, 0, 742, 7016, 1, 0, 0, 0, 744, 7036, 1, 0, 0, 0, + 746, 7056, 1, 0, 0, 0, 748, 7068, 1, 0, 0, 0, 750, 7147, 1, 0, 0, 0, 752, + 7152, 1, 0, 0, 0, 754, 7154, 1, 0, 0, 0, 756, 7165, 1, 0, 0, 0, 758, 7176, + 1, 0, 0, 0, 760, 7193, 1, 0, 0, 0, 762, 7224, 1, 0, 0, 0, 764, 7324, 1, + 0, 0, 0, 766, 7341, 1, 0, 0, 0, 768, 7343, 1, 0, 0, 0, 770, 7369, 1, 0, + 0, 0, 772, 7431, 1, 0, 0, 0, 774, 7433, 1, 0, 0, 0, 776, 7441, 1, 0, 0, + 0, 778, 7446, 1, 0, 0, 0, 780, 7450, 1, 0, 0, 0, 782, 7483, 1, 0, 0, 0, + 784, 7485, 1, 0, 0, 0, 786, 7489, 1, 0, 0, 0, 788, 7493, 1, 0, 0, 0, 790, + 7502, 1, 0, 0, 0, 792, 7514, 1, 0, 0, 0, 794, 7546, 1, 0, 0, 0, 796, 7548, + 1, 0, 0, 0, 798, 7550, 1, 0, 0, 0, 800, 7589, 1, 0, 0, 0, 802, 7591, 1, + 0, 0, 0, 804, 7593, 1, 0, 0, 0, 806, 7595, 1, 0, 0, 0, 808, 7598, 1, 0, + 0, 0, 810, 7629, 1, 0, 0, 0, 812, 7642, 1, 0, 0, 0, 814, 7644, 1, 0, 0, + 0, 816, 7649, 1, 0, 0, 0, 818, 7657, 1, 0, 0, 0, 820, 7660, 1, 0, 0, 0, + 822, 7662, 1, 0, 0, 0, 824, 7668, 1, 0, 0, 0, 826, 7670, 1, 0, 0, 0, 828, + 7691, 1, 0, 0, 0, 830, 7714, 1, 0, 0, 0, 832, 7716, 1, 0, 0, 0, 834, 7719, + 1, 0, 0, 0, 836, 7744, 1, 0, 0, 0, 838, 7746, 1, 0, 0, 0, 840, 7752, 1, + 0, 0, 0, 842, 7760, 1, 0, 0, 0, 844, 7776, 1, 0, 0, 0, 846, 7778, 1, 0, + 0, 0, 848, 7784, 1, 0, 0, 0, 850, 7805, 1, 0, 0, 0, 852, 7807, 1, 0, 0, + 0, 854, 7813, 1, 0, 0, 0, 856, 7815, 1, 0, 0, 0, 858, 7831, 1, 0, 0, 0, + 860, 7833, 1, 0, 0, 0, 862, 7838, 1, 0, 0, 0, 864, 7840, 1, 0, 0, 0, 866, + 7855, 1, 0, 0, 0, 868, 7863, 1, 0, 0, 0, 870, 7866, 1, 0, 0, 0, 872, 7875, + 1, 0, 0, 0, 874, 7916, 1, 0, 0, 0, 876, 7931, 1, 0, 0, 0, 878, 7938, 1, + 0, 0, 0, 880, 7940, 1, 0, 0, 0, 882, 7952, 1, 0, 0, 0, 884, 7955, 1, 0, + 0, 0, 886, 7958, 1, 0, 0, 0, 888, 7966, 1, 0, 0, 0, 890, 7978, 1, 0, 0, + 0, 892, 7991, 1, 0, 0, 0, 894, 7995, 1, 0, 0, 0, 896, 8039, 1, 0, 0, 0, + 898, 8055, 1, 0, 0, 0, 900, 8071, 1, 0, 0, 0, 902, 8095, 1, 0, 0, 0, 904, + 8102, 1, 0, 0, 0, 906, 8107, 1, 0, 0, 0, 908, 8115, 1, 0, 0, 0, 910, 8118, + 1, 0, 0, 0, 912, 8122, 1, 0, 0, 0, 914, 8129, 1, 0, 0, 0, 916, 8168, 1, + 0, 0, 0, 918, 8174, 1, 0, 0, 0, 920, 8176, 1, 0, 0, 0, 922, 8189, 1, 0, + 0, 0, 924, 8192, 1, 0, 0, 0, 926, 8239, 1, 0, 0, 0, 928, 8241, 1, 0, 0, + 0, 930, 8287, 1, 0, 0, 0, 932, 8289, 1, 0, 0, 0, 934, 8291, 1, 0, 0, 0, + 936, 8293, 1, 0, 0, 0, 938, 8301, 1, 0, 0, 0, 940, 8315, 1, 0, 0, 0, 942, + 8804, 1, 0, 0, 0, 944, 8806, 1, 0, 0, 0, 946, 8808, 1, 0, 0, 0, 948, 8880, + 1, 0, 0, 0, 950, 8882, 1, 0, 0, 0, 952, 9101, 1, 0, 0, 0, 954, 9103, 1, + 0, 0, 0, 956, 9111, 1, 0, 0, 0, 958, 9127, 1, 0, 0, 0, 960, 9134, 1, 0, + 0, 0, 962, 9136, 1, 0, 0, 0, 964, 9329, 1, 0, 0, 0, 966, 9354, 1, 0, 0, + 0, 968, 9356, 1, 0, 0, 0, 970, 9402, 1, 0, 0, 0, 972, 9404, 1, 0, 0, 0, + 974, 9433, 1, 0, 0, 0, 976, 9435, 1, 0, 0, 0, 978, 9445, 1, 0, 0, 0, 980, + 9453, 1, 0, 0, 0, 982, 9500, 1, 0, 0, 0, 984, 9516, 1, 0, 0, 0, 986, 9518, + 1, 0, 0, 0, 988, 9544, 1, 0, 0, 0, 990, 9547, 1, 0, 0, 0, 992, 9563, 1, + 0, 0, 0, 994, 9565, 1, 0, 0, 0, 996, 9567, 1, 0, 0, 0, 998, 9569, 1, 0, + 0, 0, 1000, 9571, 1, 0, 0, 0, 1002, 9576, 1, 0, 0, 0, 1004, 9579, 1, 0, + 0, 0, 1006, 9586, 1, 0, 0, 0, 1008, 9657, 1, 0, 0, 0, 1010, 9659, 1, 0, + 0, 0, 1012, 9671, 1, 0, 0, 0, 1014, 9673, 1, 0, 0, 0, 1016, 9683, 1, 0, + 0, 0, 1018, 9685, 1, 0, 0, 0, 1020, 9691, 1, 0, 0, 0, 1022, 9726, 1, 0, + 0, 0, 1024, 9731, 1, 0, 0, 0, 1026, 9738, 1, 0, 0, 0, 1028, 9741, 1, 0, + 0, 0, 1030, 9765, 1, 0, 0, 0, 1032, 9767, 1, 0, 0, 0, 1034, 9785, 1, 0, + 0, 0, 1036, 9787, 1, 0, 0, 0, 1038, 9795, 1, 0, 0, 0, 1040, 9802, 1, 0, + 0, 0, 1042, 9804, 1, 0, 0, 0, 1044, 9806, 1, 0, 0, 0, 1046, 9814, 1, 0, + 0, 0, 1048, 9817, 1, 0, 0, 0, 1050, 9822, 1, 0, 0, 0, 1052, 9828, 1, 0, + 0, 0, 1054, 9838, 1, 0, 0, 0, 1056, 9841, 1, 0, 0, 0, 1058, 9850, 1, 0, + 0, 0, 1060, 9853, 1, 0, 0, 0, 1062, 9865, 1, 0, 0, 0, 1064, 9872, 1, 0, + 0, 0, 1066, 9901, 1, 0, 0, 0, 1068, 9903, 1, 0, 0, 0, 1070, 9916, 1, 0, + 0, 0, 1072, 9934, 1, 0, 0, 0, 1074, 9960, 1, 0, 0, 0, 1076, 9981, 1, 0, + 0, 0, 1078, 10002, 1, 0, 0, 0, 1080, 10016, 1, 0, 0, 0, 1082, 10035, 1, + 0, 0, 0, 1084, 10050, 1, 0, 0, 0, 1086, 10055, 1, 0, 0, 0, 1088, 10071, + 1, 0, 0, 0, 1090, 10087, 1, 0, 0, 0, 1092, 10107, 1, 0, 0, 0, 1094, 10111, + 1, 0, 0, 0, 1096, 10113, 1, 0, 0, 0, 1098, 10115, 1, 0, 0, 0, 1100, 10150, + 1, 0, 0, 0, 1102, 10167, 1, 0, 0, 0, 1104, 10169, 1, 0, 0, 0, 1106, 10206, + 1, 0, 0, 0, 1108, 10208, 1, 0, 0, 0, 1110, 10237, 1, 0, 0, 0, 1112, 10245, + 1, 0, 0, 0, 1114, 10250, 1, 0, 0, 0, 1116, 10267, 1, 0, 0, 0, 1118, 10321, + 1, 0, 0, 0, 1120, 10323, 1, 0, 0, 0, 1122, 10331, 1, 0, 0, 0, 1124, 10335, + 1, 0, 0, 0, 1126, 10337, 1, 0, 0, 0, 1128, 10345, 1, 0, 0, 0, 1130, 10349, + 1, 0, 0, 0, 1132, 10374, 1, 0, 0, 0, 1134, 10384, 1, 0, 0, 0, 1136, 10412, + 1, 0, 0, 0, 1138, 10414, 1, 0, 0, 0, 1140, 10420, 1, 0, 0, 0, 1142, 10490, + 1, 0, 0, 0, 1144, 10492, 1, 0, 0, 0, 1146, 10500, 1, 0, 0, 0, 1148, 10503, + 1, 0, 0, 0, 1150, 10512, 1, 0, 0, 0, 1152, 10534, 1, 0, 0, 0, 1154, 10542, + 1, 0, 0, 0, 1156, 10544, 1, 0, 0, 0, 1158, 10555, 1, 0, 0, 0, 1160, 10557, + 1, 0, 0, 0, 1162, 10569, 1, 0, 0, 0, 1164, 10577, 1, 0, 0, 0, 1166, 10618, + 1, 0, 0, 0, 1168, 10628, 1, 0, 0, 0, 1170, 10630, 1, 0, 0, 0, 1172, 10660, + 1, 0, 0, 0, 1174, 10662, 1, 0, 0, 0, 1176, 10678, 1, 0, 0, 0, 1178, 10686, + 1, 0, 0, 0, 1180, 10689, 1, 0, 0, 0, 1182, 10691, 1, 0, 0, 0, 1184, 10755, + 1, 0, 0, 0, 1186, 10759, 1, 0, 0, 0, 1188, 10761, 1, 0, 0, 0, 1190, 10766, + 1, 0, 0, 0, 1192, 10768, 1, 0, 0, 0, 1194, 10772, 1, 0, 0, 0, 1196, 10774, + 1, 0, 0, 0, 1198, 10785, 1, 0, 0, 0, 1200, 10787, 1, 0, 0, 0, 1202, 10795, + 1, 0, 0, 0, 1204, 10798, 1, 0, 0, 0, 1206, 10840, 1, 0, 0, 0, 1208, 10842, + 1, 0, 0, 0, 1210, 10857, 1, 0, 0, 0, 1212, 10859, 1, 0, 0, 0, 1214, 10878, + 1, 0, 0, 0, 1216, 10883, 1, 0, 0, 0, 1218, 10895, 1, 0, 0, 0, 1220, 10907, + 1, 0, 0, 0, 1222, 10919, 1, 0, 0, 0, 1224, 10921, 1, 0, 0, 0, 1226, 10923, + 1, 0, 0, 0, 1228, 10933, 1, 0, 0, 0, 1230, 10940, 1, 0, 0, 0, 1232, 10948, + 1, 0, 0, 0, 1234, 10955, 1, 0, 0, 0, 1236, 10965, 1, 0, 0, 0, 1238, 10977, + 1, 0, 0, 0, 1240, 10979, 1, 0, 0, 0, 1242, 11029, 1, 0, 0, 0, 1244, 11031, + 1, 0, 0, 0, 1246, 11046, 1, 0, 0, 0, 1248, 11054, 1, 0, 0, 0, 1250, 11057, + 1, 0, 0, 0, 1252, 11064, 1, 0, 0, 0, 1254, 11066, 1, 0, 0, 0, 1256, 11087, + 1, 0, 0, 0, 1258, 11089, 1, 0, 0, 0, 1260, 11096, 1, 0, 0, 0, 1262, 11111, + 1, 0, 0, 0, 1264, 11146, 1, 0, 0, 0, 1266, 11148, 1, 0, 0, 0, 1268, 11154, + 1, 0, 0, 0, 1270, 11184, 1, 0, 0, 0, 1272, 11203, 1, 0, 0, 0, 1274, 11208, + 1, 0, 0, 0, 1276, 11210, 1, 0, 0, 0, 1278, 11216, 1, 0, 0, 0, 1280, 11222, + 1, 0, 0, 0, 1282, 11237, 1, 0, 0, 0, 1284, 11241, 1, 0, 0, 0, 1286, 11256, + 1, 0, 0, 0, 1288, 11260, 1, 0, 0, 0, 1290, 11273, 1, 0, 0, 0, 1292, 11297, + 1, 0, 0, 0, 1294, 11299, 1, 0, 0, 0, 1296, 11302, 1, 0, 0, 0, 1298, 11310, + 1, 0, 0, 0, 1300, 11314, 1, 0, 0, 0, 1302, 11316, 1, 0, 0, 0, 1304, 11322, + 1, 0, 0, 0, 1306, 11325, 1, 0, 0, 0, 1308, 11329, 1, 0, 0, 0, 1310, 11332, + 1, 0, 0, 0, 1312, 11334, 1, 0, 0, 0, 1314, 11336, 1, 0, 0, 0, 1316, 11340, + 1, 0, 0, 0, 1318, 11342, 1, 0, 0, 0, 1320, 11344, 1, 0, 0, 0, 1322, 11346, + 1, 0, 0, 0, 1324, 11349, 1, 0, 0, 0, 1326, 11357, 1, 0, 0, 0, 1328, 11365, + 1, 0, 0, 0, 1330, 11367, 1, 0, 0, 0, 1332, 11373, 1, 0, 0, 0, 1334, 11376, + 1, 0, 0, 0, 1336, 11379, 1, 0, 0, 0, 1338, 11388, 1, 0, 0, 0, 1340, 11391, + 1, 0, 0, 0, 1342, 11410, 1, 0, 0, 0, 1344, 11420, 1, 0, 0, 0, 1346, 11422, + 1, 0, 0, 0, 1348, 11424, 1, 0, 0, 0, 1350, 11450, 1, 0, 0, 0, 1352, 11455, + 1, 0, 0, 0, 1354, 11459, 1, 0, 0, 0, 1356, 11467, 1, 0, 0, 0, 1358, 11469, + 1, 0, 0, 0, 1360, 11475, 1, 0, 0, 0, 1362, 11480, 1, 0, 0, 0, 1364, 11489, + 1, 0, 0, 0, 1366, 11516, 1, 0, 0, 0, 1368, 11518, 1, 0, 0, 0, 1370, 11597, + 1, 0, 0, 0, 1372, 11599, 1, 0, 0, 0, 1374, 11601, 1, 0, 0, 0, 1376, 11634, + 1, 0, 0, 0, 1378, 11636, 1, 0, 0, 0, 1380, 11678, 1, 0, 0, 0, 1382, 11687, + 1, 0, 0, 0, 1384, 11689, 1, 0, 0, 0, 1386, 11708, 1, 0, 0, 0, 1388, 11716, + 1, 0, 0, 0, 1390, 11718, 1, 0, 0, 0, 1392, 11724, 1, 0, 0, 0, 1394, 11728, + 1, 0, 0, 0, 1396, 11730, 1, 0, 0, 0, 1398, 11732, 1, 0, 0, 0, 1400, 11734, + 1, 0, 0, 0, 1402, 11736, 1, 0, 0, 0, 1404, 11738, 1, 0, 0, 0, 1406, 11742, + 1, 0, 0, 0, 1408, 11746, 1, 0, 0, 0, 1410, 11754, 1, 0, 0, 0, 1412, 11774, + 1, 0, 0, 0, 1414, 11785, 1, 0, 0, 0, 1416, 11787, 1, 0, 0, 0, 1418, 11795, + 1, 0, 0, 0, 1420, 11801, 1, 0, 0, 0, 1422, 11805, 1, 0, 0, 0, 1424, 11807, + 1, 0, 0, 0, 1426, 11815, 1, 0, 0, 0, 1428, 11824, 1, 0, 0, 0, 1430, 11864, + 1, 0, 0, 0, 1432, 11866, 1, 0, 0, 0, 1434, 11880, 1, 0, 0, 0, 1436, 11883, + 1, 0, 0, 0, 1438, 11895, 1, 0, 0, 0, 1440, 11919, 1, 0, 0, 0, 1442, 11921, + 1, 0, 0, 0, 1444, 11923, 1, 0, 0, 0, 1446, 11931, 1, 0, 0, 0, 1448, 11934, + 1, 0, 0, 0, 1450, 11958, 1, 0, 0, 0, 1452, 11960, 1, 0, 0, 0, 1454, 11964, + 1, 0, 0, 0, 1456, 11997, 1, 0, 0, 0, 1458, 11999, 1, 0, 0, 0, 1460, 12018, + 1, 0, 0, 0, 1462, 12031, 1, 0, 0, 0, 1464, 12043, 1, 0, 0, 0, 1466, 12059, + 1, 0, 0, 0, 1468, 12062, 1, 0, 0, 0, 1470, 12073, 1, 0, 0, 0, 1472, 12089, + 1, 0, 0, 0, 1474, 12091, 1, 0, 0, 0, 1476, 12096, 1, 0, 0, 0, 1478, 12099, + 1, 0, 0, 0, 1480, 12114, 1, 0, 0, 0, 1482, 12132, 1, 0, 0, 0, 1484, 12134, + 1, 0, 0, 0, 1486, 12137, 1, 0, 0, 0, 1488, 12145, 1, 0, 0, 0, 1490, 12155, + 1, 0, 0, 0, 1492, 12164, 1, 0, 0, 0, 1494, 12171, 1, 0, 0, 0, 1496, 12175, + 1, 0, 0, 0, 1498, 12185, 1, 0, 0, 0, 1500, 12216, 1, 0, 0, 0, 1502, 12218, + 1, 0, 0, 0, 1504, 12229, 1, 0, 0, 0, 1506, 12293, 1, 0, 0, 0, 1508, 12295, + 1, 0, 0, 0, 1510, 12300, 1, 0, 0, 0, 1512, 12306, 1, 0, 0, 0, 1514, 12312, + 1, 0, 0, 0, 1516, 12318, 1, 0, 0, 0, 1518, 12326, 1, 0, 0, 0, 1520, 12341, + 1, 0, 0, 0, 1522, 12343, 1, 0, 0, 0, 1524, 12345, 1, 0, 0, 0, 1526, 12353, + 1, 0, 0, 0, 1528, 12356, 1, 0, 0, 0, 1530, 12374, 1, 0, 0, 0, 1532, 12376, + 1, 0, 0, 0, 1534, 12378, 1, 0, 0, 0, 1536, 12380, 1, 0, 0, 0, 1538, 12388, + 1, 0, 0, 0, 1540, 12390, 1, 0, 0, 0, 1542, 12392, 1, 0, 0, 0, 1544, 12396, + 1, 0, 0, 0, 1546, 12404, 1, 0, 0, 0, 1548, 12423, 1, 0, 0, 0, 1550, 12425, + 1, 0, 0, 0, 1552, 12450, 1, 0, 0, 0, 1554, 12452, 1, 0, 0, 0, 1556, 12461, + 1, 0, 0, 0, 1558, 12463, 1, 0, 0, 0, 1560, 12470, 1, 0, 0, 0, 1562, 12474, + 1, 0, 0, 0, 1564, 12476, 1, 0, 0, 0, 1566, 12478, 1, 0, 0, 0, 1568, 12480, + 1, 0, 0, 0, 1570, 12493, 1, 0, 0, 0, 1572, 12500, 1, 0, 0, 0, 1574, 12502, + 1, 0, 0, 0, 1576, 12505, 1, 0, 0, 0, 1578, 12510, 1, 0, 0, 0, 1580, 12515, + 1, 0, 0, 0, 1582, 12521, 1, 0, 0, 0, 1584, 12528, 1, 0, 0, 0, 1586, 12530, + 1, 0, 0, 0, 1588, 12533, 1, 0, 0, 0, 1590, 12537, 1, 0, 0, 0, 1592, 12544, + 1, 0, 0, 0, 1594, 12556, 1, 0, 0, 0, 1596, 12559, 1, 0, 0, 0, 1598, 12573, + 1, 0, 0, 0, 1600, 12576, 1, 0, 0, 0, 1602, 12642, 1, 0, 0, 0, 1604, 12666, + 1, 0, 0, 0, 1606, 12669, 1, 0, 0, 0, 1608, 12678, 1, 0, 0, 0, 1610, 12681, + 1, 0, 0, 0, 1612, 12702, 1, 0, 0, 0, 1614, 12704, 1, 0, 0, 0, 1616, 12715, + 1, 0, 0, 0, 1618, 12729, 1, 0, 0, 0, 1620, 12731, 1, 0, 0, 0, 1622, 12739, + 1, 0, 0, 0, 1624, 12746, 1, 0, 0, 0, 1626, 12754, 1, 0, 0, 0, 1628, 12771, + 1, 0, 0, 0, 1630, 12773, 1, 0, 0, 0, 1632, 12777, 1, 0, 0, 0, 1634, 12785, + 1, 0, 0, 0, 1636, 12790, 1, 0, 0, 0, 1638, 12793, 1, 0, 0, 0, 1640, 12796, + 1, 0, 0, 0, 1642, 12803, 1, 0, 0, 0, 1644, 12805, 1, 0, 0, 0, 1646, 12813, + 1, 0, 0, 0, 1648, 12818, 1, 0, 0, 0, 1650, 12839, 1, 0, 0, 0, 1652, 12847, + 1, 0, 0, 0, 1654, 12857, 1, 0, 0, 0, 1656, 12869, 1, 0, 0, 0, 1658, 12871, + 1, 0, 0, 0, 1660, 12885, 1, 0, 0, 0, 1662, 12908, 1, 0, 0, 0, 1664, 12915, + 1, 0, 0, 0, 1666, 12936, 1, 0, 0, 0, 1668, 12942, 1, 0, 0, 0, 1670, 12948, + 1, 0, 0, 0, 1672, 12954, 1, 0, 0, 0, 1674, 12960, 1, 0, 0, 0, 1676, 12968, + 1, 0, 0, 0, 1678, 12996, 1, 0, 0, 0, 1680, 12998, 1, 0, 0, 0, 1682, 13004, + 1, 0, 0, 0, 1684, 13008, 1, 0, 0, 0, 1686, 13010, 1, 0, 0, 0, 1688, 13018, + 1, 0, 0, 0, 1690, 13022, 1, 0, 0, 0, 1692, 13032, 1, 0, 0, 0, 1694, 13052, + 1, 0, 0, 0, 1696, 13054, 1, 0, 0, 0, 1698, 13056, 1, 0, 0, 0, 1700, 13066, + 1, 0, 0, 0, 1702, 13074, 1, 0, 0, 0, 1704, 13101, 1, 0, 0, 0, 1706, 13103, + 1, 0, 0, 0, 1708, 13110, 1, 0, 0, 0, 1710, 13113, 1, 0, 0, 0, 1712, 13115, + 1, 0, 0, 0, 1714, 13119, 1, 0, 0, 0, 1716, 13127, 1, 0, 0, 0, 1718, 13135, + 1, 0, 0, 0, 1720, 13143, 1, 0, 0, 0, 1722, 13157, 1, 0, 0, 0, 1724, 13166, + 1, 0, 0, 0, 1726, 13170, 1, 0, 0, 0, 1728, 13174, 1, 0, 0, 0, 1730, 13200, + 1, 0, 0, 0, 1732, 13215, 1, 0, 0, 0, 1734, 13219, 1, 0, 0, 0, 1736, 13235, + 1, 0, 0, 0, 1738, 13245, 1, 0, 0, 0, 1740, 13249, 1, 0, 0, 0, 1742, 13257, + 1, 0, 0, 0, 1744, 13265, 1, 0, 0, 0, 1746, 13271, 1, 0, 0, 0, 1748, 13275, + 1, 0, 0, 0, 1750, 13282, 1, 0, 0, 0, 1752, 13287, 1, 0, 0, 0, 1754, 13302, + 1, 0, 0, 0, 1756, 13382, 1, 0, 0, 0, 1758, 13384, 1, 0, 0, 0, 1760, 13386, + 1, 0, 0, 0, 1762, 13424, 1, 0, 0, 0, 1764, 13428, 1, 0, 0, 0, 1766, 13613, + 1, 0, 0, 0, 1768, 13620, 1, 0, 0, 0, 1770, 13632, 1, 0, 0, 0, 1772, 13634, + 1, 0, 0, 0, 1774, 13639, 1, 0, 0, 0, 1776, 13647, 1, 0, 0, 0, 1778, 13652, + 1, 0, 0, 0, 1780, 13658, 1, 0, 0, 0, 1782, 13675, 1, 0, 0, 0, 1784, 13677, + 1, 0, 0, 0, 1786, 13680, 1, 0, 0, 0, 1788, 13686, 1, 0, 0, 0, 1790, 13692, + 1, 0, 0, 0, 1792, 13695, 1, 0, 0, 0, 1794, 13703, 1, 0, 0, 0, 1796, 13707, + 1, 0, 0, 0, 1798, 13712, 1, 0, 0, 0, 1800, 13727, 1, 0, 0, 0, 1802, 13729, + 1, 0, 0, 0, 1804, 13748, 1, 0, 0, 0, 1806, 13756, 1, 0, 0, 0, 1808, 13765, + 1, 0, 0, 0, 1810, 13767, 1, 0, 0, 0, 1812, 13788, 1, 0, 0, 0, 1814, 13790, + 1, 0, 0, 0, 1816, 13797, 1, 0, 0, 0, 1818, 13803, 1, 0, 0, 0, 1820, 13807, + 1, 0, 0, 0, 1822, 13809, 1, 0, 0, 0, 1824, 13817, 1, 0, 0, 0, 1826, 13825, + 1, 0, 0, 0, 1828, 13839, 1, 0, 0, 0, 1830, 13841, 1, 0, 0, 0, 1832, 13849, + 1, 0, 0, 0, 1834, 13862, 1, 0, 0, 0, 1836, 13864, 1, 0, 0, 0, 1838, 13872, + 1, 0, 0, 0, 1840, 13879, 1, 0, 0, 0, 1842, 13887, 1, 0, 0, 0, 1844, 13899, + 1, 0, 0, 0, 1846, 13901, 1, 0, 0, 0, 1848, 13903, 1, 0, 0, 0, 1850, 13912, + 1, 0, 0, 0, 1852, 13943, 1, 0, 0, 0, 1854, 13952, 1, 0, 0, 0, 1856, 13959, + 1, 0, 0, 0, 1858, 13961, 1, 0, 0, 0, 1860, 13972, 1, 0, 0, 0, 1862, 13976, + 1, 0, 0, 0, 1864, 13981, 1, 0, 0, 0, 1866, 13984, 1, 0, 0, 0, 1868, 13986, + 1, 0, 0, 0, 1870, 14007, 1, 0, 0, 0, 1872, 14009, 1, 0, 0, 0, 1874, 14012, + 1, 0, 0, 0, 1876, 14019, 1, 0, 0, 0, 1878, 14022, 1, 0, 0, 0, 1880, 14024, + 1, 0, 0, 0, 1882, 14037, 1, 0, 0, 0, 1884, 14042, 1, 0, 0, 0, 1886, 14044, + 1, 0, 0, 0, 1888, 14052, 1, 0, 0, 0, 1890, 14056, 1, 0, 0, 0, 1892, 14064, + 1, 0, 0, 0, 1894, 14066, 1, 0, 0, 0, 1896, 14068, 1, 0, 0, 0, 1898, 14077, + 1, 0, 0, 0, 1900, 14114, 1, 0, 0, 0, 1902, 14116, 1, 0, 0, 0, 1904, 14118, + 1, 0, 0, 0, 1906, 14120, 1, 0, 0, 0, 1908, 14122, 1, 0, 0, 0, 1910, 14124, + 1, 0, 0, 0, 1912, 14139, 1, 0, 0, 0, 1914, 14141, 1, 0, 0, 0, 1916, 14149, + 1, 0, 0, 0, 1918, 14151, 1, 0, 0, 0, 1920, 14157, 1, 0, 0, 0, 1922, 14159, + 1, 0, 0, 0, 1924, 14173, 1, 0, 0, 0, 1926, 14179, 1, 0, 0, 0, 1928, 14185, + 1, 0, 0, 0, 1930, 14191, 1, 0, 0, 0, 1932, 14199, 1, 0, 0, 0, 1934, 14210, + 1, 0, 0, 0, 1936, 14212, 1, 0, 0, 0, 1938, 14214, 1, 0, 0, 0, 1940, 14307, + 1, 0, 0, 0, 1942, 14309, 1, 0, 0, 0, 1944, 14311, 1, 0, 0, 0, 1946, 14313, + 1, 0, 0, 0, 1948, 14315, 1, 0, 0, 0, 1950, 14323, 1, 0, 0, 0, 1952, 14346, + 1, 0, 0, 0, 1954, 14348, 1, 0, 0, 0, 1956, 14354, 1, 0, 0, 0, 1958, 14356, + 1, 0, 0, 0, 1960, 14358, 1, 0, 0, 0, 1962, 14369, 1, 0, 0, 0, 1964, 14377, + 1, 0, 0, 0, 1966, 14380, 1, 0, 0, 0, 1968, 14384, 1, 0, 0, 0, 1970, 14391, + 1, 0, 0, 0, 1972, 14393, 1, 0, 0, 0, 1974, 14427, 1, 0, 0, 0, 1976, 14429, + 1, 0, 0, 0, 1978, 14431, 1, 0, 0, 0, 1980, 14435, 1, 0, 0, 0, 1982, 14443, + 1, 0, 0, 0, 1984, 14446, 1, 0, 0, 0, 1986, 14450, 1, 0, 0, 0, 1988, 14452, + 1, 0, 0, 0, 1990, 14454, 1, 0, 0, 0, 1992, 14456, 1, 0, 0, 0, 1994, 14458, + 1, 0, 0, 0, 1996, 14461, 1, 0, 0, 0, 1998, 14464, 1, 0, 0, 0, 2000, 14469, + 1, 0, 0, 0, 2002, 14471, 1, 0, 0, 0, 2004, 14476, 1, 0, 0, 0, 2006, 14506, + 1, 0, 0, 0, 2008, 14508, 1, 0, 0, 0, 2010, 14530, 1, 0, 0, 0, 2012, 14532, + 1, 0, 0, 0, 2014, 14534, 1, 0, 0, 0, 2016, 14539, 1, 0, 0, 0, 2018, 14547, + 1, 0, 0, 0, 2020, 14549, 1, 0, 0, 0, 2022, 14557, 1, 0, 0, 0, 2024, 14561, + 1, 0, 0, 0, 2026, 14563, 1, 0, 0, 0, 2028, 14567, 1, 0, 0, 0, 2030, 14578, + 1, 0, 0, 0, 2032, 14597, 1, 0, 0, 0, 2034, 14600, 1, 0, 0, 0, 2036, 14603, + 1, 0, 0, 0, 2038, 14615, 1, 0, 0, 0, 2040, 14618, 1, 0, 0, 0, 2042, 14622, + 1, 0, 0, 0, 2044, 14627, 1, 0, 0, 0, 2046, 14631, 1, 0, 0, 0, 2048, 14636, + 1, 0, 0, 0, 2050, 14643, 1, 0, 0, 0, 2052, 14649, 1, 0, 0, 0, 2054, 14673, + 1, 0, 0, 0, 2056, 14676, 1, 0, 0, 0, 2058, 14687, 1, 0, 0, 0, 2060, 14689, + 1, 0, 0, 0, 2062, 14692, 1, 0, 0, 0, 2064, 14695, 1, 0, 0, 0, 2066, 14707, + 1, 0, 0, 0, 2068, 14710, 1, 0, 0, 0, 2070, 14719, 1, 0, 0, 0, 2072, 14721, + 1, 0, 0, 0, 2074, 14740, 1, 0, 0, 0, 2076, 14785, 1, 0, 0, 0, 2078, 14787, + 1, 0, 0, 0, 2080, 14791, 1, 0, 0, 0, 2082, 14795, 1, 0, 0, 0, 2084, 14798, + 1, 0, 0, 0, 2086, 14802, 1, 0, 0, 0, 2088, 14810, 1, 0, 0, 0, 2090, 14817, + 1, 0, 0, 0, 2092, 14820, 1, 0, 0, 0, 2094, 14829, 1, 0, 0, 0, 2096, 14832, + 1, 0, 0, 0, 2098, 14851, 1, 0, 0, 0, 2100, 14854, 1, 0, 0, 0, 2102, 14862, + 1, 0, 0, 0, 2104, 14868, 1, 0, 0, 0, 2106, 14898, 1, 0, 0, 0, 2108, 14900, + 1, 0, 0, 0, 2110, 14908, 1, 0, 0, 0, 2112, 14912, 1, 0, 0, 0, 2114, 14916, + 1, 0, 0, 0, 2116, 14918, 1, 0, 0, 0, 2118, 14930, 1, 0, 0, 0, 2120, 14932, + 1, 0, 0, 0, 2122, 14949, 1, 0, 0, 0, 2124, 14951, 1, 0, 0, 0, 2126, 14958, + 1, 0, 0, 0, 2128, 14962, 1, 0, 0, 0, 2130, 14965, 1, 0, 0, 0, 2132, 14971, + 1, 0, 0, 0, 2134, 14977, 1, 0, 0, 0, 2136, 14995, 1, 0, 0, 0, 2138, 14999, + 1, 0, 0, 0, 2140, 15001, 1, 0, 0, 0, 2142, 15005, 1, 0, 0, 0, 2144, 15009, + 1, 0, 0, 0, 2146, 15014, 1, 0, 0, 0, 2148, 15025, 1, 0, 0, 0, 2150, 15027, + 1, 0, 0, 0, 2152, 15029, 1, 0, 0, 0, 2154, 15031, 1, 0, 0, 0, 2156, 15033, + 1, 0, 0, 0, 2158, 15038, 1, 0, 0, 0, 2160, 15040, 1, 0, 0, 0, 2162, 15043, + 1, 0, 0, 0, 2164, 15063, 1, 0, 0, 0, 2166, 15065, 1, 0, 0, 0, 2168, 15067, + 1, 0, 0, 0, 2170, 15069, 1, 0, 0, 0, 2172, 15071, 1, 0, 0, 0, 2174, 15075, + 1, 0, 0, 0, 2176, 2177, 3, 4, 2, 0, 2177, 2178, 5, 0, 0, 1, 2178, 1, 1, + 0, 0, 0, 2179, 2180, 3, 1948, 974, 0, 2180, 3, 1, 0, 0, 0, 2181, 2182, + 3, 6, 3, 0, 2182, 5, 1, 0, 0, 0, 2183, 2185, 3, 8, 4, 0, 2184, 2186, 5, + 7, 0, 0, 2185, 2184, 1, 0, 0, 0, 2185, 2186, 1, 0, 0, 0, 2186, 2188, 1, + 0, 0, 0, 2187, 2183, 1, 0, 0, 0, 2188, 2191, 1, 0, 0, 0, 2189, 2187, 1, + 0, 0, 0, 2189, 2190, 1, 0, 0, 0, 2190, 7, 1, 0, 0, 0, 2191, 2189, 1, 0, + 0, 0, 2192, 2376, 3, 494, 247, 0, 2193, 2376, 3, 1358, 679, 0, 2194, 2376, + 3, 1348, 674, 0, 2195, 2376, 3, 1350, 675, 0, 2196, 2376, 3, 788, 394, + 0, 2197, 2376, 3, 1364, 682, 0, 2198, 2376, 3, 520, 260, 0, 2199, 2376, + 3, 364, 182, 0, 2200, 2376, 3, 370, 185, 0, 2201, 2376, 3, 380, 190, 0, + 2202, 2376, 3, 406, 203, 0, 2203, 2376, 3, 888, 444, 0, 2204, 2376, 3, + 890, 445, 0, 2205, 2376, 3, 46, 23, 0, 2206, 2376, 3, 948, 474, 0, 2207, + 2376, 3, 952, 476, 0, 2208, 2376, 3, 964, 482, 0, 2209, 2376, 3, 954, 477, + 0, 2210, 2376, 3, 962, 481, 0, 2211, 2376, 3, 426, 213, 0, 2212, 2376, + 3, 322, 161, 0, 2213, 2376, 3, 1360, 680, 0, 2214, 2376, 3, 106, 53, 0, + 2215, 2376, 3, 940, 470, 0, 2216, 2376, 3, 146, 73, 0, 2217, 2376, 3, 974, + 487, 0, 2218, 2376, 3, 34, 17, 0, 2219, 2376, 3, 28, 14, 0, 2220, 2376, + 3, 1240, 620, 0, 2221, 2376, 3, 36, 18, 0, 2222, 2376, 3, 982, 491, 0, + 2223, 2376, 3, 300, 150, 0, 2224, 2376, 3, 1370, 685, 0, 2225, 2376, 3, + 1368, 684, 0, 2226, 2376, 3, 422, 211, 0, 2227, 2376, 3, 1384, 692, 0, + 2228, 2376, 3, 12, 6, 0, 2229, 2376, 3, 102, 51, 0, 2230, 2376, 3, 152, + 76, 0, 2231, 2376, 3, 1376, 688, 0, 2232, 2376, 3, 576, 288, 0, 2233, 2376, + 3, 96, 48, 0, 2234, 2376, 3, 154, 77, 0, 2235, 2376, 3, 442, 221, 0, 2236, + 2376, 3, 302, 151, 0, 2237, 2376, 3, 498, 249, 0, 2238, 2376, 3, 916, 458, + 0, 2239, 2376, 3, 1374, 687, 0, 2240, 2376, 3, 1362, 681, 0, 2241, 2376, + 3, 358, 179, 0, 2242, 2376, 3, 372, 186, 0, 2243, 2376, 3, 398, 199, 0, + 2244, 2376, 3, 408, 204, 0, 2245, 2376, 3, 826, 413, 0, 2246, 2376, 3, + 828, 414, 0, 2247, 2376, 3, 44, 22, 0, 2248, 2376, 3, 314, 157, 0, 2249, + 2376, 3, 524, 262, 0, 2250, 2376, 3, 538, 269, 0, 2251, 2376, 3, 966, 483, + 0, 2252, 2376, 3, 540, 270, 0, 2253, 2376, 3, 424, 212, 0, 2254, 2376, + 3, 338, 169, 0, 2255, 2376, 3, 50, 25, 0, 2256, 2376, 3, 320, 160, 0, 2257, + 2376, 3, 194, 97, 0, 2258, 2376, 3, 976, 488, 0, 2259, 2376, 3, 298, 149, + 0, 2260, 2376, 3, 352, 176, 0, 2261, 2376, 3, 924, 462, 0, 2262, 2376, + 3, 446, 223, 0, 2263, 2376, 3, 486, 243, 0, 2264, 2376, 3, 14, 7, 0, 2265, + 2376, 3, 26, 13, 0, 2266, 2376, 3, 416, 208, 0, 2267, 2376, 3, 1336, 668, + 0, 2268, 2376, 3, 1434, 717, 0, 2269, 2376, 3, 1488, 744, 0, 2270, 2376, + 3, 500, 250, 0, 2271, 2376, 3, 1464, 732, 0, 2272, 2376, 3, 104, 52, 0, + 2273, 2376, 3, 910, 455, 0, 2274, 2376, 3, 920, 460, 0, 2275, 2376, 3, + 546, 273, 0, 2276, 2376, 3, 548, 274, 0, 2277, 2376, 3, 550, 275, 0, 2278, + 2376, 3, 1074, 537, 0, 2279, 2376, 3, 554, 277, 0, 2280, 2376, 3, 984, + 492, 0, 2281, 2376, 3, 356, 178, 0, 2282, 2376, 3, 928, 464, 0, 2283, 2376, + 3, 38, 19, 0, 2284, 2376, 3, 40, 20, 0, 2285, 2376, 3, 42, 21, 0, 2286, + 2376, 3, 420, 210, 0, 2287, 2376, 3, 1352, 676, 0, 2288, 2376, 3, 1430, + 715, 0, 2289, 2376, 3, 1412, 706, 0, 2290, 2376, 3, 586, 293, 0, 2291, + 2376, 3, 590, 295, 0, 2292, 2376, 3, 410, 205, 0, 2293, 2376, 3, 798, 399, + 0, 2294, 2376, 3, 1436, 718, 0, 2295, 2376, 3, 1454, 727, 0, 2296, 2376, + 3, 1004, 502, 0, 2297, 2376, 3, 318, 159, 0, 2298, 2376, 3, 1026, 513, + 0, 2299, 2376, 3, 1468, 734, 0, 2300, 2376, 3, 1000, 500, 0, 2301, 2376, + 3, 1424, 712, 0, 2302, 2376, 3, 552, 276, 0, 2303, 2376, 3, 930, 465, 0, + 2304, 2376, 3, 898, 449, 0, 2305, 2376, 3, 896, 448, 0, 2306, 2376, 3, + 900, 450, 0, 2307, 2376, 3, 942, 471, 0, 2308, 2376, 3, 726, 363, 0, 2309, + 2376, 3, 782, 391, 0, 2310, 2376, 3, 986, 493, 0, 2311, 2376, 3, 580, 290, + 0, 2312, 2376, 3, 1496, 748, 0, 2313, 2376, 3, 1008, 504, 0, 2314, 2376, + 3, 572, 286, 0, 2315, 2376, 3, 1006, 503, 0, 2316, 2376, 3, 1478, 739, + 0, 2317, 2376, 3, 1380, 690, 0, 2318, 2376, 3, 84, 42, 0, 2319, 2376, 3, + 60, 30, 0, 2320, 2376, 3, 94, 47, 0, 2321, 2376, 3, 1020, 510, 0, 2322, + 2376, 3, 1028, 514, 0, 2323, 2376, 3, 1064, 532, 0, 2324, 2376, 3, 1068, + 534, 0, 2325, 2376, 3, 1134, 567, 0, 2326, 2376, 3, 1138, 569, 0, 2327, + 2376, 3, 1140, 570, 0, 2328, 2376, 3, 1148, 574, 0, 2329, 2376, 3, 1236, + 618, 0, 2330, 2376, 3, 1244, 622, 0, 2331, 2376, 3, 1150, 575, 0, 2332, + 2376, 3, 1160, 580, 0, 2333, 2376, 3, 1246, 623, 0, 2334, 2376, 3, 1248, + 624, 0, 2335, 2376, 3, 1050, 525, 0, 2336, 2376, 3, 1098, 549, 0, 2337, + 2376, 3, 1106, 553, 0, 2338, 2376, 3, 1070, 535, 0, 2339, 2376, 3, 1108, + 554, 0, 2340, 2376, 3, 1130, 565, 0, 2341, 2376, 3, 1164, 582, 0, 2342, + 2376, 3, 1170, 585, 0, 2343, 2376, 3, 1174, 587, 0, 2344, 2376, 3, 1182, + 591, 0, 2345, 2376, 3, 1212, 606, 0, 2346, 2376, 3, 1060, 530, 0, 2347, + 2376, 3, 1214, 607, 0, 2348, 2376, 3, 1216, 608, 0, 2349, 2376, 3, 1218, + 609, 0, 2350, 2376, 3, 1062, 531, 0, 2351, 2376, 3, 1132, 566, 0, 2352, + 2376, 3, 1226, 613, 0, 2353, 2376, 3, 1228, 614, 0, 2354, 2376, 3, 1230, + 615, 0, 2355, 2376, 3, 1232, 616, 0, 2356, 2376, 3, 1234, 617, 0, 2357, + 2376, 3, 1250, 625, 0, 2358, 2376, 3, 1254, 627, 0, 2359, 2376, 3, 1256, + 628, 0, 2360, 2376, 3, 1258, 629, 0, 2361, 2376, 3, 1260, 630, 0, 2362, + 2376, 3, 1262, 631, 0, 2363, 2376, 3, 1266, 633, 0, 2364, 2376, 3, 1268, + 634, 0, 2365, 2376, 3, 1270, 635, 0, 2366, 2376, 3, 1276, 638, 0, 2367, + 2376, 3, 1278, 639, 0, 2368, 2376, 3, 1280, 640, 0, 2369, 2376, 3, 1282, + 641, 0, 2370, 2376, 3, 1284, 642, 0, 2371, 2376, 3, 1286, 643, 0, 2372, + 2376, 3, 1288, 644, 0, 2373, 2376, 3, 1334, 667, 0, 2374, 2376, 3, 10, + 5, 0, 2375, 2192, 1, 0, 0, 0, 2375, 2193, 1, 0, 0, 0, 2375, 2194, 1, 0, + 0, 0, 2375, 2195, 1, 0, 0, 0, 2375, 2196, 1, 0, 0, 0, 2375, 2197, 1, 0, + 0, 0, 2375, 2198, 1, 0, 0, 0, 2375, 2199, 1, 0, 0, 0, 2375, 2200, 1, 0, + 0, 0, 2375, 2201, 1, 0, 0, 0, 2375, 2202, 1, 0, 0, 0, 2375, 2203, 1, 0, + 0, 0, 2375, 2204, 1, 0, 0, 0, 2375, 2205, 1, 0, 0, 0, 2375, 2206, 1, 0, + 0, 0, 2375, 2207, 1, 0, 0, 0, 2375, 2208, 1, 0, 0, 0, 2375, 2209, 1, 0, + 0, 0, 2375, 2210, 1, 0, 0, 0, 2375, 2211, 1, 0, 0, 0, 2375, 2212, 1, 0, + 0, 0, 2375, 2213, 1, 0, 0, 0, 2375, 2214, 1, 0, 0, 0, 2375, 2215, 1, 0, + 0, 0, 2375, 2216, 1, 0, 0, 0, 2375, 2217, 1, 0, 0, 0, 2375, 2218, 1, 0, + 0, 0, 2375, 2219, 1, 0, 0, 0, 2375, 2220, 1, 0, 0, 0, 2375, 2221, 1, 0, + 0, 0, 2375, 2222, 1, 0, 0, 0, 2375, 2223, 1, 0, 0, 0, 2375, 2224, 1, 0, + 0, 0, 2375, 2225, 1, 0, 0, 0, 2375, 2226, 1, 0, 0, 0, 2375, 2227, 1, 0, + 0, 0, 2375, 2228, 1, 0, 0, 0, 2375, 2229, 1, 0, 0, 0, 2375, 2230, 1, 0, + 0, 0, 2375, 2231, 1, 0, 0, 0, 2375, 2232, 1, 0, 0, 0, 2375, 2233, 1, 0, + 0, 0, 2375, 2234, 1, 0, 0, 0, 2375, 2235, 1, 0, 0, 0, 2375, 2236, 1, 0, + 0, 0, 2375, 2237, 1, 0, 0, 0, 2375, 2238, 1, 0, 0, 0, 2375, 2239, 1, 0, + 0, 0, 2375, 2240, 1, 0, 0, 0, 2375, 2241, 1, 0, 0, 0, 2375, 2242, 1, 0, + 0, 0, 2375, 2243, 1, 0, 0, 0, 2375, 2244, 1, 0, 0, 0, 2375, 2245, 1, 0, + 0, 0, 2375, 2246, 1, 0, 0, 0, 2375, 2247, 1, 0, 0, 0, 2375, 2248, 1, 0, + 0, 0, 2375, 2249, 1, 0, 0, 0, 2375, 2250, 1, 0, 0, 0, 2375, 2251, 1, 0, + 0, 0, 2375, 2252, 1, 0, 0, 0, 2375, 2253, 1, 0, 0, 0, 2375, 2254, 1, 0, + 0, 0, 2375, 2255, 1, 0, 0, 0, 2375, 2256, 1, 0, 0, 0, 2375, 2257, 1, 0, + 0, 0, 2375, 2258, 1, 0, 0, 0, 2375, 2259, 1, 0, 0, 0, 2375, 2260, 1, 0, + 0, 0, 2375, 2261, 1, 0, 0, 0, 2375, 2262, 1, 0, 0, 0, 2375, 2263, 1, 0, + 0, 0, 2375, 2264, 1, 0, 0, 0, 2375, 2265, 1, 0, 0, 0, 2375, 2266, 1, 0, + 0, 0, 2375, 2267, 1, 0, 0, 0, 2375, 2268, 1, 0, 0, 0, 2375, 2269, 1, 0, + 0, 0, 2375, 2270, 1, 0, 0, 0, 2375, 2271, 1, 0, 0, 0, 2375, 2272, 1, 0, + 0, 0, 2375, 2273, 1, 0, 0, 0, 2375, 2274, 1, 0, 0, 0, 2375, 2275, 1, 0, + 0, 0, 2375, 2276, 1, 0, 0, 0, 2375, 2277, 1, 0, 0, 0, 2375, 2278, 1, 0, + 0, 0, 2375, 2279, 1, 0, 0, 0, 2375, 2280, 1, 0, 0, 0, 2375, 2281, 1, 0, + 0, 0, 2375, 2282, 1, 0, 0, 0, 2375, 2283, 1, 0, 0, 0, 2375, 2284, 1, 0, + 0, 0, 2375, 2285, 1, 0, 0, 0, 2375, 2286, 1, 0, 0, 0, 2375, 2287, 1, 0, + 0, 0, 2375, 2288, 1, 0, 0, 0, 2375, 2289, 1, 0, 0, 0, 2375, 2290, 1, 0, + 0, 0, 2375, 2291, 1, 0, 0, 0, 2375, 2292, 1, 0, 0, 0, 2375, 2293, 1, 0, + 0, 0, 2375, 2294, 1, 0, 0, 0, 2375, 2295, 1, 0, 0, 0, 2375, 2296, 1, 0, + 0, 0, 2375, 2297, 1, 0, 0, 0, 2375, 2298, 1, 0, 0, 0, 2375, 2299, 1, 0, + 0, 0, 2375, 2300, 1, 0, 0, 0, 2375, 2301, 1, 0, 0, 0, 2375, 2302, 1, 0, + 0, 0, 2375, 2303, 1, 0, 0, 0, 2375, 2304, 1, 0, 0, 0, 2375, 2305, 1, 0, + 0, 0, 2375, 2306, 1, 0, 0, 0, 2375, 2307, 1, 0, 0, 0, 2375, 2308, 1, 0, + 0, 0, 2375, 2309, 1, 0, 0, 0, 2375, 2310, 1, 0, 0, 0, 2375, 2311, 1, 0, + 0, 0, 2375, 2312, 1, 0, 0, 0, 2375, 2313, 1, 0, 0, 0, 2375, 2314, 1, 0, + 0, 0, 2375, 2315, 1, 0, 0, 0, 2375, 2316, 1, 0, 0, 0, 2375, 2317, 1, 0, + 0, 0, 2375, 2318, 1, 0, 0, 0, 2375, 2319, 1, 0, 0, 0, 2375, 2320, 1, 0, + 0, 0, 2375, 2321, 1, 0, 0, 0, 2375, 2322, 1, 0, 0, 0, 2375, 2323, 1, 0, + 0, 0, 2375, 2324, 1, 0, 0, 0, 2375, 2325, 1, 0, 0, 0, 2375, 2326, 1, 0, + 0, 0, 2375, 2327, 1, 0, 0, 0, 2375, 2328, 1, 0, 0, 0, 2375, 2329, 1, 0, + 0, 0, 2375, 2330, 1, 0, 0, 0, 2375, 2331, 1, 0, 0, 0, 2375, 2332, 1, 0, + 0, 0, 2375, 2333, 1, 0, 0, 0, 2375, 2334, 1, 0, 0, 0, 2375, 2335, 1, 0, + 0, 0, 2375, 2336, 1, 0, 0, 0, 2375, 2337, 1, 0, 0, 0, 2375, 2338, 1, 0, + 0, 0, 2375, 2339, 1, 0, 0, 0, 2375, 2340, 1, 0, 0, 0, 2375, 2341, 1, 0, + 0, 0, 2375, 2342, 1, 0, 0, 0, 2375, 2343, 1, 0, 0, 0, 2375, 2344, 1, 0, + 0, 0, 2375, 2345, 1, 0, 0, 0, 2375, 2346, 1, 0, 0, 0, 2375, 2347, 1, 0, + 0, 0, 2375, 2348, 1, 0, 0, 0, 2375, 2349, 1, 0, 0, 0, 2375, 2350, 1, 0, + 0, 0, 2375, 2351, 1, 0, 0, 0, 2375, 2352, 1, 0, 0, 0, 2375, 2353, 1, 0, + 0, 0, 2375, 2354, 1, 0, 0, 0, 2375, 2355, 1, 0, 0, 0, 2375, 2356, 1, 0, + 0, 0, 2375, 2357, 1, 0, 0, 0, 2375, 2358, 1, 0, 0, 0, 2375, 2359, 1, 0, + 0, 0, 2375, 2360, 1, 0, 0, 0, 2375, 2361, 1, 0, 0, 0, 2375, 2362, 1, 0, + 0, 0, 2375, 2363, 1, 0, 0, 0, 2375, 2364, 1, 0, 0, 0, 2375, 2365, 1, 0, + 0, 0, 2375, 2366, 1, 0, 0, 0, 2375, 2367, 1, 0, 0, 0, 2375, 2368, 1, 0, + 0, 0, 2375, 2369, 1, 0, 0, 0, 2375, 2370, 1, 0, 0, 0, 2375, 2371, 1, 0, + 0, 0, 2375, 2372, 1, 0, 0, 0, 2375, 2373, 1, 0, 0, 0, 2375, 2374, 1, 0, + 0, 0, 2376, 9, 1, 0, 0, 0, 2377, 2379, 5, 885, 0, 0, 2378, 2380, 5, 886, + 0, 0, 2379, 2378, 1, 0, 0, 0, 2379, 2380, 1, 0, 0, 0, 2380, 11, 1, 0, 0, + 0, 2381, 2382, 5, 603, 0, 0, 2382, 2383, 3, 1760, 880, 0, 2383, 13, 1, + 0, 0, 0, 2384, 2385, 5, 46, 0, 0, 2385, 2386, 5, 316, 0, 0, 2386, 2388, + 3, 1918, 959, 0, 2387, 2389, 3, 16, 8, 0, 2388, 2387, 1, 0, 0, 0, 2388, + 2389, 1, 0, 0, 0, 2389, 2390, 1, 0, 0, 0, 2390, 2391, 3, 18, 9, 0, 2391, + 15, 1, 0, 0, 0, 2392, 2393, 5, 106, 0, 0, 2393, 17, 1, 0, 0, 0, 2394, 2396, + 3, 24, 12, 0, 2395, 2394, 1, 0, 0, 0, 2396, 2399, 1, 0, 0, 0, 2397, 2395, + 1, 0, 0, 0, 2397, 2398, 1, 0, 0, 0, 2398, 19, 1, 0, 0, 0, 2399, 2397, 1, + 0, 0, 0, 2400, 2405, 3, 22, 11, 0, 2401, 2402, 5, 6, 0, 0, 2402, 2404, + 3, 22, 11, 0, 2403, 2401, 1, 0, 0, 0, 2404, 2407, 1, 0, 0, 0, 2405, 2403, + 1, 0, 0, 0, 2405, 2406, 1, 0, 0, 0, 2406, 2415, 1, 0, 0, 0, 2407, 2405, + 1, 0, 0, 0, 2408, 2410, 3, 22, 11, 0, 2409, 2408, 1, 0, 0, 0, 2410, 2413, + 1, 0, 0, 0, 2411, 2409, 1, 0, 0, 0, 2411, 2412, 1, 0, 0, 0, 2412, 2415, + 1, 0, 0, 0, 2413, 2411, 1, 0, 0, 0, 2414, 2400, 1, 0, 0, 0, 2414, 2411, + 1, 0, 0, 0, 2415, 21, 1, 0, 0, 0, 2416, 2420, 5, 284, 0, 0, 2417, 2421, + 3, 1910, 955, 0, 2418, 2421, 5, 78, 0, 0, 2419, 2421, 5, 190, 0, 0, 2420, + 2417, 1, 0, 0, 0, 2420, 2418, 1, 0, 0, 0, 2420, 2419, 1, 0, 0, 0, 2421, + 2468, 1, 0, 0, 0, 2422, 2423, 7, 0, 0, 0, 2423, 2424, 5, 284, 0, 0, 2424, + 2468, 3, 1910, 955, 0, 2425, 2468, 5, 232, 0, 0, 2426, 2427, 5, 166, 0, + 0, 2427, 2430, 5, 74, 0, 0, 2428, 2431, 3, 1916, 958, 0, 2429, 2431, 5, + 497, 0, 0, 2430, 2428, 1, 0, 0, 0, 2430, 2429, 1, 0, 0, 0, 2431, 2468, + 1, 0, 0, 0, 2432, 2433, 5, 369, 0, 0, 2433, 2434, 5, 366, 0, 0, 2434, 2468, + 3, 1910, 955, 0, 2435, 2436, 5, 100, 0, 0, 2436, 2468, 3, 1922, 961, 0, + 2437, 2440, 5, 498, 0, 0, 2438, 2441, 3, 1910, 955, 0, 2439, 2441, 3, 1934, + 967, 0, 2440, 2438, 1, 0, 0, 0, 2440, 2439, 1, 0, 0, 0, 2441, 2468, 1, + 0, 0, 0, 2442, 2468, 5, 494, 0, 0, 2443, 2468, 5, 495, 0, 0, 2444, 2468, + 5, 488, 0, 0, 2445, 2468, 5, 489, 0, 0, 2446, 2447, 5, 500, 0, 0, 2447, + 2448, 5, 133, 0, 0, 2448, 2468, 7, 1, 0, 0, 2449, 2450, 5, 330, 0, 0, 2450, + 2451, 5, 499, 0, 0, 2451, 2468, 3, 1908, 954, 0, 2452, 2453, 5, 311, 0, + 0, 2453, 2454, 5, 330, 0, 0, 2454, 2468, 5, 499, 0, 0, 2455, 2456, 5, 311, + 0, 0, 2456, 2468, 5, 30, 0, 0, 2457, 2458, 5, 331, 0, 0, 2458, 2460, 3, + 68, 34, 0, 2459, 2461, 7, 2, 0, 0, 2460, 2459, 1, 0, 0, 0, 2460, 2461, + 1, 0, 0, 0, 2461, 2462, 1, 0, 0, 0, 2462, 2463, 3, 70, 35, 0, 2463, 2468, + 1, 0, 0, 0, 2464, 2465, 5, 311, 0, 0, 2465, 2468, 3, 68, 34, 0, 2466, 2468, + 3, 1934, 967, 0, 2467, 2416, 1, 0, 0, 0, 2467, 2422, 1, 0, 0, 0, 2467, + 2425, 1, 0, 0, 0, 2467, 2426, 1, 0, 0, 0, 2467, 2432, 1, 0, 0, 0, 2467, + 2435, 1, 0, 0, 0, 2467, 2437, 1, 0, 0, 0, 2467, 2442, 1, 0, 0, 0, 2467, + 2443, 1, 0, 0, 0, 2467, 2444, 1, 0, 0, 0, 2467, 2445, 1, 0, 0, 0, 2467, + 2446, 1, 0, 0, 0, 2467, 2449, 1, 0, 0, 0, 2467, 2452, 1, 0, 0, 0, 2467, + 2455, 1, 0, 0, 0, 2467, 2457, 1, 0, 0, 0, 2467, 2464, 1, 0, 0, 0, 2467, + 2466, 1, 0, 0, 0, 2468, 23, 1, 0, 0, 0, 2469, 2480, 3, 22, 11, 0, 2470, + 2471, 5, 346, 0, 0, 2471, 2480, 3, 1908, 954, 0, 2472, 2473, 5, 136, 0, + 0, 2473, 2480, 3, 1922, 961, 0, 2474, 2475, 5, 316, 0, 0, 2475, 2480, 3, + 1922, 961, 0, 2476, 2477, 5, 68, 0, 0, 2477, 2478, 7, 3, 0, 0, 2478, 2480, + 3, 1922, 961, 0, 2479, 2469, 1, 0, 0, 0, 2479, 2470, 1, 0, 0, 0, 2479, + 2472, 1, 0, 0, 0, 2479, 2474, 1, 0, 0, 0, 2479, 2476, 1, 0, 0, 0, 2480, + 25, 1, 0, 0, 0, 2481, 2482, 5, 46, 0, 0, 2482, 2483, 5, 100, 0, 0, 2483, + 2485, 3, 1918, 959, 0, 2484, 2486, 3, 16, 8, 0, 2485, 2484, 1, 0, 0, 0, + 2485, 2486, 1, 0, 0, 0, 2486, 2487, 1, 0, 0, 0, 2487, 2488, 3, 18, 9, 0, + 2488, 27, 1, 0, 0, 0, 2489, 2490, 5, 140, 0, 0, 2490, 2491, 5, 316, 0, + 0, 2491, 2493, 3, 1920, 960, 0, 2492, 2494, 3, 16, 8, 0, 2493, 2492, 1, + 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2495, 1, 0, 0, 0, 2495, 2496, 3, + 30, 15, 0, 2496, 29, 1, 0, 0, 0, 2497, 2498, 5, 307, 0, 0, 2498, 2499, + 5, 95, 0, 0, 2499, 2507, 3, 1924, 962, 0, 2500, 2501, 5, 279, 0, 0, 2501, + 2502, 5, 95, 0, 0, 2502, 2507, 3, 1924, 962, 0, 2503, 2504, 5, 498, 0, + 0, 2504, 2505, 5, 95, 0, 0, 2505, 2507, 3, 1924, 962, 0, 2506, 2497, 1, + 0, 0, 0, 2506, 2500, 1, 0, 0, 0, 2506, 2503, 1, 0, 0, 0, 2507, 31, 1, 0, + 0, 0, 2508, 2509, 5, 68, 0, 0, 2509, 2510, 5, 179, 0, 0, 2510, 2511, 3, + 1892, 946, 0, 2511, 33, 1, 0, 0, 0, 2512, 2513, 5, 140, 0, 0, 2513, 2515, + 7, 4, 0, 0, 2514, 2516, 5, 30, 0, 0, 2515, 2514, 1, 0, 0, 0, 2515, 2516, + 1, 0, 0, 0, 2516, 2517, 1, 0, 0, 0, 2517, 2519, 3, 1920, 960, 0, 2518, + 2520, 3, 32, 16, 0, 2519, 2518, 1, 0, 0, 0, 2519, 2520, 1, 0, 0, 0, 2520, + 2521, 1, 0, 0, 0, 2521, 2522, 3, 90, 45, 0, 2522, 35, 1, 0, 0, 0, 2523, + 2524, 5, 140, 0, 0, 2524, 2525, 5, 321, 0, 0, 2525, 2526, 3, 1892, 946, + 0, 2526, 2532, 5, 844, 0, 0, 2527, 2529, 3, 1908, 954, 0, 2528, 2530, 7, + 5, 0, 0, 2529, 2528, 1, 0, 0, 0, 2529, 2530, 1, 0, 0, 0, 2530, 2533, 1, + 0, 0, 0, 2531, 2533, 5, 497, 0, 0, 2532, 2527, 1, 0, 0, 0, 2532, 2531, + 1, 0, 0, 0, 2533, 37, 1, 0, 0, 0, 2534, 2535, 5, 195, 0, 0, 2535, 2536, + 5, 316, 0, 0, 2536, 2538, 3, 1920, 960, 0, 2537, 2539, 7, 6, 0, 0, 2538, + 2537, 1, 0, 0, 0, 2538, 2539, 1, 0, 0, 0, 2539, 39, 1, 0, 0, 0, 2540, 2541, + 5, 195, 0, 0, 2541, 2543, 5, 100, 0, 0, 2542, 2544, 3, 922, 461, 0, 2543, + 2542, 1, 0, 0, 0, 2543, 2544, 1, 0, 0, 0, 2544, 2545, 1, 0, 0, 0, 2545, + 2546, 3, 1922, 961, 0, 2546, 41, 1, 0, 0, 0, 2547, 2548, 5, 195, 0, 0, + 2548, 2549, 5, 66, 0, 0, 2549, 2550, 3, 1920, 960, 0, 2550, 43, 1, 0, 0, + 0, 2551, 2552, 5, 46, 0, 0, 2552, 2553, 5, 66, 0, 0, 2553, 2555, 3, 1918, + 959, 0, 2554, 2556, 3, 16, 8, 0, 2555, 2554, 1, 0, 0, 0, 2555, 2556, 1, + 0, 0, 0, 2556, 2557, 1, 0, 0, 0, 2557, 2558, 3, 18, 9, 0, 2558, 45, 1, + 0, 0, 0, 2559, 2560, 5, 140, 0, 0, 2560, 2561, 5, 66, 0, 0, 2561, 2562, + 3, 1920, 960, 0, 2562, 2563, 3, 48, 24, 0, 2563, 2564, 5, 100, 0, 0, 2564, + 2565, 3, 1922, 961, 0, 2565, 47, 1, 0, 0, 0, 2566, 2567, 7, 7, 0, 0, 2567, + 49, 1, 0, 0, 0, 2568, 2569, 5, 46, 0, 0, 2569, 2571, 5, 321, 0, 0, 2570, + 2572, 3, 522, 261, 0, 2571, 2570, 1, 0, 0, 0, 2571, 2572, 1, 0, 0, 0, 2572, + 2573, 1, 0, 0, 0, 2573, 2575, 3, 1924, 962, 0, 2574, 2576, 3, 52, 26, 0, + 2575, 2574, 1, 0, 0, 0, 2575, 2576, 1, 0, 0, 0, 2576, 2578, 1, 0, 0, 0, + 2577, 2579, 3, 54, 27, 0, 2578, 2577, 1, 0, 0, 0, 2578, 2579, 1, 0, 0, + 0, 2579, 2581, 1, 0, 0, 0, 2580, 2582, 3, 56, 28, 0, 2581, 2580, 1, 0, + 0, 0, 2581, 2582, 1, 0, 0, 0, 2582, 2593, 1, 0, 0, 0, 2583, 2584, 5, 46, + 0, 0, 2584, 2585, 5, 321, 0, 0, 2585, 2587, 3, 52, 26, 0, 2586, 2588, 3, + 54, 27, 0, 2587, 2586, 1, 0, 0, 0, 2587, 2588, 1, 0, 0, 0, 2588, 2590, + 1, 0, 0, 0, 2589, 2591, 3, 56, 28, 0, 2590, 2589, 1, 0, 0, 0, 2590, 2591, + 1, 0, 0, 0, 2591, 2593, 1, 0, 0, 0, 2592, 2568, 1, 0, 0, 0, 2592, 2583, + 1, 0, 0, 0, 2593, 51, 1, 0, 0, 0, 2594, 2595, 5, 107, 0, 0, 2595, 2596, + 3, 1920, 960, 0, 2596, 53, 1, 0, 0, 0, 2597, 2606, 5, 844, 0, 0, 2598, + 2601, 3, 1906, 953, 0, 2599, 2601, 3, 1908, 954, 0, 2600, 2598, 1, 0, 0, + 0, 2600, 2599, 1, 0, 0, 0, 2601, 2603, 1, 0, 0, 0, 2602, 2604, 7, 5, 0, + 0, 2603, 2602, 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2607, 1, 0, 0, + 0, 2605, 2607, 5, 497, 0, 0, 2606, 2600, 1, 0, 0, 0, 2606, 2605, 1, 0, + 0, 0, 2607, 55, 1, 0, 0, 0, 2608, 2610, 3, 58, 29, 0, 2609, 2608, 1, 0, + 0, 0, 2610, 2611, 1, 0, 0, 0, 2611, 2609, 1, 0, 0, 0, 2611, 2612, 1, 0, + 0, 0, 2612, 57, 1, 0, 0, 0, 2613, 2620, 3, 194, 97, 0, 2614, 2620, 3, 798, + 399, 0, 2615, 2620, 3, 320, 160, 0, 2616, 2620, 3, 446, 223, 0, 2617, 2620, + 3, 590, 295, 0, 2618, 2620, 3, 1020, 510, 0, 2619, 2613, 1, 0, 0, 0, 2619, + 2614, 1, 0, 0, 0, 2619, 2615, 1, 0, 0, 0, 2619, 2616, 1, 0, 0, 0, 2619, + 2617, 1, 0, 0, 0, 2619, 2618, 1, 0, 0, 0, 2620, 59, 1, 0, 0, 0, 2621, 2623, + 5, 331, 0, 0, 2622, 2624, 7, 8, 0, 0, 2623, 2622, 1, 0, 0, 0, 2623, 2624, + 1, 0, 0, 0, 2624, 2625, 1, 0, 0, 0, 2625, 2626, 3, 62, 31, 0, 2626, 61, + 1, 0, 0, 0, 2627, 2628, 5, 354, 0, 0, 2628, 2636, 3, 1014, 507, 0, 2629, + 2630, 5, 330, 0, 0, 2630, 2631, 5, 156, 0, 0, 2631, 2632, 5, 36, 0, 0, + 2632, 2633, 5, 354, 0, 0, 2633, 2636, 3, 1014, 507, 0, 2634, 2636, 3, 66, + 33, 0, 2635, 2627, 1, 0, 0, 0, 2635, 2629, 1, 0, 0, 0, 2635, 2634, 1, 0, + 0, 0, 2636, 63, 1, 0, 0, 0, 2637, 2638, 3, 68, 34, 0, 2638, 2639, 7, 2, + 0, 0, 2639, 2640, 3, 70, 35, 0, 2640, 65, 1, 0, 0, 0, 2641, 2669, 3, 64, + 32, 0, 2642, 2643, 3, 68, 34, 0, 2643, 2644, 5, 64, 0, 0, 2644, 2645, 5, + 604, 0, 0, 2645, 2669, 1, 0, 0, 0, 2646, 2647, 5, 581, 0, 0, 2647, 2648, + 5, 384, 0, 0, 2648, 2669, 3, 78, 39, 0, 2649, 2650, 5, 154, 0, 0, 2650, + 2669, 3, 1910, 955, 0, 2651, 2652, 5, 321, 0, 0, 2652, 2669, 3, 1910, 955, + 0, 2653, 2655, 5, 264, 0, 0, 2654, 2656, 3, 80, 40, 0, 2655, 2654, 1, 0, + 0, 0, 2655, 2656, 1, 0, 0, 0, 2656, 2669, 1, 0, 0, 0, 2657, 2658, 5, 316, + 0, 0, 2658, 2669, 3, 82, 41, 0, 2659, 2660, 5, 330, 0, 0, 2660, 2661, 5, + 107, 0, 0, 2661, 2669, 3, 82, 41, 0, 2662, 2663, 5, 381, 0, 0, 2663, 2664, + 5, 276, 0, 0, 2664, 2669, 3, 1778, 889, 0, 2665, 2666, 5, 354, 0, 0, 2666, + 2667, 5, 335, 0, 0, 2667, 2669, 3, 1910, 955, 0, 2668, 2641, 1, 0, 0, 0, + 2668, 2642, 1, 0, 0, 0, 2668, 2646, 1, 0, 0, 0, 2668, 2649, 1, 0, 0, 0, + 2668, 2651, 1, 0, 0, 0, 2668, 2653, 1, 0, 0, 0, 2668, 2657, 1, 0, 0, 0, + 2668, 2659, 1, 0, 0, 0, 2668, 2662, 1, 0, 0, 0, 2668, 2665, 1, 0, 0, 0, + 2669, 67, 1, 0, 0, 0, 2670, 2675, 3, 1924, 962, 0, 2671, 2672, 5, 11, 0, + 0, 2672, 2674, 3, 1924, 962, 0, 2673, 2671, 1, 0, 0, 0, 2674, 2677, 1, + 0, 0, 0, 2675, 2673, 1, 0, 0, 0, 2675, 2676, 1, 0, 0, 0, 2676, 69, 1, 0, + 0, 0, 2677, 2675, 1, 0, 0, 0, 2678, 2683, 3, 72, 36, 0, 2679, 2680, 5, + 6, 0, 0, 2680, 2682, 3, 72, 36, 0, 2681, 2679, 1, 0, 0, 0, 2682, 2685, + 1, 0, 0, 0, 2683, 2681, 1, 0, 0, 0, 2683, 2684, 1, 0, 0, 0, 2684, 71, 1, + 0, 0, 0, 2685, 2683, 1, 0, 0, 0, 2686, 2689, 3, 76, 38, 0, 2687, 2689, + 3, 334, 167, 0, 2688, 2686, 1, 0, 0, 0, 2688, 2687, 1, 0, 0, 0, 2689, 73, + 1, 0, 0, 0, 2690, 2691, 5, 298, 0, 0, 2691, 2696, 7, 9, 0, 0, 2692, 2693, + 5, 308, 0, 0, 2693, 2696, 5, 298, 0, 0, 2694, 2696, 5, 328, 0, 0, 2695, + 2690, 1, 0, 0, 0, 2695, 2692, 1, 0, 0, 0, 2695, 2694, 1, 0, 0, 0, 2696, + 75, 1, 0, 0, 0, 2697, 2702, 5, 97, 0, 0, 2698, 2702, 5, 60, 0, 0, 2699, + 2702, 5, 80, 0, 0, 2700, 2702, 3, 82, 41, 0, 2701, 2697, 1, 0, 0, 0, 2701, + 2698, 1, 0, 0, 0, 2701, 2699, 1, 0, 0, 0, 2701, 2700, 1, 0, 0, 0, 2702, + 77, 1, 0, 0, 0, 2703, 2720, 3, 1910, 955, 0, 2704, 2720, 3, 1934, 967, + 0, 2705, 2706, 3, 1700, 850, 0, 2706, 2708, 3, 1910, 955, 0, 2707, 2709, + 3, 1704, 852, 0, 2708, 2707, 1, 0, 0, 0, 2708, 2709, 1, 0, 0, 0, 2709, + 2720, 1, 0, 0, 0, 2710, 2711, 3, 1700, 850, 0, 2711, 2712, 5, 2, 0, 0, + 2712, 2713, 3, 1908, 954, 0, 2713, 2714, 5, 3, 0, 0, 2714, 2715, 3, 1910, + 955, 0, 2715, 2720, 1, 0, 0, 0, 2716, 2720, 3, 334, 167, 0, 2717, 2720, + 5, 53, 0, 0, 2718, 2720, 5, 249, 0, 0, 2719, 2703, 1, 0, 0, 0, 2719, 2704, + 1, 0, 0, 0, 2719, 2705, 1, 0, 0, 0, 2719, 2710, 1, 0, 0, 0, 2719, 2716, + 1, 0, 0, 0, 2719, 2717, 1, 0, 0, 0, 2719, 2718, 1, 0, 0, 0, 2720, 79, 1, + 0, 0, 0, 2721, 2724, 3, 1910, 955, 0, 2722, 2724, 5, 53, 0, 0, 2723, 2721, + 1, 0, 0, 0, 2723, 2722, 1, 0, 0, 0, 2724, 81, 1, 0, 0, 0, 2725, 2728, 3, + 1930, 965, 0, 2726, 2728, 3, 1910, 955, 0, 2727, 2725, 1, 0, 0, 0, 2727, + 2726, 1, 0, 0, 0, 2728, 83, 1, 0, 0, 0, 2729, 2730, 5, 311, 0, 0, 2730, + 2731, 3, 86, 43, 0, 2731, 85, 1, 0, 0, 0, 2732, 2741, 3, 88, 44, 0, 2733, + 2734, 5, 581, 0, 0, 2734, 2741, 5, 384, 0, 0, 2735, 2736, 5, 354, 0, 0, + 2736, 2737, 5, 239, 0, 0, 2737, 2741, 5, 246, 0, 0, 2738, 2739, 5, 330, + 0, 0, 2739, 2741, 5, 107, 0, 0, 2740, 2732, 1, 0, 0, 0, 2740, 2733, 1, + 0, 0, 0, 2740, 2735, 1, 0, 0, 0, 2740, 2738, 1, 0, 0, 0, 2741, 87, 1, 0, + 0, 0, 2742, 2745, 3, 68, 34, 0, 2743, 2745, 5, 30, 0, 0, 2744, 2742, 1, + 0, 0, 0, 2744, 2743, 1, 0, 0, 0, 2745, 89, 1, 0, 0, 0, 2746, 2747, 5, 331, + 0, 0, 2747, 2750, 3, 62, 31, 0, 2748, 2750, 3, 84, 42, 0, 2749, 2746, 1, + 0, 0, 0, 2749, 2748, 1, 0, 0, 0, 2750, 91, 1, 0, 0, 0, 2751, 2752, 5, 331, + 0, 0, 2752, 2755, 3, 66, 33, 0, 2753, 2755, 3, 84, 42, 0, 2754, 2751, 1, + 0, 0, 0, 2754, 2753, 1, 0, 0, 0, 2755, 93, 1, 0, 0, 0, 2756, 2769, 5, 333, + 0, 0, 2757, 2770, 3, 68, 34, 0, 2758, 2759, 5, 581, 0, 0, 2759, 2770, 5, + 384, 0, 0, 2760, 2761, 5, 354, 0, 0, 2761, 2762, 5, 239, 0, 0, 2762, 2770, + 5, 246, 0, 0, 2763, 2764, 5, 330, 0, 0, 2764, 2770, 5, 107, 0, 0, 2765, + 2770, 5, 113, 0, 0, 2766, 2770, 5, 90, 0, 0, 2767, 2770, 5, 52, 0, 0, 2768, + 2770, 5, 30, 0, 0, 2769, 2757, 1, 0, 0, 0, 2769, 2758, 1, 0, 0, 0, 2769, + 2760, 1, 0, 0, 0, 2769, 2763, 1, 0, 0, 0, 2769, 2765, 1, 0, 0, 0, 2769, + 2766, 1, 0, 0, 0, 2769, 2767, 1, 0, 0, 0, 2769, 2768, 1, 0, 0, 0, 2770, + 95, 1, 0, 0, 0, 2771, 2772, 5, 331, 0, 0, 2772, 2773, 5, 167, 0, 0, 2773, + 2774, 3, 98, 49, 0, 2774, 2775, 3, 100, 50, 0, 2775, 97, 1, 0, 0, 0, 2776, + 2779, 5, 30, 0, 0, 2777, 2779, 3, 1886, 943, 0, 2778, 2776, 1, 0, 0, 0, + 2778, 2777, 1, 0, 0, 0, 2779, 99, 1, 0, 0, 0, 2780, 2781, 7, 10, 0, 0, + 2781, 101, 1, 0, 0, 0, 2782, 2783, 5, 157, 0, 0, 2783, 103, 1, 0, 0, 0, + 2784, 2785, 5, 191, 0, 0, 2785, 2786, 7, 11, 0, 0, 2786, 105, 1, 0, 0, + 0, 2787, 2788, 5, 140, 0, 0, 2788, 2789, 5, 93, 0, 0, 2789, 2790, 3, 1888, + 944, 0, 2790, 2795, 3, 108, 54, 0, 2791, 2792, 5, 6, 0, 0, 2792, 2794, + 3, 108, 54, 0, 2793, 2791, 1, 0, 0, 0, 2794, 2797, 1, 0, 0, 0, 2795, 2793, + 1, 0, 0, 0, 2795, 2796, 1, 0, 0, 0, 2796, 107, 1, 0, 0, 0, 2797, 2795, + 1, 0, 0, 0, 2798, 2799, 5, 135, 0, 0, 2799, 2999, 3, 110, 55, 0, 2800, + 2801, 5, 195, 0, 0, 2801, 2802, 5, 45, 0, 0, 2802, 2804, 3, 1924, 962, + 0, 2803, 2805, 7, 12, 0, 0, 2804, 2803, 1, 0, 0, 0, 2804, 2805, 1, 0, 0, + 0, 2805, 2999, 1, 0, 0, 0, 2806, 2807, 5, 279, 0, 0, 2807, 2808, 5, 95, + 0, 0, 2808, 2999, 3, 1920, 960, 0, 2809, 2810, 5, 307, 0, 0, 2810, 2811, + 5, 95, 0, 0, 2811, 2999, 3, 1924, 962, 0, 2812, 2813, 5, 307, 0, 0, 2813, + 2814, 5, 44, 0, 0, 2814, 2815, 3, 1924, 962, 0, 2815, 2816, 5, 95, 0, 0, + 2816, 2817, 3, 1924, 962, 0, 2817, 2999, 1, 0, 0, 0, 2818, 2819, 5, 140, + 0, 0, 2819, 2820, 5, 44, 0, 0, 2820, 2821, 3, 1924, 962, 0, 2821, 2822, + 5, 358, 0, 0, 2822, 2823, 3, 1662, 831, 0, 2823, 2999, 1, 0, 0, 0, 2824, + 2825, 5, 140, 0, 0, 2825, 2826, 5, 44, 0, 0, 2826, 2827, 3, 1924, 962, + 0, 2827, 2828, 5, 835, 0, 0, 2828, 2829, 3, 1924, 962, 0, 2829, 2999, 1, + 0, 0, 0, 2830, 2831, 5, 140, 0, 0, 2831, 2832, 5, 836, 0, 0, 2832, 2999, + 3, 1924, 962, 0, 2833, 2834, 5, 140, 0, 0, 2834, 2835, 5, 838, 0, 0, 2835, + 2999, 5, 30, 0, 0, 2836, 2837, 5, 140, 0, 0, 2837, 2838, 5, 838, 0, 0, + 2838, 2999, 5, 842, 0, 0, 2839, 2840, 5, 140, 0, 0, 2840, 2841, 5, 838, + 0, 0, 2841, 2842, 5, 240, 0, 0, 2842, 2843, 5, 836, 0, 0, 2843, 2999, 3, + 1924, 962, 0, 2844, 2845, 5, 140, 0, 0, 2845, 2846, 5, 838, 0, 0, 2846, + 2999, 5, 420, 0, 0, 2847, 2849, 5, 140, 0, 0, 2848, 2850, 5, 840, 0, 0, + 2849, 2848, 1, 0, 0, 0, 2849, 2850, 1, 0, 0, 0, 2850, 2851, 1, 0, 0, 0, + 2851, 2852, 5, 837, 0, 0, 2852, 2853, 5, 2, 0, 0, 2853, 2854, 3, 246, 123, + 0, 2854, 2855, 5, 3, 0, 0, 2855, 2999, 1, 0, 0, 0, 2856, 2857, 5, 140, + 0, 0, 2857, 2858, 5, 837, 0, 0, 2858, 2999, 5, 420, 0, 0, 2859, 2860, 5, + 140, 0, 0, 2860, 2861, 5, 837, 0, 0, 2861, 2999, 5, 569, 0, 0, 2862, 2863, + 5, 140, 0, 0, 2863, 2864, 5, 835, 0, 0, 2864, 2999, 5, 420, 0, 0, 2865, + 2867, 5, 135, 0, 0, 2866, 2868, 5, 44, 0, 0, 2867, 2866, 1, 0, 0, 0, 2867, + 2868, 1, 0, 0, 0, 2868, 2869, 1, 0, 0, 0, 2869, 2870, 3, 1924, 962, 0, + 2870, 2873, 3, 1662, 831, 0, 2871, 2872, 5, 53, 0, 0, 2872, 2874, 3, 1710, + 855, 0, 2873, 2871, 1, 0, 0, 0, 2873, 2874, 1, 0, 0, 0, 2874, 2877, 1, + 0, 0, 0, 2875, 2876, 5, 835, 0, 0, 2876, 2878, 3, 1924, 962, 0, 2877, 2875, + 1, 0, 0, 0, 2877, 2878, 1, 0, 0, 0, 2878, 2883, 1, 0, 0, 0, 2879, 2881, + 5, 77, 0, 0, 2880, 2879, 1, 0, 0, 0, 2880, 2881, 1, 0, 0, 0, 2881, 2882, + 1, 0, 0, 0, 2882, 2884, 5, 78, 0, 0, 2883, 2880, 1, 0, 0, 0, 2883, 2884, + 1, 0, 0, 0, 2884, 2887, 1, 0, 0, 0, 2885, 2886, 5, 43, 0, 0, 2886, 2888, + 7, 13, 0, 0, 2887, 2885, 1, 0, 0, 0, 2887, 2888, 1, 0, 0, 0, 2888, 2999, + 1, 0, 0, 0, 2889, 2891, 5, 195, 0, 0, 2890, 2892, 5, 44, 0, 0, 2891, 2890, + 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, 2893, 1, 0, 0, 0, 2893, 2895, + 3, 1924, 962, 0, 2894, 2896, 7, 12, 0, 0, 2895, 2894, 1, 0, 0, 0, 2895, + 2896, 1, 0, 0, 0, 2896, 2999, 1, 0, 0, 0, 2897, 2898, 5, 577, 0, 0, 2898, + 2899, 5, 246, 0, 0, 2899, 2900, 5, 325, 0, 0, 2900, 2904, 7, 14, 0, 0, + 2901, 2902, 5, 390, 0, 0, 2902, 2903, 5, 358, 0, 0, 2903, 2905, 7, 15, + 0, 0, 2904, 2901, 1, 0, 0, 0, 2904, 2905, 1, 0, 0, 0, 2905, 2908, 1, 0, + 0, 0, 2906, 2907, 5, 62, 0, 0, 2907, 2909, 5, 455, 0, 0, 2908, 2906, 1, + 0, 0, 0, 2908, 2909, 1, 0, 0, 0, 2909, 2999, 1, 0, 0, 0, 2910, 2911, 5, + 412, 0, 0, 2911, 2912, 7, 14, 0, 0, 2912, 2913, 5, 62, 0, 0, 2913, 2999, + 5, 455, 0, 0, 2914, 2915, 5, 463, 0, 0, 2915, 2916, 5, 64, 0, 0, 2916, + 2918, 3, 1888, 944, 0, 2917, 2919, 7, 16, 0, 0, 2918, 2917, 1, 0, 0, 0, + 2918, 2919, 1, 0, 0, 0, 2919, 2999, 1, 0, 0, 0, 2920, 2921, 5, 331, 0, + 0, 2921, 2922, 5, 250, 0, 0, 2922, 2999, 5, 862, 0, 0, 2923, 2924, 5, 331, + 0, 0, 2924, 2925, 5, 393, 0, 0, 2925, 2926, 5, 780, 0, 0, 2926, 2999, 3, + 1924, 962, 0, 2927, 2928, 5, 331, 0, 0, 2928, 2929, 5, 93, 0, 0, 2929, + 2930, 5, 512, 0, 0, 2930, 2931, 5, 2, 0, 0, 2931, 2932, 3, 1126, 563, 0, + 2932, 2933, 5, 3, 0, 0, 2933, 2999, 1, 0, 0, 0, 2934, 2935, 5, 282, 0, + 0, 2935, 2936, 5, 2, 0, 0, 2936, 2937, 3, 1924, 962, 0, 2937, 2938, 5, + 10, 0, 0, 2938, 2939, 3, 1710, 855, 0, 2939, 2947, 1, 0, 0, 0, 2940, 2941, + 5, 6, 0, 0, 2941, 2942, 3, 1924, 962, 0, 2942, 2943, 5, 10, 0, 0, 2943, + 2944, 3, 1710, 855, 0, 2944, 2946, 1, 0, 0, 0, 2945, 2940, 1, 0, 0, 0, + 2946, 2949, 1, 0, 0, 0, 2947, 2945, 1, 0, 0, 0, 2947, 2948, 1, 0, 0, 0, + 2948, 2950, 1, 0, 0, 0, 2949, 2947, 1, 0, 0, 0, 2950, 2951, 5, 3, 0, 0, + 2951, 2952, 5, 331, 0, 0, 2952, 2953, 5, 250, 0, 0, 2953, 2954, 5, 862, + 0, 0, 2954, 2999, 1, 0, 0, 0, 2955, 2957, 5, 135, 0, 0, 2956, 2958, 3, + 522, 261, 0, 2957, 2956, 1, 0, 0, 0, 2957, 2958, 1, 0, 0, 0, 2958, 2959, + 1, 0, 0, 0, 2959, 2960, 5, 282, 0, 0, 2960, 2961, 5, 2, 0, 0, 2961, 2962, + 3, 1924, 962, 0, 2962, 2963, 5, 10, 0, 0, 2963, 2964, 3, 1710, 855, 0, + 2964, 2972, 1, 0, 0, 0, 2965, 2966, 5, 6, 0, 0, 2966, 2967, 3, 1924, 962, + 0, 2967, 2968, 5, 10, 0, 0, 2968, 2969, 3, 1710, 855, 0, 2969, 2971, 1, + 0, 0, 0, 2970, 2965, 1, 0, 0, 0, 2971, 2974, 1, 0, 0, 0, 2972, 2970, 1, + 0, 0, 0, 2972, 2973, 1, 0, 0, 0, 2973, 2975, 1, 0, 0, 0, 2974, 2972, 1, + 0, 0, 0, 2975, 2976, 5, 3, 0, 0, 2976, 2977, 5, 250, 0, 0, 2977, 2978, + 5, 862, 0, 0, 2978, 2999, 1, 0, 0, 0, 2979, 2980, 5, 195, 0, 0, 2980, 2981, + 5, 282, 0, 0, 2981, 2982, 5, 2, 0, 0, 2982, 2983, 3, 1924, 962, 0, 2983, + 2984, 5, 10, 0, 0, 2984, 2985, 3, 1710, 855, 0, 2985, 2993, 1, 0, 0, 0, + 2986, 2987, 5, 6, 0, 0, 2987, 2988, 3, 1924, 962, 0, 2988, 2989, 5, 10, + 0, 0, 2989, 2990, 3, 1710, 855, 0, 2990, 2992, 1, 0, 0, 0, 2991, 2986, + 1, 0, 0, 0, 2992, 2995, 1, 0, 0, 0, 2993, 2991, 1, 0, 0, 0, 2993, 2994, + 1, 0, 0, 0, 2994, 2996, 1, 0, 0, 0, 2995, 2993, 1, 0, 0, 0, 2996, 2997, + 5, 3, 0, 0, 2997, 2999, 1, 0, 0, 0, 2998, 2798, 1, 0, 0, 0, 2998, 2800, + 1, 0, 0, 0, 2998, 2806, 1, 0, 0, 0, 2998, 2809, 1, 0, 0, 0, 2998, 2812, + 1, 0, 0, 0, 2998, 2818, 1, 0, 0, 0, 2998, 2824, 1, 0, 0, 0, 2998, 2830, + 1, 0, 0, 0, 2998, 2833, 1, 0, 0, 0, 2998, 2836, 1, 0, 0, 0, 2998, 2839, + 1, 0, 0, 0, 2998, 2844, 1, 0, 0, 0, 2998, 2847, 1, 0, 0, 0, 2998, 2856, + 1, 0, 0, 0, 2998, 2859, 1, 0, 0, 0, 2998, 2862, 1, 0, 0, 0, 2998, 2865, + 1, 0, 0, 0, 2998, 2889, 1, 0, 0, 0, 2998, 2897, 1, 0, 0, 0, 2998, 2910, + 1, 0, 0, 0, 2998, 2914, 1, 0, 0, 0, 2998, 2920, 1, 0, 0, 0, 2998, 2923, + 1, 0, 0, 0, 2998, 2927, 1, 0, 0, 0, 2998, 2934, 1, 0, 0, 0, 2998, 2955, + 1, 0, 0, 0, 2998, 2979, 1, 0, 0, 0, 2999, 109, 1, 0, 0, 0, 3000, 3001, + 5, 45, 0, 0, 3001, 3003, 3, 1924, 962, 0, 3002, 3000, 1, 0, 0, 0, 3002, + 3003, 1, 0, 0, 0, 3003, 3026, 1, 0, 0, 0, 3004, 3005, 5, 99, 0, 0, 3005, + 3006, 5, 2, 0, 0, 3006, 3007, 3, 246, 123, 0, 3007, 3008, 5, 3, 0, 0, 3008, + 3027, 1, 0, 0, 0, 3009, 3010, 5, 85, 0, 0, 3010, 3011, 5, 240, 0, 0, 3011, + 3012, 5, 2, 0, 0, 3012, 3013, 3, 246, 123, 0, 3013, 3014, 5, 3, 0, 0, 3014, + 3027, 1, 0, 0, 0, 3015, 3016, 5, 63, 0, 0, 3016, 3017, 5, 240, 0, 0, 3017, + 3018, 5, 2, 0, 0, 3018, 3019, 3, 246, 123, 0, 3019, 3020, 5, 3, 0, 0, 3020, + 3021, 5, 87, 0, 0, 3021, 3022, 3, 1888, 944, 0, 3022, 3023, 5, 2, 0, 0, + 3023, 3024, 3, 246, 123, 0, 3024, 3025, 5, 3, 0, 0, 3025, 3027, 1, 0, 0, + 0, 3026, 3004, 1, 0, 0, 0, 3026, 3009, 1, 0, 0, 0, 3026, 3015, 1, 0, 0, + 0, 3027, 111, 1, 0, 0, 0, 3028, 3029, 5, 605, 0, 0, 3029, 3030, 5, 282, + 0, 0, 3030, 3031, 3, 1888, 944, 0, 3031, 3032, 3, 140, 70, 0, 3032, 3037, + 1, 0, 0, 0, 3033, 3034, 5, 606, 0, 0, 3034, 3035, 5, 282, 0, 0, 3035, 3037, + 3, 1888, 944, 0, 3036, 3028, 1, 0, 0, 0, 3036, 3033, 1, 0, 0, 0, 3037, + 113, 1, 0, 0, 0, 3038, 3039, 5, 605, 0, 0, 3039, 3040, 5, 282, 0, 0, 3040, + 3041, 3, 1888, 944, 0, 3041, 115, 1, 0, 0, 0, 3042, 3043, 5, 135, 0, 0, + 3043, 3345, 3, 212, 106, 0, 3044, 3045, 5, 135, 0, 0, 3045, 3046, 5, 224, + 0, 0, 3046, 3047, 5, 77, 0, 0, 3047, 3048, 5, 558, 0, 0, 3048, 3345, 3, + 212, 106, 0, 3049, 3050, 5, 135, 0, 0, 3050, 3051, 5, 44, 0, 0, 3051, 3345, + 3, 212, 106, 0, 3052, 3053, 5, 135, 0, 0, 3053, 3054, 5, 44, 0, 0, 3054, + 3055, 5, 224, 0, 0, 3055, 3056, 5, 77, 0, 0, 3056, 3057, 5, 558, 0, 0, + 3057, 3345, 3, 212, 106, 0, 3058, 3060, 5, 140, 0, 0, 3059, 3061, 3, 944, + 472, 0, 3060, 3059, 1, 0, 0, 0, 3060, 3061, 1, 0, 0, 0, 3061, 3062, 1, + 0, 0, 0, 3062, 3063, 3, 1924, 962, 0, 3063, 3064, 3, 118, 59, 0, 3064, + 3345, 1, 0, 0, 0, 3065, 3067, 5, 140, 0, 0, 3066, 3068, 3, 944, 472, 0, + 3067, 3066, 1, 0, 0, 0, 3067, 3068, 1, 0, 0, 0, 3068, 3069, 1, 0, 0, 0, + 3069, 3070, 3, 1924, 962, 0, 3070, 3071, 5, 195, 0, 0, 3071, 3072, 5, 77, + 0, 0, 3072, 3073, 5, 78, 0, 0, 3073, 3345, 1, 0, 0, 0, 3074, 3076, 5, 140, + 0, 0, 3075, 3077, 3, 944, 472, 0, 3076, 3075, 1, 0, 0, 0, 3076, 3077, 1, + 0, 0, 0, 3077, 3078, 1, 0, 0, 0, 3078, 3079, 3, 1924, 962, 0, 3079, 3080, + 5, 331, 0, 0, 3080, 3081, 5, 77, 0, 0, 3081, 3082, 5, 78, 0, 0, 3082, 3345, + 1, 0, 0, 0, 3083, 3085, 5, 140, 0, 0, 3084, 3086, 3, 944, 472, 0, 3085, + 3084, 1, 0, 0, 0, 3085, 3086, 1, 0, 0, 0, 3086, 3087, 1, 0, 0, 0, 3087, + 3088, 3, 1924, 962, 0, 3088, 3089, 5, 195, 0, 0, 3089, 3090, 5, 607, 0, + 0, 3090, 3345, 1, 0, 0, 0, 3091, 3093, 5, 140, 0, 0, 3092, 3094, 3, 944, + 472, 0, 3093, 3092, 1, 0, 0, 0, 3093, 3094, 1, 0, 0, 0, 3094, 3095, 1, + 0, 0, 0, 3095, 3096, 3, 1924, 962, 0, 3096, 3097, 5, 195, 0, 0, 3097, 3098, + 5, 607, 0, 0, 3098, 3099, 5, 224, 0, 0, 3099, 3100, 5, 558, 0, 0, 3100, + 3345, 1, 0, 0, 0, 3101, 3103, 5, 140, 0, 0, 3102, 3104, 3, 944, 472, 0, + 3103, 3102, 1, 0, 0, 0, 3103, 3104, 1, 0, 0, 0, 3104, 3105, 1, 0, 0, 0, + 3105, 3106, 3, 1924, 962, 0, 3106, 3107, 5, 331, 0, 0, 3107, 3108, 5, 340, + 0, 0, 3108, 3109, 3, 1916, 958, 0, 3109, 3345, 1, 0, 0, 0, 3110, 3112, + 5, 140, 0, 0, 3111, 3113, 3, 944, 472, 0, 3112, 3111, 1, 0, 0, 0, 3112, + 3113, 1, 0, 0, 0, 3113, 3114, 1, 0, 0, 0, 3114, 3115, 3, 1908, 954, 0, + 3115, 3116, 5, 331, 0, 0, 3116, 3117, 5, 340, 0, 0, 3117, 3118, 3, 1916, + 958, 0, 3118, 3345, 1, 0, 0, 0, 3119, 3121, 5, 140, 0, 0, 3120, 3122, 3, + 944, 472, 0, 3121, 3120, 1, 0, 0, 0, 3121, 3122, 1, 0, 0, 0, 3122, 3123, + 1, 0, 0, 0, 3123, 3124, 3, 1924, 962, 0, 3124, 3125, 5, 331, 0, 0, 3125, + 3126, 3, 128, 64, 0, 3126, 3345, 1, 0, 0, 0, 3127, 3129, 5, 140, 0, 0, + 3128, 3130, 3, 944, 472, 0, 3129, 3128, 1, 0, 0, 0, 3129, 3130, 1, 0, 0, + 0, 3130, 3131, 1, 0, 0, 0, 3131, 3132, 3, 1924, 962, 0, 3132, 3133, 5, + 311, 0, 0, 3133, 3134, 3, 128, 64, 0, 3134, 3345, 1, 0, 0, 0, 3135, 3137, + 5, 140, 0, 0, 3136, 3138, 3, 944, 472, 0, 3137, 3136, 1, 0, 0, 0, 3137, + 3138, 1, 0, 0, 0, 3138, 3139, 1, 0, 0, 0, 3139, 3140, 3, 1924, 962, 0, + 3140, 3141, 5, 331, 0, 0, 3141, 3142, 5, 343, 0, 0, 3142, 3143, 3, 1924, + 962, 0, 3143, 3345, 1, 0, 0, 0, 3144, 3146, 5, 140, 0, 0, 3145, 3147, 3, + 944, 472, 0, 3146, 3145, 1, 0, 0, 0, 3146, 3147, 1, 0, 0, 0, 3147, 3148, + 1, 0, 0, 0, 3148, 3149, 3, 1924, 962, 0, 3149, 3150, 5, 135, 0, 0, 3150, + 3151, 5, 608, 0, 0, 3151, 3152, 3, 228, 114, 0, 3152, 3153, 5, 36, 0, 0, + 3153, 3155, 5, 223, 0, 0, 3154, 3156, 3, 326, 163, 0, 3155, 3154, 1, 0, + 0, 0, 3155, 3156, 1, 0, 0, 0, 3156, 3345, 1, 0, 0, 0, 3157, 3159, 5, 140, + 0, 0, 3158, 3160, 3, 944, 472, 0, 3159, 3158, 1, 0, 0, 0, 3159, 3160, 1, + 0, 0, 0, 3160, 3161, 1, 0, 0, 0, 3161, 3162, 3, 1924, 962, 0, 3162, 3163, + 3, 136, 68, 0, 3163, 3345, 1, 0, 0, 0, 3164, 3166, 5, 140, 0, 0, 3165, + 3167, 3, 944, 472, 0, 3166, 3165, 1, 0, 0, 0, 3166, 3167, 1, 0, 0, 0, 3167, + 3168, 1, 0, 0, 0, 3168, 3169, 3, 1924, 962, 0, 3169, 3170, 5, 195, 0, 0, + 3170, 3171, 5, 223, 0, 0, 3171, 3345, 1, 0, 0, 0, 3172, 3174, 5, 140, 0, + 0, 3173, 3175, 3, 944, 472, 0, 3174, 3173, 1, 0, 0, 0, 3174, 3175, 1, 0, + 0, 0, 3175, 3176, 1, 0, 0, 0, 3176, 3177, 3, 1924, 962, 0, 3177, 3178, + 5, 195, 0, 0, 3178, 3179, 5, 223, 0, 0, 3179, 3180, 5, 224, 0, 0, 3180, + 3181, 5, 558, 0, 0, 3181, 3345, 1, 0, 0, 0, 3182, 3184, 5, 195, 0, 0, 3183, + 3185, 3, 944, 472, 0, 3184, 3183, 1, 0, 0, 0, 3184, 3185, 1, 0, 0, 0, 3185, + 3186, 1, 0, 0, 0, 3186, 3187, 5, 224, 0, 0, 3187, 3188, 5, 558, 0, 0, 3188, + 3190, 3, 1924, 962, 0, 3189, 3191, 3, 120, 60, 0, 3190, 3189, 1, 0, 0, + 0, 3190, 3191, 1, 0, 0, 0, 3191, 3345, 1, 0, 0, 0, 3192, 3194, 5, 195, + 0, 0, 3193, 3195, 3, 944, 472, 0, 3194, 3193, 1, 0, 0, 0, 3194, 3195, 1, + 0, 0, 0, 3195, 3196, 1, 0, 0, 0, 3196, 3198, 3, 1924, 962, 0, 3197, 3199, + 3, 120, 60, 0, 3198, 3197, 1, 0, 0, 0, 3198, 3199, 1, 0, 0, 0, 3199, 3345, + 1, 0, 0, 0, 3200, 3202, 5, 140, 0, 0, 3201, 3203, 3, 944, 472, 0, 3202, + 3201, 1, 0, 0, 0, 3202, 3203, 1, 0, 0, 0, 3203, 3204, 1, 0, 0, 0, 3204, + 3206, 3, 1924, 962, 0, 3205, 3207, 3, 946, 473, 0, 3206, 3205, 1, 0, 0, + 0, 3206, 3207, 1, 0, 0, 0, 3207, 3208, 1, 0, 0, 0, 3208, 3209, 5, 358, + 0, 0, 3209, 3211, 3, 1662, 831, 0, 3210, 3212, 3, 122, 61, 0, 3211, 3210, + 1, 0, 0, 0, 3211, 3212, 1, 0, 0, 0, 3212, 3214, 1, 0, 0, 0, 3213, 3215, + 3, 124, 62, 0, 3214, 3213, 1, 0, 0, 0, 3214, 3215, 1, 0, 0, 0, 3215, 3345, + 1, 0, 0, 0, 3216, 3218, 5, 140, 0, 0, 3217, 3219, 3, 944, 472, 0, 3218, + 3217, 1, 0, 0, 0, 3218, 3219, 1, 0, 0, 0, 3219, 3220, 1, 0, 0, 0, 3220, + 3221, 3, 1924, 962, 0, 3221, 3222, 3, 386, 193, 0, 3222, 3345, 1, 0, 0, + 0, 3223, 3224, 5, 135, 0, 0, 3224, 3345, 3, 238, 119, 0, 3225, 3226, 5, + 140, 0, 0, 3226, 3227, 5, 45, 0, 0, 3227, 3228, 3, 1892, 946, 0, 3228, + 3229, 3, 482, 241, 0, 3229, 3345, 1, 0, 0, 0, 3230, 3231, 5, 370, 0, 0, + 3231, 3232, 5, 45, 0, 0, 3232, 3345, 3, 1892, 946, 0, 3233, 3234, 5, 195, + 0, 0, 3234, 3235, 5, 45, 0, 0, 3235, 3236, 5, 224, 0, 0, 3236, 3237, 5, + 558, 0, 0, 3237, 3239, 3, 1892, 946, 0, 3238, 3240, 3, 120, 60, 0, 3239, + 3238, 1, 0, 0, 0, 3239, 3240, 1, 0, 0, 0, 3240, 3345, 1, 0, 0, 0, 3241, + 3242, 5, 195, 0, 0, 3242, 3243, 5, 45, 0, 0, 3243, 3245, 3, 1892, 946, + 0, 3244, 3246, 3, 120, 60, 0, 3245, 3244, 1, 0, 0, 0, 3245, 3246, 1, 0, + 0, 0, 3246, 3345, 1, 0, 0, 0, 3247, 3248, 5, 331, 0, 0, 3248, 3249, 5, + 377, 0, 0, 3249, 3345, 5, 274, 0, 0, 3250, 3251, 5, 160, 0, 0, 3251, 3252, + 5, 80, 0, 0, 3252, 3345, 3, 1892, 946, 0, 3253, 3254, 5, 331, 0, 0, 3254, + 3255, 5, 377, 0, 0, 3255, 3345, 5, 160, 0, 0, 3256, 3257, 5, 331, 0, 0, + 3257, 3345, 5, 609, 0, 0, 3258, 3259, 5, 331, 0, 0, 3259, 3345, 5, 365, + 0, 0, 3260, 3261, 5, 197, 0, 0, 3261, 3262, 5, 355, 0, 0, 3262, 3345, 3, + 1892, 946, 0, 3263, 3264, 5, 197, 0, 0, 3264, 3265, 5, 141, 0, 0, 3265, + 3266, 5, 355, 0, 0, 3266, 3345, 3, 1892, 946, 0, 3267, 3268, 5, 197, 0, + 0, 3268, 3269, 5, 310, 0, 0, 3269, 3270, 5, 355, 0, 0, 3270, 3345, 3, 1892, + 946, 0, 3271, 3272, 5, 197, 0, 0, 3272, 3273, 5, 355, 0, 0, 3273, 3345, + 5, 30, 0, 0, 3274, 3275, 5, 197, 0, 0, 3275, 3276, 5, 355, 0, 0, 3276, + 3345, 5, 100, 0, 0, 3277, 3278, 5, 190, 0, 0, 3278, 3279, 5, 355, 0, 0, + 3279, 3345, 3, 1892, 946, 0, 3280, 3281, 5, 190, 0, 0, 3281, 3282, 5, 355, + 0, 0, 3282, 3345, 5, 30, 0, 0, 3283, 3284, 5, 190, 0, 0, 3284, 3285, 5, + 355, 0, 0, 3285, 3345, 5, 100, 0, 0, 3286, 3287, 5, 197, 0, 0, 3287, 3288, + 5, 319, 0, 0, 3288, 3345, 3, 1892, 946, 0, 3289, 3290, 5, 197, 0, 0, 3290, + 3291, 5, 141, 0, 0, 3291, 3292, 5, 319, 0, 0, 3292, 3345, 3, 1892, 946, + 0, 3293, 3294, 5, 197, 0, 0, 3294, 3295, 5, 310, 0, 0, 3295, 3296, 5, 319, + 0, 0, 3296, 3345, 3, 1892, 946, 0, 3297, 3298, 5, 190, 0, 0, 3298, 3299, + 5, 319, 0, 0, 3299, 3345, 3, 1892, 946, 0, 3300, 3301, 5, 232, 0, 0, 3301, + 3345, 3, 1888, 944, 0, 3302, 3303, 5, 266, 0, 0, 3303, 3304, 5, 232, 0, + 0, 3304, 3345, 3, 1888, 944, 0, 3305, 3306, 5, 272, 0, 0, 3306, 3345, 3, + 566, 283, 0, 3307, 3308, 5, 77, 0, 0, 3308, 3345, 5, 272, 0, 0, 3309, 3310, + 5, 279, 0, 0, 3310, 3311, 5, 95, 0, 0, 3311, 3345, 3, 1920, 960, 0, 3312, + 3313, 5, 331, 0, 0, 3313, 3314, 5, 133, 0, 0, 3314, 3315, 5, 645, 0, 0, + 3315, 3345, 3, 1892, 946, 0, 3316, 3317, 5, 331, 0, 0, 3317, 3318, 5, 349, + 0, 0, 3318, 3345, 3, 1892, 946, 0, 3319, 3320, 5, 331, 0, 0, 3320, 3345, + 3, 128, 64, 0, 3321, 3322, 5, 311, 0, 0, 3322, 3345, 3, 128, 64, 0, 3323, + 3324, 5, 310, 0, 0, 3324, 3325, 5, 223, 0, 0, 3325, 3345, 3, 126, 63, 0, + 3326, 3327, 5, 197, 0, 0, 3327, 3328, 5, 577, 0, 0, 3328, 3329, 5, 246, + 0, 0, 3329, 3345, 5, 325, 0, 0, 3330, 3331, 5, 190, 0, 0, 3331, 3332, 5, + 577, 0, 0, 3332, 3333, 5, 246, 0, 0, 3333, 3345, 5, 325, 0, 0, 3334, 3335, + 5, 213, 0, 0, 3335, 3336, 5, 577, 0, 0, 3336, 3337, 5, 246, 0, 0, 3337, + 3345, 5, 325, 0, 0, 3338, 3339, 5, 266, 0, 0, 3339, 3340, 5, 213, 0, 0, + 3340, 3341, 5, 577, 0, 0, 3341, 3342, 5, 246, 0, 0, 3342, 3345, 5, 325, + 0, 0, 3343, 3345, 3, 386, 193, 0, 3344, 3042, 1, 0, 0, 0, 3344, 3044, 1, + 0, 0, 0, 3344, 3049, 1, 0, 0, 0, 3344, 3052, 1, 0, 0, 0, 3344, 3058, 1, + 0, 0, 0, 3344, 3065, 1, 0, 0, 0, 3344, 3074, 1, 0, 0, 0, 3344, 3083, 1, + 0, 0, 0, 3344, 3091, 1, 0, 0, 0, 3344, 3101, 1, 0, 0, 0, 3344, 3110, 1, + 0, 0, 0, 3344, 3119, 1, 0, 0, 0, 3344, 3127, 1, 0, 0, 0, 3344, 3135, 1, + 0, 0, 0, 3344, 3144, 1, 0, 0, 0, 3344, 3157, 1, 0, 0, 0, 3344, 3164, 1, + 0, 0, 0, 3344, 3172, 1, 0, 0, 0, 3344, 3182, 1, 0, 0, 0, 3344, 3192, 1, + 0, 0, 0, 3344, 3200, 1, 0, 0, 0, 3344, 3216, 1, 0, 0, 0, 3344, 3223, 1, + 0, 0, 0, 3344, 3225, 1, 0, 0, 0, 3344, 3230, 1, 0, 0, 0, 3344, 3233, 1, + 0, 0, 0, 3344, 3241, 1, 0, 0, 0, 3344, 3247, 1, 0, 0, 0, 3344, 3250, 1, + 0, 0, 0, 3344, 3253, 1, 0, 0, 0, 3344, 3256, 1, 0, 0, 0, 3344, 3258, 1, + 0, 0, 0, 3344, 3260, 1, 0, 0, 0, 3344, 3263, 1, 0, 0, 0, 3344, 3267, 1, + 0, 0, 0, 3344, 3271, 1, 0, 0, 0, 3344, 3274, 1, 0, 0, 0, 3344, 3277, 1, + 0, 0, 0, 3344, 3280, 1, 0, 0, 0, 3344, 3283, 1, 0, 0, 0, 3344, 3286, 1, + 0, 0, 0, 3344, 3289, 1, 0, 0, 0, 3344, 3293, 1, 0, 0, 0, 3344, 3297, 1, + 0, 0, 0, 3344, 3300, 1, 0, 0, 0, 3344, 3302, 1, 0, 0, 0, 3344, 3305, 1, + 0, 0, 0, 3344, 3307, 1, 0, 0, 0, 3344, 3309, 1, 0, 0, 0, 3344, 3312, 1, + 0, 0, 0, 3344, 3316, 1, 0, 0, 0, 3344, 3319, 1, 0, 0, 0, 3344, 3321, 1, + 0, 0, 0, 3344, 3323, 1, 0, 0, 0, 3344, 3326, 1, 0, 0, 0, 3344, 3330, 1, + 0, 0, 0, 3344, 3334, 1, 0, 0, 0, 3344, 3338, 1, 0, 0, 0, 3344, 3343, 1, + 0, 0, 0, 3345, 117, 1, 0, 0, 0, 3346, 3347, 5, 331, 0, 0, 3347, 3348, 5, + 53, 0, 0, 3348, 3352, 3, 1710, 855, 0, 3349, 3350, 5, 195, 0, 0, 3350, + 3352, 5, 53, 0, 0, 3351, 3346, 1, 0, 0, 0, 3351, 3349, 1, 0, 0, 0, 3352, + 119, 1, 0, 0, 0, 3353, 3354, 7, 12, 0, 0, 3354, 121, 1, 0, 0, 0, 3355, + 3356, 5, 43, 0, 0, 3356, 3357, 3, 566, 283, 0, 3357, 123, 1, 0, 0, 0, 3358, + 3359, 5, 101, 0, 0, 3359, 3360, 3, 1710, 855, 0, 3360, 125, 1, 0, 0, 0, + 3361, 3368, 5, 267, 0, 0, 3362, 3368, 5, 115, 0, 0, 3363, 3368, 5, 53, + 0, 0, 3364, 3365, 5, 101, 0, 0, 3365, 3366, 5, 230, 0, 0, 3366, 3368, 3, + 1892, 946, 0, 3367, 3361, 1, 0, 0, 0, 3367, 3362, 1, 0, 0, 0, 3367, 3363, + 1, 0, 0, 0, 3367, 3364, 1, 0, 0, 0, 3368, 127, 1, 0, 0, 0, 3369, 3370, + 5, 2, 0, 0, 3370, 3371, 3, 132, 66, 0, 3371, 3372, 5, 3, 0, 0, 3372, 129, + 1, 0, 0, 0, 3373, 3374, 5, 106, 0, 0, 3374, 3375, 3, 128, 64, 0, 3375, + 131, 1, 0, 0, 0, 3376, 3381, 3, 134, 67, 0, 3377, 3378, 5, 6, 0, 0, 3378, + 3380, 3, 134, 67, 0, 3379, 3377, 1, 0, 0, 0, 3380, 3383, 1, 0, 0, 0, 3381, + 3379, 1, 0, 0, 0, 3381, 3382, 1, 0, 0, 0, 3382, 133, 1, 0, 0, 0, 3383, + 3381, 1, 0, 0, 0, 3384, 3393, 3, 1932, 966, 0, 3385, 3386, 5, 10, 0, 0, + 3386, 3394, 3, 508, 254, 0, 3387, 3388, 5, 11, 0, 0, 3388, 3391, 3, 1932, + 966, 0, 3389, 3390, 5, 10, 0, 0, 3390, 3392, 3, 508, 254, 0, 3391, 3389, + 1, 0, 0, 0, 3391, 3392, 1, 0, 0, 0, 3392, 3394, 1, 0, 0, 0, 3393, 3385, + 1, 0, 0, 0, 3393, 3387, 1, 0, 0, 0, 3393, 3394, 1, 0, 0, 0, 3394, 135, + 1, 0, 0, 0, 3395, 3397, 3, 138, 69, 0, 3396, 3395, 1, 0, 0, 0, 3397, 3398, + 1, 0, 0, 0, 3398, 3396, 1, 0, 0, 0, 3398, 3399, 1, 0, 0, 0, 3399, 137, + 1, 0, 0, 0, 3400, 3405, 5, 312, 0, 0, 3401, 3403, 3, 16, 8, 0, 3402, 3401, + 1, 0, 0, 0, 3402, 3403, 1, 0, 0, 0, 3403, 3404, 1, 0, 0, 0, 3404, 3406, + 3, 334, 167, 0, 3405, 3402, 1, 0, 0, 0, 3405, 3406, 1, 0, 0, 0, 3406, 3414, + 1, 0, 0, 0, 3407, 3411, 5, 331, 0, 0, 3408, 3412, 3, 330, 165, 0, 3409, + 3410, 5, 608, 0, 0, 3410, 3412, 3, 228, 114, 0, 3411, 3408, 1, 0, 0, 0, + 3411, 3409, 1, 0, 0, 0, 3412, 3414, 1, 0, 0, 0, 3413, 3400, 1, 0, 0, 0, + 3413, 3407, 1, 0, 0, 0, 3414, 139, 1, 0, 0, 0, 3415, 3416, 5, 62, 0, 0, + 3416, 3417, 5, 585, 0, 0, 3417, 3418, 5, 106, 0, 0, 3418, 3419, 5, 2, 0, + 0, 3419, 3420, 3, 144, 72, 0, 3420, 3421, 5, 3, 0, 0, 3421, 3442, 1, 0, + 0, 0, 3422, 3423, 5, 62, 0, 0, 3423, 3424, 5, 585, 0, 0, 3424, 3425, 5, + 68, 0, 0, 3425, 3426, 5, 2, 0, 0, 3426, 3427, 3, 1830, 915, 0, 3427, 3428, + 5, 3, 0, 0, 3428, 3442, 1, 0, 0, 0, 3429, 3430, 5, 62, 0, 0, 3430, 3431, + 5, 585, 0, 0, 3431, 3432, 5, 64, 0, 0, 3432, 3433, 5, 2, 0, 0, 3433, 3434, + 3, 1830, 915, 0, 3434, 3435, 5, 3, 0, 0, 3435, 3436, 5, 95, 0, 0, 3436, + 3437, 5, 2, 0, 0, 3437, 3438, 3, 1830, 915, 0, 3438, 3439, 5, 3, 0, 0, + 3439, 3442, 1, 0, 0, 0, 3440, 3442, 5, 53, 0, 0, 3441, 3415, 1, 0, 0, 0, + 3441, 3422, 1, 0, 0, 0, 3441, 3429, 1, 0, 0, 0, 3441, 3440, 1, 0, 0, 0, + 3442, 141, 1, 0, 0, 0, 3443, 3444, 3, 1930, 965, 0, 3444, 3445, 3, 1908, + 954, 0, 3445, 143, 1, 0, 0, 0, 3446, 3451, 3, 142, 71, 0, 3447, 3448, 5, + 6, 0, 0, 3448, 3450, 3, 142, 71, 0, 3449, 3447, 1, 0, 0, 0, 3450, 3453, + 1, 0, 0, 0, 3451, 3449, 1, 0, 0, 0, 3451, 3452, 1, 0, 0, 0, 3452, 145, + 1, 0, 0, 0, 3453, 3451, 1, 0, 0, 0, 3454, 3455, 5, 140, 0, 0, 3455, 3456, + 5, 358, 0, 0, 3456, 3457, 3, 566, 283, 0, 3457, 3458, 3, 148, 74, 0, 3458, + 147, 1, 0, 0, 0, 3459, 3464, 3, 150, 75, 0, 3460, 3461, 5, 6, 0, 0, 3461, + 3463, 3, 150, 75, 0, 3462, 3460, 1, 0, 0, 0, 3463, 3466, 1, 0, 0, 0, 3464, + 3462, 1, 0, 0, 0, 3464, 3465, 1, 0, 0, 0, 3465, 149, 1, 0, 0, 0, 3466, + 3464, 1, 0, 0, 0, 3467, 3468, 5, 135, 0, 0, 3468, 3469, 5, 145, 0, 0, 3469, + 3471, 3, 1646, 823, 0, 3470, 3472, 3, 120, 60, 0, 3471, 3470, 1, 0, 0, + 0, 3471, 3472, 1, 0, 0, 0, 3472, 3498, 1, 0, 0, 0, 3473, 3474, 5, 195, + 0, 0, 3474, 3477, 5, 145, 0, 0, 3475, 3476, 5, 224, 0, 0, 3476, 3478, 5, + 558, 0, 0, 3477, 3475, 1, 0, 0, 0, 3477, 3478, 1, 0, 0, 0, 3478, 3479, + 1, 0, 0, 0, 3479, 3481, 3, 1924, 962, 0, 3480, 3482, 3, 120, 60, 0, 3481, + 3480, 1, 0, 0, 0, 3481, 3482, 1, 0, 0, 0, 3482, 3498, 1, 0, 0, 0, 3483, + 3484, 5, 140, 0, 0, 3484, 3485, 5, 145, 0, 0, 3485, 3487, 3, 1924, 962, + 0, 3486, 3488, 3, 946, 473, 0, 3487, 3486, 1, 0, 0, 0, 3487, 3488, 1, 0, + 0, 0, 3488, 3489, 1, 0, 0, 0, 3489, 3490, 5, 358, 0, 0, 3490, 3492, 3, + 1662, 831, 0, 3491, 3493, 3, 122, 61, 0, 3492, 3491, 1, 0, 0, 0, 3492, + 3493, 1, 0, 0, 0, 3493, 3495, 1, 0, 0, 0, 3494, 3496, 3, 120, 60, 0, 3495, + 3494, 1, 0, 0, 0, 3495, 3496, 1, 0, 0, 0, 3496, 3498, 1, 0, 0, 0, 3497, + 3467, 1, 0, 0, 0, 3497, 3473, 1, 0, 0, 0, 3497, 3483, 1, 0, 0, 0, 3498, + 151, 1, 0, 0, 0, 3499, 3502, 5, 159, 0, 0, 3500, 3503, 3, 1490, 745, 0, + 3501, 3503, 5, 30, 0, 0, 3502, 3500, 1, 0, 0, 0, 3502, 3501, 1, 0, 0, 0, + 3503, 153, 1, 0, 0, 0, 3504, 3506, 5, 171, 0, 0, 3505, 3507, 3, 178, 89, + 0, 3506, 3505, 1, 0, 0, 0, 3506, 3507, 1, 0, 0, 0, 3507, 3508, 1, 0, 0, + 0, 3508, 3510, 3, 1888, 944, 0, 3509, 3511, 3, 244, 122, 0, 3510, 3509, + 1, 0, 0, 0, 3510, 3511, 1, 0, 0, 0, 3511, 3512, 1, 0, 0, 0, 3512, 3514, + 3, 166, 83, 0, 3513, 3515, 3, 168, 84, 0, 3514, 3513, 1, 0, 0, 0, 3514, + 3515, 1, 0, 0, 0, 3515, 3516, 1, 0, 0, 0, 3516, 3518, 3, 170, 85, 0, 3517, + 3519, 3, 180, 90, 0, 3518, 3517, 1, 0, 0, 0, 3518, 3519, 1, 0, 0, 0, 3519, + 3521, 1, 0, 0, 0, 3520, 3522, 3, 16, 8, 0, 3521, 3520, 1, 0, 0, 0, 3521, + 3522, 1, 0, 0, 0, 3522, 3523, 1, 0, 0, 0, 3523, 3525, 3, 172, 86, 0, 3524, + 3526, 3, 1638, 819, 0, 3525, 3524, 1, 0, 0, 0, 3525, 3526, 1, 0, 0, 0, + 3526, 3559, 1, 0, 0, 0, 3527, 3528, 5, 171, 0, 0, 3528, 3529, 5, 2, 0, + 0, 3529, 3530, 3, 1428, 714, 0, 3530, 3531, 5, 3, 0, 0, 3531, 3533, 5, + 95, 0, 0, 3532, 3534, 3, 168, 84, 0, 3533, 3532, 1, 0, 0, 0, 3533, 3534, + 1, 0, 0, 0, 3534, 3535, 1, 0, 0, 0, 3535, 3537, 3, 170, 85, 0, 3536, 3538, + 3, 16, 8, 0, 3537, 3536, 1, 0, 0, 0, 3537, 3538, 1, 0, 0, 0, 3538, 3539, + 1, 0, 0, 0, 3539, 3540, 3, 172, 86, 0, 3540, 3559, 1, 0, 0, 0, 3541, 3542, + 5, 171, 0, 0, 3542, 3544, 3, 1888, 944, 0, 3543, 3545, 3, 244, 122, 0, + 3544, 3543, 1, 0, 0, 0, 3544, 3545, 1, 0, 0, 0, 3545, 3546, 1, 0, 0, 0, + 3546, 3547, 5, 64, 0, 0, 3547, 3548, 3, 1910, 955, 0, 3548, 3550, 3, 156, + 78, 0, 3549, 3551, 3, 158, 79, 0, 3550, 3549, 1, 0, 0, 0, 3550, 3551, 1, + 0, 0, 0, 3551, 3555, 1, 0, 0, 0, 3552, 3554, 3, 160, 80, 0, 3553, 3552, + 1, 0, 0, 0, 3554, 3557, 1, 0, 0, 0, 3555, 3553, 1, 0, 0, 0, 3555, 3556, + 1, 0, 0, 0, 3556, 3559, 1, 0, 0, 0, 3557, 3555, 1, 0, 0, 0, 3558, 3504, + 1, 0, 0, 0, 3558, 3527, 1, 0, 0, 0, 3558, 3541, 1, 0, 0, 0, 3559, 155, + 1, 0, 0, 0, 3560, 3563, 5, 396, 0, 0, 3561, 3564, 5, 53, 0, 0, 3562, 3564, + 3, 1910, 955, 0, 3563, 3561, 1, 0, 0, 0, 3563, 3562, 1, 0, 0, 0, 3564, + 3576, 1, 0, 0, 0, 3565, 3566, 5, 501, 0, 0, 3566, 3576, 3, 1910, 955, 0, + 3567, 3568, 5, 542, 0, 0, 3568, 3569, 3, 1910, 955, 0, 3569, 3570, 5, 543, + 0, 0, 3570, 3573, 3, 1910, 955, 0, 3571, 3572, 5, 544, 0, 0, 3572, 3574, + 3, 1910, 955, 0, 3573, 3571, 1, 0, 0, 0, 3573, 3574, 1, 0, 0, 0, 3574, + 3576, 1, 0, 0, 0, 3575, 3560, 1, 0, 0, 0, 3575, 3565, 1, 0, 0, 0, 3575, + 3567, 1, 0, 0, 0, 3576, 157, 1, 0, 0, 0, 3577, 3579, 5, 780, 0, 0, 3578, + 3577, 1, 0, 0, 0, 3578, 3579, 1, 0, 0, 0, 3579, 3581, 1, 0, 0, 0, 3580, + 3582, 5, 36, 0, 0, 3581, 3580, 1, 0, 0, 0, 3581, 3582, 1, 0, 0, 0, 3582, + 3583, 1, 0, 0, 0, 3583, 3585, 7, 17, 0, 0, 3584, 3586, 3, 1910, 955, 0, + 3585, 3584, 1, 0, 0, 0, 3585, 3586, 1, 0, 0, 0, 3586, 159, 1, 0, 0, 0, + 3587, 3592, 3, 162, 81, 0, 3588, 3590, 5, 36, 0, 0, 3589, 3588, 1, 0, 0, + 0, 3589, 3590, 1, 0, 0, 0, 3590, 3591, 1, 0, 0, 0, 3591, 3593, 3, 164, + 82, 0, 3592, 3589, 1, 0, 0, 0, 3592, 3593, 1, 0, 0, 0, 3593, 161, 1, 0, + 0, 0, 3594, 3597, 3, 1924, 962, 0, 3595, 3597, 5, 78, 0, 0, 3596, 3594, + 1, 0, 0, 0, 3596, 3595, 1, 0, 0, 0, 3597, 163, 1, 0, 0, 0, 3598, 3610, + 3, 1910, 955, 0, 3599, 3610, 3, 1908, 954, 0, 3600, 3610, 3, 1924, 962, + 0, 3601, 3610, 5, 80, 0, 0, 3602, 3610, 5, 273, 0, 0, 3603, 3610, 5, 97, + 0, 0, 3604, 3610, 5, 60, 0, 0, 3605, 3610, 5, 541, 0, 0, 3606, 3610, 5, + 420, 0, 0, 3607, 3610, 5, 53, 0, 0, 3608, 3610, 5, 569, 0, 0, 3609, 3598, + 1, 0, 0, 0, 3609, 3599, 1, 0, 0, 0, 3609, 3600, 1, 0, 0, 0, 3609, 3601, + 1, 0, 0, 0, 3609, 3602, 1, 0, 0, 0, 3609, 3603, 1, 0, 0, 0, 3609, 3604, + 1, 0, 0, 0, 3609, 3605, 1, 0, 0, 0, 3609, 3606, 1, 0, 0, 0, 3609, 3607, + 1, 0, 0, 0, 3609, 3608, 1, 0, 0, 0, 3610, 165, 1, 0, 0, 0, 3611, 3612, + 7, 18, 0, 0, 3612, 167, 1, 0, 0, 0, 3613, 3614, 5, 295, 0, 0, 3614, 169, + 1, 0, 0, 0, 3615, 3619, 3, 1910, 955, 0, 3616, 3619, 5, 341, 0, 0, 3617, + 3619, 5, 342, 0, 0, 3618, 3615, 1, 0, 0, 0, 3618, 3616, 1, 0, 0, 0, 3618, + 3617, 1, 0, 0, 0, 3619, 171, 1, 0, 0, 0, 3620, 3626, 3, 174, 87, 0, 3621, + 3622, 5, 2, 0, 0, 3622, 3623, 3, 184, 92, 0, 3623, 3624, 5, 3, 0, 0, 3624, + 3626, 1, 0, 0, 0, 3625, 3620, 1, 0, 0, 0, 3625, 3621, 1, 0, 0, 0, 3626, + 173, 1, 0, 0, 0, 3627, 3629, 3, 176, 88, 0, 3628, 3627, 1, 0, 0, 0, 3629, + 3632, 1, 0, 0, 0, 3630, 3628, 1, 0, 0, 0, 3630, 3631, 1, 0, 0, 0, 3631, + 175, 1, 0, 0, 0, 3632, 3630, 1, 0, 0, 0, 3633, 3673, 5, 108, 0, 0, 3634, + 3673, 5, 114, 0, 0, 3635, 3637, 5, 187, 0, 0, 3636, 3638, 3, 1366, 683, + 0, 3637, 3636, 1, 0, 0, 0, 3637, 3638, 1, 0, 0, 0, 3638, 3639, 1, 0, 0, + 0, 3639, 3673, 3, 1910, 955, 0, 3640, 3642, 5, 78, 0, 0, 3641, 3643, 3, + 1366, 683, 0, 3642, 3641, 1, 0, 0, 0, 3642, 3643, 1, 0, 0, 0, 3643, 3644, + 1, 0, 0, 0, 3644, 3673, 3, 1910, 955, 0, 3645, 3673, 5, 173, 0, 0, 3646, + 3673, 5, 220, 0, 0, 3647, 3649, 5, 296, 0, 0, 3648, 3650, 3, 1366, 683, + 0, 3649, 3648, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, 3651, 1, 0, 0, + 0, 3651, 3673, 3, 1910, 955, 0, 3652, 3654, 5, 201, 0, 0, 3653, 3655, 3, + 1366, 683, 0, 3654, 3653, 1, 0, 0, 0, 3654, 3655, 1, 0, 0, 0, 3655, 3656, + 1, 0, 0, 0, 3656, 3673, 3, 1910, 955, 0, 3657, 3658, 5, 213, 0, 0, 3658, + 3659, 5, 296, 0, 0, 3659, 3673, 3, 246, 123, 0, 3660, 3661, 5, 213, 0, + 0, 3661, 3662, 5, 296, 0, 0, 3662, 3673, 5, 9, 0, 0, 3663, 3664, 5, 213, + 0, 0, 3664, 3665, 5, 77, 0, 0, 3665, 3666, 5, 78, 0, 0, 3666, 3673, 3, + 246, 123, 0, 3667, 3668, 5, 213, 0, 0, 3668, 3669, 5, 78, 0, 0, 3669, 3673, + 3, 246, 123, 0, 3670, 3671, 5, 198, 0, 0, 3671, 3673, 3, 1910, 955, 0, + 3672, 3633, 1, 0, 0, 0, 3672, 3634, 1, 0, 0, 0, 3672, 3635, 1, 0, 0, 0, + 3672, 3640, 1, 0, 0, 0, 3672, 3645, 1, 0, 0, 0, 3672, 3646, 1, 0, 0, 0, + 3672, 3647, 1, 0, 0, 0, 3672, 3652, 1, 0, 0, 0, 3672, 3657, 1, 0, 0, 0, + 3672, 3660, 1, 0, 0, 0, 3672, 3663, 1, 0, 0, 0, 3672, 3667, 1, 0, 0, 0, + 3672, 3670, 1, 0, 0, 0, 3673, 177, 1, 0, 0, 0, 3674, 3675, 5, 108, 0, 0, + 3675, 179, 1, 0, 0, 0, 3676, 3678, 3, 182, 91, 0, 3677, 3676, 1, 0, 0, + 0, 3677, 3678, 1, 0, 0, 0, 3678, 3679, 1, 0, 0, 0, 3679, 3680, 5, 188, + 0, 0, 3680, 3681, 3, 1910, 955, 0, 3681, 181, 1, 0, 0, 0, 3682, 3683, 5, + 101, 0, 0, 3683, 183, 1, 0, 0, 0, 3684, 3689, 3, 186, 93, 0, 3685, 3686, + 5, 6, 0, 0, 3686, 3688, 3, 186, 93, 0, 3687, 3685, 1, 0, 0, 0, 3688, 3691, + 1, 0, 0, 0, 3689, 3687, 1, 0, 0, 0, 3689, 3690, 1, 0, 0, 0, 3690, 185, + 1, 0, 0, 0, 3691, 3689, 1, 0, 0, 0, 3692, 3694, 3, 1932, 966, 0, 3693, + 3695, 3, 188, 94, 0, 3694, 3693, 1, 0, 0, 0, 3694, 3695, 1, 0, 0, 0, 3695, + 187, 1, 0, 0, 0, 3696, 3704, 3, 76, 38, 0, 3697, 3704, 3, 334, 167, 0, + 3698, 3704, 5, 9, 0, 0, 3699, 3700, 5, 2, 0, 0, 3700, 3701, 3, 190, 95, + 0, 3701, 3702, 5, 3, 0, 0, 3702, 3704, 1, 0, 0, 0, 3703, 3696, 1, 0, 0, + 0, 3703, 3697, 1, 0, 0, 0, 3703, 3698, 1, 0, 0, 0, 3703, 3699, 1, 0, 0, + 0, 3704, 189, 1, 0, 0, 0, 3705, 3710, 3, 192, 96, 0, 3706, 3707, 5, 6, + 0, 0, 3707, 3709, 3, 192, 96, 0, 3708, 3706, 1, 0, 0, 0, 3709, 3712, 1, + 0, 0, 0, 3710, 3708, 1, 0, 0, 0, 3710, 3711, 1, 0, 0, 0, 3711, 191, 1, + 0, 0, 0, 3712, 3710, 1, 0, 0, 0, 3713, 3714, 3, 76, 38, 0, 3714, 193, 1, + 0, 0, 0, 3715, 3717, 5, 46, 0, 0, 3716, 3718, 3, 198, 99, 0, 3717, 3716, + 1, 0, 0, 0, 3717, 3718, 1, 0, 0, 0, 3718, 3719, 1, 0, 0, 0, 3719, 3723, + 5, 93, 0, 0, 3720, 3721, 5, 224, 0, 0, 3721, 3722, 5, 77, 0, 0, 3722, 3724, + 5, 558, 0, 0, 3723, 3720, 1, 0, 0, 0, 3723, 3724, 1, 0, 0, 0, 3724, 3725, + 1, 0, 0, 0, 3725, 3726, 3, 1040, 520, 0, 3726, 3728, 5, 2, 0, 0, 3727, + 3729, 3, 200, 100, 0, 3728, 3727, 1, 0, 0, 0, 3728, 3729, 1, 0, 0, 0, 3729, + 3730, 1, 0, 0, 0, 3730, 3732, 5, 3, 0, 0, 3731, 3733, 3, 310, 155, 0, 3732, + 3731, 1, 0, 0, 0, 3732, 3733, 1, 0, 0, 0, 3733, 3737, 1, 0, 0, 0, 3734, + 3736, 3, 196, 98, 0, 3735, 3734, 1, 0, 0, 0, 3736, 3739, 1, 0, 0, 0, 3737, + 3735, 1, 0, 0, 0, 3737, 3738, 1, 0, 0, 0, 3738, 195, 1, 0, 0, 0, 3739, + 3737, 1, 0, 0, 0, 3740, 3741, 5, 838, 0, 0, 3741, 3758, 7, 19, 0, 0, 3742, + 3743, 5, 836, 0, 0, 3743, 3744, 5, 2, 0, 0, 3744, 3745, 3, 1924, 962, 0, + 3745, 3746, 5, 3, 0, 0, 3746, 3758, 1, 0, 0, 0, 3747, 3749, 7, 20, 0, 0, + 3748, 3747, 1, 0, 0, 0, 3748, 3749, 1, 0, 0, 0, 3749, 3750, 1, 0, 0, 0, + 3750, 3751, 5, 837, 0, 0, 3751, 3752, 5, 2, 0, 0, 3752, 3753, 3, 246, 123, + 0, 3753, 3754, 5, 3, 0, 0, 3754, 3758, 1, 0, 0, 0, 3755, 3756, 5, 835, + 0, 0, 3756, 3758, 5, 420, 0, 0, 3757, 3740, 1, 0, 0, 0, 3757, 3742, 1, + 0, 0, 0, 3757, 3748, 1, 0, 0, 0, 3757, 3755, 1, 0, 0, 0, 3758, 197, 1, + 0, 0, 0, 3759, 3761, 5, 249, 0, 0, 3760, 3759, 1, 0, 0, 0, 3760, 3761, + 1, 0, 0, 0, 3761, 3762, 1, 0, 0, 0, 3762, 3763, 7, 21, 0, 0, 3763, 199, + 1, 0, 0, 0, 3764, 3765, 3, 204, 102, 0, 3765, 201, 1, 0, 0, 0, 3766, 3767, + 5, 2, 0, 0, 3767, 3768, 3, 206, 103, 0, 3768, 3769, 5, 3, 0, 0, 3769, 203, + 1, 0, 0, 0, 3770, 3775, 3, 208, 104, 0, 3771, 3772, 5, 6, 0, 0, 3772, 3774, + 3, 208, 104, 0, 3773, 3771, 1, 0, 0, 0, 3774, 3777, 1, 0, 0, 0, 3775, 3773, + 1, 0, 0, 0, 3775, 3776, 1, 0, 0, 0, 3776, 205, 1, 0, 0, 0, 3777, 3775, + 1, 0, 0, 0, 3778, 3783, 3, 210, 105, 0, 3779, 3780, 5, 6, 0, 0, 3780, 3782, + 3, 210, 105, 0, 3781, 3779, 1, 0, 0, 0, 3782, 3785, 1, 0, 0, 0, 3783, 3781, + 1, 0, 0, 0, 3783, 3784, 1, 0, 0, 0, 3784, 207, 1, 0, 0, 0, 3785, 3783, + 1, 0, 0, 0, 3786, 3790, 3, 238, 119, 0, 3787, 3790, 3, 232, 116, 0, 3788, + 3790, 3, 212, 106, 0, 3789, 3786, 1, 0, 0, 0, 3789, 3787, 1, 0, 0, 0, 3789, + 3788, 1, 0, 0, 0, 3790, 209, 1, 0, 0, 0, 3791, 3794, 3, 218, 109, 0, 3792, + 3794, 3, 238, 119, 0, 3793, 3791, 1, 0, 0, 0, 3793, 3792, 1, 0, 0, 0, 3794, + 211, 1, 0, 0, 0, 3795, 3796, 3, 1924, 962, 0, 3796, 3798, 3, 1114, 557, + 0, 3797, 3799, 3, 382, 191, 0, 3798, 3797, 1, 0, 0, 0, 3798, 3799, 1, 0, + 0, 0, 3799, 3801, 1, 0, 0, 0, 3800, 3802, 3, 214, 107, 0, 3801, 3800, 1, + 0, 0, 0, 3801, 3802, 1, 0, 0, 0, 3802, 213, 1, 0, 0, 0, 3803, 3805, 3, + 216, 108, 0, 3804, 3803, 1, 0, 0, 0, 3805, 3806, 1, 0, 0, 0, 3806, 3804, + 1, 0, 0, 0, 3806, 3807, 1, 0, 0, 0, 3807, 215, 1, 0, 0, 0, 3808, 3809, + 5, 53, 0, 0, 3809, 3847, 3, 1754, 877, 0, 3810, 3811, 5, 223, 0, 0, 3811, + 3812, 5, 2, 0, 0, 3812, 3813, 3, 1908, 954, 0, 3813, 3814, 5, 6, 0, 0, + 3814, 3815, 3, 1908, 954, 0, 3815, 3816, 5, 3, 0, 0, 3816, 3847, 1, 0, + 0, 0, 3817, 3818, 5, 608, 0, 0, 3818, 3819, 3, 228, 114, 0, 3819, 3820, + 5, 36, 0, 0, 3820, 3827, 5, 223, 0, 0, 3821, 3822, 5, 2, 0, 0, 3822, 3823, + 3, 1908, 954, 0, 3823, 3824, 5, 6, 0, 0, 3824, 3825, 3, 1908, 954, 0, 3825, + 3826, 5, 3, 0, 0, 3826, 3828, 1, 0, 0, 0, 3827, 3821, 1, 0, 0, 0, 3827, + 3828, 1, 0, 0, 0, 3828, 3847, 1, 0, 0, 0, 3829, 3830, 5, 835, 0, 0, 3830, + 3847, 3, 1924, 962, 0, 3831, 3847, 5, 836, 0, 0, 3832, 3847, 5, 837, 0, + 0, 3833, 3834, 5, 43, 0, 0, 3834, 3847, 7, 22, 0, 0, 3835, 3836, 5, 77, + 0, 0, 3836, 3847, 5, 78, 0, 0, 3837, 3847, 5, 78, 0, 0, 3838, 3847, 5, + 99, 0, 0, 3839, 3840, 5, 85, 0, 0, 3840, 3847, 5, 240, 0, 0, 3841, 3842, + 5, 87, 0, 0, 3842, 3844, 3, 1888, 944, 0, 3843, 3845, 3, 244, 122, 0, 3844, + 3843, 1, 0, 0, 0, 3844, 3845, 1, 0, 0, 0, 3845, 3847, 1, 0, 0, 0, 3846, + 3808, 1, 0, 0, 0, 3846, 3810, 1, 0, 0, 0, 3846, 3817, 1, 0, 0, 0, 3846, + 3829, 1, 0, 0, 0, 3846, 3831, 1, 0, 0, 0, 3846, 3832, 1, 0, 0, 0, 3846, + 3833, 1, 0, 0, 0, 3846, 3835, 1, 0, 0, 0, 3846, 3837, 1, 0, 0, 0, 3846, + 3838, 1, 0, 0, 0, 3846, 3839, 1, 0, 0, 0, 3846, 3841, 1, 0, 0, 0, 3847, + 217, 1, 0, 0, 0, 3848, 3851, 3, 1924, 962, 0, 3849, 3850, 5, 106, 0, 0, + 3850, 3852, 5, 277, 0, 0, 3851, 3849, 1, 0, 0, 0, 3851, 3852, 1, 0, 0, + 0, 3852, 3853, 1, 0, 0, 0, 3853, 3854, 3, 220, 110, 0, 3854, 219, 1, 0, + 0, 0, 3855, 3857, 3, 222, 111, 0, 3856, 3855, 1, 0, 0, 0, 3857, 3860, 1, + 0, 0, 0, 3858, 3856, 1, 0, 0, 0, 3858, 3859, 1, 0, 0, 0, 3859, 221, 1, + 0, 0, 0, 3860, 3858, 1, 0, 0, 0, 3861, 3862, 5, 45, 0, 0, 3862, 3863, 3, + 1892, 946, 0, 3863, 3864, 3, 224, 112, 0, 3864, 3870, 1, 0, 0, 0, 3865, + 3870, 3, 224, 112, 0, 3866, 3870, 3, 230, 115, 0, 3867, 3868, 5, 43, 0, + 0, 3868, 3870, 3, 566, 283, 0, 3869, 3861, 1, 0, 0, 0, 3869, 3865, 1, 0, + 0, 0, 3869, 3866, 1, 0, 0, 0, 3869, 3867, 1, 0, 0, 0, 3870, 223, 1, 0, + 0, 0, 3871, 3872, 5, 77, 0, 0, 3872, 3927, 5, 78, 0, 0, 3873, 3927, 5, + 78, 0, 0, 3874, 3876, 5, 99, 0, 0, 3875, 3877, 3, 226, 113, 0, 3876, 3875, + 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, 3879, 1, 0, 0, 0, 3878, 3880, + 3, 882, 441, 0, 3879, 3878, 1, 0, 0, 0, 3879, 3880, 1, 0, 0, 0, 3880, 3882, + 1, 0, 0, 0, 3881, 3883, 3, 294, 147, 0, 3882, 3881, 1, 0, 0, 0, 3882, 3883, + 1, 0, 0, 0, 3883, 3927, 1, 0, 0, 0, 3884, 3885, 5, 85, 0, 0, 3885, 3887, + 5, 240, 0, 0, 3886, 3888, 3, 882, 441, 0, 3887, 3886, 1, 0, 0, 0, 3887, + 3888, 1, 0, 0, 0, 3888, 3890, 1, 0, 0, 0, 3889, 3891, 3, 294, 147, 0, 3890, + 3889, 1, 0, 0, 0, 3890, 3891, 1, 0, 0, 0, 3891, 3927, 1, 0, 0, 0, 3892, + 3893, 5, 42, 0, 0, 3893, 3894, 5, 2, 0, 0, 3894, 3895, 3, 1710, 855, 0, + 3895, 3897, 5, 3, 0, 0, 3896, 3898, 3, 242, 121, 0, 3897, 3896, 1, 0, 0, + 0, 3897, 3898, 1, 0, 0, 0, 3898, 3927, 1, 0, 0, 0, 3899, 3900, 5, 53, 0, + 0, 3900, 3927, 3, 1754, 877, 0, 3901, 3902, 5, 608, 0, 0, 3902, 3903, 3, + 228, 114, 0, 3903, 3913, 5, 36, 0, 0, 3904, 3906, 5, 223, 0, 0, 3905, 3907, + 3, 326, 163, 0, 3906, 3905, 1, 0, 0, 0, 3906, 3907, 1, 0, 0, 0, 3907, 3914, + 1, 0, 0, 0, 3908, 3909, 5, 2, 0, 0, 3909, 3910, 3, 1710, 855, 0, 3910, + 3911, 5, 3, 0, 0, 3911, 3912, 5, 610, 0, 0, 3912, 3914, 1, 0, 0, 0, 3913, + 3904, 1, 0, 0, 0, 3913, 3908, 1, 0, 0, 0, 3914, 3927, 1, 0, 0, 0, 3915, + 3916, 5, 87, 0, 0, 3916, 3918, 3, 1888, 944, 0, 3917, 3919, 3, 244, 122, + 0, 3918, 3917, 1, 0, 0, 0, 3918, 3919, 1, 0, 0, 0, 3919, 3921, 1, 0, 0, + 0, 3920, 3922, 3, 252, 126, 0, 3921, 3920, 1, 0, 0, 0, 3921, 3922, 1, 0, + 0, 0, 3922, 3924, 1, 0, 0, 0, 3923, 3925, 3, 260, 130, 0, 3924, 3923, 1, + 0, 0, 0, 3924, 3925, 1, 0, 0, 0, 3925, 3927, 1, 0, 0, 0, 3926, 3871, 1, + 0, 0, 0, 3926, 3873, 1, 0, 0, 0, 3926, 3874, 1, 0, 0, 0, 3926, 3884, 1, + 0, 0, 0, 3926, 3892, 1, 0, 0, 0, 3926, 3899, 1, 0, 0, 0, 3926, 3901, 1, + 0, 0, 0, 3926, 3915, 1, 0, 0, 0, 3927, 225, 1, 0, 0, 0, 3928, 3930, 5, + 270, 0, 0, 3929, 3931, 5, 77, 0, 0, 3930, 3929, 1, 0, 0, 0, 3930, 3931, + 1, 0, 0, 0, 3931, 3932, 1, 0, 0, 0, 3932, 3933, 5, 56, 0, 0, 3933, 227, + 1, 0, 0, 0, 3934, 3938, 5, 141, 0, 0, 3935, 3936, 5, 149, 0, 0, 3936, 3938, + 5, 53, 0, 0, 3937, 3934, 1, 0, 0, 0, 3937, 3935, 1, 0, 0, 0, 3938, 229, + 1, 0, 0, 0, 3939, 3945, 5, 54, 0, 0, 3940, 3941, 5, 77, 0, 0, 3941, 3945, + 5, 54, 0, 0, 3942, 3943, 5, 69, 0, 0, 3943, 3945, 7, 10, 0, 0, 3944, 3939, + 1, 0, 0, 0, 3944, 3940, 1, 0, 0, 0, 3944, 3942, 1, 0, 0, 0, 3945, 231, + 1, 0, 0, 0, 3946, 3947, 5, 122, 0, 0, 3947, 3948, 3, 1888, 944, 0, 3948, + 3949, 3, 234, 117, 0, 3949, 233, 1, 0, 0, 0, 3950, 3951, 7, 23, 0, 0, 3951, + 3953, 3, 236, 118, 0, 3952, 3950, 1, 0, 0, 0, 3953, 3956, 1, 0, 0, 0, 3954, + 3952, 1, 0, 0, 0, 3954, 3955, 1, 0, 0, 0, 3955, 235, 1, 0, 0, 0, 3956, + 3954, 1, 0, 0, 0, 3957, 3958, 7, 24, 0, 0, 3958, 237, 1, 0, 0, 0, 3959, + 3960, 5, 45, 0, 0, 3960, 3961, 3, 1892, 946, 0, 3961, 3962, 3, 240, 120, + 0, 3962, 3965, 1, 0, 0, 0, 3963, 3965, 3, 240, 120, 0, 3964, 3959, 1, 0, + 0, 0, 3964, 3963, 1, 0, 0, 0, 3965, 239, 1, 0, 0, 0, 3966, 3967, 5, 42, + 0, 0, 3967, 3968, 5, 2, 0, 0, 3968, 3969, 3, 1710, 855, 0, 3969, 3970, + 5, 3, 0, 0, 3970, 3971, 3, 482, 241, 0, 3971, 4056, 1, 0, 0, 0, 3972, 3974, + 5, 99, 0, 0, 3973, 3975, 3, 226, 113, 0, 3974, 3973, 1, 0, 0, 0, 3974, + 3975, 1, 0, 0, 0, 3975, 3993, 1, 0, 0, 0, 3976, 3977, 5, 2, 0, 0, 3977, + 3978, 3, 246, 123, 0, 3978, 3980, 5, 3, 0, 0, 3979, 3981, 3, 250, 125, + 0, 3980, 3979, 1, 0, 0, 0, 3980, 3981, 1, 0, 0, 0, 3981, 3983, 1, 0, 0, + 0, 3982, 3984, 3, 882, 441, 0, 3983, 3982, 1, 0, 0, 0, 3983, 3984, 1, 0, + 0, 0, 3984, 3986, 1, 0, 0, 0, 3985, 3987, 3, 294, 147, 0, 3986, 3985, 1, + 0, 0, 0, 3986, 3987, 1, 0, 0, 0, 3987, 3988, 1, 0, 0, 0, 3988, 3989, 3, + 482, 241, 0, 3989, 3994, 1, 0, 0, 0, 3990, 3991, 3, 296, 148, 0, 3991, + 3992, 3, 482, 241, 0, 3992, 3994, 1, 0, 0, 0, 3993, 3976, 1, 0, 0, 0, 3993, + 3990, 1, 0, 0, 0, 3994, 4056, 1, 0, 0, 0, 3995, 3996, 5, 85, 0, 0, 3996, + 4014, 5, 240, 0, 0, 3997, 3998, 5, 2, 0, 0, 3998, 3999, 3, 246, 123, 0, + 3999, 4001, 5, 3, 0, 0, 4000, 4002, 3, 250, 125, 0, 4001, 4000, 1, 0, 0, + 0, 4001, 4002, 1, 0, 0, 0, 4002, 4004, 1, 0, 0, 0, 4003, 4005, 3, 882, + 441, 0, 4004, 4003, 1, 0, 0, 0, 4004, 4005, 1, 0, 0, 0, 4005, 4007, 1, + 0, 0, 0, 4006, 4008, 3, 294, 147, 0, 4007, 4006, 1, 0, 0, 0, 4007, 4008, + 1, 0, 0, 0, 4008, 4009, 1, 0, 0, 0, 4009, 4010, 3, 482, 241, 0, 4010, 4015, + 1, 0, 0, 0, 4011, 4012, 3, 296, 148, 0, 4012, 4013, 3, 482, 241, 0, 4013, + 4015, 1, 0, 0, 0, 4014, 3997, 1, 0, 0, 0, 4014, 4011, 1, 0, 0, 0, 4015, + 4056, 1, 0, 0, 0, 4016, 4018, 5, 203, 0, 0, 4017, 4019, 3, 806, 403, 0, + 4018, 4017, 1, 0, 0, 0, 4018, 4019, 1, 0, 0, 0, 4019, 4020, 1, 0, 0, 0, + 4020, 4021, 5, 2, 0, 0, 4021, 4022, 3, 254, 127, 0, 4022, 4024, 5, 3, 0, + 0, 4023, 4025, 3, 250, 125, 0, 4024, 4023, 1, 0, 0, 0, 4024, 4025, 1, 0, + 0, 0, 4025, 4027, 1, 0, 0, 0, 4026, 4028, 3, 882, 441, 0, 4027, 4026, 1, + 0, 0, 0, 4027, 4028, 1, 0, 0, 0, 4028, 4030, 1, 0, 0, 0, 4029, 4031, 3, + 294, 147, 0, 4030, 4029, 1, 0, 0, 0, 4030, 4031, 1, 0, 0, 0, 4031, 4033, + 1, 0, 0, 0, 4032, 4034, 3, 258, 129, 0, 4033, 4032, 1, 0, 0, 0, 4033, 4034, + 1, 0, 0, 0, 4034, 4035, 1, 0, 0, 0, 4035, 4036, 3, 482, 241, 0, 4036, 4056, + 1, 0, 0, 0, 4037, 4038, 5, 63, 0, 0, 4038, 4039, 5, 240, 0, 0, 4039, 4040, + 5, 2, 0, 0, 4040, 4041, 3, 246, 123, 0, 4041, 4042, 5, 3, 0, 0, 4042, 4043, + 5, 87, 0, 0, 4043, 4045, 3, 1888, 944, 0, 4044, 4046, 3, 244, 122, 0, 4045, + 4044, 1, 0, 0, 0, 4045, 4046, 1, 0, 0, 0, 4046, 4048, 1, 0, 0, 0, 4047, + 4049, 3, 252, 126, 0, 4048, 4047, 1, 0, 0, 0, 4048, 4049, 1, 0, 0, 0, 4049, + 4051, 1, 0, 0, 0, 4050, 4052, 3, 260, 130, 0, 4051, 4050, 1, 0, 0, 0, 4051, + 4052, 1, 0, 0, 0, 4052, 4053, 1, 0, 0, 0, 4053, 4054, 3, 482, 241, 0, 4054, + 4056, 1, 0, 0, 0, 4055, 3966, 1, 0, 0, 0, 4055, 3972, 1, 0, 0, 0, 4055, + 3995, 1, 0, 0, 0, 4055, 4016, 1, 0, 0, 0, 4055, 4037, 1, 0, 0, 0, 4056, + 241, 1, 0, 0, 0, 4057, 4058, 5, 266, 0, 0, 4058, 4059, 5, 232, 0, 0, 4059, + 243, 1, 0, 0, 0, 4060, 4061, 5, 2, 0, 0, 4061, 4062, 3, 246, 123, 0, 4062, + 4063, 5, 3, 0, 0, 4063, 245, 1, 0, 0, 0, 4064, 4069, 3, 248, 124, 0, 4065, + 4066, 5, 6, 0, 0, 4066, 4068, 3, 248, 124, 0, 4067, 4065, 1, 0, 0, 0, 4068, + 4071, 1, 0, 0, 0, 4069, 4067, 1, 0, 0, 0, 4069, 4070, 1, 0, 0, 0, 4070, + 247, 1, 0, 0, 0, 4071, 4069, 1, 0, 0, 0, 4072, 4073, 3, 1924, 962, 0, 4073, + 249, 1, 0, 0, 0, 4074, 4075, 5, 639, 0, 0, 4075, 4076, 5, 2, 0, 0, 4076, + 4077, 3, 246, 123, 0, 4077, 4078, 5, 3, 0, 0, 4078, 251, 1, 0, 0, 0, 4079, + 4080, 5, 253, 0, 0, 4080, 4081, 7, 25, 0, 0, 4081, 253, 1, 0, 0, 0, 4082, + 4087, 3, 256, 128, 0, 4083, 4084, 5, 6, 0, 0, 4084, 4086, 3, 256, 128, + 0, 4085, 4083, 1, 0, 0, 0, 4086, 4089, 1, 0, 0, 0, 4087, 4085, 1, 0, 0, + 0, 4087, 4088, 1, 0, 0, 0, 4088, 255, 1, 0, 0, 0, 4089, 4087, 1, 0, 0, + 0, 4090, 4091, 3, 812, 406, 0, 4091, 4098, 5, 106, 0, 0, 4092, 4099, 3, + 904, 452, 0, 4093, 4094, 5, 275, 0, 0, 4094, 4095, 5, 2, 0, 0, 4095, 4096, + 3, 904, 452, 0, 4096, 4097, 5, 3, 0, 0, 4097, 4099, 1, 0, 0, 0, 4098, 4092, + 1, 0, 0, 0, 4098, 4093, 1, 0, 0, 0, 4099, 257, 1, 0, 0, 0, 4100, 4101, + 5, 104, 0, 0, 4101, 4102, 5, 2, 0, 0, 4102, 4103, 3, 1710, 855, 0, 4103, + 4104, 5, 3, 0, 0, 4104, 259, 1, 0, 0, 0, 4105, 4114, 3, 262, 131, 0, 4106, + 4114, 3, 264, 132, 0, 4107, 4108, 3, 262, 131, 0, 4108, 4109, 3, 264, 132, + 0, 4109, 4114, 1, 0, 0, 0, 4110, 4111, 3, 264, 132, 0, 4111, 4112, 3, 262, + 131, 0, 4112, 4114, 1, 0, 0, 0, 4113, 4105, 1, 0, 0, 0, 4113, 4106, 1, + 0, 0, 0, 4113, 4107, 1, 0, 0, 0, 4113, 4110, 1, 0, 0, 0, 4114, 261, 1, + 0, 0, 0, 4115, 4116, 5, 80, 0, 0, 4116, 4117, 5, 367, 0, 0, 4117, 4118, + 3, 266, 133, 0, 4118, 263, 1, 0, 0, 0, 4119, 4120, 5, 80, 0, 0, 4120, 4121, + 5, 186, 0, 0, 4121, 4122, 3, 266, 133, 0, 4122, 265, 1, 0, 0, 0, 4123, + 4124, 5, 266, 0, 0, 4124, 4133, 5, 134, 0, 0, 4125, 4133, 5, 313, 0, 0, + 4126, 4133, 5, 152, 0, 0, 4127, 4128, 5, 331, 0, 0, 4128, 4130, 7, 26, + 0, 0, 4129, 4131, 3, 244, 122, 0, 4130, 4129, 1, 0, 0, 0, 4130, 4131, 1, + 0, 0, 0, 4131, 4133, 1, 0, 0, 0, 4132, 4123, 1, 0, 0, 0, 4132, 4125, 1, + 0, 0, 0, 4132, 4126, 1, 0, 0, 0, 4132, 4127, 1, 0, 0, 0, 4133, 267, 1, + 0, 0, 0, 4134, 4135, 5, 233, 0, 0, 4135, 4136, 5, 2, 0, 0, 4136, 4137, + 3, 1886, 943, 0, 4137, 4138, 5, 3, 0, 0, 4138, 269, 1, 0, 0, 0, 4139, 4140, + 3, 272, 136, 0, 4140, 271, 1, 0, 0, 0, 4141, 4142, 5, 282, 0, 0, 4142, + 4143, 5, 149, 0, 0, 4143, 4144, 3, 1924, 962, 0, 4144, 4145, 5, 2, 0, 0, + 4145, 4146, 3, 274, 137, 0, 4146, 4147, 5, 3, 0, 0, 4147, 273, 1, 0, 0, + 0, 4148, 4153, 3, 276, 138, 0, 4149, 4150, 5, 6, 0, 0, 4150, 4152, 3, 276, + 138, 0, 4151, 4149, 1, 0, 0, 0, 4152, 4155, 1, 0, 0, 0, 4153, 4151, 1, + 0, 0, 0, 4153, 4154, 1, 0, 0, 0, 4154, 275, 1, 0, 0, 0, 4155, 4153, 1, + 0, 0, 0, 4156, 4158, 3, 1924, 962, 0, 4157, 4159, 3, 818, 409, 0, 4158, + 4157, 1, 0, 0, 0, 4158, 4159, 1, 0, 0, 0, 4159, 4161, 1, 0, 0, 0, 4160, + 4162, 3, 820, 410, 0, 4161, 4160, 1, 0, 0, 0, 4161, 4162, 1, 0, 0, 0, 4162, + 4180, 1, 0, 0, 0, 4163, 4165, 3, 1764, 882, 0, 4164, 4166, 3, 818, 409, + 0, 4165, 4164, 1, 0, 0, 0, 4165, 4166, 1, 0, 0, 0, 4166, 4168, 1, 0, 0, + 0, 4167, 4169, 3, 820, 410, 0, 4168, 4167, 1, 0, 0, 0, 4168, 4169, 1, 0, + 0, 0, 4169, 4180, 1, 0, 0, 0, 4170, 4171, 5, 2, 0, 0, 4171, 4172, 3, 1710, + 855, 0, 4172, 4174, 5, 3, 0, 0, 4173, 4175, 3, 818, 409, 0, 4174, 4173, + 1, 0, 0, 0, 4174, 4175, 1, 0, 0, 0, 4175, 4177, 1, 0, 0, 0, 4176, 4178, + 3, 820, 410, 0, 4177, 4176, 1, 0, 0, 0, 4177, 4178, 1, 0, 0, 0, 4178, 4180, + 1, 0, 0, 0, 4179, 4156, 1, 0, 0, 0, 4179, 4163, 1, 0, 0, 0, 4179, 4170, + 1, 0, 0, 0, 4180, 277, 1, 0, 0, 0, 4181, 4182, 5, 101, 0, 0, 4182, 4183, + 3, 1892, 946, 0, 4183, 279, 1, 0, 0, 0, 4184, 4185, 5, 106, 0, 0, 4185, + 4189, 3, 128, 64, 0, 4186, 4187, 5, 377, 0, 0, 4187, 4189, 5, 274, 0, 0, + 4188, 4184, 1, 0, 0, 0, 4188, 4186, 1, 0, 0, 0, 4189, 281, 1, 0, 0, 0, + 4190, 4191, 5, 80, 0, 0, 4191, 4197, 5, 163, 0, 0, 4192, 4198, 5, 195, + 0, 0, 4193, 4194, 5, 186, 0, 0, 4194, 4198, 5, 318, 0, 0, 4195, 4196, 5, + 290, 0, 0, 4196, 4198, 5, 318, 0, 0, 4197, 4192, 1, 0, 0, 0, 4197, 4193, + 1, 0, 0, 0, 4197, 4195, 1, 0, 0, 0, 4198, 283, 1, 0, 0, 0, 4199, 4200, + 5, 349, 0, 0, 4200, 4201, 3, 1892, 946, 0, 4201, 285, 1, 0, 0, 0, 4202, + 4204, 3, 288, 144, 0, 4203, 4202, 1, 0, 0, 0, 4204, 4205, 1, 0, 0, 0, 4205, + 4203, 1, 0, 0, 0, 4205, 4206, 1, 0, 0, 0, 4206, 287, 1, 0, 0, 0, 4207, + 4208, 5, 839, 0, 0, 4208, 4220, 7, 27, 0, 0, 4209, 4210, 5, 838, 0, 0, + 4210, 4220, 7, 19, 0, 0, 4211, 4212, 5, 836, 0, 0, 4212, 4213, 5, 2, 0, + 0, 4213, 4214, 3, 1924, 962, 0, 4214, 4215, 5, 3, 0, 0, 4215, 4220, 1, + 0, 0, 0, 4216, 4220, 3, 290, 145, 0, 4217, 4218, 5, 835, 0, 0, 4218, 4220, + 5, 420, 0, 0, 4219, 4207, 1, 0, 0, 0, 4219, 4209, 1, 0, 0, 0, 4219, 4211, + 1, 0, 0, 0, 4219, 4216, 1, 0, 0, 0, 4219, 4217, 1, 0, 0, 0, 4220, 289, + 1, 0, 0, 0, 4221, 4223, 3, 292, 146, 0, 4222, 4221, 1, 0, 0, 0, 4222, 4223, + 1, 0, 0, 0, 4223, 4224, 1, 0, 0, 0, 4224, 4225, 5, 837, 0, 0, 4225, 4226, + 5, 2, 0, 0, 4226, 4227, 3, 246, 123, 0, 4227, 4228, 5, 3, 0, 0, 4228, 291, + 1, 0, 0, 0, 4229, 4230, 7, 20, 0, 0, 4230, 293, 1, 0, 0, 0, 4231, 4232, + 5, 101, 0, 0, 4232, 4233, 5, 230, 0, 0, 4233, 4234, 5, 349, 0, 0, 4234, + 4235, 3, 1892, 946, 0, 4235, 295, 1, 0, 0, 0, 4236, 4237, 5, 101, 0, 0, + 4237, 4238, 5, 230, 0, 0, 4238, 4239, 3, 1892, 946, 0, 4239, 297, 1, 0, + 0, 0, 4240, 4241, 5, 46, 0, 0, 4241, 4245, 5, 340, 0, 0, 4242, 4243, 5, + 224, 0, 0, 4243, 4244, 5, 77, 0, 0, 4244, 4246, 5, 558, 0, 0, 4245, 4242, + 1, 0, 0, 0, 4245, 4246, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4249, + 3, 566, 283, 0, 4248, 4250, 3, 1404, 702, 0, 4249, 4248, 1, 0, 0, 0, 4249, + 4250, 1, 0, 0, 0, 4250, 4251, 1, 0, 0, 0, 4251, 4252, 5, 80, 0, 0, 4252, + 4253, 3, 1830, 915, 0, 4253, 4254, 5, 64, 0, 0, 4254, 4255, 3, 1600, 800, + 0, 4255, 299, 1, 0, 0, 0, 4256, 4257, 5, 140, 0, 0, 4257, 4260, 5, 340, + 0, 0, 4258, 4259, 5, 224, 0, 0, 4259, 4261, 5, 558, 0, 0, 4260, 4258, 1, + 0, 0, 0, 4260, 4261, 1, 0, 0, 0, 4261, 4262, 1, 0, 0, 0, 4262, 4263, 3, + 566, 283, 0, 4263, 4264, 5, 331, 0, 0, 4264, 4265, 5, 340, 0, 0, 4265, + 4266, 3, 1916, 958, 0, 4266, 301, 1, 0, 0, 0, 4267, 4269, 5, 46, 0, 0, + 4268, 4270, 3, 198, 99, 0, 4269, 4268, 1, 0, 0, 0, 4269, 4270, 1, 0, 0, + 0, 4270, 4271, 1, 0, 0, 0, 4271, 4272, 5, 93, 0, 0, 4272, 4273, 3, 304, + 152, 0, 4273, 4274, 5, 36, 0, 0, 4274, 4275, 3, 1496, 748, 0, 4275, 303, + 1, 0, 0, 0, 4276, 4278, 3, 1040, 520, 0, 4277, 4279, 3, 244, 122, 0, 4278, + 4277, 1, 0, 0, 0, 4278, 4279, 1, 0, 0, 0, 4279, 4281, 1, 0, 0, 0, 4280, + 4282, 3, 306, 153, 0, 4281, 4280, 1, 0, 0, 0, 4281, 4282, 1, 0, 0, 0, 4282, + 305, 1, 0, 0, 0, 4283, 4287, 3, 310, 155, 0, 4284, 4286, 3, 196, 98, 0, + 4285, 4284, 1, 0, 0, 0, 4286, 4289, 1, 0, 0, 0, 4287, 4285, 1, 0, 0, 0, + 4287, 4288, 1, 0, 0, 0, 4288, 4305, 1, 0, 0, 0, 4289, 4287, 1, 0, 0, 0, + 4290, 4292, 3, 196, 98, 0, 4291, 4290, 1, 0, 0, 0, 4292, 4293, 1, 0, 0, + 0, 4293, 4291, 1, 0, 0, 0, 4293, 4294, 1, 0, 0, 0, 4294, 4296, 1, 0, 0, + 0, 4295, 4297, 3, 310, 155, 0, 4296, 4295, 1, 0, 0, 0, 4296, 4297, 1, 0, + 0, 0, 4297, 4301, 1, 0, 0, 0, 4298, 4300, 3, 196, 98, 0, 4299, 4298, 1, + 0, 0, 0, 4300, 4303, 1, 0, 0, 0, 4301, 4299, 1, 0, 0, 0, 4301, 4302, 1, + 0, 0, 0, 4302, 4305, 1, 0, 0, 0, 4303, 4301, 1, 0, 0, 0, 4304, 4283, 1, + 0, 0, 0, 4304, 4291, 1, 0, 0, 0, 4305, 307, 1, 0, 0, 0, 4306, 4307, 5, + 838, 0, 0, 4307, 4322, 7, 19, 0, 0, 4308, 4309, 5, 836, 0, 0, 4309, 4310, + 5, 2, 0, 0, 4310, 4311, 3, 1924, 962, 0, 4311, 4312, 5, 3, 0, 0, 4312, + 4322, 1, 0, 0, 0, 4313, 4315, 7, 20, 0, 0, 4314, 4313, 1, 0, 0, 0, 4314, + 4315, 1, 0, 0, 0, 4315, 4316, 1, 0, 0, 0, 4316, 4317, 5, 837, 0, 0, 4317, + 4318, 5, 2, 0, 0, 4318, 4319, 3, 246, 123, 0, 4319, 4320, 5, 3, 0, 0, 4320, + 4322, 1, 0, 0, 0, 4321, 4306, 1, 0, 0, 0, 4321, 4308, 1, 0, 0, 0, 4321, + 4314, 1, 0, 0, 0, 4322, 309, 1, 0, 0, 0, 4323, 4324, 5, 839, 0, 0, 4324, + 4325, 7, 27, 0, 0, 4325, 311, 1, 0, 0, 0, 4326, 4330, 5, 106, 0, 0, 4327, + 4331, 5, 177, 0, 0, 4328, 4329, 5, 266, 0, 0, 4329, 4331, 5, 177, 0, 0, + 4330, 4327, 1, 0, 0, 0, 4330, 4328, 1, 0, 0, 0, 4331, 313, 1, 0, 0, 0, + 4332, 4333, 5, 46, 0, 0, 4333, 4334, 5, 255, 0, 0, 4334, 4335, 5, 374, + 0, 0, 4335, 4337, 3, 1888, 944, 0, 4336, 4338, 3, 310, 155, 0, 4337, 4336, + 1, 0, 0, 0, 4337, 4338, 1, 0, 0, 0, 4338, 4342, 1, 0, 0, 0, 4339, 4341, + 3, 196, 98, 0, 4340, 4339, 1, 0, 0, 0, 4341, 4344, 1, 0, 0, 0, 4342, 4340, + 1, 0, 0, 0, 4342, 4343, 1, 0, 0, 0, 4343, 4346, 1, 0, 0, 0, 4344, 4342, + 1, 0, 0, 0, 4345, 4347, 3, 316, 158, 0, 4346, 4345, 1, 0, 0, 0, 4346, 4347, + 1, 0, 0, 0, 4347, 4348, 1, 0, 0, 0, 4348, 4349, 5, 36, 0, 0, 4349, 4350, + 3, 1496, 748, 0, 4350, 315, 1, 0, 0, 0, 4351, 4352, 5, 420, 0, 0, 4352, + 4353, 5, 303, 0, 0, 4353, 4354, 7, 27, 0, 0, 4354, 317, 1, 0, 0, 0, 4355, + 4356, 5, 303, 0, 0, 4356, 4357, 5, 255, 0, 0, 4357, 4359, 5, 374, 0, 0, + 4358, 4360, 3, 802, 401, 0, 4359, 4358, 1, 0, 0, 0, 4359, 4360, 1, 0, 0, + 0, 4360, 4361, 1, 0, 0, 0, 4361, 4363, 3, 1888, 944, 0, 4362, 4364, 3, + 312, 156, 0, 4363, 4362, 1, 0, 0, 0, 4363, 4364, 1, 0, 0, 0, 4364, 4366, + 1, 0, 0, 0, 4365, 4367, 7, 12, 0, 0, 4366, 4365, 1, 0, 0, 0, 4366, 4367, + 1, 0, 0, 0, 4367, 319, 1, 0, 0, 0, 4368, 4370, 5, 46, 0, 0, 4369, 4371, + 3, 198, 99, 0, 4370, 4369, 1, 0, 0, 0, 4370, 4371, 1, 0, 0, 0, 4371, 4372, + 1, 0, 0, 0, 4372, 4376, 5, 326, 0, 0, 4373, 4374, 5, 224, 0, 0, 4374, 4375, + 5, 77, 0, 0, 4375, 4377, 5, 558, 0, 0, 4376, 4373, 1, 0, 0, 0, 4376, 4377, + 1, 0, 0, 0, 4377, 4378, 1, 0, 0, 0, 4378, 4380, 3, 1888, 944, 0, 4379, + 4381, 3, 324, 162, 0, 4380, 4379, 1, 0, 0, 0, 4380, 4381, 1, 0, 0, 0, 4381, + 321, 1, 0, 0, 0, 4382, 4383, 5, 140, 0, 0, 4383, 4386, 5, 326, 0, 0, 4384, + 4385, 5, 224, 0, 0, 4385, 4387, 5, 558, 0, 0, 4386, 4384, 1, 0, 0, 0, 4386, + 4387, 1, 0, 0, 0, 4387, 4388, 1, 0, 0, 0, 4388, 4389, 3, 1888, 944, 0, + 4389, 4390, 3, 328, 164, 0, 4390, 323, 1, 0, 0, 0, 4391, 4392, 3, 328, + 164, 0, 4392, 325, 1, 0, 0, 0, 4393, 4394, 5, 2, 0, 0, 4394, 4395, 3, 328, + 164, 0, 4395, 4396, 5, 3, 0, 0, 4396, 327, 1, 0, 0, 0, 4397, 4399, 3, 330, + 165, 0, 4398, 4397, 1, 0, 0, 0, 4399, 4400, 1, 0, 0, 0, 4400, 4398, 1, + 0, 0, 0, 4400, 4401, 1, 0, 0, 0, 4401, 329, 1, 0, 0, 0, 4402, 4403, 5, + 36, 0, 0, 4403, 4439, 3, 1666, 833, 0, 4404, 4405, 5, 150, 0, 0, 4405, + 4439, 3, 334, 167, 0, 4406, 4439, 5, 176, 0, 0, 4407, 4409, 5, 229, 0, + 0, 4408, 4410, 3, 332, 166, 0, 4409, 4408, 1, 0, 0, 0, 4409, 4410, 1, 0, + 0, 0, 4410, 4411, 1, 0, 0, 0, 4411, 4439, 3, 334, 167, 0, 4412, 4439, 5, + 609, 0, 0, 4413, 4414, 5, 256, 0, 0, 4414, 4439, 3, 334, 167, 0, 4415, + 4416, 5, 259, 0, 0, 4416, 4439, 3, 334, 167, 0, 4417, 4418, 5, 266, 0, + 0, 4418, 4439, 7, 28, 0, 0, 4419, 4420, 5, 278, 0, 0, 4420, 4421, 5, 149, + 0, 0, 4421, 4439, 3, 566, 283, 0, 4422, 4423, 5, 326, 0, 0, 4423, 4424, + 5, 263, 0, 0, 4424, 4439, 3, 566, 283, 0, 4425, 4427, 5, 338, 0, 0, 4426, + 4428, 3, 16, 8, 0, 4427, 4426, 1, 0, 0, 0, 4427, 4428, 1, 0, 0, 0, 4428, + 4429, 1, 0, 0, 0, 4429, 4439, 3, 334, 167, 0, 4430, 4432, 5, 312, 0, 0, + 4431, 4433, 3, 16, 8, 0, 4432, 4431, 1, 0, 0, 0, 4432, 4433, 1, 0, 0, 0, + 4433, 4435, 1, 0, 0, 0, 4434, 4436, 3, 334, 167, 0, 4435, 4434, 1, 0, 0, + 0, 4435, 4436, 1, 0, 0, 0, 4436, 4439, 1, 0, 0, 0, 4437, 4439, 5, 365, + 0, 0, 4438, 4402, 1, 0, 0, 0, 4438, 4404, 1, 0, 0, 0, 4438, 4406, 1, 0, + 0, 0, 4438, 4407, 1, 0, 0, 0, 4438, 4412, 1, 0, 0, 0, 4438, 4413, 1, 0, + 0, 0, 4438, 4415, 1, 0, 0, 0, 4438, 4417, 1, 0, 0, 0, 4438, 4419, 1, 0, + 0, 0, 4438, 4422, 1, 0, 0, 0, 4438, 4425, 1, 0, 0, 0, 4438, 4430, 1, 0, + 0, 0, 4438, 4437, 1, 0, 0, 0, 4439, 331, 1, 0, 0, 0, 4440, 4441, 5, 149, + 0, 0, 4441, 333, 1, 0, 0, 0, 4442, 4449, 3, 1906, 953, 0, 4443, 4444, 5, + 12, 0, 0, 4444, 4449, 3, 1906, 953, 0, 4445, 4446, 5, 13, 0, 0, 4446, 4449, + 3, 1906, 953, 0, 4447, 4449, 3, 1916, 958, 0, 4448, 4442, 1, 0, 0, 0, 4448, + 4443, 1, 0, 0, 0, 4448, 4445, 1, 0, 0, 0, 4448, 4447, 1, 0, 0, 0, 4449, + 335, 1, 0, 0, 0, 4450, 4455, 3, 334, 167, 0, 4451, 4452, 5, 6, 0, 0, 4452, + 4454, 3, 334, 167, 0, 4453, 4451, 1, 0, 0, 0, 4454, 4457, 1, 0, 0, 0, 4455, + 4453, 1, 0, 0, 0, 4455, 4456, 1, 0, 0, 0, 4456, 337, 1, 0, 0, 0, 4457, + 4455, 1, 0, 0, 0, 4458, 4460, 5, 46, 0, 0, 4459, 4461, 3, 832, 416, 0, + 4460, 4459, 1, 0, 0, 0, 4460, 4461, 1, 0, 0, 0, 4461, 4463, 1, 0, 0, 0, + 4462, 4464, 3, 340, 170, 0, 4463, 4462, 1, 0, 0, 0, 4463, 4464, 1, 0, 0, + 0, 4464, 4466, 1, 0, 0, 0, 4465, 4467, 3, 350, 175, 0, 4466, 4465, 1, 0, + 0, 0, 4466, 4467, 1, 0, 0, 0, 4467, 4468, 1, 0, 0, 0, 4468, 4469, 5, 242, + 0, 0, 4469, 4478, 3, 1892, 946, 0, 4470, 4471, 5, 219, 0, 0, 4471, 4473, + 3, 342, 171, 0, 4472, 4474, 3, 344, 172, 0, 4473, 4472, 1, 0, 0, 0, 4473, + 4474, 1, 0, 0, 0, 4474, 4476, 1, 0, 0, 0, 4475, 4477, 3, 348, 174, 0, 4476, + 4475, 1, 0, 0, 0, 4476, 4477, 1, 0, 0, 0, 4477, 4479, 1, 0, 0, 0, 4478, + 4470, 1, 0, 0, 0, 4478, 4479, 1, 0, 0, 0, 4479, 339, 1, 0, 0, 0, 4480, + 4481, 5, 357, 0, 0, 4481, 341, 1, 0, 0, 0, 4482, 4484, 3, 1892, 946, 0, + 4483, 4485, 3, 568, 284, 0, 4484, 4483, 1, 0, 0, 0, 4484, 4485, 1, 0, 0, + 0, 4485, 343, 1, 0, 0, 0, 4486, 4487, 5, 234, 0, 0, 4487, 4488, 3, 342, + 171, 0, 4488, 345, 1, 0, 0, 0, 4489, 4490, 5, 371, 0, 0, 4490, 4494, 3, + 342, 171, 0, 4491, 4492, 5, 266, 0, 0, 4492, 4494, 5, 371, 0, 0, 4493, + 4489, 1, 0, 0, 0, 4493, 4491, 1, 0, 0, 0, 4494, 347, 1, 0, 0, 0, 4495, + 4496, 3, 346, 173, 0, 4496, 349, 1, 0, 0, 0, 4497, 4498, 5, 293, 0, 0, + 4498, 351, 1, 0, 0, 0, 4499, 4500, 5, 46, 0, 0, 4500, 4501, 5, 349, 0, + 0, 4501, 4503, 3, 1892, 946, 0, 4502, 4504, 3, 354, 177, 0, 4503, 4502, + 1, 0, 0, 0, 4503, 4504, 1, 0, 0, 0, 4504, 4505, 1, 0, 0, 0, 4505, 4506, + 5, 250, 0, 0, 4506, 4508, 3, 1910, 955, 0, 4507, 4509, 3, 130, 65, 0, 4508, + 4507, 1, 0, 0, 0, 4508, 4509, 1, 0, 0, 0, 4509, 353, 1, 0, 0, 0, 4510, + 4511, 5, 279, 0, 0, 4511, 4512, 3, 1920, 960, 0, 4512, 355, 1, 0, 0, 0, + 4513, 4514, 5, 195, 0, 0, 4514, 4517, 5, 349, 0, 0, 4515, 4516, 5, 224, + 0, 0, 4516, 4518, 5, 558, 0, 0, 4517, 4515, 1, 0, 0, 0, 4517, 4518, 1, + 0, 0, 0, 4518, 4519, 1, 0, 0, 0, 4519, 4520, 3, 1892, 946, 0, 4520, 357, + 1, 0, 0, 0, 4521, 4522, 5, 46, 0, 0, 4522, 4526, 5, 208, 0, 0, 4523, 4524, + 5, 224, 0, 0, 4524, 4525, 5, 77, 0, 0, 4525, 4527, 5, 558, 0, 0, 4526, + 4523, 1, 0, 0, 0, 4526, 4527, 1, 0, 0, 0, 4527, 4528, 1, 0, 0, 0, 4528, + 4530, 3, 1892, 946, 0, 4529, 4531, 3, 16, 8, 0, 4530, 4529, 1, 0, 0, 0, + 4530, 4531, 1, 0, 0, 0, 4531, 4532, 1, 0, 0, 0, 4532, 4533, 3, 360, 180, + 0, 4533, 359, 1, 0, 0, 0, 4534, 4536, 3, 362, 181, 0, 4535, 4534, 1, 0, + 0, 0, 4536, 4539, 1, 0, 0, 0, 4537, 4535, 1, 0, 0, 0, 4537, 4538, 1, 0, + 0, 0, 4538, 361, 1, 0, 0, 0, 4539, 4537, 1, 0, 0, 0, 4540, 4541, 5, 321, + 0, 0, 4541, 4548, 3, 1892, 946, 0, 4542, 4543, 5, 373, 0, 0, 4543, 4548, + 3, 82, 41, 0, 4544, 4545, 5, 64, 0, 0, 4545, 4548, 3, 82, 41, 0, 4546, + 4548, 5, 152, 0, 0, 4547, 4540, 1, 0, 0, 0, 4547, 4542, 1, 0, 0, 0, 4547, + 4544, 1, 0, 0, 0, 4547, 4546, 1, 0, 0, 0, 4548, 363, 1, 0, 0, 0, 4549, + 4550, 5, 140, 0, 0, 4550, 4551, 5, 208, 0, 0, 4551, 4552, 3, 1892, 946, + 0, 4552, 4553, 5, 367, 0, 0, 4553, 4554, 3, 366, 183, 0, 4554, 365, 1, + 0, 0, 0, 4555, 4557, 3, 368, 184, 0, 4556, 4555, 1, 0, 0, 0, 4557, 4560, + 1, 0, 0, 0, 4558, 4556, 1, 0, 0, 0, 4558, 4559, 1, 0, 0, 0, 4559, 367, + 1, 0, 0, 0, 4560, 4558, 1, 0, 0, 0, 4561, 4562, 5, 95, 0, 0, 4562, 4563, + 3, 82, 41, 0, 4563, 369, 1, 0, 0, 0, 4564, 4565, 5, 140, 0, 0, 4565, 4566, + 5, 208, 0, 0, 4566, 4567, 3, 1892, 946, 0, 4567, 4568, 3, 48, 24, 0, 4568, + 4569, 3, 558, 279, 0, 4569, 4570, 3, 1892, 946, 0, 4570, 4669, 1, 0, 0, + 0, 4571, 4572, 5, 140, 0, 0, 4572, 4573, 5, 208, 0, 0, 4573, 4574, 3, 1892, + 946, 0, 4574, 4575, 3, 48, 24, 0, 4575, 4576, 3, 556, 278, 0, 4576, 4577, + 3, 566, 283, 0, 4577, 4669, 1, 0, 0, 0, 4578, 4579, 5, 140, 0, 0, 4579, + 4580, 5, 208, 0, 0, 4580, 4581, 3, 1892, 946, 0, 4581, 4582, 3, 48, 24, + 0, 4582, 4583, 5, 138, 0, 0, 4583, 4584, 3, 868, 434, 0, 4584, 4669, 1, + 0, 0, 0, 4585, 4586, 5, 140, 0, 0, 4586, 4587, 5, 208, 0, 0, 4587, 4588, + 3, 1892, 946, 0, 4588, 4589, 3, 48, 24, 0, 4589, 4590, 5, 41, 0, 0, 4590, + 4591, 5, 2, 0, 0, 4591, 4592, 3, 1662, 831, 0, 4592, 4593, 5, 36, 0, 0, + 4593, 4594, 3, 1662, 831, 0, 4594, 4595, 5, 3, 0, 0, 4595, 4669, 1, 0, + 0, 0, 4596, 4597, 5, 140, 0, 0, 4597, 4598, 5, 208, 0, 0, 4598, 4599, 3, + 1892, 946, 0, 4599, 4600, 3, 48, 24, 0, 4600, 4601, 5, 193, 0, 0, 4601, + 4602, 3, 1662, 831, 0, 4602, 4669, 1, 0, 0, 0, 4603, 4604, 5, 140, 0, 0, + 4604, 4605, 5, 208, 0, 0, 4605, 4606, 3, 1892, 946, 0, 4606, 4607, 3, 48, + 24, 0, 4607, 4608, 5, 215, 0, 0, 4608, 4609, 3, 844, 422, 0, 4609, 4669, + 1, 0, 0, 0, 4610, 4611, 5, 140, 0, 0, 4611, 4612, 5, 208, 0, 0, 4612, 4613, + 3, 1892, 946, 0, 4613, 4614, 3, 48, 24, 0, 4614, 4615, 5, 275, 0, 0, 4615, + 4616, 3, 908, 454, 0, 4616, 4669, 1, 0, 0, 0, 4617, 4618, 5, 140, 0, 0, + 4618, 4619, 5, 208, 0, 0, 4619, 4620, 3, 1892, 946, 0, 4620, 4621, 3, 48, + 24, 0, 4621, 4622, 5, 275, 0, 0, 4622, 4623, 5, 158, 0, 0, 4623, 4624, + 3, 566, 283, 0, 4624, 4625, 5, 101, 0, 0, 4625, 4626, 3, 1892, 946, 0, + 4626, 4669, 1, 0, 0, 0, 4627, 4628, 5, 140, 0, 0, 4628, 4629, 5, 208, 0, + 0, 4629, 4630, 3, 1892, 946, 0, 4630, 4631, 3, 48, 24, 0, 4631, 4632, 5, + 275, 0, 0, 4632, 4633, 5, 210, 0, 0, 4633, 4634, 3, 566, 283, 0, 4634, + 4635, 5, 101, 0, 0, 4635, 4636, 3, 1892, 946, 0, 4636, 4669, 1, 0, 0, 0, + 4637, 4638, 5, 140, 0, 0, 4638, 4639, 5, 208, 0, 0, 4639, 4640, 3, 1892, + 946, 0, 4640, 4641, 3, 48, 24, 0, 4641, 4642, 5, 294, 0, 0, 4642, 4643, + 3, 844, 422, 0, 4643, 4669, 1, 0, 0, 0, 4644, 4645, 5, 140, 0, 0, 4645, + 4646, 5, 208, 0, 0, 4646, 4647, 3, 1892, 946, 0, 4647, 4648, 3, 48, 24, + 0, 4648, 4649, 5, 640, 0, 0, 4649, 4650, 3, 844, 422, 0, 4650, 4669, 1, + 0, 0, 0, 4651, 4652, 5, 140, 0, 0, 4652, 4653, 5, 208, 0, 0, 4653, 4654, + 3, 1892, 946, 0, 4654, 4655, 3, 48, 24, 0, 4655, 4656, 5, 641, 0, 0, 4656, + 4657, 5, 62, 0, 0, 4657, 4658, 3, 1662, 831, 0, 4658, 4659, 5, 242, 0, + 0, 4659, 4660, 3, 1892, 946, 0, 4660, 4669, 1, 0, 0, 0, 4661, 4662, 5, + 140, 0, 0, 4662, 4663, 5, 208, 0, 0, 4663, 4664, 3, 1892, 946, 0, 4664, + 4665, 3, 48, 24, 0, 4665, 4666, 5, 358, 0, 0, 4666, 4667, 3, 1662, 831, + 0, 4667, 4669, 1, 0, 0, 0, 4668, 4564, 1, 0, 0, 0, 4668, 4571, 1, 0, 0, + 0, 4668, 4578, 1, 0, 0, 0, 4668, 4585, 1, 0, 0, 0, 4668, 4596, 1, 0, 0, + 0, 4668, 4603, 1, 0, 0, 0, 4668, 4610, 1, 0, 0, 0, 4668, 4617, 1, 0, 0, + 0, 4668, 4627, 1, 0, 0, 0, 4668, 4637, 1, 0, 0, 0, 4668, 4644, 1, 0, 0, + 0, 4668, 4651, 1, 0, 0, 0, 4668, 4661, 1, 0, 0, 0, 4669, 371, 1, 0, 0, + 0, 4670, 4671, 5, 46, 0, 0, 4671, 4672, 5, 63, 0, 0, 4672, 4673, 5, 177, + 0, 0, 4673, 4674, 5, 379, 0, 0, 4674, 4676, 3, 1892, 946, 0, 4675, 4677, + 3, 378, 189, 0, 4676, 4675, 1, 0, 0, 0, 4676, 4677, 1, 0, 0, 0, 4677, 4679, + 1, 0, 0, 0, 4678, 4680, 3, 382, 191, 0, 4679, 4678, 1, 0, 0, 0, 4679, 4680, + 1, 0, 0, 0, 4680, 373, 1, 0, 0, 0, 4681, 4682, 5, 219, 0, 0, 4682, 4690, + 3, 342, 171, 0, 4683, 4684, 5, 266, 0, 0, 4684, 4690, 5, 219, 0, 0, 4685, + 4686, 5, 371, 0, 0, 4686, 4690, 3, 342, 171, 0, 4687, 4688, 5, 266, 0, + 0, 4688, 4690, 5, 371, 0, 0, 4689, 4681, 1, 0, 0, 0, 4689, 4683, 1, 0, + 0, 0, 4689, 4685, 1, 0, 0, 0, 4689, 4687, 1, 0, 0, 0, 4690, 375, 1, 0, + 0, 0, 4691, 4693, 3, 374, 187, 0, 4692, 4691, 1, 0, 0, 0, 4693, 4694, 1, + 0, 0, 0, 4694, 4692, 1, 0, 0, 0, 4694, 4695, 1, 0, 0, 0, 4695, 377, 1, + 0, 0, 0, 4696, 4697, 3, 376, 188, 0, 4697, 379, 1, 0, 0, 0, 4698, 4699, + 5, 140, 0, 0, 4699, 4700, 5, 63, 0, 0, 4700, 4701, 5, 177, 0, 0, 4701, + 4702, 5, 379, 0, 0, 4702, 4704, 3, 1892, 946, 0, 4703, 4705, 3, 378, 189, + 0, 4704, 4703, 1, 0, 0, 0, 4704, 4705, 1, 0, 0, 0, 4705, 4706, 1, 0, 0, + 0, 4706, 4707, 3, 386, 193, 0, 4707, 4716, 1, 0, 0, 0, 4708, 4709, 5, 140, + 0, 0, 4709, 4710, 5, 63, 0, 0, 4710, 4711, 5, 177, 0, 0, 4711, 4712, 5, + 379, 0, 0, 4712, 4713, 3, 1892, 946, 0, 4713, 4714, 3, 376, 188, 0, 4714, + 4716, 1, 0, 0, 0, 4715, 4698, 1, 0, 0, 0, 4715, 4708, 1, 0, 0, 0, 4716, + 381, 1, 0, 0, 0, 4717, 4718, 5, 277, 0, 0, 4718, 4719, 5, 2, 0, 0, 4719, + 4720, 3, 384, 192, 0, 4720, 4721, 5, 3, 0, 0, 4721, 383, 1, 0, 0, 0, 4722, + 4727, 3, 392, 196, 0, 4723, 4724, 5, 6, 0, 0, 4724, 4726, 3, 392, 196, + 0, 4725, 4723, 1, 0, 0, 0, 4726, 4729, 1, 0, 0, 0, 4727, 4725, 1, 0, 0, + 0, 4727, 4728, 1, 0, 0, 0, 4728, 385, 1, 0, 0, 0, 4729, 4727, 1, 0, 0, + 0, 4730, 4731, 5, 277, 0, 0, 4731, 4732, 5, 2, 0, 0, 4732, 4733, 3, 388, + 194, 0, 4733, 4734, 5, 3, 0, 0, 4734, 387, 1, 0, 0, 0, 4735, 4740, 3, 390, + 195, 0, 4736, 4737, 5, 6, 0, 0, 4737, 4739, 3, 390, 195, 0, 4738, 4736, + 1, 0, 0, 0, 4739, 4742, 1, 0, 0, 0, 4740, 4738, 1, 0, 0, 0, 4740, 4741, + 1, 0, 0, 0, 4741, 389, 1, 0, 0, 0, 4742, 4740, 1, 0, 0, 0, 4743, 4751, + 3, 392, 196, 0, 4744, 4745, 5, 331, 0, 0, 4745, 4751, 3, 392, 196, 0, 4746, + 4747, 5, 135, 0, 0, 4747, 4751, 3, 392, 196, 0, 4748, 4749, 5, 195, 0, + 0, 4749, 4751, 3, 394, 197, 0, 4750, 4743, 1, 0, 0, 0, 4750, 4744, 1, 0, + 0, 0, 4750, 4746, 1, 0, 0, 0, 4750, 4748, 1, 0, 0, 0, 4751, 391, 1, 0, + 0, 0, 4752, 4753, 3, 394, 197, 0, 4753, 4754, 3, 396, 198, 0, 4754, 393, + 1, 0, 0, 0, 4755, 4756, 3, 1932, 966, 0, 4756, 395, 1, 0, 0, 0, 4757, 4758, + 3, 1910, 955, 0, 4758, 397, 1, 0, 0, 0, 4759, 4760, 5, 46, 0, 0, 4760, + 4761, 5, 329, 0, 0, 4761, 4763, 3, 1892, 946, 0, 4762, 4764, 3, 400, 200, + 0, 4763, 4762, 1, 0, 0, 0, 4763, 4764, 1, 0, 0, 0, 4764, 4766, 1, 0, 0, + 0, 4765, 4767, 3, 404, 202, 0, 4766, 4765, 1, 0, 0, 0, 4766, 4767, 1, 0, + 0, 0, 4767, 4768, 1, 0, 0, 0, 4768, 4769, 5, 63, 0, 0, 4769, 4770, 5, 177, + 0, 0, 4770, 4771, 5, 379, 0, 0, 4771, 4773, 3, 1892, 946, 0, 4772, 4774, + 3, 382, 191, 0, 4773, 4772, 1, 0, 0, 0, 4773, 4774, 1, 0, 0, 0, 4774, 4795, + 1, 0, 0, 0, 4775, 4776, 5, 46, 0, 0, 4776, 4777, 5, 329, 0, 0, 4777, 4778, + 5, 224, 0, 0, 4778, 4779, 5, 77, 0, 0, 4779, 4780, 5, 558, 0, 0, 4780, + 4782, 3, 1892, 946, 0, 4781, 4783, 3, 400, 200, 0, 4782, 4781, 1, 0, 0, + 0, 4782, 4783, 1, 0, 0, 0, 4783, 4785, 1, 0, 0, 0, 4784, 4786, 3, 404, + 202, 0, 4785, 4784, 1, 0, 0, 0, 4785, 4786, 1, 0, 0, 0, 4786, 4787, 1, + 0, 0, 0, 4787, 4788, 5, 63, 0, 0, 4788, 4789, 5, 177, 0, 0, 4789, 4790, + 5, 379, 0, 0, 4790, 4792, 3, 1892, 946, 0, 4791, 4793, 3, 382, 191, 0, + 4792, 4791, 1, 0, 0, 0, 4792, 4793, 1, 0, 0, 0, 4793, 4795, 1, 0, 0, 0, + 4794, 4759, 1, 0, 0, 0, 4794, 4775, 1, 0, 0, 0, 4795, 399, 1, 0, 0, 0, + 4796, 4797, 5, 358, 0, 0, 4797, 4798, 3, 1910, 955, 0, 4798, 401, 1, 0, + 0, 0, 4799, 4802, 5, 373, 0, 0, 4800, 4803, 3, 1910, 955, 0, 4801, 4803, + 5, 78, 0, 0, 4802, 4800, 1, 0, 0, 0, 4802, 4801, 1, 0, 0, 0, 4803, 403, + 1, 0, 0, 0, 4804, 4805, 3, 402, 201, 0, 4805, 405, 1, 0, 0, 0, 4806, 4807, + 5, 140, 0, 0, 4807, 4808, 5, 329, 0, 0, 4808, 4814, 3, 1892, 946, 0, 4809, + 4815, 3, 386, 193, 0, 4810, 4812, 3, 402, 201, 0, 4811, 4813, 3, 386, 193, + 0, 4812, 4811, 1, 0, 0, 0, 4812, 4813, 1, 0, 0, 0, 4813, 4815, 1, 0, 0, + 0, 4814, 4809, 1, 0, 0, 0, 4814, 4810, 1, 0, 0, 0, 4815, 407, 1, 0, 0, + 0, 4816, 4817, 5, 46, 0, 0, 4817, 4818, 5, 63, 0, 0, 4818, 4819, 5, 93, + 0, 0, 4819, 4820, 3, 1888, 944, 0, 4820, 4822, 5, 2, 0, 0, 4821, 4823, + 3, 200, 100, 0, 4822, 4821, 1, 0, 0, 0, 4822, 4823, 1, 0, 0, 0, 4823, 4824, + 1, 0, 0, 0, 4824, 4826, 5, 3, 0, 0, 4825, 4827, 3, 268, 134, 0, 4826, 4825, + 1, 0, 0, 0, 4826, 4827, 1, 0, 0, 0, 4827, 4828, 1, 0, 0, 0, 4828, 4829, + 5, 329, 0, 0, 4829, 4831, 3, 1892, 946, 0, 4830, 4832, 3, 382, 191, 0, + 4831, 4830, 1, 0, 0, 0, 4831, 4832, 1, 0, 0, 0, 4832, 4889, 1, 0, 0, 0, + 4833, 4834, 5, 46, 0, 0, 4834, 4835, 5, 63, 0, 0, 4835, 4836, 5, 93, 0, + 0, 4836, 4837, 5, 224, 0, 0, 4837, 4838, 5, 77, 0, 0, 4838, 4839, 5, 558, + 0, 0, 4839, 4840, 3, 1888, 944, 0, 4840, 4842, 5, 2, 0, 0, 4841, 4843, + 3, 200, 100, 0, 4842, 4841, 1, 0, 0, 0, 4842, 4843, 1, 0, 0, 0, 4843, 4844, + 1, 0, 0, 0, 4844, 4846, 5, 3, 0, 0, 4845, 4847, 3, 268, 134, 0, 4846, 4845, + 1, 0, 0, 0, 4846, 4847, 1, 0, 0, 0, 4847, 4848, 1, 0, 0, 0, 4848, 4849, + 5, 329, 0, 0, 4849, 4851, 3, 1892, 946, 0, 4850, 4852, 3, 382, 191, 0, + 4851, 4850, 1, 0, 0, 0, 4851, 4852, 1, 0, 0, 0, 4852, 4889, 1, 0, 0, 0, + 4853, 4854, 5, 46, 0, 0, 4854, 4855, 5, 63, 0, 0, 4855, 4856, 5, 93, 0, + 0, 4856, 4857, 3, 1888, 944, 0, 4857, 4858, 5, 282, 0, 0, 4858, 4859, 5, + 272, 0, 0, 4859, 4861, 3, 1888, 944, 0, 4860, 4862, 3, 202, 101, 0, 4861, + 4860, 1, 0, 0, 0, 4861, 4862, 1, 0, 0, 0, 4862, 4863, 1, 0, 0, 0, 4863, + 4864, 3, 140, 70, 0, 4864, 4865, 5, 329, 0, 0, 4865, 4867, 3, 1892, 946, + 0, 4866, 4868, 3, 382, 191, 0, 4867, 4866, 1, 0, 0, 0, 4867, 4868, 1, 0, + 0, 0, 4868, 4889, 1, 0, 0, 0, 4869, 4870, 5, 46, 0, 0, 4870, 4871, 5, 63, + 0, 0, 4871, 4872, 5, 93, 0, 0, 4872, 4873, 5, 224, 0, 0, 4873, 4874, 5, + 77, 0, 0, 4874, 4875, 5, 558, 0, 0, 4875, 4876, 3, 1888, 944, 0, 4876, + 4877, 5, 282, 0, 0, 4877, 4878, 5, 272, 0, 0, 4878, 4880, 3, 1888, 944, + 0, 4879, 4881, 3, 202, 101, 0, 4880, 4879, 1, 0, 0, 0, 4880, 4881, 1, 0, + 0, 0, 4881, 4882, 1, 0, 0, 0, 4882, 4883, 3, 140, 70, 0, 4883, 4884, 5, + 329, 0, 0, 4884, 4886, 3, 1892, 946, 0, 4885, 4887, 3, 382, 191, 0, 4886, + 4885, 1, 0, 0, 0, 4886, 4887, 1, 0, 0, 0, 4887, 4889, 1, 0, 0, 0, 4888, + 4816, 1, 0, 0, 0, 4888, 4833, 1, 0, 0, 0, 4888, 4853, 1, 0, 0, 0, 4888, + 4869, 1, 0, 0, 0, 4889, 409, 1, 0, 0, 0, 4890, 4891, 5, 642, 0, 0, 4891, + 4892, 5, 63, 0, 0, 4892, 4893, 5, 321, 0, 0, 4893, 4895, 3, 1892, 946, + 0, 4894, 4896, 3, 414, 207, 0, 4895, 4894, 1, 0, 0, 0, 4895, 4896, 1, 0, + 0, 0, 4896, 4897, 1, 0, 0, 0, 4897, 4898, 5, 64, 0, 0, 4898, 4899, 5, 329, + 0, 0, 4899, 4900, 3, 1892, 946, 0, 4900, 4901, 5, 71, 0, 0, 4901, 4903, + 3, 1892, 946, 0, 4902, 4904, 3, 382, 191, 0, 4903, 4902, 1, 0, 0, 0, 4903, + 4904, 1, 0, 0, 0, 4904, 411, 1, 0, 0, 0, 4905, 4906, 5, 74, 0, 0, 4906, + 4909, 5, 95, 0, 0, 4907, 4909, 5, 59, 0, 0, 4908, 4905, 1, 0, 0, 0, 4908, + 4907, 1, 0, 0, 0, 4909, 413, 1, 0, 0, 0, 4910, 4911, 3, 412, 206, 0, 4911, + 4912, 5, 2, 0, 0, 4912, 4913, 3, 1620, 810, 0, 4913, 4914, 5, 3, 0, 0, + 4914, 415, 1, 0, 0, 0, 4915, 4916, 5, 46, 0, 0, 4916, 4917, 5, 100, 0, + 0, 4917, 4918, 5, 252, 0, 0, 4918, 4919, 5, 62, 0, 0, 4919, 4920, 3, 418, + 209, 0, 4920, 4921, 5, 329, 0, 0, 4921, 4923, 3, 1892, 946, 0, 4922, 4924, + 3, 382, 191, 0, 4923, 4922, 1, 0, 0, 0, 4923, 4924, 1, 0, 0, 0, 4924, 4939, + 1, 0, 0, 0, 4925, 4926, 5, 46, 0, 0, 4926, 4927, 5, 100, 0, 0, 4927, 4928, + 5, 252, 0, 0, 4928, 4929, 5, 224, 0, 0, 4929, 4930, 5, 77, 0, 0, 4930, + 4931, 5, 558, 0, 0, 4931, 4932, 5, 62, 0, 0, 4932, 4933, 3, 418, 209, 0, + 4933, 4934, 5, 329, 0, 0, 4934, 4936, 3, 1892, 946, 0, 4935, 4937, 3, 382, + 191, 0, 4936, 4935, 1, 0, 0, 0, 4936, 4937, 1, 0, 0, 0, 4937, 4939, 1, + 0, 0, 0, 4938, 4915, 1, 0, 0, 0, 4938, 4925, 1, 0, 0, 0, 4939, 417, 1, + 0, 0, 0, 4940, 4943, 3, 1920, 960, 0, 4941, 4943, 5, 100, 0, 0, 4942, 4940, + 1, 0, 0, 0, 4942, 4941, 1, 0, 0, 0, 4943, 419, 1, 0, 0, 0, 4944, 4945, + 5, 195, 0, 0, 4945, 4946, 5, 100, 0, 0, 4946, 4947, 5, 252, 0, 0, 4947, + 4948, 5, 62, 0, 0, 4948, 4949, 3, 418, 209, 0, 4949, 4950, 5, 329, 0, 0, + 4950, 4951, 3, 1892, 946, 0, 4951, 4963, 1, 0, 0, 0, 4952, 4953, 5, 195, + 0, 0, 4953, 4954, 5, 100, 0, 0, 4954, 4955, 5, 252, 0, 0, 4955, 4956, 5, + 224, 0, 0, 4956, 4957, 5, 558, 0, 0, 4957, 4958, 5, 62, 0, 0, 4958, 4959, + 3, 418, 209, 0, 4959, 4960, 5, 329, 0, 0, 4960, 4961, 3, 1892, 946, 0, + 4961, 4963, 1, 0, 0, 0, 4962, 4944, 1, 0, 0, 0, 4962, 4952, 1, 0, 0, 0, + 4963, 421, 1, 0, 0, 0, 4964, 4965, 5, 140, 0, 0, 4965, 4966, 5, 100, 0, + 0, 4966, 4967, 5, 252, 0, 0, 4967, 4968, 5, 62, 0, 0, 4968, 4969, 3, 418, + 209, 0, 4969, 4970, 5, 329, 0, 0, 4970, 4971, 3, 1892, 946, 0, 4971, 4972, + 3, 386, 193, 0, 4972, 423, 1, 0, 0, 0, 4973, 4974, 5, 46, 0, 0, 4974, 4975, + 5, 643, 0, 0, 4975, 4976, 3, 1892, 946, 0, 4976, 4977, 5, 80, 0, 0, 4977, + 4979, 3, 1888, 944, 0, 4978, 4980, 3, 436, 218, 0, 4979, 4978, 1, 0, 0, + 0, 4979, 4980, 1, 0, 0, 0, 4980, 4982, 1, 0, 0, 0, 4981, 4983, 3, 438, + 219, 0, 4982, 4981, 1, 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 4985, 1, + 0, 0, 0, 4984, 4986, 3, 432, 216, 0, 4985, 4984, 1, 0, 0, 0, 4985, 4986, + 1, 0, 0, 0, 4986, 4988, 1, 0, 0, 0, 4987, 4989, 3, 428, 214, 0, 4988, 4987, + 1, 0, 0, 0, 4988, 4989, 1, 0, 0, 0, 4989, 4991, 1, 0, 0, 0, 4990, 4992, + 3, 430, 215, 0, 4991, 4990, 1, 0, 0, 0, 4991, 4992, 1, 0, 0, 0, 4992, 425, + 1, 0, 0, 0, 4993, 4994, 5, 140, 0, 0, 4994, 4995, 5, 643, 0, 0, 4995, 4996, + 3, 1892, 946, 0, 4996, 4997, 5, 80, 0, 0, 4997, 4999, 3, 1888, 944, 0, + 4998, 5000, 3, 434, 217, 0, 4999, 4998, 1, 0, 0, 0, 4999, 5000, 1, 0, 0, + 0, 5000, 5002, 1, 0, 0, 0, 5001, 5003, 3, 428, 214, 0, 5002, 5001, 1, 0, + 0, 0, 5002, 5003, 1, 0, 0, 0, 5003, 5005, 1, 0, 0, 0, 5004, 5006, 3, 430, + 215, 0, 5005, 5004, 1, 0, 0, 0, 5005, 5006, 1, 0, 0, 0, 5006, 427, 1, 0, + 0, 0, 5007, 5008, 5, 101, 0, 0, 5008, 5009, 5, 2, 0, 0, 5009, 5010, 3, + 1710, 855, 0, 5010, 5011, 5, 3, 0, 0, 5011, 429, 1, 0, 0, 0, 5012, 5013, + 5, 106, 0, 0, 5013, 5014, 5, 42, 0, 0, 5014, 5015, 5, 2, 0, 0, 5015, 5016, + 3, 1710, 855, 0, 5016, 5017, 5, 3, 0, 0, 5017, 431, 1, 0, 0, 0, 5018, 5019, + 5, 95, 0, 0, 5019, 5020, 3, 1922, 961, 0, 5020, 433, 1, 0, 0, 0, 5021, + 5022, 5, 95, 0, 0, 5022, 5023, 3, 1922, 961, 0, 5023, 435, 1, 0, 0, 0, + 5024, 5025, 5, 36, 0, 0, 5025, 5026, 3, 1934, 967, 0, 5026, 437, 1, 0, + 0, 0, 5027, 5028, 5, 62, 0, 0, 5028, 5029, 3, 440, 220, 0, 5029, 439, 1, + 0, 0, 0, 5030, 5031, 7, 29, 0, 0, 5031, 441, 1, 0, 0, 0, 5032, 5033, 5, + 46, 0, 0, 5033, 5034, 5, 133, 0, 0, 5034, 5035, 5, 645, 0, 0, 5035, 5036, + 3, 1892, 946, 0, 5036, 5037, 5, 358, 0, 0, 5037, 5038, 3, 444, 222, 0, + 5038, 5039, 5, 219, 0, 0, 5039, 5040, 3, 342, 171, 0, 5040, 443, 1, 0, + 0, 0, 5041, 5042, 7, 30, 0, 0, 5042, 445, 1, 0, 0, 0, 5043, 5044, 5, 46, + 0, 0, 5044, 5045, 5, 355, 0, 0, 5045, 5046, 3, 1892, 946, 0, 5046, 5047, + 3, 448, 224, 0, 5047, 5048, 3, 450, 225, 0, 5048, 5049, 5, 80, 0, 0, 5049, + 5051, 3, 1888, 944, 0, 5050, 5052, 3, 454, 227, 0, 5051, 5050, 1, 0, 0, + 0, 5051, 5052, 1, 0, 0, 0, 5052, 5054, 1, 0, 0, 0, 5053, 5055, 3, 466, + 233, 0, 5054, 5053, 1, 0, 0, 0, 5054, 5055, 1, 0, 0, 0, 5055, 5057, 1, + 0, 0, 0, 5056, 5058, 3, 472, 236, 0, 5057, 5056, 1, 0, 0, 0, 5057, 5058, + 1, 0, 0, 0, 5058, 5059, 1, 0, 0, 0, 5059, 5060, 5, 206, 0, 0, 5060, 5061, + 3, 474, 237, 0, 5061, 5062, 3, 1898, 949, 0, 5062, 5063, 5, 2, 0, 0, 5063, + 5064, 3, 476, 238, 0, 5064, 5065, 5, 3, 0, 0, 5065, 5092, 1, 0, 0, 0, 5066, + 5067, 5, 46, 0, 0, 5067, 5068, 5, 45, 0, 0, 5068, 5069, 5, 355, 0, 0, 5069, + 5070, 3, 1892, 946, 0, 5070, 5071, 5, 137, 0, 0, 5071, 5072, 3, 450, 225, + 0, 5072, 5073, 5, 80, 0, 0, 5073, 5075, 3, 1888, 944, 0, 5074, 5076, 3, + 480, 240, 0, 5075, 5074, 1, 0, 0, 0, 5075, 5076, 1, 0, 0, 0, 5076, 5077, + 1, 0, 0, 0, 5077, 5078, 3, 482, 241, 0, 5078, 5079, 5, 62, 0, 0, 5079, + 5080, 5, 196, 0, 0, 5080, 5082, 5, 577, 0, 0, 5081, 5083, 3, 472, 236, + 0, 5082, 5081, 1, 0, 0, 0, 5082, 5083, 1, 0, 0, 0, 5083, 5084, 1, 0, 0, + 0, 5084, 5085, 5, 206, 0, 0, 5085, 5086, 3, 474, 237, 0, 5086, 5087, 3, + 1898, 949, 0, 5087, 5088, 5, 2, 0, 0, 5088, 5089, 3, 476, 238, 0, 5089, + 5090, 5, 3, 0, 0, 5090, 5092, 1, 0, 0, 0, 5091, 5043, 1, 0, 0, 0, 5091, + 5066, 1, 0, 0, 0, 5092, 447, 1, 0, 0, 0, 5093, 5098, 5, 147, 0, 0, 5094, + 5098, 5, 137, 0, 0, 5095, 5096, 5, 237, 0, 0, 5096, 5098, 5, 272, 0, 0, + 5097, 5093, 1, 0, 0, 0, 5097, 5094, 1, 0, 0, 0, 5097, 5095, 1, 0, 0, 0, + 5098, 449, 1, 0, 0, 0, 5099, 5104, 3, 452, 226, 0, 5100, 5101, 5, 82, 0, + 0, 5101, 5103, 3, 452, 226, 0, 5102, 5100, 1, 0, 0, 0, 5103, 5106, 1, 0, + 0, 0, 5104, 5102, 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 451, 1, 0, + 0, 0, 5106, 5104, 1, 0, 0, 0, 5107, 5115, 5, 236, 0, 0, 5108, 5115, 5, + 186, 0, 0, 5109, 5115, 5, 367, 0, 0, 5110, 5111, 5, 367, 0, 0, 5111, 5112, + 5, 272, 0, 0, 5112, 5115, 3, 246, 123, 0, 5113, 5115, 5, 356, 0, 0, 5114, + 5107, 1, 0, 0, 0, 5114, 5108, 1, 0, 0, 0, 5114, 5109, 1, 0, 0, 0, 5114, + 5110, 1, 0, 0, 0, 5114, 5113, 1, 0, 0, 0, 5115, 453, 1, 0, 0, 0, 5116, + 5117, 5, 646, 0, 0, 5117, 5118, 3, 456, 228, 0, 5118, 455, 1, 0, 0, 0, + 5119, 5121, 3, 458, 229, 0, 5120, 5119, 1, 0, 0, 0, 5121, 5122, 1, 0, 0, + 0, 5122, 5120, 1, 0, 0, 0, 5122, 5123, 1, 0, 0, 0, 5123, 457, 1, 0, 0, + 0, 5124, 5125, 3, 460, 230, 0, 5125, 5127, 3, 462, 231, 0, 5126, 5128, + 3, 1366, 683, 0, 5127, 5126, 1, 0, 0, 0, 5127, 5128, 1, 0, 0, 0, 5128, + 5129, 1, 0, 0, 0, 5129, 5130, 3, 464, 232, 0, 5130, 459, 1, 0, 0, 0, 5131, + 5132, 7, 31, 0, 0, 5132, 461, 1, 0, 0, 0, 5133, 5134, 7, 32, 0, 0, 5134, + 463, 1, 0, 0, 0, 5135, 5136, 3, 1924, 962, 0, 5136, 465, 1, 0, 0, 0, 5137, + 5139, 5, 62, 0, 0, 5138, 5140, 3, 468, 234, 0, 5139, 5138, 1, 0, 0, 0, + 5139, 5140, 1, 0, 0, 0, 5140, 5141, 1, 0, 0, 0, 5141, 5142, 3, 470, 235, + 0, 5142, 467, 1, 0, 0, 0, 5143, 5144, 5, 196, 0, 0, 5144, 469, 1, 0, 0, + 0, 5145, 5146, 7, 33, 0, 0, 5146, 471, 1, 0, 0, 0, 5147, 5148, 5, 103, + 0, 0, 5148, 5149, 5, 2, 0, 0, 5149, 5150, 3, 1710, 855, 0, 5150, 5151, + 5, 3, 0, 0, 5151, 473, 1, 0, 0, 0, 5152, 5153, 7, 34, 0, 0, 5153, 475, + 1, 0, 0, 0, 5154, 5157, 3, 478, 239, 0, 5155, 5157, 1, 0, 0, 0, 5156, 5154, + 1, 0, 0, 0, 5156, 5155, 1, 0, 0, 0, 5157, 5162, 1, 0, 0, 0, 5158, 5159, + 5, 6, 0, 0, 5159, 5161, 3, 478, 239, 0, 5160, 5158, 1, 0, 0, 0, 5161, 5164, + 1, 0, 0, 0, 5162, 5160, 1, 0, 0, 0, 5162, 5163, 1, 0, 0, 0, 5163, 477, + 1, 0, 0, 0, 5164, 5162, 1, 0, 0, 0, 5165, 5170, 3, 1908, 954, 0, 5166, + 5170, 3, 1906, 953, 0, 5167, 5170, 3, 1910, 955, 0, 5168, 5170, 3, 1932, + 966, 0, 5169, 5165, 1, 0, 0, 0, 5169, 5166, 1, 0, 0, 0, 5169, 5167, 1, + 0, 0, 0, 5169, 5168, 1, 0, 0, 0, 5170, 479, 1, 0, 0, 0, 5171, 5172, 5, + 64, 0, 0, 5172, 5173, 3, 1888, 944, 0, 5173, 481, 1, 0, 0, 0, 5174, 5176, + 3, 484, 242, 0, 5175, 5174, 1, 0, 0, 0, 5176, 5179, 1, 0, 0, 0, 5177, 5175, + 1, 0, 0, 0, 5177, 5178, 1, 0, 0, 0, 5178, 483, 1, 0, 0, 0, 5179, 5177, + 1, 0, 0, 0, 5180, 5181, 5, 77, 0, 0, 5181, 5192, 5, 54, 0, 0, 5182, 5192, + 5, 54, 0, 0, 5183, 5184, 5, 69, 0, 0, 5184, 5192, 5, 225, 0, 0, 5185, 5186, + 5, 69, 0, 0, 5186, 5192, 5, 184, 0, 0, 5187, 5188, 5, 77, 0, 0, 5188, 5192, + 5, 369, 0, 0, 5189, 5190, 5, 266, 0, 0, 5190, 5192, 5, 232, 0, 0, 5191, + 5180, 1, 0, 0, 0, 5191, 5182, 1, 0, 0, 0, 5191, 5183, 1, 0, 0, 0, 5191, + 5185, 1, 0, 0, 0, 5191, 5187, 1, 0, 0, 0, 5191, 5189, 1, 0, 0, 0, 5192, + 485, 1, 0, 0, 0, 5193, 5194, 5, 46, 0, 0, 5194, 5195, 5, 202, 0, 0, 5195, + 5196, 5, 355, 0, 0, 5196, 5197, 3, 1892, 946, 0, 5197, 5198, 5, 80, 0, + 0, 5198, 5199, 3, 1932, 966, 0, 5199, 5200, 5, 206, 0, 0, 5200, 5201, 3, + 474, 237, 0, 5201, 5202, 3, 1898, 949, 0, 5202, 5203, 5, 2, 0, 0, 5203, + 5204, 5, 3, 0, 0, 5204, 5220, 1, 0, 0, 0, 5205, 5206, 5, 46, 0, 0, 5206, + 5207, 5, 202, 0, 0, 5207, 5208, 5, 355, 0, 0, 5208, 5209, 3, 1892, 946, + 0, 5209, 5210, 5, 80, 0, 0, 5210, 5211, 3, 1932, 966, 0, 5211, 5212, 5, + 103, 0, 0, 5212, 5213, 3, 488, 244, 0, 5213, 5214, 5, 206, 0, 0, 5214, + 5215, 3, 474, 237, 0, 5215, 5216, 3, 1898, 949, 0, 5216, 5217, 5, 2, 0, + 0, 5217, 5218, 5, 3, 0, 0, 5218, 5220, 1, 0, 0, 0, 5219, 5193, 1, 0, 0, + 0, 5219, 5205, 1, 0, 0, 0, 5220, 487, 1, 0, 0, 0, 5221, 5226, 3, 490, 245, + 0, 5222, 5223, 5, 33, 0, 0, 5223, 5225, 3, 490, 245, 0, 5224, 5222, 1, + 0, 0, 0, 5225, 5228, 1, 0, 0, 0, 5226, 5224, 1, 0, 0, 0, 5226, 5227, 1, + 0, 0, 0, 5227, 489, 1, 0, 0, 0, 5228, 5226, 1, 0, 0, 0, 5229, 5230, 3, + 1924, 962, 0, 5230, 5231, 5, 68, 0, 0, 5231, 5232, 5, 2, 0, 0, 5232, 5233, + 3, 492, 246, 0, 5233, 5234, 5, 3, 0, 0, 5234, 491, 1, 0, 0, 0, 5235, 5240, + 3, 1910, 955, 0, 5236, 5237, 5, 6, 0, 0, 5237, 5239, 3, 1910, 955, 0, 5238, + 5236, 1, 0, 0, 0, 5239, 5242, 1, 0, 0, 0, 5240, 5238, 1, 0, 0, 0, 5240, + 5241, 1, 0, 0, 0, 5241, 493, 1, 0, 0, 0, 5242, 5240, 1, 0, 0, 0, 5243, + 5244, 5, 140, 0, 0, 5244, 5245, 5, 202, 0, 0, 5245, 5246, 5, 355, 0, 0, + 5246, 5247, 3, 1892, 946, 0, 5247, 5248, 3, 496, 248, 0, 5248, 495, 1, + 0, 0, 0, 5249, 5256, 5, 197, 0, 0, 5250, 5251, 5, 197, 0, 0, 5251, 5256, + 5, 310, 0, 0, 5252, 5253, 5, 197, 0, 0, 5253, 5256, 5, 141, 0, 0, 5254, + 5256, 5, 190, 0, 0, 5255, 5249, 1, 0, 0, 0, 5255, 5250, 1, 0, 0, 0, 5255, + 5252, 1, 0, 0, 0, 5255, 5254, 1, 0, 0, 0, 5256, 497, 1, 0, 0, 0, 5257, + 5258, 5, 46, 0, 0, 5258, 5259, 5, 142, 0, 0, 5259, 5260, 3, 566, 283, 0, + 5260, 5261, 5, 42, 0, 0, 5261, 5262, 5, 2, 0, 0, 5262, 5263, 3, 1710, 855, + 0, 5263, 5264, 5, 3, 0, 0, 5264, 5265, 3, 482, 241, 0, 5265, 499, 1, 0, + 0, 0, 5266, 5268, 5, 46, 0, 0, 5267, 5269, 3, 832, 416, 0, 5268, 5267, + 1, 0, 0, 0, 5268, 5269, 1, 0, 0, 0, 5269, 5270, 1, 0, 0, 0, 5270, 5271, + 5, 138, 0, 0, 5271, 5272, 3, 1898, 949, 0, 5272, 5273, 3, 864, 432, 0, + 5273, 5274, 3, 502, 251, 0, 5274, 5381, 1, 0, 0, 0, 5275, 5277, 5, 46, + 0, 0, 5276, 5278, 3, 832, 416, 0, 5277, 5276, 1, 0, 0, 0, 5277, 5278, 1, + 0, 0, 0, 5278, 5279, 1, 0, 0, 0, 5279, 5280, 5, 138, 0, 0, 5280, 5281, + 3, 1898, 949, 0, 5281, 5282, 3, 510, 255, 0, 5282, 5381, 1, 0, 0, 0, 5283, + 5284, 5, 46, 0, 0, 5284, 5285, 5, 275, 0, 0, 5285, 5286, 3, 904, 452, 0, + 5286, 5287, 3, 502, 251, 0, 5287, 5381, 1, 0, 0, 0, 5288, 5289, 5, 46, + 0, 0, 5289, 5290, 5, 358, 0, 0, 5290, 5291, 3, 566, 283, 0, 5291, 5292, + 3, 502, 251, 0, 5292, 5381, 1, 0, 0, 0, 5293, 5294, 5, 46, 0, 0, 5294, + 5295, 5, 358, 0, 0, 5295, 5381, 3, 566, 283, 0, 5296, 5297, 5, 46, 0, 0, + 5297, 5298, 5, 358, 0, 0, 5298, 5299, 3, 566, 283, 0, 5299, 5300, 5, 36, + 0, 0, 5300, 5302, 5, 2, 0, 0, 5301, 5303, 3, 1642, 821, 0, 5302, 5301, + 1, 0, 0, 0, 5302, 5303, 1, 0, 0, 0, 5303, 5304, 1, 0, 0, 0, 5304, 5305, + 5, 3, 0, 0, 5305, 5381, 1, 0, 0, 0, 5306, 5307, 5, 46, 0, 0, 5307, 5308, + 5, 358, 0, 0, 5308, 5309, 3, 566, 283, 0, 5309, 5310, 5, 36, 0, 0, 5310, + 5311, 5, 200, 0, 0, 5311, 5313, 5, 2, 0, 0, 5312, 5314, 3, 516, 258, 0, + 5313, 5312, 1, 0, 0, 0, 5313, 5314, 1, 0, 0, 0, 5314, 5315, 1, 0, 0, 0, + 5315, 5316, 5, 3, 0, 0, 5316, 5381, 1, 0, 0, 0, 5317, 5318, 5, 46, 0, 0, + 5318, 5319, 5, 358, 0, 0, 5319, 5320, 3, 566, 283, 0, 5320, 5321, 5, 36, + 0, 0, 5321, 5322, 5, 297, 0, 0, 5322, 5323, 3, 502, 251, 0, 5323, 5381, + 1, 0, 0, 0, 5324, 5325, 5, 46, 0, 0, 5325, 5326, 5, 353, 0, 0, 5326, 5327, + 5, 323, 0, 0, 5327, 5328, 5, 280, 0, 0, 5328, 5329, 3, 566, 283, 0, 5329, + 5330, 3, 502, 251, 0, 5330, 5381, 1, 0, 0, 0, 5331, 5332, 5, 46, 0, 0, + 5332, 5333, 5, 353, 0, 0, 5333, 5334, 5, 323, 0, 0, 5334, 5335, 5, 189, + 0, 0, 5335, 5336, 3, 566, 283, 0, 5336, 5337, 3, 502, 251, 0, 5337, 5381, + 1, 0, 0, 0, 5338, 5339, 5, 46, 0, 0, 5339, 5340, 5, 353, 0, 0, 5340, 5341, + 5, 323, 0, 0, 5341, 5342, 5, 351, 0, 0, 5342, 5343, 3, 566, 283, 0, 5343, + 5344, 3, 502, 251, 0, 5344, 5381, 1, 0, 0, 0, 5345, 5346, 5, 46, 0, 0, + 5346, 5347, 5, 353, 0, 0, 5347, 5348, 5, 323, 0, 0, 5348, 5349, 5, 165, + 0, 0, 5349, 5350, 3, 566, 283, 0, 5350, 5351, 3, 502, 251, 0, 5351, 5381, + 1, 0, 0, 0, 5352, 5353, 5, 46, 0, 0, 5353, 5354, 5, 110, 0, 0, 5354, 5355, + 3, 566, 283, 0, 5355, 5356, 3, 502, 251, 0, 5356, 5381, 1, 0, 0, 0, 5357, + 5358, 5, 46, 0, 0, 5358, 5359, 5, 110, 0, 0, 5359, 5360, 5, 224, 0, 0, + 5360, 5361, 5, 77, 0, 0, 5361, 5362, 5, 558, 0, 0, 5362, 5363, 3, 566, + 283, 0, 5363, 5364, 3, 502, 251, 0, 5364, 5381, 1, 0, 0, 0, 5365, 5366, + 5, 46, 0, 0, 5366, 5367, 5, 110, 0, 0, 5367, 5368, 3, 566, 283, 0, 5368, + 5369, 5, 64, 0, 0, 5369, 5370, 3, 566, 283, 0, 5370, 5381, 1, 0, 0, 0, + 5371, 5372, 5, 46, 0, 0, 5372, 5373, 5, 110, 0, 0, 5373, 5374, 5, 224, + 0, 0, 5374, 5375, 5, 77, 0, 0, 5375, 5376, 5, 558, 0, 0, 5376, 5377, 3, + 566, 283, 0, 5377, 5378, 5, 64, 0, 0, 5378, 5379, 3, 566, 283, 0, 5379, + 5381, 1, 0, 0, 0, 5380, 5266, 1, 0, 0, 0, 5380, 5275, 1, 0, 0, 0, 5380, + 5283, 1, 0, 0, 0, 5380, 5288, 1, 0, 0, 0, 5380, 5293, 1, 0, 0, 0, 5380, + 5296, 1, 0, 0, 0, 5380, 5306, 1, 0, 0, 0, 5380, 5317, 1, 0, 0, 0, 5380, + 5324, 1, 0, 0, 0, 5380, 5331, 1, 0, 0, 0, 5380, 5338, 1, 0, 0, 0, 5380, + 5345, 1, 0, 0, 0, 5380, 5352, 1, 0, 0, 0, 5380, 5357, 1, 0, 0, 0, 5380, + 5365, 1, 0, 0, 0, 5380, 5371, 1, 0, 0, 0, 5381, 501, 1, 0, 0, 0, 5382, + 5383, 5, 2, 0, 0, 5383, 5384, 3, 504, 252, 0, 5384, 5385, 5, 3, 0, 0, 5385, + 503, 1, 0, 0, 0, 5386, 5391, 3, 506, 253, 0, 5387, 5388, 5, 6, 0, 0, 5388, + 5390, 3, 506, 253, 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, 505, 1, 0, 0, 0, 5393, + 5391, 1, 0, 0, 0, 5394, 5397, 3, 1932, 966, 0, 5395, 5396, 5, 10, 0, 0, + 5396, 5398, 3, 508, 254, 0, 5397, 5395, 1, 0, 0, 0, 5397, 5398, 1, 0, 0, + 0, 5398, 507, 1, 0, 0, 0, 5399, 5406, 3, 858, 429, 0, 5400, 5406, 3, 1944, + 972, 0, 5401, 5406, 3, 1826, 913, 0, 5402, 5406, 3, 334, 167, 0, 5403, + 5406, 3, 1910, 955, 0, 5404, 5406, 5, 569, 0, 0, 5405, 5399, 1, 0, 0, 0, + 5405, 5400, 1, 0, 0, 0, 5405, 5401, 1, 0, 0, 0, 5405, 5402, 1, 0, 0, 0, + 5405, 5403, 1, 0, 0, 0, 5405, 5404, 1, 0, 0, 0, 5406, 509, 1, 0, 0, 0, + 5407, 5408, 5, 2, 0, 0, 5408, 5409, 3, 512, 256, 0, 5409, 5410, 5, 3, 0, + 0, 5410, 511, 1, 0, 0, 0, 5411, 5416, 3, 514, 257, 0, 5412, 5413, 5, 6, + 0, 0, 5413, 5415, 3, 514, 257, 0, 5414, 5412, 1, 0, 0, 0, 5415, 5418, 1, + 0, 0, 0, 5416, 5414, 1, 0, 0, 0, 5416, 5417, 1, 0, 0, 0, 5417, 513, 1, + 0, 0, 0, 5418, 5416, 1, 0, 0, 0, 5419, 5420, 3, 1934, 967, 0, 5420, 5421, + 5, 10, 0, 0, 5421, 5422, 3, 508, 254, 0, 5422, 515, 1, 0, 0, 0, 5423, 5424, + 3, 518, 259, 0, 5424, 517, 1, 0, 0, 0, 5425, 5430, 3, 1910, 955, 0, 5426, + 5427, 5, 6, 0, 0, 5427, 5429, 3, 1910, 955, 0, 5428, 5426, 1, 0, 0, 0, + 5429, 5432, 1, 0, 0, 0, 5430, 5428, 1, 0, 0, 0, 5430, 5431, 1, 0, 0, 0, + 5431, 519, 1, 0, 0, 0, 5432, 5430, 1, 0, 0, 0, 5433, 5434, 5, 140, 0, 0, + 5434, 5435, 5, 358, 0, 0, 5435, 5436, 3, 566, 283, 0, 5436, 5437, 5, 135, + 0, 0, 5437, 5439, 5, 649, 0, 0, 5438, 5440, 3, 522, 261, 0, 5439, 5438, + 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5441, 1, 0, 0, 0, 5441, 5442, + 3, 1910, 955, 0, 5442, 5477, 1, 0, 0, 0, 5443, 5444, 5, 140, 0, 0, 5444, + 5445, 5, 358, 0, 0, 5445, 5446, 3, 566, 283, 0, 5446, 5447, 5, 135, 0, + 0, 5447, 5449, 5, 649, 0, 0, 5448, 5450, 3, 522, 261, 0, 5449, 5448, 1, + 0, 0, 0, 5449, 5450, 1, 0, 0, 0, 5450, 5451, 1, 0, 0, 0, 5451, 5452, 3, + 1910, 955, 0, 5452, 5453, 5, 147, 0, 0, 5453, 5454, 3, 1910, 955, 0, 5454, + 5477, 1, 0, 0, 0, 5455, 5456, 5, 140, 0, 0, 5456, 5457, 5, 358, 0, 0, 5457, + 5458, 3, 566, 283, 0, 5458, 5459, 5, 135, 0, 0, 5459, 5461, 5, 649, 0, + 0, 5460, 5462, 3, 522, 261, 0, 5461, 5460, 1, 0, 0, 0, 5461, 5462, 1, 0, + 0, 0, 5462, 5463, 1, 0, 0, 0, 5463, 5464, 3, 1910, 955, 0, 5464, 5465, + 5, 137, 0, 0, 5465, 5466, 3, 1910, 955, 0, 5466, 5477, 1, 0, 0, 0, 5467, + 5468, 5, 140, 0, 0, 5468, 5469, 5, 358, 0, 0, 5469, 5470, 3, 566, 283, + 0, 5470, 5471, 5, 307, 0, 0, 5471, 5472, 5, 649, 0, 0, 5472, 5473, 3, 1910, + 955, 0, 5473, 5474, 5, 95, 0, 0, 5474, 5475, 3, 1910, 955, 0, 5475, 5477, + 1, 0, 0, 0, 5476, 5433, 1, 0, 0, 0, 5476, 5443, 1, 0, 0, 0, 5476, 5455, + 1, 0, 0, 0, 5476, 5467, 1, 0, 0, 0, 5477, 521, 1, 0, 0, 0, 5478, 5479, + 5, 224, 0, 0, 5479, 5480, 5, 77, 0, 0, 5480, 5481, 5, 558, 0, 0, 5481, + 523, 1, 0, 0, 0, 5482, 5483, 5, 46, 0, 0, 5483, 5484, 5, 275, 0, 0, 5484, + 5485, 5, 158, 0, 0, 5485, 5487, 3, 566, 283, 0, 5486, 5488, 3, 530, 265, + 0, 5487, 5486, 1, 0, 0, 0, 5487, 5488, 1, 0, 0, 0, 5488, 5489, 1, 0, 0, + 0, 5489, 5490, 5, 62, 0, 0, 5490, 5491, 5, 358, 0, 0, 5491, 5492, 3, 1662, + 831, 0, 5492, 5493, 5, 101, 0, 0, 5493, 5495, 3, 1892, 946, 0, 5494, 5496, + 3, 532, 266, 0, 5495, 5494, 1, 0, 0, 0, 5495, 5496, 1, 0, 0, 0, 5496, 5497, + 1, 0, 0, 0, 5497, 5498, 5, 36, 0, 0, 5498, 5499, 3, 526, 263, 0, 5499, + 525, 1, 0, 0, 0, 5500, 5505, 3, 528, 264, 0, 5501, 5502, 5, 6, 0, 0, 5502, + 5504, 3, 528, 264, 0, 5503, 5501, 1, 0, 0, 0, 5504, 5507, 1, 0, 0, 0, 5505, + 5503, 1, 0, 0, 0, 5505, 5506, 1, 0, 0, 0, 5506, 527, 1, 0, 0, 0, 5507, + 5505, 1, 0, 0, 0, 5508, 5509, 5, 275, 0, 0, 5509, 5510, 3, 1908, 954, 0, + 5510, 5512, 3, 904, 452, 0, 5511, 5513, 3, 534, 267, 0, 5512, 5511, 1, + 0, 0, 0, 5512, 5513, 1, 0, 0, 0, 5513, 5515, 1, 0, 0, 0, 5514, 5516, 3, + 536, 268, 0, 5515, 5514, 1, 0, 0, 0, 5515, 5516, 1, 0, 0, 0, 5516, 5540, + 1, 0, 0, 0, 5517, 5518, 5, 275, 0, 0, 5518, 5519, 3, 1908, 954, 0, 5519, + 5521, 3, 908, 454, 0, 5520, 5522, 3, 534, 267, 0, 5521, 5520, 1, 0, 0, + 0, 5521, 5522, 1, 0, 0, 0, 5522, 5524, 1, 0, 0, 0, 5523, 5525, 3, 536, + 268, 0, 5524, 5523, 1, 0, 0, 0, 5524, 5525, 1, 0, 0, 0, 5525, 5540, 1, + 0, 0, 0, 5526, 5527, 5, 215, 0, 0, 5527, 5528, 3, 1908, 954, 0, 5528, 5529, + 3, 844, 422, 0, 5529, 5540, 1, 0, 0, 0, 5530, 5531, 5, 215, 0, 0, 5531, + 5532, 3, 1908, 954, 0, 5532, 5533, 5, 2, 0, 0, 5533, 5534, 3, 1836, 918, + 0, 5534, 5535, 5, 3, 0, 0, 5535, 5536, 3, 844, 422, 0, 5536, 5540, 1, 0, + 0, 0, 5537, 5538, 5, 343, 0, 0, 5538, 5540, 3, 1662, 831, 0, 5539, 5508, + 1, 0, 0, 0, 5539, 5517, 1, 0, 0, 0, 5539, 5526, 1, 0, 0, 0, 5539, 5530, + 1, 0, 0, 0, 5539, 5537, 1, 0, 0, 0, 5540, 529, 1, 0, 0, 0, 5541, 5542, + 5, 53, 0, 0, 5542, 531, 1, 0, 0, 0, 5543, 5544, 5, 210, 0, 0, 5544, 5545, + 3, 566, 283, 0, 5545, 533, 1, 0, 0, 0, 5546, 5547, 5, 62, 0, 0, 5547, 5553, + 5, 323, 0, 0, 5548, 5549, 5, 62, 0, 0, 5549, 5550, 5, 83, 0, 0, 5550, 5551, + 5, 149, 0, 0, 5551, 5553, 3, 566, 283, 0, 5552, 5546, 1, 0, 0, 0, 5552, + 5548, 1, 0, 0, 0, 5553, 535, 1, 0, 0, 0, 5554, 5555, 5, 300, 0, 0, 5555, + 537, 1, 0, 0, 0, 5556, 5557, 5, 46, 0, 0, 5557, 5558, 5, 275, 0, 0, 5558, + 5559, 5, 210, 0, 0, 5559, 5560, 3, 566, 283, 0, 5560, 5561, 5, 101, 0, + 0, 5561, 5562, 3, 1892, 946, 0, 5562, 539, 1, 0, 0, 0, 5563, 5564, 5, 140, + 0, 0, 5564, 5565, 5, 275, 0, 0, 5565, 5566, 5, 210, 0, 0, 5566, 5567, 3, + 566, 283, 0, 5567, 5568, 5, 101, 0, 0, 5568, 5569, 3, 1892, 946, 0, 5569, + 5570, 5, 135, 0, 0, 5570, 5571, 3, 526, 263, 0, 5571, 5582, 1, 0, 0, 0, + 5572, 5573, 5, 140, 0, 0, 5573, 5574, 5, 275, 0, 0, 5574, 5575, 5, 210, + 0, 0, 5575, 5576, 3, 566, 283, 0, 5576, 5577, 5, 101, 0, 0, 5577, 5578, + 3, 1892, 946, 0, 5578, 5579, 5, 195, 0, 0, 5579, 5580, 3, 542, 271, 0, + 5580, 5582, 1, 0, 0, 0, 5581, 5563, 1, 0, 0, 0, 5581, 5572, 1, 0, 0, 0, + 5582, 541, 1, 0, 0, 0, 5583, 5588, 3, 544, 272, 0, 5584, 5585, 5, 6, 0, + 0, 5585, 5587, 3, 544, 272, 0, 5586, 5584, 1, 0, 0, 0, 5587, 5590, 1, 0, + 0, 0, 5588, 5586, 1, 0, 0, 0, 5588, 5589, 1, 0, 0, 0, 5589, 543, 1, 0, + 0, 0, 5590, 5588, 1, 0, 0, 0, 5591, 5592, 5, 275, 0, 0, 5592, 5593, 3, + 1908, 954, 0, 5593, 5594, 5, 2, 0, 0, 5594, 5595, 3, 1836, 918, 0, 5595, + 5596, 5, 3, 0, 0, 5596, 5604, 1, 0, 0, 0, 5597, 5598, 5, 215, 0, 0, 5598, + 5599, 3, 1908, 954, 0, 5599, 5600, 5, 2, 0, 0, 5600, 5601, 3, 1836, 918, + 0, 5601, 5602, 5, 3, 0, 0, 5602, 5604, 1, 0, 0, 0, 5603, 5591, 1, 0, 0, + 0, 5603, 5597, 1, 0, 0, 0, 5604, 545, 1, 0, 0, 0, 5605, 5606, 5, 195, 0, + 0, 5606, 5607, 5, 275, 0, 0, 5607, 5608, 5, 158, 0, 0, 5608, 5609, 3, 566, + 283, 0, 5609, 5610, 5, 101, 0, 0, 5610, 5612, 3, 1892, 946, 0, 5611, 5613, + 3, 120, 60, 0, 5612, 5611, 1, 0, 0, 0, 5612, 5613, 1, 0, 0, 0, 5613, 5626, + 1, 0, 0, 0, 5614, 5615, 5, 195, 0, 0, 5615, 5616, 5, 275, 0, 0, 5616, 5617, + 5, 158, 0, 0, 5617, 5618, 5, 224, 0, 0, 5618, 5619, 5, 558, 0, 0, 5619, + 5620, 3, 566, 283, 0, 5620, 5621, 5, 101, 0, 0, 5621, 5623, 3, 1892, 946, + 0, 5622, 5624, 3, 120, 60, 0, 5623, 5622, 1, 0, 0, 0, 5623, 5624, 1, 0, + 0, 0, 5624, 5626, 1, 0, 0, 0, 5625, 5605, 1, 0, 0, 0, 5625, 5614, 1, 0, + 0, 0, 5626, 547, 1, 0, 0, 0, 5627, 5628, 5, 195, 0, 0, 5628, 5629, 5, 275, + 0, 0, 5629, 5630, 5, 210, 0, 0, 5630, 5631, 3, 566, 283, 0, 5631, 5632, + 5, 101, 0, 0, 5632, 5634, 3, 1892, 946, 0, 5633, 5635, 3, 120, 60, 0, 5634, + 5633, 1, 0, 0, 0, 5634, 5635, 1, 0, 0, 0, 5635, 5648, 1, 0, 0, 0, 5636, + 5637, 5, 195, 0, 0, 5637, 5638, 5, 275, 0, 0, 5638, 5639, 5, 210, 0, 0, + 5639, 5640, 5, 224, 0, 0, 5640, 5641, 5, 558, 0, 0, 5641, 5642, 3, 566, + 283, 0, 5642, 5643, 5, 101, 0, 0, 5643, 5645, 3, 1892, 946, 0, 5644, 5646, + 3, 120, 60, 0, 5645, 5644, 1, 0, 0, 0, 5645, 5646, 1, 0, 0, 0, 5646, 5648, + 1, 0, 0, 0, 5647, 5627, 1, 0, 0, 0, 5647, 5636, 1, 0, 0, 0, 5648, 549, + 1, 0, 0, 0, 5649, 5650, 5, 195, 0, 0, 5650, 5651, 5, 278, 0, 0, 5651, 5652, + 5, 149, 0, 0, 5652, 5654, 3, 1922, 961, 0, 5653, 5655, 3, 120, 60, 0, 5654, + 5653, 1, 0, 0, 0, 5654, 5655, 1, 0, 0, 0, 5655, 551, 1, 0, 0, 0, 5656, + 5657, 5, 299, 0, 0, 5657, 5658, 5, 278, 0, 0, 5658, 5659, 5, 149, 0, 0, + 5659, 5660, 3, 1922, 961, 0, 5660, 5661, 5, 95, 0, 0, 5661, 5662, 3, 1920, + 960, 0, 5662, 553, 1, 0, 0, 0, 5663, 5664, 5, 195, 0, 0, 5664, 5665, 3, + 556, 278, 0, 5665, 5666, 5, 224, 0, 0, 5666, 5667, 5, 558, 0, 0, 5667, + 5669, 3, 564, 282, 0, 5668, 5670, 3, 120, 60, 0, 5669, 5668, 1, 0, 0, 0, + 5669, 5670, 1, 0, 0, 0, 5670, 5754, 1, 0, 0, 0, 5671, 5672, 5, 195, 0, + 0, 5672, 5673, 3, 556, 278, 0, 5673, 5675, 3, 564, 282, 0, 5674, 5676, + 3, 120, 60, 0, 5675, 5674, 1, 0, 0, 0, 5675, 5676, 1, 0, 0, 0, 5676, 5754, + 1, 0, 0, 0, 5677, 5678, 5, 195, 0, 0, 5678, 5679, 3, 560, 280, 0, 5679, + 5680, 5, 224, 0, 0, 5680, 5681, 5, 558, 0, 0, 5681, 5683, 3, 1890, 945, + 0, 5682, 5684, 3, 120, 60, 0, 5683, 5682, 1, 0, 0, 0, 5683, 5684, 1, 0, + 0, 0, 5684, 5754, 1, 0, 0, 0, 5685, 5686, 5, 195, 0, 0, 5686, 5687, 3, + 560, 280, 0, 5687, 5689, 3, 1890, 945, 0, 5688, 5690, 3, 120, 60, 0, 5689, + 5688, 1, 0, 0, 0, 5689, 5690, 1, 0, 0, 0, 5690, 5754, 1, 0, 0, 0, 5691, + 5692, 5, 195, 0, 0, 5692, 5693, 3, 562, 281, 0, 5693, 5694, 3, 1892, 946, + 0, 5694, 5695, 5, 80, 0, 0, 5695, 5697, 3, 566, 283, 0, 5696, 5698, 3, + 120, 60, 0, 5697, 5696, 1, 0, 0, 0, 5697, 5698, 1, 0, 0, 0, 5698, 5754, + 1, 0, 0, 0, 5699, 5700, 5, 195, 0, 0, 5700, 5701, 3, 562, 281, 0, 5701, + 5702, 5, 224, 0, 0, 5702, 5703, 5, 558, 0, 0, 5703, 5704, 3, 1892, 946, + 0, 5704, 5705, 5, 80, 0, 0, 5705, 5707, 3, 566, 283, 0, 5706, 5708, 3, + 120, 60, 0, 5707, 5706, 1, 0, 0, 0, 5707, 5708, 1, 0, 0, 0, 5708, 5754, + 1, 0, 0, 0, 5709, 5710, 5, 195, 0, 0, 5710, 5711, 5, 358, 0, 0, 5711, 5713, + 3, 570, 285, 0, 5712, 5714, 3, 120, 60, 0, 5713, 5712, 1, 0, 0, 0, 5713, + 5714, 1, 0, 0, 0, 5714, 5754, 1, 0, 0, 0, 5715, 5716, 5, 195, 0, 0, 5716, + 5717, 5, 358, 0, 0, 5717, 5718, 5, 224, 0, 0, 5718, 5719, 5, 558, 0, 0, + 5719, 5721, 3, 570, 285, 0, 5720, 5722, 3, 120, 60, 0, 5721, 5720, 1, 0, + 0, 0, 5721, 5722, 1, 0, 0, 0, 5722, 5754, 1, 0, 0, 0, 5723, 5724, 5, 195, + 0, 0, 5724, 5725, 5, 193, 0, 0, 5725, 5727, 3, 570, 285, 0, 5726, 5728, + 3, 120, 60, 0, 5727, 5726, 1, 0, 0, 0, 5727, 5728, 1, 0, 0, 0, 5728, 5754, + 1, 0, 0, 0, 5729, 5730, 5, 195, 0, 0, 5730, 5731, 5, 193, 0, 0, 5731, 5732, + 5, 224, 0, 0, 5732, 5733, 5, 558, 0, 0, 5733, 5735, 3, 570, 285, 0, 5734, + 5736, 3, 120, 60, 0, 5735, 5734, 1, 0, 0, 0, 5735, 5736, 1, 0, 0, 0, 5736, + 5754, 1, 0, 0, 0, 5737, 5738, 5, 195, 0, 0, 5738, 5739, 5, 230, 0, 0, 5739, + 5740, 5, 111, 0, 0, 5740, 5742, 3, 564, 282, 0, 5741, 5743, 3, 120, 60, + 0, 5742, 5741, 1, 0, 0, 0, 5742, 5743, 1, 0, 0, 0, 5743, 5754, 1, 0, 0, + 0, 5744, 5745, 5, 195, 0, 0, 5745, 5746, 5, 230, 0, 0, 5746, 5747, 5, 111, + 0, 0, 5747, 5748, 5, 224, 0, 0, 5748, 5749, 5, 558, 0, 0, 5749, 5751, 3, + 564, 282, 0, 5750, 5752, 3, 120, 60, 0, 5751, 5750, 1, 0, 0, 0, 5751, 5752, + 1, 0, 0, 0, 5752, 5754, 1, 0, 0, 0, 5753, 5663, 1, 0, 0, 0, 5753, 5671, + 1, 0, 0, 0, 5753, 5677, 1, 0, 0, 0, 5753, 5685, 1, 0, 0, 0, 5753, 5691, + 1, 0, 0, 0, 5753, 5699, 1, 0, 0, 0, 5753, 5709, 1, 0, 0, 0, 5753, 5715, + 1, 0, 0, 0, 5753, 5723, 1, 0, 0, 0, 5753, 5729, 1, 0, 0, 0, 5753, 5737, + 1, 0, 0, 0, 5753, 5744, 1, 0, 0, 0, 5754, 555, 1, 0, 0, 0, 5755, 5779, + 5, 93, 0, 0, 5756, 5779, 5, 326, 0, 0, 5757, 5779, 5, 374, 0, 0, 5758, + 5759, 5, 255, 0, 0, 5759, 5779, 5, 374, 0, 0, 5760, 5779, 5, 230, 0, 0, + 5761, 5762, 5, 63, 0, 0, 5762, 5779, 5, 93, 0, 0, 5763, 5779, 5, 110, 0, + 0, 5764, 5779, 5, 170, 0, 0, 5765, 5779, 5, 340, 0, 0, 5766, 5767, 5, 353, + 0, 0, 5767, 5768, 5, 323, 0, 0, 5768, 5779, 5, 280, 0, 0, 5769, 5770, 5, + 353, 0, 0, 5770, 5771, 5, 323, 0, 0, 5771, 5779, 5, 189, 0, 0, 5772, 5773, + 5, 353, 0, 0, 5773, 5774, 5, 323, 0, 0, 5774, 5779, 5, 351, 0, 0, 5775, + 5776, 5, 353, 0, 0, 5776, 5777, 5, 323, 0, 0, 5777, 5779, 5, 165, 0, 0, + 5778, 5755, 1, 0, 0, 0, 5778, 5756, 1, 0, 0, 0, 5778, 5757, 1, 0, 0, 0, + 5778, 5758, 1, 0, 0, 0, 5778, 5760, 1, 0, 0, 0, 5778, 5761, 1, 0, 0, 0, + 5778, 5763, 1, 0, 0, 0, 5778, 5764, 1, 0, 0, 0, 5778, 5765, 1, 0, 0, 0, + 5778, 5766, 1, 0, 0, 0, 5778, 5769, 1, 0, 0, 0, 5778, 5772, 1, 0, 0, 0, + 5778, 5775, 1, 0, 0, 0, 5779, 557, 1, 0, 0, 0, 5780, 5787, 3, 560, 280, + 0, 5781, 5787, 5, 321, 0, 0, 5782, 5787, 5, 179, 0, 0, 5783, 5787, 5, 316, + 0, 0, 5784, 5787, 5, 650, 0, 0, 5785, 5787, 5, 349, 0, 0, 5786, 5780, 1, + 0, 0, 0, 5786, 5781, 1, 0, 0, 0, 5786, 5782, 1, 0, 0, 0, 5786, 5783, 1, + 0, 0, 0, 5786, 5784, 1, 0, 0, 0, 5786, 5785, 1, 0, 0, 0, 5787, 559, 1, + 0, 0, 0, 5788, 5789, 5, 133, 0, 0, 5789, 5803, 5, 645, 0, 0, 5790, 5791, + 5, 202, 0, 0, 5791, 5803, 5, 355, 0, 0, 5792, 5803, 5, 208, 0, 0, 5793, + 5794, 5, 63, 0, 0, 5794, 5795, 5, 177, 0, 0, 5795, 5803, 5, 379, 0, 0, + 5796, 5798, 3, 350, 175, 0, 5797, 5796, 1, 0, 0, 0, 5797, 5798, 1, 0, 0, + 0, 5798, 5799, 1, 0, 0, 0, 5799, 5803, 5, 242, 0, 0, 5800, 5803, 5, 651, + 0, 0, 5801, 5803, 5, 329, 0, 0, 5802, 5788, 1, 0, 0, 0, 5802, 5790, 1, + 0, 0, 0, 5802, 5792, 1, 0, 0, 0, 5802, 5793, 1, 0, 0, 0, 5802, 5797, 1, + 0, 0, 0, 5802, 5800, 1, 0, 0, 0, 5802, 5801, 1, 0, 0, 0, 5803, 561, 1, + 0, 0, 0, 5804, 5805, 7, 35, 0, 0, 5805, 563, 1, 0, 0, 0, 5806, 5811, 3, + 566, 283, 0, 5807, 5808, 5, 6, 0, 0, 5808, 5810, 3, 566, 283, 0, 5809, + 5807, 1, 0, 0, 0, 5810, 5813, 1, 0, 0, 0, 5811, 5809, 1, 0, 0, 0, 5811, + 5812, 1, 0, 0, 0, 5812, 565, 1, 0, 0, 0, 5813, 5811, 1, 0, 0, 0, 5814, + 5816, 3, 1924, 962, 0, 5815, 5817, 3, 568, 284, 0, 5816, 5815, 1, 0, 0, + 0, 5816, 5817, 1, 0, 0, 0, 5817, 567, 1, 0, 0, 0, 5818, 5819, 5, 11, 0, + 0, 5819, 5821, 3, 1894, 947, 0, 5820, 5818, 1, 0, 0, 0, 5821, 5822, 1, + 0, 0, 0, 5822, 5820, 1, 0, 0, 0, 5822, 5823, 1, 0, 0, 0, 5823, 569, 1, + 0, 0, 0, 5824, 5829, 3, 1662, 831, 0, 5825, 5826, 5, 6, 0, 0, 5826, 5828, + 3, 1662, 831, 0, 5827, 5825, 1, 0, 0, 0, 5828, 5831, 1, 0, 0, 0, 5829, + 5827, 1, 0, 0, 0, 5829, 5830, 1, 0, 0, 0, 5830, 571, 1, 0, 0, 0, 5831, + 5829, 1, 0, 0, 0, 5832, 5834, 5, 356, 0, 0, 5833, 5835, 3, 1532, 766, 0, + 5834, 5833, 1, 0, 0, 0, 5834, 5835, 1, 0, 0, 0, 5835, 5836, 1, 0, 0, 0, + 5836, 5838, 3, 1620, 810, 0, 5837, 5839, 3, 574, 287, 0, 5838, 5837, 1, + 0, 0, 0, 5838, 5839, 1, 0, 0, 0, 5839, 5841, 1, 0, 0, 0, 5840, 5842, 3, + 120, 60, 0, 5841, 5840, 1, 0, 0, 0, 5841, 5842, 1, 0, 0, 0, 5842, 573, + 1, 0, 0, 0, 5843, 5844, 5, 169, 0, 0, 5844, 5848, 5, 223, 0, 0, 5845, 5846, + 5, 312, 0, 0, 5846, 5848, 5, 223, 0, 0, 5847, 5843, 1, 0, 0, 0, 5847, 5845, + 1, 0, 0, 0, 5848, 575, 1, 0, 0, 0, 5849, 5850, 5, 161, 0, 0, 5850, 5851, + 5, 80, 0, 0, 5851, 5852, 3, 556, 278, 0, 5852, 5853, 3, 566, 283, 0, 5853, + 5854, 5, 118, 0, 0, 5854, 5855, 3, 578, 289, 0, 5855, 5997, 1, 0, 0, 0, + 5856, 5857, 5, 161, 0, 0, 5857, 5858, 5, 80, 0, 0, 5858, 5859, 5, 44, 0, + 0, 5859, 5860, 3, 566, 283, 0, 5860, 5861, 5, 118, 0, 0, 5861, 5862, 3, + 578, 289, 0, 5862, 5997, 1, 0, 0, 0, 5863, 5864, 5, 161, 0, 0, 5864, 5865, + 5, 80, 0, 0, 5865, 5866, 3, 558, 279, 0, 5866, 5867, 3, 1892, 946, 0, 5867, + 5868, 5, 118, 0, 0, 5868, 5869, 3, 578, 289, 0, 5869, 5997, 1, 0, 0, 0, + 5870, 5871, 5, 161, 0, 0, 5871, 5872, 5, 80, 0, 0, 5872, 5873, 5, 358, + 0, 0, 5873, 5874, 3, 1662, 831, 0, 5874, 5875, 5, 118, 0, 0, 5875, 5876, + 3, 578, 289, 0, 5876, 5997, 1, 0, 0, 0, 5877, 5878, 5, 161, 0, 0, 5878, + 5879, 5, 80, 0, 0, 5879, 5880, 5, 193, 0, 0, 5880, 5881, 3, 1662, 831, + 0, 5881, 5882, 5, 118, 0, 0, 5882, 5883, 3, 578, 289, 0, 5883, 5997, 1, + 0, 0, 0, 5884, 5885, 5, 161, 0, 0, 5885, 5886, 5, 80, 0, 0, 5886, 5887, + 5, 138, 0, 0, 5887, 5888, 3, 868, 434, 0, 5888, 5889, 5, 118, 0, 0, 5889, + 5890, 3, 578, 289, 0, 5890, 5997, 1, 0, 0, 0, 5891, 5892, 5, 161, 0, 0, + 5892, 5893, 5, 80, 0, 0, 5893, 5894, 5, 215, 0, 0, 5894, 5895, 3, 844, + 422, 0, 5895, 5896, 5, 118, 0, 0, 5896, 5897, 3, 578, 289, 0, 5897, 5997, + 1, 0, 0, 0, 5898, 5899, 5, 161, 0, 0, 5899, 5900, 5, 80, 0, 0, 5900, 5901, + 5, 275, 0, 0, 5901, 5902, 3, 908, 454, 0, 5902, 5903, 5, 118, 0, 0, 5903, + 5904, 3, 578, 289, 0, 5904, 5997, 1, 0, 0, 0, 5905, 5906, 5, 161, 0, 0, + 5906, 5907, 5, 80, 0, 0, 5907, 5908, 5, 45, 0, 0, 5908, 5909, 3, 1892, + 946, 0, 5909, 5910, 5, 80, 0, 0, 5910, 5911, 3, 566, 283, 0, 5911, 5912, + 5, 118, 0, 0, 5912, 5913, 3, 578, 289, 0, 5913, 5997, 1, 0, 0, 0, 5914, + 5915, 5, 161, 0, 0, 5915, 5916, 5, 80, 0, 0, 5916, 5917, 5, 45, 0, 0, 5917, + 5918, 3, 1892, 946, 0, 5918, 5919, 5, 80, 0, 0, 5919, 5920, 5, 193, 0, + 0, 5920, 5921, 3, 566, 283, 0, 5921, 5922, 5, 118, 0, 0, 5922, 5923, 3, + 578, 289, 0, 5923, 5997, 1, 0, 0, 0, 5924, 5925, 5, 161, 0, 0, 5925, 5926, + 5, 80, 0, 0, 5926, 5927, 3, 562, 281, 0, 5927, 5928, 3, 1892, 946, 0, 5928, + 5929, 5, 80, 0, 0, 5929, 5930, 3, 566, 283, 0, 5930, 5931, 5, 118, 0, 0, + 5931, 5932, 3, 578, 289, 0, 5932, 5997, 1, 0, 0, 0, 5933, 5934, 5, 161, + 0, 0, 5934, 5935, 5, 80, 0, 0, 5935, 5936, 5, 294, 0, 0, 5936, 5937, 3, + 844, 422, 0, 5937, 5938, 5, 118, 0, 0, 5938, 5939, 3, 578, 289, 0, 5939, + 5997, 1, 0, 0, 0, 5940, 5941, 5, 161, 0, 0, 5941, 5942, 5, 80, 0, 0, 5942, + 5943, 5, 640, 0, 0, 5943, 5944, 3, 844, 422, 0, 5944, 5945, 5, 118, 0, + 0, 5945, 5946, 3, 578, 289, 0, 5946, 5997, 1, 0, 0, 0, 5947, 5948, 5, 161, + 0, 0, 5948, 5949, 5, 80, 0, 0, 5949, 5950, 5, 641, 0, 0, 5950, 5951, 5, + 62, 0, 0, 5951, 5952, 3, 1662, 831, 0, 5952, 5953, 5, 242, 0, 0, 5953, + 5954, 3, 1892, 946, 0, 5954, 5955, 5, 118, 0, 0, 5955, 5956, 3, 578, 289, + 0, 5956, 5997, 1, 0, 0, 0, 5957, 5958, 5, 161, 0, 0, 5958, 5959, 5, 80, + 0, 0, 5959, 5960, 5, 275, 0, 0, 5960, 5961, 5, 158, 0, 0, 5961, 5962, 3, + 566, 283, 0, 5962, 5963, 5, 101, 0, 0, 5963, 5964, 3, 1892, 946, 0, 5964, + 5965, 5, 118, 0, 0, 5965, 5966, 3, 578, 289, 0, 5966, 5997, 1, 0, 0, 0, + 5967, 5968, 5, 161, 0, 0, 5968, 5969, 5, 80, 0, 0, 5969, 5970, 5, 275, + 0, 0, 5970, 5971, 5, 210, 0, 0, 5971, 5972, 3, 566, 283, 0, 5972, 5973, + 5, 101, 0, 0, 5973, 5974, 3, 1892, 946, 0, 5974, 5975, 5, 118, 0, 0, 5975, + 5976, 3, 578, 289, 0, 5976, 5997, 1, 0, 0, 0, 5977, 5978, 5, 161, 0, 0, + 5978, 5979, 5, 80, 0, 0, 5979, 5980, 5, 243, 0, 0, 5980, 5981, 5, 271, + 0, 0, 5981, 5982, 3, 334, 167, 0, 5982, 5983, 5, 118, 0, 0, 5983, 5984, + 3, 578, 289, 0, 5984, 5997, 1, 0, 0, 0, 5985, 5986, 5, 161, 0, 0, 5986, + 5987, 5, 80, 0, 0, 5987, 5988, 5, 41, 0, 0, 5988, 5989, 5, 2, 0, 0, 5989, + 5990, 3, 1662, 831, 0, 5990, 5991, 5, 36, 0, 0, 5991, 5992, 3, 1662, 831, + 0, 5992, 5993, 5, 3, 0, 0, 5993, 5994, 5, 118, 0, 0, 5994, 5995, 3, 578, + 289, 0, 5995, 5997, 1, 0, 0, 0, 5996, 5849, 1, 0, 0, 0, 5996, 5856, 1, + 0, 0, 0, 5996, 5863, 1, 0, 0, 0, 5996, 5870, 1, 0, 0, 0, 5996, 5877, 1, + 0, 0, 0, 5996, 5884, 1, 0, 0, 0, 5996, 5891, 1, 0, 0, 0, 5996, 5898, 1, + 0, 0, 0, 5996, 5905, 1, 0, 0, 0, 5996, 5914, 1, 0, 0, 0, 5996, 5924, 1, + 0, 0, 0, 5996, 5933, 1, 0, 0, 0, 5996, 5940, 1, 0, 0, 0, 5996, 5947, 1, + 0, 0, 0, 5996, 5957, 1, 0, 0, 0, 5996, 5967, 1, 0, 0, 0, 5996, 5977, 1, + 0, 0, 0, 5996, 5985, 1, 0, 0, 0, 5997, 577, 1, 0, 0, 0, 5998, 6001, 3, + 1910, 955, 0, 5999, 6001, 5, 78, 0, 0, 6000, 5998, 1, 0, 0, 0, 6000, 5999, + 1, 0, 0, 0, 6001, 579, 1, 0, 0, 0, 6002, 6003, 5, 325, 0, 0, 6003, 6005, + 5, 241, 0, 0, 6004, 6006, 3, 582, 291, 0, 6005, 6004, 1, 0, 0, 0, 6005, + 6006, 1, 0, 0, 0, 6006, 6007, 1, 0, 0, 0, 6007, 6008, 5, 80, 0, 0, 6008, + 6009, 3, 556, 278, 0, 6009, 6010, 3, 566, 283, 0, 6010, 6011, 5, 118, 0, + 0, 6011, 6012, 3, 584, 292, 0, 6012, 6114, 1, 0, 0, 0, 6013, 6014, 5, 325, + 0, 0, 6014, 6016, 5, 241, 0, 0, 6015, 6017, 3, 582, 291, 0, 6016, 6015, + 1, 0, 0, 0, 6016, 6017, 1, 0, 0, 0, 6017, 6018, 1, 0, 0, 0, 6018, 6019, + 5, 80, 0, 0, 6019, 6020, 5, 44, 0, 0, 6020, 6021, 3, 566, 283, 0, 6021, + 6022, 5, 118, 0, 0, 6022, 6023, 3, 584, 292, 0, 6023, 6114, 1, 0, 0, 0, + 6024, 6025, 5, 325, 0, 0, 6025, 6027, 5, 241, 0, 0, 6026, 6028, 3, 582, + 291, 0, 6027, 6026, 1, 0, 0, 0, 6027, 6028, 1, 0, 0, 0, 6028, 6029, 1, + 0, 0, 0, 6029, 6030, 5, 80, 0, 0, 6030, 6031, 3, 558, 279, 0, 6031, 6032, + 3, 1892, 946, 0, 6032, 6033, 5, 118, 0, 0, 6033, 6034, 3, 584, 292, 0, + 6034, 6114, 1, 0, 0, 0, 6035, 6036, 5, 325, 0, 0, 6036, 6038, 5, 241, 0, + 0, 6037, 6039, 3, 582, 291, 0, 6038, 6037, 1, 0, 0, 0, 6038, 6039, 1, 0, + 0, 0, 6039, 6040, 1, 0, 0, 0, 6040, 6041, 5, 80, 0, 0, 6041, 6042, 5, 358, + 0, 0, 6042, 6043, 3, 1662, 831, 0, 6043, 6044, 5, 118, 0, 0, 6044, 6045, + 3, 584, 292, 0, 6045, 6114, 1, 0, 0, 0, 6046, 6047, 5, 325, 0, 0, 6047, + 6049, 5, 241, 0, 0, 6048, 6050, 3, 582, 291, 0, 6049, 6048, 1, 0, 0, 0, + 6049, 6050, 1, 0, 0, 0, 6050, 6051, 1, 0, 0, 0, 6051, 6052, 5, 80, 0, 0, + 6052, 6053, 5, 193, 0, 0, 6053, 6054, 3, 1662, 831, 0, 6054, 6055, 5, 118, + 0, 0, 6055, 6056, 3, 584, 292, 0, 6056, 6114, 1, 0, 0, 0, 6057, 6058, 5, + 325, 0, 0, 6058, 6060, 5, 241, 0, 0, 6059, 6061, 3, 582, 291, 0, 6060, + 6059, 1, 0, 0, 0, 6060, 6061, 1, 0, 0, 0, 6061, 6062, 1, 0, 0, 0, 6062, + 6063, 5, 80, 0, 0, 6063, 6064, 5, 138, 0, 0, 6064, 6065, 3, 868, 434, 0, + 6065, 6066, 5, 118, 0, 0, 6066, 6067, 3, 584, 292, 0, 6067, 6114, 1, 0, + 0, 0, 6068, 6069, 5, 325, 0, 0, 6069, 6071, 5, 241, 0, 0, 6070, 6072, 3, + 582, 291, 0, 6071, 6070, 1, 0, 0, 0, 6071, 6072, 1, 0, 0, 0, 6072, 6073, + 1, 0, 0, 0, 6073, 6074, 5, 80, 0, 0, 6074, 6075, 5, 215, 0, 0, 6075, 6076, + 3, 844, 422, 0, 6076, 6077, 5, 118, 0, 0, 6077, 6078, 3, 584, 292, 0, 6078, + 6114, 1, 0, 0, 0, 6079, 6080, 5, 325, 0, 0, 6080, 6082, 5, 241, 0, 0, 6081, + 6083, 3, 582, 291, 0, 6082, 6081, 1, 0, 0, 0, 6082, 6083, 1, 0, 0, 0, 6083, + 6084, 1, 0, 0, 0, 6084, 6085, 5, 80, 0, 0, 6085, 6086, 5, 243, 0, 0, 6086, + 6087, 5, 271, 0, 0, 6087, 6088, 3, 334, 167, 0, 6088, 6089, 5, 118, 0, + 0, 6089, 6090, 3, 584, 292, 0, 6090, 6114, 1, 0, 0, 0, 6091, 6092, 5, 325, + 0, 0, 6092, 6094, 5, 241, 0, 0, 6093, 6095, 3, 582, 291, 0, 6094, 6093, + 1, 0, 0, 0, 6094, 6095, 1, 0, 0, 0, 6095, 6096, 1, 0, 0, 0, 6096, 6097, + 5, 80, 0, 0, 6097, 6098, 5, 294, 0, 0, 6098, 6099, 3, 844, 422, 0, 6099, + 6100, 5, 118, 0, 0, 6100, 6101, 3, 584, 292, 0, 6101, 6114, 1, 0, 0, 0, + 6102, 6103, 5, 325, 0, 0, 6103, 6105, 5, 241, 0, 0, 6104, 6106, 3, 582, + 291, 0, 6105, 6104, 1, 0, 0, 0, 6105, 6106, 1, 0, 0, 0, 6106, 6107, 1, + 0, 0, 0, 6107, 6108, 5, 80, 0, 0, 6108, 6109, 5, 640, 0, 0, 6109, 6110, + 3, 844, 422, 0, 6110, 6111, 5, 118, 0, 0, 6111, 6112, 3, 584, 292, 0, 6112, + 6114, 1, 0, 0, 0, 6113, 6002, 1, 0, 0, 0, 6113, 6013, 1, 0, 0, 0, 6113, + 6024, 1, 0, 0, 0, 6113, 6035, 1, 0, 0, 0, 6113, 6046, 1, 0, 0, 0, 6113, + 6057, 1, 0, 0, 0, 6113, 6068, 1, 0, 0, 0, 6113, 6079, 1, 0, 0, 0, 6113, + 6091, 1, 0, 0, 0, 6113, 6102, 1, 0, 0, 0, 6114, 581, 1, 0, 0, 0, 6115, + 6116, 5, 62, 0, 0, 6116, 6117, 3, 82, 41, 0, 6117, 583, 1, 0, 0, 0, 6118, + 6121, 3, 1910, 955, 0, 6119, 6121, 5, 78, 0, 0, 6120, 6118, 1, 0, 0, 0, + 6120, 6119, 1, 0, 0, 0, 6121, 585, 1, 0, 0, 0, 6122, 6123, 5, 61, 0, 0, + 6123, 6124, 3, 588, 294, 0, 6124, 587, 1, 0, 0, 0, 6125, 6126, 5, 265, + 0, 0, 6126, 6127, 5, 64, 0, 0, 6127, 6141, 3, 1490, 745, 0, 6128, 6129, + 5, 30, 0, 0, 6129, 6130, 5, 64, 0, 0, 6130, 6141, 3, 1490, 745, 0, 6131, + 6134, 5, 214, 0, 0, 6132, 6135, 3, 1916, 958, 0, 6133, 6135, 5, 30, 0, + 0, 6134, 6132, 1, 0, 0, 0, 6134, 6133, 1, 0, 0, 0, 6134, 6135, 1, 0, 0, + 0, 6135, 6136, 1, 0, 0, 0, 6136, 6137, 5, 64, 0, 0, 6137, 6141, 3, 1490, + 745, 0, 6138, 6139, 5, 64, 0, 0, 6139, 6141, 3, 1490, 745, 0, 6140, 6125, + 1, 0, 0, 0, 6140, 6128, 1, 0, 0, 0, 6140, 6131, 1, 0, 0, 0, 6140, 6138, + 1, 0, 0, 0, 6141, 589, 1, 0, 0, 0, 6142, 6153, 3, 668, 334, 0, 6143, 6153, + 3, 658, 329, 0, 6144, 6153, 3, 650, 325, 0, 6145, 6153, 3, 630, 315, 0, + 6146, 6153, 3, 628, 314, 0, 6147, 6153, 3, 610, 305, 0, 6148, 6153, 3, + 596, 298, 0, 6149, 6153, 3, 598, 299, 0, 6150, 6153, 3, 594, 297, 0, 6151, + 6153, 3, 592, 296, 0, 6152, 6142, 1, 0, 0, 0, 6152, 6143, 1, 0, 0, 0, 6152, + 6144, 1, 0, 0, 0, 6152, 6145, 1, 0, 0, 0, 6152, 6146, 1, 0, 0, 0, 6152, + 6147, 1, 0, 0, 0, 6152, 6148, 1, 0, 0, 0, 6152, 6149, 1, 0, 0, 0, 6152, + 6150, 1, 0, 0, 0, 6152, 6151, 1, 0, 0, 0, 6153, 591, 1, 0, 0, 0, 6154, + 6155, 5, 65, 0, 0, 6155, 6156, 5, 89, 0, 0, 6156, 6158, 5, 80, 0, 0, 6157, + 6159, 5, 93, 0, 0, 6158, 6157, 1, 0, 0, 0, 6158, 6159, 1, 0, 0, 0, 6159, + 6160, 1, 0, 0, 0, 6160, 6161, 3, 1886, 943, 0, 6161, 6162, 5, 95, 0, 0, + 6162, 6163, 5, 413, 0, 0, 6163, 6164, 5, 643, 0, 0, 6164, 6165, 3, 246, + 123, 0, 6165, 593, 1, 0, 0, 0, 6166, 6167, 5, 65, 0, 0, 6167, 6168, 7, + 36, 0, 0, 6168, 6169, 5, 413, 0, 0, 6169, 6170, 5, 95, 0, 0, 6170, 6171, + 5, 316, 0, 0, 6171, 6172, 3, 1920, 960, 0, 6172, 595, 1, 0, 0, 0, 6173, + 6174, 5, 65, 0, 0, 6174, 6175, 5, 46, 0, 0, 6175, 6176, 5, 417, 0, 0, 6176, + 6177, 5, 95, 0, 0, 6177, 6187, 3, 716, 358, 0, 6178, 6179, 5, 65, 0, 0, + 6179, 6180, 3, 688, 344, 0, 6180, 6181, 5, 80, 0, 0, 6181, 6182, 5, 417, + 0, 0, 6182, 6183, 3, 246, 123, 0, 6183, 6184, 5, 95, 0, 0, 6184, 6185, + 3, 716, 358, 0, 6185, 6187, 1, 0, 0, 0, 6186, 6173, 1, 0, 0, 0, 6186, 6178, + 1, 0, 0, 0, 6187, 597, 1, 0, 0, 0, 6188, 6189, 5, 65, 0, 0, 6189, 6190, + 5, 316, 0, 0, 6190, 6196, 3, 1920, 960, 0, 6191, 6192, 5, 6, 0, 0, 6192, + 6193, 5, 316, 0, 0, 6193, 6195, 3, 1920, 960, 0, 6194, 6191, 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, 95, 0, 0, + 6200, 6201, 3, 600, 300, 0, 6201, 6209, 1, 0, 0, 0, 6202, 6203, 5, 65, + 0, 0, 6203, 6204, 3, 604, 302, 0, 6204, 6205, 5, 95, 0, 0, 6205, 6206, + 5, 316, 0, 0, 6206, 6207, 3, 1922, 961, 0, 6207, 6209, 1, 0, 0, 0, 6208, + 6188, 1, 0, 0, 0, 6208, 6202, 1, 0, 0, 0, 6209, 599, 1, 0, 0, 0, 6210, + 6215, 3, 602, 301, 0, 6211, 6212, 5, 6, 0, 0, 6212, 6214, 3, 602, 301, + 0, 6213, 6211, 1, 0, 0, 0, 6214, 6217, 1, 0, 0, 0, 6215, 6213, 1, 0, 0, + 0, 6215, 6216, 1, 0, 0, 0, 6216, 601, 1, 0, 0, 0, 6217, 6215, 1, 0, 0, + 0, 6218, 6220, 3, 1920, 960, 0, 6219, 6221, 3, 608, 304, 0, 6220, 6219, + 1, 0, 0, 0, 6220, 6221, 1, 0, 0, 0, 6221, 6225, 1, 0, 0, 0, 6222, 6223, + 5, 316, 0, 0, 6223, 6225, 3, 1920, 960, 0, 6224, 6218, 1, 0, 0, 0, 6224, + 6222, 1, 0, 0, 0, 6225, 603, 1, 0, 0, 0, 6226, 6231, 3, 606, 303, 0, 6227, + 6228, 5, 6, 0, 0, 6228, 6230, 3, 606, 303, 0, 6229, 6227, 1, 0, 0, 0, 6230, + 6233, 1, 0, 0, 0, 6231, 6229, 1, 0, 0, 0, 6231, 6232, 1, 0, 0, 0, 6232, + 6236, 1, 0, 0, 0, 6233, 6231, 1, 0, 0, 0, 6234, 6236, 3, 714, 357, 0, 6235, + 6226, 1, 0, 0, 0, 6235, 6234, 1, 0, 0, 0, 6236, 605, 1, 0, 0, 0, 6237, + 6238, 7, 37, 0, 0, 6238, 6294, 5, 100, 0, 0, 6239, 6240, 7, 38, 0, 0, 6240, + 6294, 5, 321, 0, 0, 6241, 6242, 5, 140, 0, 0, 6242, 6243, 5, 53, 0, 0, + 6243, 6294, 5, 292, 0, 0, 6244, 6248, 5, 133, 0, 0, 6245, 6249, 5, 154, + 0, 0, 6246, 6247, 5, 347, 0, 0, 6247, 6249, 5, 93, 0, 0, 6248, 6245, 1, + 0, 0, 0, 6248, 6246, 1, 0, 0, 0, 6249, 6294, 1, 0, 0, 0, 6250, 6251, 7, + 37, 0, 0, 6251, 6294, 5, 93, 0, 0, 6252, 6253, 5, 46, 0, 0, 6253, 6254, + 5, 82, 0, 0, 6254, 6258, 5, 309, 0, 0, 6255, 6259, 5, 215, 0, 0, 6256, + 6257, 5, 209, 0, 0, 6257, 6259, 5, 215, 0, 0, 6258, 6255, 1, 0, 0, 0, 6258, + 6256, 1, 0, 0, 0, 6259, 6294, 1, 0, 0, 0, 6260, 6261, 5, 195, 0, 0, 6261, + 6294, 5, 215, 0, 0, 6262, 6263, 5, 46, 0, 0, 6263, 6264, 5, 82, 0, 0, 6264, + 6267, 5, 309, 0, 0, 6265, 6267, 5, 195, 0, 0, 6266, 6262, 1, 0, 0, 0, 6266, + 6265, 1, 0, 0, 0, 6267, 6268, 1, 0, 0, 0, 6268, 6294, 5, 294, 0, 0, 6269, + 6270, 5, 46, 0, 0, 6270, 6271, 5, 82, 0, 0, 6271, 6274, 5, 309, 0, 0, 6272, + 6274, 5, 195, 0, 0, 6273, 6269, 1, 0, 0, 0, 6273, 6272, 1, 0, 0, 0, 6274, + 6275, 1, 0, 0, 0, 6275, 6294, 5, 374, 0, 0, 6276, 6277, 7, 38, 0, 0, 6277, + 6294, 5, 417, 0, 0, 6278, 6279, 7, 37, 0, 0, 6279, 6294, 5, 392, 0, 0, + 6280, 6281, 7, 38, 0, 0, 6281, 6294, 5, 462, 0, 0, 6282, 6283, 7, 38, 0, + 0, 6283, 6294, 5, 316, 0, 0, 6284, 6285, 5, 356, 0, 0, 6285, 6294, 5, 93, + 0, 0, 6286, 6294, 5, 368, 0, 0, 6287, 6294, 5, 32, 0, 0, 6288, 6294, 5, + 458, 0, 0, 6289, 6290, 7, 36, 0, 0, 6290, 6294, 5, 413, 0, 0, 6291, 6292, + 5, 207, 0, 0, 6292, 6294, 5, 412, 0, 0, 6293, 6237, 1, 0, 0, 0, 6293, 6239, + 1, 0, 0, 0, 6293, 6241, 1, 0, 0, 0, 6293, 6244, 1, 0, 0, 0, 6293, 6250, + 1, 0, 0, 0, 6293, 6252, 1, 0, 0, 0, 6293, 6260, 1, 0, 0, 0, 6293, 6266, + 1, 0, 0, 0, 6293, 6273, 1, 0, 0, 0, 6293, 6276, 1, 0, 0, 0, 6293, 6278, + 1, 0, 0, 0, 6293, 6280, 1, 0, 0, 0, 6293, 6282, 1, 0, 0, 0, 6293, 6284, + 1, 0, 0, 0, 6293, 6286, 1, 0, 0, 0, 6293, 6287, 1, 0, 0, 0, 6293, 6288, + 1, 0, 0, 0, 6293, 6289, 1, 0, 0, 0, 6293, 6291, 1, 0, 0, 0, 6294, 607, + 1, 0, 0, 0, 6295, 6296, 5, 106, 0, 0, 6296, 6297, 5, 136, 0, 0, 6297, 6298, + 5, 276, 0, 0, 6298, 609, 1, 0, 0, 0, 6299, 6306, 3, 612, 306, 0, 6300, + 6306, 3, 614, 307, 0, 6301, 6306, 3, 616, 308, 0, 6302, 6306, 3, 618, 309, + 0, 6303, 6306, 3, 620, 310, 0, 6304, 6306, 3, 622, 311, 0, 6305, 6299, + 1, 0, 0, 0, 6305, 6300, 1, 0, 0, 0, 6305, 6301, 1, 0, 0, 0, 6305, 6302, + 1, 0, 0, 0, 6305, 6303, 1, 0, 0, 0, 6305, 6304, 1, 0, 0, 0, 6306, 611, + 1, 0, 0, 0, 6307, 6308, 5, 65, 0, 0, 6308, 6309, 3, 698, 349, 0, 6309, + 6310, 5, 62, 0, 0, 6310, 6311, 5, 655, 0, 0, 6311, 6312, 5, 68, 0, 0, 6312, + 6313, 5, 179, 0, 0, 6313, 6314, 3, 1924, 962, 0, 6314, 6315, 5, 95, 0, + 0, 6315, 6316, 3, 624, 312, 0, 6316, 613, 1, 0, 0, 0, 6317, 6318, 5, 65, + 0, 0, 6318, 6319, 3, 724, 362, 0, 6319, 6320, 5, 62, 0, 0, 6320, 6321, + 5, 348, 0, 0, 6321, 6330, 5, 68, 0, 0, 6322, 6323, 5, 321, 0, 0, 6323, + 6326, 3, 1924, 962, 0, 6324, 6325, 5, 179, 0, 0, 6325, 6327, 3, 1924, 962, + 0, 6326, 6324, 1, 0, 0, 0, 6326, 6327, 1, 0, 0, 0, 6327, 6331, 1, 0, 0, + 0, 6328, 6329, 5, 179, 0, 0, 6329, 6331, 3, 1924, 962, 0, 6330, 6322, 1, + 0, 0, 0, 6330, 6328, 1, 0, 0, 0, 6331, 6332, 1, 0, 0, 0, 6332, 6333, 5, + 95, 0, 0, 6333, 6334, 3, 624, 312, 0, 6334, 615, 1, 0, 0, 0, 6335, 6336, + 5, 65, 0, 0, 6336, 6337, 3, 688, 344, 0, 6337, 6338, 5, 62, 0, 0, 6338, + 6339, 5, 216, 0, 0, 6339, 6348, 5, 68, 0, 0, 6340, 6341, 5, 321, 0, 0, + 6341, 6344, 3, 1924, 962, 0, 6342, 6343, 5, 179, 0, 0, 6343, 6345, 3, 1924, + 962, 0, 6344, 6342, 1, 0, 0, 0, 6344, 6345, 1, 0, 0, 0, 6345, 6349, 1, + 0, 0, 0, 6346, 6347, 5, 179, 0, 0, 6347, 6349, 3, 1924, 962, 0, 6348, 6340, + 1, 0, 0, 0, 6348, 6346, 1, 0, 0, 0, 6349, 6350, 1, 0, 0, 0, 6350, 6351, + 5, 95, 0, 0, 6351, 6352, 3, 624, 312, 0, 6352, 617, 1, 0, 0, 0, 6353, 6354, + 5, 65, 0, 0, 6354, 6355, 3, 684, 342, 0, 6355, 6356, 5, 62, 0, 0, 6356, + 6357, 5, 656, 0, 0, 6357, 6366, 5, 68, 0, 0, 6358, 6359, 5, 321, 0, 0, + 6359, 6362, 3, 1924, 962, 0, 6360, 6361, 5, 179, 0, 0, 6361, 6363, 3, 1924, + 962, 0, 6362, 6360, 1, 0, 0, 0, 6362, 6363, 1, 0, 0, 0, 6363, 6367, 1, + 0, 0, 0, 6364, 6365, 5, 179, 0, 0, 6365, 6367, 3, 1924, 962, 0, 6366, 6358, + 1, 0, 0, 0, 6366, 6364, 1, 0, 0, 0, 6367, 6368, 1, 0, 0, 0, 6368, 6369, + 5, 95, 0, 0, 6369, 6370, 3, 624, 312, 0, 6370, 619, 1, 0, 0, 0, 6371, 6372, + 5, 65, 0, 0, 6372, 6373, 3, 678, 339, 0, 6373, 6374, 5, 62, 0, 0, 6374, + 6375, 5, 630, 0, 0, 6375, 6376, 5, 68, 0, 0, 6376, 6377, 5, 179, 0, 0, + 6377, 6378, 3, 1924, 962, 0, 6378, 6379, 5, 95, 0, 0, 6379, 6380, 3, 624, + 312, 0, 6380, 621, 1, 0, 0, 0, 6381, 6382, 5, 65, 0, 0, 6382, 6383, 3, + 670, 335, 0, 6383, 6384, 5, 62, 0, 0, 6384, 6385, 5, 171, 0, 0, 6385, 6386, + 5, 632, 0, 0, 6386, 6395, 5, 68, 0, 0, 6387, 6388, 5, 321, 0, 0, 6388, + 6391, 3, 1924, 962, 0, 6389, 6390, 5, 179, 0, 0, 6390, 6392, 3, 1924, 962, + 0, 6391, 6389, 1, 0, 0, 0, 6391, 6392, 1, 0, 0, 0, 6392, 6396, 1, 0, 0, + 0, 6393, 6394, 5, 179, 0, 0, 6394, 6396, 3, 1924, 962, 0, 6395, 6387, 1, + 0, 0, 0, 6395, 6393, 1, 0, 0, 0, 6396, 6397, 1, 0, 0, 0, 6397, 6398, 5, + 95, 0, 0, 6398, 6399, 3, 624, 312, 0, 6399, 623, 1, 0, 0, 0, 6400, 6405, + 3, 626, 313, 0, 6401, 6402, 5, 6, 0, 0, 6402, 6404, 3, 626, 313, 0, 6403, + 6401, 1, 0, 0, 0, 6404, 6407, 1, 0, 0, 0, 6405, 6403, 1, 0, 0, 0, 6405, + 6406, 1, 0, 0, 0, 6406, 625, 1, 0, 0, 0, 6407, 6405, 1, 0, 0, 0, 6408, + 6410, 3, 1920, 960, 0, 6409, 6411, 3, 720, 360, 0, 6410, 6409, 1, 0, 0, + 0, 6410, 6411, 1, 0, 0, 0, 6411, 6415, 1, 0, 0, 0, 6412, 6413, 5, 316, + 0, 0, 6413, 6415, 3, 1920, 960, 0, 6414, 6408, 1, 0, 0, 0, 6414, 6412, + 1, 0, 0, 0, 6415, 627, 1, 0, 0, 0, 6416, 6417, 5, 65, 0, 0, 6417, 6418, + 7, 39, 0, 0, 6418, 6419, 5, 80, 0, 0, 6419, 6420, 5, 392, 0, 0, 6420, 6421, + 3, 1924, 962, 0, 6421, 6422, 5, 95, 0, 0, 6422, 6423, 3, 716, 358, 0, 6423, + 6454, 1, 0, 0, 0, 6424, 6425, 5, 65, 0, 0, 6425, 6426, 5, 628, 0, 0, 6426, + 6427, 5, 80, 0, 0, 6427, 6428, 5, 392, 0, 0, 6428, 6429, 3, 1924, 962, + 0, 6429, 6439, 5, 95, 0, 0, 6430, 6431, 5, 467, 0, 0, 6431, 6440, 3, 1910, + 955, 0, 6432, 6433, 5, 466, 0, 0, 6433, 6437, 3, 1910, 955, 0, 6434, 6435, + 5, 633, 0, 0, 6435, 6436, 5, 177, 0, 0, 6436, 6438, 5, 154, 0, 0, 6437, + 6434, 1, 0, 0, 0, 6437, 6438, 1, 0, 0, 0, 6438, 6440, 1, 0, 0, 0, 6439, + 6430, 1, 0, 0, 0, 6439, 6432, 1, 0, 0, 0, 6440, 6454, 1, 0, 0, 0, 6441, + 6442, 5, 65, 0, 0, 6442, 6443, 5, 628, 0, 0, 6443, 6448, 5, 80, 0, 0, 6444, + 6445, 5, 179, 0, 0, 6445, 6449, 3, 246, 123, 0, 6446, 6447, 5, 321, 0, + 0, 6447, 6449, 3, 1924, 962, 0, 6448, 6444, 1, 0, 0, 0, 6448, 6446, 1, + 0, 0, 0, 6449, 6450, 1, 0, 0, 0, 6450, 6451, 5, 95, 0, 0, 6451, 6452, 3, + 716, 358, 0, 6452, 6454, 1, 0, 0, 0, 6453, 6416, 1, 0, 0, 0, 6453, 6424, + 1, 0, 0, 0, 6453, 6441, 1, 0, 0, 0, 6454, 629, 1, 0, 0, 0, 6455, 6459, + 3, 644, 322, 0, 6456, 6459, 3, 638, 319, 0, 6457, 6459, 3, 632, 316, 0, + 6458, 6455, 1, 0, 0, 0, 6458, 6456, 1, 0, 0, 0, 6458, 6457, 1, 0, 0, 0, + 6459, 631, 1, 0, 0, 0, 6460, 6461, 5, 65, 0, 0, 6461, 6462, 3, 634, 317, + 0, 6462, 6463, 5, 80, 0, 0, 6463, 6464, 5, 209, 0, 0, 6464, 6465, 5, 321, + 0, 0, 6465, 6466, 3, 246, 123, 0, 6466, 6467, 5, 95, 0, 0, 6467, 6469, + 3, 646, 323, 0, 6468, 6470, 3, 720, 360, 0, 6469, 6468, 1, 0, 0, 0, 6469, + 6470, 1, 0, 0, 0, 6470, 633, 1, 0, 0, 0, 6471, 6476, 3, 636, 318, 0, 6472, + 6473, 5, 6, 0, 0, 6473, 6475, 3, 636, 318, 0, 6474, 6472, 1, 0, 0, 0, 6475, + 6478, 1, 0, 0, 0, 6476, 6474, 1, 0, 0, 0, 6476, 6477, 1, 0, 0, 0, 6477, + 6481, 1, 0, 0, 0, 6478, 6476, 1, 0, 0, 0, 6479, 6481, 3, 714, 357, 0, 6480, + 6471, 1, 0, 0, 0, 6480, 6479, 1, 0, 0, 0, 6481, 635, 1, 0, 0, 0, 6482, + 6483, 7, 37, 0, 0, 6483, 637, 1, 0, 0, 0, 6484, 6485, 5, 65, 0, 0, 6485, + 6486, 3, 642, 321, 0, 6486, 6487, 5, 80, 0, 0, 6487, 6488, 5, 209, 0, 0, + 6488, 6489, 5, 93, 0, 0, 6489, 6490, 3, 1886, 943, 0, 6490, 6491, 5, 95, + 0, 0, 6491, 6493, 3, 646, 323, 0, 6492, 6494, 3, 720, 360, 0, 6493, 6492, + 1, 0, 0, 0, 6493, 6494, 1, 0, 0, 0, 6494, 639, 1, 0, 0, 0, 6495, 6502, + 5, 89, 0, 0, 6496, 6502, 5, 140, 0, 0, 6497, 6502, 5, 195, 0, 0, 6498, + 6502, 5, 186, 0, 0, 6499, 6502, 5, 236, 0, 0, 6500, 6502, 3, 714, 357, + 0, 6501, 6495, 1, 0, 0, 0, 6501, 6496, 1, 0, 0, 0, 6501, 6497, 1, 0, 0, + 0, 6501, 6498, 1, 0, 0, 0, 6501, 6499, 1, 0, 0, 0, 6501, 6500, 1, 0, 0, + 0, 6502, 641, 1, 0, 0, 0, 6503, 6508, 3, 640, 320, 0, 6504, 6505, 5, 6, + 0, 0, 6505, 6507, 3, 640, 320, 0, 6506, 6504, 1, 0, 0, 0, 6507, 6510, 1, + 0, 0, 0, 6508, 6506, 1, 0, 0, 0, 6508, 6509, 1, 0, 0, 0, 6509, 643, 1, + 0, 0, 0, 6510, 6508, 1, 0, 0, 0, 6511, 6514, 5, 65, 0, 0, 6512, 6515, 5, + 89, 0, 0, 6513, 6515, 3, 714, 357, 0, 6514, 6512, 1, 0, 0, 0, 6514, 6513, + 1, 0, 0, 0, 6515, 6516, 1, 0, 0, 0, 6516, 6517, 5, 2, 0, 0, 6517, 6518, + 3, 246, 123, 0, 6518, 6519, 5, 3, 0, 0, 6519, 6520, 5, 80, 0, 0, 6520, + 6521, 5, 209, 0, 0, 6521, 6522, 5, 93, 0, 0, 6522, 6523, 3, 1888, 944, + 0, 6523, 6524, 5, 95, 0, 0, 6524, 6526, 3, 646, 323, 0, 6525, 6527, 3, + 720, 360, 0, 6526, 6525, 1, 0, 0, 0, 6526, 6527, 1, 0, 0, 0, 6527, 645, + 1, 0, 0, 0, 6528, 6531, 3, 648, 324, 0, 6529, 6531, 5, 86, 0, 0, 6530, + 6528, 1, 0, 0, 0, 6530, 6529, 1, 0, 0, 0, 6531, 647, 1, 0, 0, 0, 6532, + 6533, 5, 396, 0, 0, 6533, 6539, 3, 1092, 546, 0, 6534, 6535, 5, 6, 0, 0, + 6535, 6536, 5, 396, 0, 0, 6536, 6538, 3, 1092, 546, 0, 6537, 6534, 1, 0, + 0, 0, 6538, 6541, 1, 0, 0, 0, 6539, 6537, 1, 0, 0, 0, 6539, 6540, 1, 0, + 0, 0, 6540, 649, 1, 0, 0, 0, 6541, 6539, 1, 0, 0, 0, 6542, 6543, 5, 65, + 0, 0, 6543, 6544, 5, 634, 0, 0, 6544, 6545, 3, 656, 328, 0, 6545, 6546, + 5, 95, 0, 0, 6546, 6547, 3, 716, 358, 0, 6547, 6548, 5, 62, 0, 0, 6548, + 6549, 3, 652, 326, 0, 6549, 651, 1, 0, 0, 0, 6550, 6555, 3, 654, 327, 0, + 6551, 6552, 5, 6, 0, 0, 6552, 6554, 3, 654, 327, 0, 6553, 6551, 1, 0, 0, + 0, 6554, 6557, 1, 0, 0, 0, 6555, 6553, 1, 0, 0, 0, 6555, 6556, 1, 0, 0, + 0, 6556, 653, 1, 0, 0, 0, 6557, 6555, 1, 0, 0, 0, 6558, 6566, 5, 30, 0, + 0, 6559, 6566, 5, 171, 0, 0, 6560, 6566, 5, 444, 0, 0, 6561, 6562, 5, 209, + 0, 0, 6562, 6566, 5, 215, 0, 0, 6563, 6564, 5, 46, 0, 0, 6564, 6566, 5, + 417, 0, 0, 6565, 6558, 1, 0, 0, 0, 6565, 6559, 1, 0, 0, 0, 6565, 6560, + 1, 0, 0, 0, 6565, 6561, 1, 0, 0, 0, 6565, 6563, 1, 0, 0, 0, 6566, 655, + 1, 0, 0, 0, 6567, 6572, 3, 1910, 955, 0, 6568, 6569, 5, 6, 0, 0, 6569, + 6571, 3, 1910, 955, 0, 6570, 6568, 1, 0, 0, 0, 6571, 6574, 1, 0, 0, 0, + 6572, 6570, 1, 0, 0, 0, 6572, 6573, 1, 0, 0, 0, 6573, 6578, 1, 0, 0, 0, + 6574, 6572, 1, 0, 0, 0, 6575, 6578, 5, 53, 0, 0, 6576, 6578, 5, 30, 0, + 0, 6577, 6567, 1, 0, 0, 0, 6577, 6575, 1, 0, 0, 0, 6577, 6576, 1, 0, 0, + 0, 6578, 657, 1, 0, 0, 0, 6579, 6580, 5, 65, 0, 0, 6580, 6581, 3, 662, + 331, 0, 6581, 6582, 5, 80, 0, 0, 6582, 6583, 3, 660, 330, 0, 6583, 6584, + 5, 95, 0, 0, 6584, 6585, 3, 716, 358, 0, 6585, 659, 1, 0, 0, 0, 6586, 6588, + 5, 93, 0, 0, 6587, 6586, 1, 0, 0, 0, 6587, 6588, 1, 0, 0, 0, 6588, 6589, + 1, 0, 0, 0, 6589, 6590, 3, 1886, 943, 0, 6590, 661, 1, 0, 0, 0, 6591, 6596, + 3, 666, 333, 0, 6592, 6593, 5, 6, 0, 0, 6593, 6595, 3, 666, 333, 0, 6594, + 6592, 1, 0, 0, 0, 6595, 6598, 1, 0, 0, 0, 6596, 6594, 1, 0, 0, 0, 6596, + 6597, 1, 0, 0, 0, 6597, 6608, 1, 0, 0, 0, 6598, 6596, 1, 0, 0, 0, 6599, + 6604, 3, 664, 332, 0, 6600, 6601, 5, 6, 0, 0, 6601, 6603, 3, 664, 332, + 0, 6602, 6600, 1, 0, 0, 0, 6603, 6606, 1, 0, 0, 0, 6604, 6602, 1, 0, 0, + 0, 6604, 6605, 1, 0, 0, 0, 6605, 6608, 1, 0, 0, 0, 6606, 6604, 1, 0, 0, + 0, 6607, 6591, 1, 0, 0, 0, 6607, 6599, 1, 0, 0, 0, 6608, 663, 1, 0, 0, + 0, 6609, 6611, 5, 30, 0, 0, 6610, 6612, 5, 292, 0, 0, 6611, 6610, 1, 0, + 0, 0, 6611, 6612, 1, 0, 0, 0, 6612, 6613, 1, 0, 0, 0, 6613, 6615, 5, 2, + 0, 0, 6614, 6616, 3, 246, 123, 0, 6615, 6614, 1, 0, 0, 0, 6615, 6616, 1, + 0, 0, 0, 6616, 6617, 1, 0, 0, 0, 6617, 6618, 5, 3, 0, 0, 6618, 665, 1, + 0, 0, 0, 6619, 6620, 7, 40, 0, 0, 6620, 6622, 5, 2, 0, 0, 6621, 6623, 3, + 246, 123, 0, 6622, 6621, 1, 0, 0, 0, 6622, 6623, 1, 0, 0, 0, 6623, 6624, + 1, 0, 0, 0, 6624, 6625, 5, 3, 0, 0, 6625, 667, 1, 0, 0, 0, 6626, 6627, + 5, 65, 0, 0, 6627, 6628, 3, 724, 362, 0, 6628, 6629, 5, 80, 0, 0, 6629, + 6630, 3, 708, 354, 0, 6630, 6631, 5, 95, 0, 0, 6631, 6632, 3, 716, 358, + 0, 6632, 6676, 1, 0, 0, 0, 6633, 6634, 5, 65, 0, 0, 6634, 6635, 3, 702, + 351, 0, 6635, 6636, 5, 80, 0, 0, 6636, 6637, 3, 706, 353, 0, 6637, 6638, + 5, 95, 0, 0, 6638, 6639, 3, 716, 358, 0, 6639, 6676, 1, 0, 0, 0, 6640, + 6641, 5, 65, 0, 0, 6641, 6642, 3, 698, 349, 0, 6642, 6643, 5, 80, 0, 0, + 6643, 6644, 3, 694, 347, 0, 6644, 6645, 5, 95, 0, 0, 6645, 6646, 3, 716, + 358, 0, 6646, 6676, 1, 0, 0, 0, 6647, 6648, 5, 65, 0, 0, 6648, 6649, 3, + 688, 344, 0, 6649, 6650, 5, 80, 0, 0, 6650, 6651, 3, 692, 346, 0, 6651, + 6652, 5, 95, 0, 0, 6652, 6653, 3, 716, 358, 0, 6653, 6676, 1, 0, 0, 0, + 6654, 6655, 5, 65, 0, 0, 6655, 6656, 3, 684, 342, 0, 6656, 6657, 5, 80, + 0, 0, 6657, 6658, 3, 682, 341, 0, 6658, 6659, 5, 95, 0, 0, 6659, 6660, + 3, 716, 358, 0, 6660, 6676, 1, 0, 0, 0, 6661, 6662, 5, 65, 0, 0, 6662, + 6663, 3, 678, 339, 0, 6663, 6664, 5, 80, 0, 0, 6664, 6665, 3, 680, 340, + 0, 6665, 6666, 5, 95, 0, 0, 6666, 6667, 3, 716, 358, 0, 6667, 6676, 1, + 0, 0, 0, 6668, 6669, 5, 65, 0, 0, 6669, 6670, 3, 670, 335, 0, 6670, 6671, + 5, 80, 0, 0, 6671, 6672, 3, 674, 337, 0, 6672, 6673, 5, 95, 0, 0, 6673, + 6674, 3, 716, 358, 0, 6674, 6676, 1, 0, 0, 0, 6675, 6626, 1, 0, 0, 0, 6675, + 6633, 1, 0, 0, 0, 6675, 6640, 1, 0, 0, 0, 6675, 6647, 1, 0, 0, 0, 6675, + 6654, 1, 0, 0, 0, 6675, 6661, 1, 0, 0, 0, 6675, 6668, 1, 0, 0, 0, 6676, + 669, 1, 0, 0, 0, 6677, 6682, 3, 672, 336, 0, 6678, 6679, 5, 6, 0, 0, 6679, + 6681, 3, 672, 336, 0, 6680, 6678, 1, 0, 0, 0, 6681, 6684, 1, 0, 0, 0, 6682, + 6680, 1, 0, 0, 0, 6682, 6683, 1, 0, 0, 0, 6683, 6687, 1, 0, 0, 0, 6684, + 6682, 1, 0, 0, 0, 6685, 6687, 3, 714, 357, 0, 6686, 6677, 1, 0, 0, 0, 6686, + 6685, 1, 0, 0, 0, 6687, 671, 1, 0, 0, 0, 6688, 6689, 7, 41, 0, 0, 6689, + 673, 1, 0, 0, 0, 6690, 6691, 5, 171, 0, 0, 6691, 6692, 5, 631, 0, 0, 6692, + 6697, 3, 676, 338, 0, 6693, 6694, 5, 6, 0, 0, 6694, 6696, 3, 676, 338, + 0, 6695, 6693, 1, 0, 0, 0, 6696, 6699, 1, 0, 0, 0, 6697, 6695, 1, 0, 0, + 0, 6697, 6698, 1, 0, 0, 0, 6698, 675, 1, 0, 0, 0, 6699, 6697, 1, 0, 0, + 0, 6700, 6701, 3, 1924, 962, 0, 6701, 677, 1, 0, 0, 0, 6702, 6703, 5, 628, + 0, 0, 6703, 679, 1, 0, 0, 0, 6704, 6705, 5, 242, 0, 0, 6705, 6706, 3, 246, + 123, 0, 6706, 681, 1, 0, 0, 0, 6707, 6708, 5, 294, 0, 0, 6708, 6713, 3, + 842, 421, 0, 6709, 6710, 5, 6, 0, 0, 6710, 6712, 3, 842, 421, 0, 6711, + 6709, 1, 0, 0, 0, 6712, 6715, 1, 0, 0, 0, 6713, 6711, 1, 0, 0, 0, 6713, + 6714, 1, 0, 0, 0, 6714, 6722, 1, 0, 0, 0, 6715, 6713, 1, 0, 0, 0, 6716, + 6717, 5, 30, 0, 0, 6717, 6718, 5, 656, 0, 0, 6718, 6719, 5, 68, 0, 0, 6719, + 6720, 5, 321, 0, 0, 6720, 6722, 3, 246, 123, 0, 6721, 6707, 1, 0, 0, 0, + 6721, 6716, 1, 0, 0, 0, 6722, 683, 1, 0, 0, 0, 6723, 6726, 3, 686, 343, + 0, 6724, 6726, 3, 714, 357, 0, 6725, 6723, 1, 0, 0, 0, 6725, 6724, 1, 0, + 0, 0, 6726, 685, 1, 0, 0, 0, 6727, 6730, 5, 206, 0, 0, 6728, 6730, 3, 714, + 357, 0, 6729, 6727, 1, 0, 0, 0, 6729, 6728, 1, 0, 0, 0, 6730, 687, 1, 0, + 0, 0, 6731, 6734, 3, 690, 345, 0, 6732, 6734, 3, 714, 357, 0, 6733, 6731, + 1, 0, 0, 0, 6733, 6732, 1, 0, 0, 0, 6734, 689, 1, 0, 0, 0, 6735, 6738, + 5, 206, 0, 0, 6736, 6738, 3, 714, 357, 0, 6737, 6735, 1, 0, 0, 0, 6737, + 6736, 1, 0, 0, 0, 6738, 691, 1, 0, 0, 0, 6739, 6740, 5, 215, 0, 0, 6740, + 6745, 3, 842, 421, 0, 6741, 6742, 5, 6, 0, 0, 6742, 6744, 3, 842, 421, + 0, 6743, 6741, 1, 0, 0, 0, 6744, 6747, 1, 0, 0, 0, 6745, 6743, 1, 0, 0, + 0, 6745, 6746, 1, 0, 0, 0, 6746, 6754, 1, 0, 0, 0, 6747, 6745, 1, 0, 0, + 0, 6748, 6749, 5, 30, 0, 0, 6749, 6750, 5, 216, 0, 0, 6750, 6751, 5, 68, + 0, 0, 6751, 6752, 5, 321, 0, 0, 6752, 6754, 3, 246, 123, 0, 6753, 6739, + 1, 0, 0, 0, 6753, 6748, 1, 0, 0, 0, 6754, 693, 1, 0, 0, 0, 6755, 6756, + 5, 321, 0, 0, 6756, 6761, 3, 1924, 962, 0, 6757, 6758, 5, 6, 0, 0, 6758, + 6760, 3, 1924, 962, 0, 6759, 6757, 1, 0, 0, 0, 6760, 6763, 1, 0, 0, 0, + 6761, 6759, 1, 0, 0, 0, 6761, 6762, 1, 0, 0, 0, 6762, 695, 1, 0, 0, 0, + 6763, 6761, 1, 0, 0, 0, 6764, 6767, 5, 321, 0, 0, 6765, 6766, 5, 224, 0, + 0, 6766, 6768, 5, 558, 0, 0, 6767, 6765, 1, 0, 0, 0, 6767, 6768, 1, 0, + 0, 0, 6768, 6769, 1, 0, 0, 0, 6769, 6774, 3, 1924, 962, 0, 6770, 6771, + 5, 6, 0, 0, 6771, 6773, 3, 1924, 962, 0, 6772, 6770, 1, 0, 0, 0, 6773, + 6776, 1, 0, 0, 0, 6774, 6772, 1, 0, 0, 0, 6774, 6775, 1, 0, 0, 0, 6775, + 697, 1, 0, 0, 0, 6776, 6774, 1, 0, 0, 0, 6777, 6782, 3, 700, 350, 0, 6778, + 6779, 5, 6, 0, 0, 6779, 6781, 3, 700, 350, 0, 6780, 6778, 1, 0, 0, 0, 6781, + 6784, 1, 0, 0, 0, 6782, 6780, 1, 0, 0, 0, 6782, 6783, 1, 0, 0, 0, 6783, + 6787, 1, 0, 0, 0, 6784, 6782, 1, 0, 0, 0, 6785, 6787, 3, 714, 357, 0, 6786, + 6777, 1, 0, 0, 0, 6786, 6785, 1, 0, 0, 0, 6787, 699, 1, 0, 0, 0, 6788, + 6789, 7, 42, 0, 0, 6789, 701, 1, 0, 0, 0, 6790, 6795, 3, 704, 352, 0, 6791, + 6792, 5, 6, 0, 0, 6792, 6794, 3, 704, 352, 0, 6793, 6791, 1, 0, 0, 0, 6794, + 6797, 1, 0, 0, 0, 6795, 6793, 1, 0, 0, 0, 6795, 6796, 1, 0, 0, 0, 6796, + 6800, 1, 0, 0, 0, 6797, 6795, 1, 0, 0, 0, 6798, 6800, 3, 714, 357, 0, 6799, + 6790, 1, 0, 0, 0, 6799, 6798, 1, 0, 0, 0, 6800, 703, 1, 0, 0, 0, 6801, + 6802, 7, 43, 0, 0, 6802, 705, 1, 0, 0, 0, 6803, 6804, 5, 179, 0, 0, 6804, + 6809, 3, 1924, 962, 0, 6805, 6806, 5, 6, 0, 0, 6806, 6808, 3, 1924, 962, + 0, 6807, 6805, 1, 0, 0, 0, 6808, 6811, 1, 0, 0, 0, 6809, 6807, 1, 0, 0, + 0, 6809, 6810, 1, 0, 0, 0, 6810, 707, 1, 0, 0, 0, 6811, 6809, 1, 0, 0, + 0, 6812, 6814, 5, 93, 0, 0, 6813, 6812, 1, 0, 0, 0, 6813, 6814, 1, 0, 0, + 0, 6814, 6815, 1, 0, 0, 0, 6815, 6818, 3, 1886, 943, 0, 6816, 6818, 3, + 712, 356, 0, 6817, 6813, 1, 0, 0, 0, 6817, 6816, 1, 0, 0, 0, 6818, 709, + 1, 0, 0, 0, 6819, 6821, 5, 93, 0, 0, 6820, 6819, 1, 0, 0, 0, 6820, 6821, + 1, 0, 0, 0, 6821, 6824, 1, 0, 0, 0, 6822, 6823, 5, 224, 0, 0, 6823, 6825, + 5, 558, 0, 0, 6824, 6822, 1, 0, 0, 0, 6824, 6825, 1, 0, 0, 0, 6825, 6826, + 1, 0, 0, 0, 6826, 6829, 3, 1886, 943, 0, 6827, 6829, 3, 712, 356, 0, 6828, + 6820, 1, 0, 0, 0, 6828, 6827, 1, 0, 0, 0, 6829, 711, 1, 0, 0, 0, 6830, + 6831, 5, 30, 0, 0, 6831, 6832, 5, 348, 0, 0, 6832, 6833, 5, 68, 0, 0, 6833, + 6834, 5, 321, 0, 0, 6834, 6835, 3, 1886, 943, 0, 6835, 713, 1, 0, 0, 0, + 6836, 6838, 5, 30, 0, 0, 6837, 6839, 5, 292, 0, 0, 6838, 6837, 1, 0, 0, + 0, 6838, 6839, 1, 0, 0, 0, 6839, 715, 1, 0, 0, 0, 6840, 6845, 3, 718, 359, + 0, 6841, 6842, 5, 6, 0, 0, 6842, 6844, 3, 718, 359, 0, 6843, 6841, 1, 0, + 0, 0, 6844, 6847, 1, 0, 0, 0, 6845, 6843, 1, 0, 0, 0, 6845, 6846, 1, 0, + 0, 0, 6846, 717, 1, 0, 0, 0, 6847, 6845, 1, 0, 0, 0, 6848, 6850, 3, 1920, + 960, 0, 6849, 6851, 3, 720, 360, 0, 6850, 6849, 1, 0, 0, 0, 6850, 6851, + 1, 0, 0, 0, 6851, 6858, 1, 0, 0, 0, 6852, 6853, 5, 66, 0, 0, 6853, 6858, + 3, 1920, 960, 0, 6854, 6855, 5, 316, 0, 0, 6855, 6858, 3, 1920, 960, 0, + 6856, 6858, 5, 86, 0, 0, 6857, 6848, 1, 0, 0, 0, 6857, 6852, 1, 0, 0, 0, + 6857, 6854, 1, 0, 0, 0, 6857, 6856, 1, 0, 0, 0, 6858, 719, 1, 0, 0, 0, + 6859, 6860, 5, 106, 0, 0, 6860, 6861, 5, 65, 0, 0, 6861, 6862, 5, 276, + 0, 0, 6862, 721, 1, 0, 0, 0, 6863, 6864, 7, 44, 0, 0, 6864, 723, 1, 0, + 0, 0, 6865, 6870, 3, 722, 361, 0, 6866, 6867, 5, 6, 0, 0, 6867, 6869, 3, + 722, 361, 0, 6868, 6866, 1, 0, 0, 0, 6869, 6872, 1, 0, 0, 0, 6870, 6868, + 1, 0, 0, 0, 6870, 6871, 1, 0, 0, 0, 6871, 6875, 1, 0, 0, 0, 6872, 6870, + 1, 0, 0, 0, 6873, 6875, 3, 714, 357, 0, 6874, 6865, 1, 0, 0, 0, 6874, 6873, + 1, 0, 0, 0, 6875, 725, 1, 0, 0, 0, 6876, 6887, 3, 764, 382, 0, 6877, 6887, + 3, 762, 381, 0, 6878, 6887, 3, 760, 380, 0, 6879, 6887, 3, 752, 376, 0, + 6880, 6887, 3, 750, 375, 0, 6881, 6887, 3, 736, 368, 0, 6882, 6887, 3, + 732, 366, 0, 6883, 6887, 3, 734, 367, 0, 6884, 6887, 3, 730, 365, 0, 6885, + 6887, 3, 728, 364, 0, 6886, 6876, 1, 0, 0, 0, 6886, 6877, 1, 0, 0, 0, 6886, + 6878, 1, 0, 0, 0, 6886, 6879, 1, 0, 0, 0, 6886, 6880, 1, 0, 0, 0, 6886, + 6881, 1, 0, 0, 0, 6886, 6882, 1, 0, 0, 0, 6886, 6883, 1, 0, 0, 0, 6886, + 6884, 1, 0, 0, 0, 6886, 6885, 1, 0, 0, 0, 6887, 727, 1, 0, 0, 0, 6888, + 6889, 5, 315, 0, 0, 6889, 6890, 5, 89, 0, 0, 6890, 6892, 5, 80, 0, 0, 6891, + 6893, 5, 93, 0, 0, 6892, 6891, 1, 0, 0, 0, 6892, 6893, 1, 0, 0, 0, 6893, + 6894, 1, 0, 0, 0, 6894, 6895, 3, 1886, 943, 0, 6895, 6896, 5, 64, 0, 0, + 6896, 6897, 5, 413, 0, 0, 6897, 6898, 5, 643, 0, 0, 6898, 6900, 3, 246, + 123, 0, 6899, 6901, 3, 120, 60, 0, 6900, 6899, 1, 0, 0, 0, 6900, 6901, + 1, 0, 0, 0, 6901, 729, 1, 0, 0, 0, 6902, 6903, 5, 315, 0, 0, 6903, 6904, + 7, 36, 0, 0, 6904, 6905, 5, 413, 0, 0, 6905, 6906, 5, 64, 0, 0, 6906, 6907, + 5, 316, 0, 0, 6907, 6909, 3, 1920, 960, 0, 6908, 6910, 3, 120, 60, 0, 6909, + 6908, 1, 0, 0, 0, 6909, 6910, 1, 0, 0, 0, 6910, 731, 1, 0, 0, 0, 6911, + 6912, 5, 315, 0, 0, 6912, 6913, 5, 46, 0, 0, 6913, 6914, 5, 417, 0, 0, + 6914, 6915, 5, 64, 0, 0, 6915, 6917, 3, 716, 358, 0, 6916, 6918, 3, 120, + 60, 0, 6917, 6916, 1, 0, 0, 0, 6917, 6918, 1, 0, 0, 0, 6918, 6930, 1, 0, + 0, 0, 6919, 6920, 5, 315, 0, 0, 6920, 6921, 3, 688, 344, 0, 6921, 6922, + 5, 80, 0, 0, 6922, 6923, 5, 417, 0, 0, 6923, 6924, 3, 246, 123, 0, 6924, + 6925, 5, 64, 0, 0, 6925, 6927, 3, 716, 358, 0, 6926, 6928, 3, 120, 60, + 0, 6927, 6926, 1, 0, 0, 0, 6927, 6928, 1, 0, 0, 0, 6928, 6930, 1, 0, 0, + 0, 6929, 6911, 1, 0, 0, 0, 6929, 6919, 1, 0, 0, 0, 6930, 733, 1, 0, 0, + 0, 6931, 6932, 5, 315, 0, 0, 6932, 6933, 5, 316, 0, 0, 6933, 6939, 3, 1920, + 960, 0, 6934, 6935, 5, 6, 0, 0, 6935, 6936, 5, 316, 0, 0, 6936, 6938, 3, + 1920, 960, 0, 6937, 6934, 1, 0, 0, 0, 6938, 6941, 1, 0, 0, 0, 6939, 6937, + 1, 0, 0, 0, 6939, 6940, 1, 0, 0, 0, 6940, 6942, 1, 0, 0, 0, 6941, 6939, + 1, 0, 0, 0, 6942, 6943, 5, 64, 0, 0, 6943, 6945, 3, 600, 300, 0, 6944, + 6946, 3, 120, 60, 0, 6945, 6944, 1, 0, 0, 0, 6945, 6946, 1, 0, 0, 0, 6946, + 6975, 1, 0, 0, 0, 6947, 6948, 5, 315, 0, 0, 6948, 6949, 3, 604, 302, 0, + 6949, 6950, 5, 64, 0, 0, 6950, 6951, 5, 316, 0, 0, 6951, 6953, 3, 1922, + 961, 0, 6952, 6954, 3, 120, 60, 0, 6953, 6952, 1, 0, 0, 0, 6953, 6954, + 1, 0, 0, 0, 6954, 6975, 1, 0, 0, 0, 6955, 6956, 5, 315, 0, 0, 6956, 6957, + 5, 136, 0, 0, 6957, 6958, 5, 276, 0, 0, 6958, 6959, 5, 62, 0, 0, 6959, + 6960, 5, 316, 0, 0, 6960, 6966, 3, 1920, 960, 0, 6961, 6962, 5, 6, 0, 0, + 6962, 6963, 5, 316, 0, 0, 6963, 6965, 3, 1920, 960, 0, 6964, 6961, 1, 0, + 0, 0, 6965, 6968, 1, 0, 0, 0, 6966, 6964, 1, 0, 0, 0, 6966, 6967, 1, 0, + 0, 0, 6967, 6969, 1, 0, 0, 0, 6968, 6966, 1, 0, 0, 0, 6969, 6970, 5, 64, + 0, 0, 6970, 6972, 3, 600, 300, 0, 6971, 6973, 3, 120, 60, 0, 6972, 6971, + 1, 0, 0, 0, 6972, 6973, 1, 0, 0, 0, 6973, 6975, 1, 0, 0, 0, 6974, 6931, + 1, 0, 0, 0, 6974, 6947, 1, 0, 0, 0, 6974, 6955, 1, 0, 0, 0, 6975, 735, + 1, 0, 0, 0, 6976, 6983, 3, 738, 369, 0, 6977, 6983, 3, 740, 370, 0, 6978, + 6983, 3, 742, 371, 0, 6979, 6983, 3, 744, 372, 0, 6980, 6983, 3, 746, 373, + 0, 6981, 6983, 3, 748, 374, 0, 6982, 6976, 1, 0, 0, 0, 6982, 6977, 1, 0, + 0, 0, 6982, 6978, 1, 0, 0, 0, 6982, 6979, 1, 0, 0, 0, 6982, 6980, 1, 0, + 0, 0, 6982, 6981, 1, 0, 0, 0, 6983, 737, 1, 0, 0, 0, 6984, 6985, 5, 315, + 0, 0, 6985, 6986, 3, 698, 349, 0, 6986, 6987, 5, 62, 0, 0, 6987, 6988, + 5, 655, 0, 0, 6988, 6989, 5, 68, 0, 0, 6989, 6990, 5, 179, 0, 0, 6990, + 6991, 3, 1924, 962, 0, 6991, 6992, 5, 64, 0, 0, 6992, 6994, 3, 624, 312, + 0, 6993, 6995, 3, 120, 60, 0, 6994, 6993, 1, 0, 0, 0, 6994, 6995, 1, 0, + 0, 0, 6995, 739, 1, 0, 0, 0, 6996, 6997, 5, 315, 0, 0, 6997, 6998, 3, 724, + 362, 0, 6998, 6999, 5, 62, 0, 0, 6999, 7000, 5, 348, 0, 0, 7000, 7009, + 5, 68, 0, 0, 7001, 7002, 5, 321, 0, 0, 7002, 7005, 3, 1924, 962, 0, 7003, + 7004, 5, 179, 0, 0, 7004, 7006, 3, 1924, 962, 0, 7005, 7003, 1, 0, 0, 0, + 7005, 7006, 1, 0, 0, 0, 7006, 7010, 1, 0, 0, 0, 7007, 7008, 5, 179, 0, + 0, 7008, 7010, 3, 1924, 962, 0, 7009, 7001, 1, 0, 0, 0, 7009, 7007, 1, + 0, 0, 0, 7010, 7011, 1, 0, 0, 0, 7011, 7012, 5, 64, 0, 0, 7012, 7014, 3, + 624, 312, 0, 7013, 7015, 3, 120, 60, 0, 7014, 7013, 1, 0, 0, 0, 7014, 7015, + 1, 0, 0, 0, 7015, 741, 1, 0, 0, 0, 7016, 7017, 5, 315, 0, 0, 7017, 7018, + 3, 688, 344, 0, 7018, 7019, 5, 62, 0, 0, 7019, 7020, 5, 216, 0, 0, 7020, + 7029, 5, 68, 0, 0, 7021, 7022, 5, 321, 0, 0, 7022, 7025, 3, 1924, 962, + 0, 7023, 7024, 5, 179, 0, 0, 7024, 7026, 3, 1924, 962, 0, 7025, 7023, 1, + 0, 0, 0, 7025, 7026, 1, 0, 0, 0, 7026, 7030, 1, 0, 0, 0, 7027, 7028, 5, + 179, 0, 0, 7028, 7030, 3, 1924, 962, 0, 7029, 7021, 1, 0, 0, 0, 7029, 7027, + 1, 0, 0, 0, 7030, 7031, 1, 0, 0, 0, 7031, 7032, 5, 64, 0, 0, 7032, 7034, + 3, 624, 312, 0, 7033, 7035, 3, 120, 60, 0, 7034, 7033, 1, 0, 0, 0, 7034, + 7035, 1, 0, 0, 0, 7035, 743, 1, 0, 0, 0, 7036, 7037, 5, 315, 0, 0, 7037, + 7038, 3, 684, 342, 0, 7038, 7039, 5, 62, 0, 0, 7039, 7040, 5, 656, 0, 0, + 7040, 7049, 5, 68, 0, 0, 7041, 7042, 5, 321, 0, 0, 7042, 7045, 3, 1924, + 962, 0, 7043, 7044, 5, 179, 0, 0, 7044, 7046, 3, 1924, 962, 0, 7045, 7043, + 1, 0, 0, 0, 7045, 7046, 1, 0, 0, 0, 7046, 7050, 1, 0, 0, 0, 7047, 7048, + 5, 179, 0, 0, 7048, 7050, 3, 1924, 962, 0, 7049, 7041, 1, 0, 0, 0, 7049, + 7047, 1, 0, 0, 0, 7050, 7051, 1, 0, 0, 0, 7051, 7052, 5, 64, 0, 0, 7052, + 7054, 3, 624, 312, 0, 7053, 7055, 3, 120, 60, 0, 7054, 7053, 1, 0, 0, 0, + 7054, 7055, 1, 0, 0, 0, 7055, 745, 1, 0, 0, 0, 7056, 7057, 5, 315, 0, 0, + 7057, 7058, 3, 678, 339, 0, 7058, 7059, 5, 62, 0, 0, 7059, 7060, 5, 630, + 0, 0, 7060, 7061, 5, 68, 0, 0, 7061, 7062, 5, 179, 0, 0, 7062, 7063, 3, + 1924, 962, 0, 7063, 7064, 5, 64, 0, 0, 7064, 7066, 3, 624, 312, 0, 7065, + 7067, 3, 120, 60, 0, 7066, 7065, 1, 0, 0, 0, 7066, 7067, 1, 0, 0, 0, 7067, + 747, 1, 0, 0, 0, 7068, 7069, 5, 315, 0, 0, 7069, 7070, 3, 670, 335, 0, + 7070, 7071, 5, 62, 0, 0, 7071, 7072, 5, 171, 0, 0, 7072, 7073, 5, 632, + 0, 0, 7073, 7082, 5, 68, 0, 0, 7074, 7075, 5, 321, 0, 0, 7075, 7078, 3, + 1924, 962, 0, 7076, 7077, 5, 179, 0, 0, 7077, 7079, 3, 1924, 962, 0, 7078, + 7076, 1, 0, 0, 0, 7078, 7079, 1, 0, 0, 0, 7079, 7083, 1, 0, 0, 0, 7080, + 7081, 5, 179, 0, 0, 7081, 7083, 3, 1924, 962, 0, 7082, 7074, 1, 0, 0, 0, + 7082, 7080, 1, 0, 0, 0, 7083, 7084, 1, 0, 0, 0, 7084, 7085, 5, 64, 0, 0, + 7085, 7087, 3, 624, 312, 0, 7086, 7088, 3, 120, 60, 0, 7087, 7086, 1, 0, + 0, 0, 7087, 7088, 1, 0, 0, 0, 7088, 749, 1, 0, 0, 0, 7089, 7093, 5, 315, + 0, 0, 7090, 7091, 5, 65, 0, 0, 7091, 7092, 5, 276, 0, 0, 7092, 7094, 5, + 62, 0, 0, 7093, 7090, 1, 0, 0, 0, 7093, 7094, 1, 0, 0, 0, 7094, 7095, 1, + 0, 0, 0, 7095, 7096, 7, 39, 0, 0, 7096, 7097, 5, 80, 0, 0, 7097, 7098, + 5, 392, 0, 0, 7098, 7099, 3, 1924, 962, 0, 7099, 7100, 5, 64, 0, 0, 7100, + 7102, 3, 716, 358, 0, 7101, 7103, 3, 120, 60, 0, 7102, 7101, 1, 0, 0, 0, + 7102, 7103, 1, 0, 0, 0, 7103, 7148, 1, 0, 0, 0, 7104, 7108, 5, 315, 0, + 0, 7105, 7106, 5, 65, 0, 0, 7106, 7107, 5, 276, 0, 0, 7107, 7109, 5, 62, + 0, 0, 7108, 7105, 1, 0, 0, 0, 7108, 7109, 1, 0, 0, 0, 7109, 7110, 1, 0, + 0, 0, 7110, 7111, 5, 628, 0, 0, 7111, 7112, 5, 80, 0, 0, 7112, 7113, 5, + 392, 0, 0, 7113, 7114, 3, 1924, 962, 0, 7114, 7123, 5, 64, 0, 0, 7115, + 7116, 5, 467, 0, 0, 7116, 7124, 3, 1910, 955, 0, 7117, 7118, 5, 466, 0, + 0, 7118, 7121, 3, 1910, 955, 0, 7119, 7120, 5, 633, 0, 0, 7120, 7122, 5, + 178, 0, 0, 7121, 7119, 1, 0, 0, 0, 7121, 7122, 1, 0, 0, 0, 7122, 7124, + 1, 0, 0, 0, 7123, 7115, 1, 0, 0, 0, 7123, 7117, 1, 0, 0, 0, 7124, 7126, + 1, 0, 0, 0, 7125, 7127, 3, 120, 60, 0, 7126, 7125, 1, 0, 0, 0, 7126, 7127, + 1, 0, 0, 0, 7127, 7148, 1, 0, 0, 0, 7128, 7132, 5, 315, 0, 0, 7129, 7130, + 5, 65, 0, 0, 7130, 7131, 5, 276, 0, 0, 7131, 7133, 5, 62, 0, 0, 7132, 7129, + 1, 0, 0, 0, 7132, 7133, 1, 0, 0, 0, 7133, 7134, 1, 0, 0, 0, 7134, 7135, + 5, 628, 0, 0, 7135, 7140, 5, 80, 0, 0, 7136, 7137, 5, 179, 0, 0, 7137, + 7141, 3, 246, 123, 0, 7138, 7139, 5, 321, 0, 0, 7139, 7141, 3, 1924, 962, + 0, 7140, 7136, 1, 0, 0, 0, 7140, 7138, 1, 0, 0, 0, 7141, 7142, 1, 0, 0, + 0, 7142, 7143, 5, 64, 0, 0, 7143, 7145, 3, 716, 358, 0, 7144, 7146, 3, + 120, 60, 0, 7145, 7144, 1, 0, 0, 0, 7145, 7146, 1, 0, 0, 0, 7146, 7148, + 1, 0, 0, 0, 7147, 7089, 1, 0, 0, 0, 7147, 7104, 1, 0, 0, 0, 7147, 7128, + 1, 0, 0, 0, 7148, 751, 1, 0, 0, 0, 7149, 7153, 3, 758, 379, 0, 7150, 7153, + 3, 756, 378, 0, 7151, 7153, 3, 754, 377, 0, 7152, 7149, 1, 0, 0, 0, 7152, + 7150, 1, 0, 0, 0, 7152, 7151, 1, 0, 0, 0, 7153, 753, 1, 0, 0, 0, 7154, + 7155, 5, 315, 0, 0, 7155, 7156, 3, 634, 317, 0, 7156, 7157, 5, 80, 0, 0, + 7157, 7158, 5, 209, 0, 0, 7158, 7159, 5, 321, 0, 0, 7159, 7160, 3, 246, + 123, 0, 7160, 7161, 5, 64, 0, 0, 7161, 7163, 3, 648, 324, 0, 7162, 7164, + 3, 120, 60, 0, 7163, 7162, 1, 0, 0, 0, 7163, 7164, 1, 0, 0, 0, 7164, 755, + 1, 0, 0, 0, 7165, 7166, 5, 315, 0, 0, 7166, 7167, 3, 642, 321, 0, 7167, + 7168, 5, 80, 0, 0, 7168, 7169, 5, 209, 0, 0, 7169, 7170, 5, 93, 0, 0, 7170, + 7171, 3, 1886, 943, 0, 7171, 7172, 5, 64, 0, 0, 7172, 7174, 3, 646, 323, + 0, 7173, 7175, 3, 120, 60, 0, 7174, 7173, 1, 0, 0, 0, 7174, 7175, 1, 0, + 0, 0, 7175, 757, 1, 0, 0, 0, 7176, 7179, 5, 315, 0, 0, 7177, 7180, 5, 89, + 0, 0, 7178, 7180, 3, 714, 357, 0, 7179, 7177, 1, 0, 0, 0, 7179, 7178, 1, + 0, 0, 0, 7180, 7181, 1, 0, 0, 0, 7181, 7182, 5, 2, 0, 0, 7182, 7183, 3, + 246, 123, 0, 7183, 7184, 5, 3, 0, 0, 7184, 7185, 5, 80, 0, 0, 7185, 7186, + 5, 209, 0, 0, 7186, 7187, 5, 93, 0, 0, 7187, 7188, 3, 1888, 944, 0, 7188, + 7189, 5, 64, 0, 0, 7189, 7191, 3, 648, 324, 0, 7190, 7192, 3, 120, 60, + 0, 7191, 7190, 1, 0, 0, 0, 7191, 7192, 1, 0, 0, 0, 7192, 759, 1, 0, 0, + 0, 7193, 7194, 5, 315, 0, 0, 7194, 7195, 5, 634, 0, 0, 7195, 7196, 3, 656, + 328, 0, 7196, 7197, 5, 64, 0, 0, 7197, 7198, 3, 716, 358, 0, 7198, 7199, + 5, 62, 0, 0, 7199, 7201, 3, 652, 326, 0, 7200, 7202, 3, 120, 60, 0, 7201, + 7200, 1, 0, 0, 0, 7201, 7202, 1, 0, 0, 0, 7202, 761, 1, 0, 0, 0, 7203, + 7204, 5, 315, 0, 0, 7204, 7205, 3, 662, 331, 0, 7205, 7206, 5, 80, 0, 0, + 7206, 7207, 3, 660, 330, 0, 7207, 7208, 5, 64, 0, 0, 7208, 7210, 3, 716, + 358, 0, 7209, 7211, 3, 120, 60, 0, 7210, 7209, 1, 0, 0, 0, 7210, 7211, + 1, 0, 0, 0, 7211, 7225, 1, 0, 0, 0, 7212, 7213, 5, 315, 0, 0, 7213, 7214, + 5, 65, 0, 0, 7214, 7215, 5, 276, 0, 0, 7215, 7216, 5, 62, 0, 0, 7216, 7217, + 3, 662, 331, 0, 7217, 7218, 5, 80, 0, 0, 7218, 7219, 3, 660, 330, 0, 7219, + 7220, 5, 64, 0, 0, 7220, 7222, 3, 716, 358, 0, 7221, 7223, 3, 120, 60, + 0, 7222, 7221, 1, 0, 0, 0, 7222, 7223, 1, 0, 0, 0, 7223, 7225, 1, 0, 0, + 0, 7224, 7203, 1, 0, 0, 0, 7224, 7212, 1, 0, 0, 0, 7225, 763, 1, 0, 0, + 0, 7226, 7230, 5, 315, 0, 0, 7227, 7228, 5, 65, 0, 0, 7228, 7229, 5, 276, + 0, 0, 7229, 7231, 5, 62, 0, 0, 7230, 7227, 1, 0, 0, 0, 7230, 7231, 1, 0, + 0, 0, 7231, 7232, 1, 0, 0, 0, 7232, 7233, 3, 724, 362, 0, 7233, 7234, 5, + 80, 0, 0, 7234, 7235, 3, 710, 355, 0, 7235, 7236, 5, 64, 0, 0, 7236, 7238, + 3, 716, 358, 0, 7237, 7239, 3, 120, 60, 0, 7238, 7237, 1, 0, 0, 0, 7238, + 7239, 1, 0, 0, 0, 7239, 7325, 1, 0, 0, 0, 7240, 7244, 5, 315, 0, 0, 7241, + 7242, 5, 65, 0, 0, 7242, 7243, 5, 276, 0, 0, 7243, 7245, 5, 62, 0, 0, 7244, + 7241, 1, 0, 0, 0, 7244, 7245, 1, 0, 0, 0, 7245, 7246, 1, 0, 0, 0, 7246, + 7247, 3, 702, 351, 0, 7247, 7248, 5, 80, 0, 0, 7248, 7249, 3, 706, 353, + 0, 7249, 7250, 5, 64, 0, 0, 7250, 7252, 3, 716, 358, 0, 7251, 7253, 3, + 120, 60, 0, 7252, 7251, 1, 0, 0, 0, 7252, 7253, 1, 0, 0, 0, 7253, 7325, + 1, 0, 0, 0, 7254, 7258, 5, 315, 0, 0, 7255, 7256, 5, 65, 0, 0, 7256, 7257, + 5, 276, 0, 0, 7257, 7259, 5, 62, 0, 0, 7258, 7255, 1, 0, 0, 0, 7258, 7259, + 1, 0, 0, 0, 7259, 7260, 1, 0, 0, 0, 7260, 7261, 3, 698, 349, 0, 7261, 7262, + 5, 80, 0, 0, 7262, 7263, 3, 696, 348, 0, 7263, 7264, 5, 64, 0, 0, 7264, + 7266, 3, 716, 358, 0, 7265, 7267, 3, 120, 60, 0, 7266, 7265, 1, 0, 0, 0, + 7266, 7267, 1, 0, 0, 0, 7267, 7325, 1, 0, 0, 0, 7268, 7272, 5, 315, 0, + 0, 7269, 7270, 5, 65, 0, 0, 7270, 7271, 5, 276, 0, 0, 7271, 7273, 5, 62, + 0, 0, 7272, 7269, 1, 0, 0, 0, 7272, 7273, 1, 0, 0, 0, 7273, 7274, 1, 0, + 0, 0, 7274, 7275, 3, 688, 344, 0, 7275, 7276, 5, 80, 0, 0, 7276, 7277, + 3, 692, 346, 0, 7277, 7278, 5, 64, 0, 0, 7278, 7280, 3, 716, 358, 0, 7279, + 7281, 3, 120, 60, 0, 7280, 7279, 1, 0, 0, 0, 7280, 7281, 1, 0, 0, 0, 7281, + 7325, 1, 0, 0, 0, 7282, 7286, 5, 315, 0, 0, 7283, 7284, 5, 65, 0, 0, 7284, + 7285, 5, 276, 0, 0, 7285, 7287, 5, 62, 0, 0, 7286, 7283, 1, 0, 0, 0, 7286, + 7287, 1, 0, 0, 0, 7287, 7288, 1, 0, 0, 0, 7288, 7289, 3, 684, 342, 0, 7289, + 7290, 5, 80, 0, 0, 7290, 7291, 3, 682, 341, 0, 7291, 7292, 5, 64, 0, 0, + 7292, 7294, 3, 716, 358, 0, 7293, 7295, 3, 120, 60, 0, 7294, 7293, 1, 0, + 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 7325, 1, 0, 0, 0, 7296, 7300, 5, 315, + 0, 0, 7297, 7298, 5, 65, 0, 0, 7298, 7299, 5, 276, 0, 0, 7299, 7301, 5, + 62, 0, 0, 7300, 7297, 1, 0, 0, 0, 7300, 7301, 1, 0, 0, 0, 7301, 7302, 1, + 0, 0, 0, 7302, 7303, 3, 678, 339, 0, 7303, 7304, 5, 80, 0, 0, 7304, 7305, + 3, 680, 340, 0, 7305, 7306, 5, 64, 0, 0, 7306, 7308, 3, 716, 358, 0, 7307, + 7309, 3, 120, 60, 0, 7308, 7307, 1, 0, 0, 0, 7308, 7309, 1, 0, 0, 0, 7309, + 7325, 1, 0, 0, 0, 7310, 7314, 5, 315, 0, 0, 7311, 7312, 5, 65, 0, 0, 7312, + 7313, 5, 276, 0, 0, 7313, 7315, 5, 62, 0, 0, 7314, 7311, 1, 0, 0, 0, 7314, + 7315, 1, 0, 0, 0, 7315, 7316, 1, 0, 0, 0, 7316, 7317, 3, 670, 335, 0, 7317, + 7318, 5, 80, 0, 0, 7318, 7319, 3, 674, 337, 0, 7319, 7320, 5, 64, 0, 0, + 7320, 7322, 3, 716, 358, 0, 7321, 7323, 3, 120, 60, 0, 7322, 7321, 1, 0, + 0, 0, 7322, 7323, 1, 0, 0, 0, 7323, 7325, 1, 0, 0, 0, 7324, 7226, 1, 0, + 0, 0, 7324, 7240, 1, 0, 0, 0, 7324, 7254, 1, 0, 0, 0, 7324, 7268, 1, 0, + 0, 0, 7324, 7282, 1, 0, 0, 0, 7324, 7296, 1, 0, 0, 0, 7324, 7310, 1, 0, + 0, 0, 7325, 765, 1, 0, 0, 0, 7326, 7342, 3, 768, 384, 0, 7327, 7342, 5, + 30, 0, 0, 7328, 7329, 5, 30, 0, 0, 7329, 7342, 5, 292, 0, 0, 7330, 7331, + 5, 30, 0, 0, 7331, 7332, 5, 2, 0, 0, 7332, 7333, 3, 246, 123, 0, 7333, + 7334, 5, 3, 0, 0, 7334, 7342, 1, 0, 0, 0, 7335, 7336, 5, 30, 0, 0, 7336, + 7337, 5, 292, 0, 0, 7337, 7338, 5, 2, 0, 0, 7338, 7339, 3, 246, 123, 0, + 7339, 7340, 5, 3, 0, 0, 7340, 7342, 1, 0, 0, 0, 7341, 7326, 1, 0, 0, 0, + 7341, 7327, 1, 0, 0, 0, 7341, 7328, 1, 0, 0, 0, 7341, 7330, 1, 0, 0, 0, + 7341, 7335, 1, 0, 0, 0, 7342, 767, 1, 0, 0, 0, 7343, 7348, 3, 770, 385, + 0, 7344, 7345, 5, 6, 0, 0, 7345, 7347, 3, 770, 385, 0, 7346, 7344, 1, 0, + 0, 0, 7347, 7350, 1, 0, 0, 0, 7348, 7346, 1, 0, 0, 0, 7348, 7349, 1, 0, + 0, 0, 7349, 769, 1, 0, 0, 0, 7350, 7348, 1, 0, 0, 0, 7351, 7353, 5, 89, + 0, 0, 7352, 7354, 3, 244, 122, 0, 7353, 7352, 1, 0, 0, 0, 7353, 7354, 1, + 0, 0, 0, 7354, 7370, 1, 0, 0, 0, 7355, 7357, 5, 87, 0, 0, 7356, 7358, 3, + 244, 122, 0, 7357, 7356, 1, 0, 0, 0, 7357, 7358, 1, 0, 0, 0, 7358, 7370, + 1, 0, 0, 0, 7359, 7361, 5, 46, 0, 0, 7360, 7362, 3, 244, 122, 0, 7361, + 7360, 1, 0, 0, 0, 7361, 7362, 1, 0, 0, 0, 7362, 7370, 1, 0, 0, 0, 7363, + 7364, 5, 140, 0, 0, 7364, 7370, 5, 347, 0, 0, 7365, 7367, 3, 1924, 962, + 0, 7366, 7368, 3, 244, 122, 0, 7367, 7366, 1, 0, 0, 0, 7367, 7368, 1, 0, + 0, 0, 7368, 7370, 1, 0, 0, 0, 7369, 7351, 1, 0, 0, 0, 7369, 7355, 1, 0, + 0, 0, 7369, 7359, 1, 0, 0, 0, 7369, 7363, 1, 0, 0, 0, 7369, 7365, 1, 0, + 0, 0, 7370, 771, 1, 0, 0, 0, 7371, 7432, 3, 1886, 943, 0, 7372, 7373, 5, + 93, 0, 0, 7373, 7432, 3, 1886, 943, 0, 7374, 7375, 5, 326, 0, 0, 7375, + 7432, 3, 1886, 943, 0, 7376, 7377, 5, 63, 0, 0, 7377, 7378, 5, 177, 0, + 0, 7378, 7379, 5, 379, 0, 0, 7379, 7432, 3, 1890, 945, 0, 7380, 7381, 5, + 63, 0, 0, 7381, 7382, 5, 329, 0, 0, 7382, 7432, 3, 1890, 945, 0, 7383, + 7384, 5, 215, 0, 0, 7384, 7432, 3, 842, 421, 0, 7385, 7386, 5, 294, 0, + 0, 7386, 7432, 3, 842, 421, 0, 7387, 7388, 5, 640, 0, 0, 7388, 7432, 3, + 842, 421, 0, 7389, 7390, 5, 179, 0, 0, 7390, 7432, 3, 1890, 945, 0, 7391, + 7392, 5, 193, 0, 0, 7392, 7432, 3, 564, 282, 0, 7393, 7394, 5, 242, 0, + 0, 7394, 7432, 3, 1890, 945, 0, 7395, 7396, 5, 243, 0, 0, 7396, 7397, 5, + 271, 0, 0, 7397, 7432, 3, 336, 168, 0, 7398, 7399, 5, 573, 0, 0, 7399, + 7432, 3, 774, 387, 0, 7400, 7401, 5, 321, 0, 0, 7401, 7432, 3, 1890, 945, + 0, 7402, 7403, 5, 349, 0, 0, 7403, 7432, 3, 1890, 945, 0, 7404, 7405, 5, + 358, 0, 0, 7405, 7432, 3, 564, 282, 0, 7406, 7407, 5, 30, 0, 0, 7407, 7408, + 5, 348, 0, 0, 7408, 7409, 5, 68, 0, 0, 7409, 7410, 5, 321, 0, 0, 7410, + 7432, 3, 1890, 945, 0, 7411, 7412, 5, 30, 0, 0, 7412, 7413, 5, 327, 0, + 0, 7413, 7414, 5, 68, 0, 0, 7414, 7415, 5, 321, 0, 0, 7415, 7432, 3, 1890, + 945, 0, 7416, 7417, 5, 30, 0, 0, 7417, 7418, 5, 216, 0, 0, 7418, 7419, + 5, 68, 0, 0, 7419, 7420, 5, 321, 0, 0, 7420, 7432, 3, 1890, 945, 0, 7421, + 7422, 5, 30, 0, 0, 7422, 7423, 5, 656, 0, 0, 7423, 7424, 5, 68, 0, 0, 7424, + 7425, 5, 321, 0, 0, 7425, 7432, 3, 1890, 945, 0, 7426, 7427, 5, 30, 0, + 0, 7427, 7428, 5, 654, 0, 0, 7428, 7429, 5, 68, 0, 0, 7429, 7430, 5, 321, + 0, 0, 7430, 7432, 3, 1890, 945, 0, 7431, 7371, 1, 0, 0, 0, 7431, 7372, + 1, 0, 0, 0, 7431, 7374, 1, 0, 0, 0, 7431, 7376, 1, 0, 0, 0, 7431, 7380, + 1, 0, 0, 0, 7431, 7383, 1, 0, 0, 0, 7431, 7385, 1, 0, 0, 0, 7431, 7387, + 1, 0, 0, 0, 7431, 7389, 1, 0, 0, 0, 7431, 7391, 1, 0, 0, 0, 7431, 7393, + 1, 0, 0, 0, 7431, 7395, 1, 0, 0, 0, 7431, 7398, 1, 0, 0, 0, 7431, 7400, + 1, 0, 0, 0, 7431, 7402, 1, 0, 0, 0, 7431, 7404, 1, 0, 0, 0, 7431, 7406, + 1, 0, 0, 0, 7431, 7411, 1, 0, 0, 0, 7431, 7416, 1, 0, 0, 0, 7431, 7421, + 1, 0, 0, 0, 7431, 7426, 1, 0, 0, 0, 7432, 773, 1, 0, 0, 0, 7433, 7438, + 3, 776, 388, 0, 7434, 7435, 5, 6, 0, 0, 7435, 7437, 3, 776, 388, 0, 7436, + 7434, 1, 0, 0, 0, 7437, 7440, 1, 0, 0, 0, 7438, 7436, 1, 0, 0, 0, 7438, + 7439, 1, 0, 0, 0, 7439, 775, 1, 0, 0, 0, 7440, 7438, 1, 0, 0, 0, 7441, + 7444, 3, 1924, 962, 0, 7442, 7443, 5, 11, 0, 0, 7443, 7445, 3, 1924, 962, + 0, 7444, 7442, 1, 0, 0, 0, 7444, 7445, 1, 0, 0, 0, 7445, 777, 1, 0, 0, + 0, 7446, 7447, 5, 106, 0, 0, 7447, 7448, 5, 65, 0, 0, 7448, 7449, 5, 276, + 0, 0, 7449, 779, 1, 0, 0, 0, 7450, 7451, 5, 65, 0, 0, 7451, 7452, 3, 768, + 384, 0, 7452, 7453, 5, 95, 0, 0, 7453, 7455, 3, 1922, 961, 0, 7454, 7456, + 3, 784, 392, 0, 7455, 7454, 1, 0, 0, 0, 7455, 7456, 1, 0, 0, 0, 7456, 7458, + 1, 0, 0, 0, 7457, 7459, 3, 786, 393, 0, 7458, 7457, 1, 0, 0, 0, 7458, 7459, + 1, 0, 0, 0, 7459, 781, 1, 0, 0, 0, 7460, 7461, 5, 315, 0, 0, 7461, 7462, + 3, 768, 384, 0, 7462, 7463, 5, 64, 0, 0, 7463, 7465, 3, 1922, 961, 0, 7464, + 7466, 3, 786, 393, 0, 7465, 7464, 1, 0, 0, 0, 7465, 7466, 1, 0, 0, 0, 7466, + 7468, 1, 0, 0, 0, 7467, 7469, 3, 120, 60, 0, 7468, 7467, 1, 0, 0, 0, 7468, + 7469, 1, 0, 0, 0, 7469, 7484, 1, 0, 0, 0, 7470, 7471, 5, 315, 0, 0, 7471, + 7472, 5, 136, 0, 0, 7472, 7473, 5, 276, 0, 0, 7473, 7474, 5, 62, 0, 0, + 7474, 7475, 3, 768, 384, 0, 7475, 7476, 5, 64, 0, 0, 7476, 7478, 3, 1922, + 961, 0, 7477, 7479, 3, 786, 393, 0, 7478, 7477, 1, 0, 0, 0, 7478, 7479, + 1, 0, 0, 0, 7479, 7481, 1, 0, 0, 0, 7480, 7482, 3, 120, 60, 0, 7481, 7480, + 1, 0, 0, 0, 7481, 7482, 1, 0, 0, 0, 7482, 7484, 1, 0, 0, 0, 7483, 7460, + 1, 0, 0, 0, 7483, 7470, 1, 0, 0, 0, 7484, 783, 1, 0, 0, 0, 7485, 7486, + 5, 106, 0, 0, 7486, 7487, 5, 136, 0, 0, 7487, 7488, 5, 276, 0, 0, 7488, + 785, 1, 0, 0, 0, 7489, 7490, 5, 218, 0, 0, 7490, 7491, 5, 149, 0, 0, 7491, + 7492, 3, 1920, 960, 0, 7492, 787, 1, 0, 0, 0, 7493, 7494, 5, 140, 0, 0, + 7494, 7495, 5, 53, 0, 0, 7495, 7496, 5, 292, 0, 0, 7496, 7497, 3, 790, + 395, 0, 7497, 7498, 3, 794, 397, 0, 7498, 789, 1, 0, 0, 0, 7499, 7501, + 3, 792, 396, 0, 7500, 7499, 1, 0, 0, 0, 7501, 7504, 1, 0, 0, 0, 7502, 7500, + 1, 0, 0, 0, 7502, 7503, 1, 0, 0, 0, 7503, 791, 1, 0, 0, 0, 7504, 7502, + 1, 0, 0, 0, 7505, 7506, 5, 68, 0, 0, 7506, 7507, 5, 321, 0, 0, 7507, 7515, + 3, 1890, 945, 0, 7508, 7509, 5, 62, 0, 0, 7509, 7510, 5, 316, 0, 0, 7510, + 7515, 3, 1922, 961, 0, 7511, 7512, 5, 62, 0, 0, 7512, 7513, 5, 100, 0, + 0, 7513, 7515, 3, 1922, 961, 0, 7514, 7505, 1, 0, 0, 0, 7514, 7508, 1, + 0, 0, 0, 7514, 7511, 1, 0, 0, 0, 7515, 793, 1, 0, 0, 0, 7516, 7517, 5, + 65, 0, 0, 7517, 7518, 3, 766, 383, 0, 7518, 7519, 5, 80, 0, 0, 7519, 7520, + 3, 796, 398, 0, 7520, 7521, 5, 95, 0, 0, 7521, 7523, 3, 716, 358, 0, 7522, + 7524, 3, 778, 389, 0, 7523, 7522, 1, 0, 0, 0, 7523, 7524, 1, 0, 0, 0, 7524, + 7547, 1, 0, 0, 0, 7525, 7526, 5, 315, 0, 0, 7526, 7527, 3, 766, 383, 0, + 7527, 7528, 5, 80, 0, 0, 7528, 7529, 3, 796, 398, 0, 7529, 7530, 5, 64, + 0, 0, 7530, 7532, 3, 716, 358, 0, 7531, 7533, 3, 120, 60, 0, 7532, 7531, + 1, 0, 0, 0, 7532, 7533, 1, 0, 0, 0, 7533, 7547, 1, 0, 0, 0, 7534, 7535, + 5, 315, 0, 0, 7535, 7536, 5, 65, 0, 0, 7536, 7537, 5, 276, 0, 0, 7537, + 7538, 5, 62, 0, 0, 7538, 7539, 3, 766, 383, 0, 7539, 7540, 5, 80, 0, 0, + 7540, 7541, 3, 796, 398, 0, 7541, 7542, 5, 64, 0, 0, 7542, 7544, 3, 716, + 358, 0, 7543, 7545, 3, 120, 60, 0, 7544, 7543, 1, 0, 0, 0, 7544, 7545, + 1, 0, 0, 0, 7545, 7547, 1, 0, 0, 0, 7546, 7516, 1, 0, 0, 0, 7546, 7525, + 1, 0, 0, 0, 7546, 7534, 1, 0, 0, 0, 7547, 795, 1, 0, 0, 0, 7548, 7549, + 7, 45, 0, 0, 7549, 797, 1, 0, 0, 0, 7550, 7552, 5, 46, 0, 0, 7551, 7553, + 3, 800, 400, 0, 7552, 7551, 1, 0, 0, 0, 7552, 7553, 1, 0, 0, 0, 7553, 7554, + 1, 0, 0, 0, 7554, 7556, 5, 230, 0, 0, 7555, 7557, 3, 802, 401, 0, 7556, + 7555, 1, 0, 0, 0, 7556, 7557, 1, 0, 0, 0, 7557, 7564, 1, 0, 0, 0, 7558, + 7559, 5, 224, 0, 0, 7559, 7560, 5, 77, 0, 0, 7560, 7562, 5, 558, 0, 0, + 7561, 7558, 1, 0, 0, 0, 7561, 7562, 1, 0, 0, 0, 7562, 7563, 1, 0, 0, 0, + 7563, 7565, 3, 1892, 946, 0, 7564, 7561, 1, 0, 0, 0, 7564, 7565, 1, 0, + 0, 0, 7565, 7566, 1, 0, 0, 0, 7566, 7567, 5, 80, 0, 0, 7567, 7569, 3, 1618, + 809, 0, 7568, 7570, 3, 806, 403, 0, 7569, 7568, 1, 0, 0, 0, 7569, 7570, + 1, 0, 0, 0, 7570, 7571, 1, 0, 0, 0, 7571, 7572, 5, 2, 0, 0, 7572, 7573, + 3, 808, 404, 0, 7573, 7575, 5, 3, 0, 0, 7574, 7576, 3, 814, 407, 0, 7575, + 7574, 1, 0, 0, 0, 7575, 7576, 1, 0, 0, 0, 7576, 7578, 1, 0, 0, 0, 7577, + 7579, 3, 226, 113, 0, 7578, 7577, 1, 0, 0, 0, 7578, 7579, 1, 0, 0, 0, 7579, + 7581, 1, 0, 0, 0, 7580, 7582, 3, 130, 65, 0, 7581, 7580, 1, 0, 0, 0, 7581, + 7582, 1, 0, 0, 0, 7582, 7584, 1, 0, 0, 0, 7583, 7585, 3, 284, 142, 0, 7584, + 7583, 1, 0, 0, 0, 7584, 7585, 1, 0, 0, 0, 7585, 7587, 1, 0, 0, 0, 7586, + 7588, 3, 1638, 819, 0, 7587, 7586, 1, 0, 0, 0, 7587, 7588, 1, 0, 0, 0, + 7588, 799, 1, 0, 0, 0, 7589, 7590, 5, 99, 0, 0, 7590, 801, 1, 0, 0, 0, + 7591, 7592, 5, 111, 0, 0, 7592, 803, 1, 0, 0, 0, 7593, 7594, 3, 1892, 946, + 0, 7594, 805, 1, 0, 0, 0, 7595, 7596, 5, 101, 0, 0, 7596, 7597, 3, 1892, + 946, 0, 7597, 807, 1, 0, 0, 0, 7598, 7603, 3, 812, 406, 0, 7599, 7600, + 5, 6, 0, 0, 7600, 7602, 3, 812, 406, 0, 7601, 7599, 1, 0, 0, 0, 7602, 7605, + 1, 0, 0, 0, 7603, 7601, 1, 0, 0, 0, 7603, 7604, 1, 0, 0, 0, 7604, 809, + 1, 0, 0, 0, 7605, 7603, 1, 0, 0, 0, 7606, 7608, 3, 818, 409, 0, 7607, 7606, + 1, 0, 0, 0, 7607, 7608, 1, 0, 0, 0, 7608, 7610, 1, 0, 0, 0, 7609, 7611, + 3, 820, 410, 0, 7610, 7609, 1, 0, 0, 0, 7610, 7611, 1, 0, 0, 0, 7611, 7613, + 1, 0, 0, 0, 7612, 7614, 3, 822, 411, 0, 7613, 7612, 1, 0, 0, 0, 7613, 7614, + 1, 0, 0, 0, 7614, 7616, 1, 0, 0, 0, 7615, 7617, 3, 824, 412, 0, 7616, 7615, + 1, 0, 0, 0, 7616, 7617, 1, 0, 0, 0, 7617, 7630, 1, 0, 0, 0, 7618, 7620, + 3, 818, 409, 0, 7619, 7618, 1, 0, 0, 0, 7619, 7620, 1, 0, 0, 0, 7620, 7621, + 1, 0, 0, 0, 7621, 7622, 3, 566, 283, 0, 7622, 7624, 3, 128, 64, 0, 7623, + 7625, 3, 822, 411, 0, 7624, 7623, 1, 0, 0, 0, 7624, 7625, 1, 0, 0, 0, 7625, + 7627, 1, 0, 0, 0, 7626, 7628, 3, 824, 412, 0, 7627, 7626, 1, 0, 0, 0, 7627, + 7628, 1, 0, 0, 0, 7628, 7630, 1, 0, 0, 0, 7629, 7607, 1, 0, 0, 0, 7629, + 7619, 1, 0, 0, 0, 7630, 811, 1, 0, 0, 0, 7631, 7632, 3, 1924, 962, 0, 7632, + 7633, 3, 810, 405, 0, 7633, 7643, 1, 0, 0, 0, 7634, 7635, 3, 1764, 882, + 0, 7635, 7636, 3, 810, 405, 0, 7636, 7643, 1, 0, 0, 0, 7637, 7638, 5, 2, + 0, 0, 7638, 7639, 3, 1710, 855, 0, 7639, 7640, 5, 3, 0, 0, 7640, 7641, + 3, 810, 405, 0, 7641, 7643, 1, 0, 0, 0, 7642, 7631, 1, 0, 0, 0, 7642, 7634, + 1, 0, 0, 0, 7642, 7637, 1, 0, 0, 0, 7643, 813, 1, 0, 0, 0, 7644, 7645, + 5, 639, 0, 0, 7645, 7646, 5, 2, 0, 0, 7646, 7647, 3, 816, 408, 0, 7647, + 7648, 5, 3, 0, 0, 7648, 815, 1, 0, 0, 0, 7649, 7654, 3, 812, 406, 0, 7650, + 7651, 5, 6, 0, 0, 7651, 7653, 3, 812, 406, 0, 7652, 7650, 1, 0, 0, 0, 7653, + 7656, 1, 0, 0, 0, 7654, 7652, 1, 0, 0, 0, 7654, 7655, 1, 0, 0, 0, 7655, + 817, 1, 0, 0, 0, 7656, 7654, 1, 0, 0, 0, 7657, 7658, 5, 43, 0, 0, 7658, + 7659, 3, 566, 283, 0, 7659, 819, 1, 0, 0, 0, 7660, 7661, 3, 566, 283, 0, + 7661, 821, 1, 0, 0, 0, 7662, 7663, 7, 46, 0, 0, 7663, 823, 1, 0, 0, 0, + 7664, 7665, 5, 270, 0, 0, 7665, 7669, 5, 211, 0, 0, 7666, 7667, 5, 270, + 0, 0, 7667, 7669, 5, 244, 0, 0, 7668, 7664, 1, 0, 0, 0, 7668, 7666, 1, + 0, 0, 0, 7669, 825, 1, 0, 0, 0, 7670, 7672, 5, 46, 0, 0, 7671, 7673, 3, + 832, 416, 0, 7672, 7671, 1, 0, 0, 0, 7672, 7673, 1, 0, 0, 0, 7673, 7674, + 1, 0, 0, 0, 7674, 7675, 5, 215, 0, 0, 7675, 7676, 3, 1898, 949, 0, 7676, + 7686, 3, 834, 417, 0, 7677, 7684, 5, 314, 0, 0, 7678, 7685, 3, 856, 428, + 0, 7679, 7680, 5, 93, 0, 0, 7680, 7681, 5, 2, 0, 0, 7681, 7682, 3, 886, + 443, 0, 7682, 7683, 5, 3, 0, 0, 7683, 7685, 1, 0, 0, 0, 7684, 7678, 1, + 0, 0, 0, 7684, 7679, 1, 0, 0, 0, 7685, 7687, 1, 0, 0, 0, 7686, 7677, 1, + 0, 0, 0, 7686, 7687, 1, 0, 0, 0, 7687, 7688, 1, 0, 0, 0, 7688, 7689, 7, + 47, 0, 0, 7689, 7690, 3, 872, 436, 0, 7690, 827, 1, 0, 0, 0, 7691, 7693, + 5, 46, 0, 0, 7692, 7694, 3, 832, 416, 0, 7693, 7692, 1, 0, 0, 0, 7693, + 7694, 1, 0, 0, 0, 7694, 7695, 1, 0, 0, 0, 7695, 7696, 5, 294, 0, 0, 7696, + 7697, 3, 1898, 949, 0, 7697, 7707, 3, 838, 419, 0, 7698, 7705, 5, 314, + 0, 0, 7699, 7706, 3, 856, 428, 0, 7700, 7701, 5, 93, 0, 0, 7701, 7702, + 5, 2, 0, 0, 7702, 7703, 3, 886, 443, 0, 7703, 7704, 5, 3, 0, 0, 7704, 7706, + 1, 0, 0, 0, 7705, 7699, 1, 0, 0, 0, 7705, 7700, 1, 0, 0, 0, 7706, 7708, + 1, 0, 0, 0, 7707, 7698, 1, 0, 0, 0, 7707, 7708, 1, 0, 0, 0, 7708, 7710, + 1, 0, 0, 0, 7709, 7711, 3, 830, 415, 0, 7710, 7709, 1, 0, 0, 0, 7710, 7711, + 1, 0, 0, 0, 7711, 7712, 1, 0, 0, 0, 7712, 7713, 3, 872, 436, 0, 7713, 829, + 1, 0, 0, 0, 7714, 7715, 5, 469, 0, 0, 7715, 831, 1, 0, 0, 0, 7716, 7717, + 5, 82, 0, 0, 7717, 7718, 5, 309, 0, 0, 7718, 833, 1, 0, 0, 0, 7719, 7721, + 5, 2, 0, 0, 7720, 7722, 3, 836, 418, 0, 7721, 7720, 1, 0, 0, 0, 7721, 7722, + 1, 0, 0, 0, 7722, 7723, 1, 0, 0, 0, 7723, 7724, 5, 3, 0, 0, 7724, 835, + 1, 0, 0, 0, 7725, 7726, 3, 854, 427, 0, 7726, 7733, 3, 858, 429, 0, 7727, + 7728, 5, 6, 0, 0, 7728, 7729, 3, 854, 427, 0, 7729, 7730, 3, 858, 429, + 0, 7730, 7732, 1, 0, 0, 0, 7731, 7727, 1, 0, 0, 0, 7732, 7735, 1, 0, 0, + 0, 7733, 7731, 1, 0, 0, 0, 7733, 7734, 1, 0, 0, 0, 7734, 7745, 1, 0, 0, + 0, 7735, 7733, 1, 0, 0, 0, 7736, 7741, 3, 858, 429, 0, 7737, 7738, 5, 6, + 0, 0, 7738, 7740, 3, 858, 429, 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, 7745, 1, + 0, 0, 0, 7743, 7741, 1, 0, 0, 0, 7744, 7725, 1, 0, 0, 0, 7744, 7736, 1, + 0, 0, 0, 7745, 837, 1, 0, 0, 0, 7746, 7748, 5, 2, 0, 0, 7747, 7749, 3, + 840, 420, 0, 7748, 7747, 1, 0, 0, 0, 7748, 7749, 1, 0, 0, 0, 7749, 7750, + 1, 0, 0, 0, 7750, 7751, 5, 3, 0, 0, 7751, 839, 1, 0, 0, 0, 7752, 7757, + 3, 850, 425, 0, 7753, 7754, 5, 6, 0, 0, 7754, 7756, 3, 850, 425, 0, 7755, + 7753, 1, 0, 0, 0, 7756, 7759, 1, 0, 0, 0, 7757, 7755, 1, 0, 0, 0, 7757, + 7758, 1, 0, 0, 0, 7758, 841, 1, 0, 0, 0, 7759, 7757, 1, 0, 0, 0, 7760, + 7765, 3, 844, 422, 0, 7761, 7762, 5, 6, 0, 0, 7762, 7764, 3, 844, 422, + 0, 7763, 7761, 1, 0, 0, 0, 7764, 7767, 1, 0, 0, 0, 7765, 7763, 1, 0, 0, + 0, 7765, 7766, 1, 0, 0, 0, 7766, 843, 1, 0, 0, 0, 7767, 7765, 1, 0, 0, + 0, 7768, 7769, 3, 1898, 949, 0, 7769, 7770, 3, 838, 419, 0, 7770, 7777, + 1, 0, 0, 0, 7771, 7777, 3, 1942, 971, 0, 7772, 7774, 3, 1924, 962, 0, 7773, + 7775, 3, 1874, 937, 0, 7774, 7773, 1, 0, 0, 0, 7774, 7775, 1, 0, 0, 0, + 7775, 7777, 1, 0, 0, 0, 7776, 7768, 1, 0, 0, 0, 7776, 7771, 1, 0, 0, 0, + 7776, 7772, 1, 0, 0, 0, 7777, 845, 1, 0, 0, 0, 7778, 7780, 5, 2, 0, 0, + 7779, 7781, 3, 848, 424, 0, 7780, 7779, 1, 0, 0, 0, 7780, 7781, 1, 0, 0, + 0, 7781, 7782, 1, 0, 0, 0, 7782, 7783, 5, 3, 0, 0, 7783, 847, 1, 0, 0, + 0, 7784, 7789, 3, 860, 430, 0, 7785, 7786, 5, 6, 0, 0, 7786, 7788, 3, 860, + 430, 0, 7787, 7785, 1, 0, 0, 0, 7788, 7791, 1, 0, 0, 0, 7789, 7787, 1, + 0, 0, 0, 7789, 7790, 1, 0, 0, 0, 7790, 849, 1, 0, 0, 0, 7791, 7789, 1, + 0, 0, 0, 7792, 7794, 3, 852, 426, 0, 7793, 7795, 3, 854, 427, 0, 7794, + 7793, 1, 0, 0, 0, 7794, 7795, 1, 0, 0, 0, 7795, 7796, 1, 0, 0, 0, 7796, + 7797, 3, 858, 429, 0, 7797, 7806, 1, 0, 0, 0, 7798, 7800, 3, 854, 427, + 0, 7799, 7801, 3, 852, 426, 0, 7800, 7799, 1, 0, 0, 0, 7800, 7801, 1, 0, + 0, 0, 7801, 7802, 1, 0, 0, 0, 7802, 7803, 3, 858, 429, 0, 7803, 7806, 1, + 0, 0, 0, 7804, 7806, 3, 858, 429, 0, 7805, 7792, 1, 0, 0, 0, 7805, 7798, + 1, 0, 0, 0, 7805, 7804, 1, 0, 0, 0, 7806, 851, 1, 0, 0, 0, 7807, 7808, + 7, 48, 0, 0, 7808, 853, 1, 0, 0, 0, 7809, 7814, 3, 1928, 964, 0, 7810, + 7814, 3, 1946, 973, 0, 7811, 7814, 5, 121, 0, 0, 7812, 7814, 5, 128, 0, + 0, 7813, 7809, 1, 0, 0, 0, 7813, 7810, 1, 0, 0, 0, 7813, 7811, 1, 0, 0, + 0, 7813, 7812, 1, 0, 0, 0, 7814, 855, 1, 0, 0, 0, 7815, 7816, 3, 858, 429, + 0, 7816, 857, 1, 0, 0, 0, 7817, 7832, 3, 1662, 831, 0, 7818, 7820, 5, 578, + 0, 0, 7819, 7818, 1, 0, 0, 0, 7819, 7820, 1, 0, 0, 0, 7820, 7825, 1, 0, + 0, 0, 7821, 7826, 3, 1946, 973, 0, 7822, 7826, 3, 1928, 964, 0, 7823, 7826, + 5, 121, 0, 0, 7824, 7826, 5, 128, 0, 0, 7825, 7821, 1, 0, 0, 0, 7825, 7822, + 1, 0, 0, 0, 7825, 7823, 1, 0, 0, 0, 7825, 7824, 1, 0, 0, 0, 7826, 7827, + 1, 0, 0, 0, 7827, 7828, 3, 568, 284, 0, 7828, 7829, 5, 27, 0, 0, 7829, + 7830, 5, 358, 0, 0, 7830, 7832, 1, 0, 0, 0, 7831, 7817, 1, 0, 0, 0, 7831, + 7819, 1, 0, 0, 0, 7832, 859, 1, 0, 0, 0, 7833, 7836, 3, 850, 425, 0, 7834, + 7835, 7, 49, 0, 0, 7835, 7837, 3, 1710, 855, 0, 7836, 7834, 1, 0, 0, 0, + 7836, 7837, 1, 0, 0, 0, 7837, 861, 1, 0, 0, 0, 7838, 7839, 3, 850, 425, + 0, 7839, 863, 1, 0, 0, 0, 7840, 7851, 5, 2, 0, 0, 7841, 7852, 5, 9, 0, + 0, 7842, 7852, 3, 866, 433, 0, 7843, 7844, 5, 83, 0, 0, 7844, 7845, 5, + 149, 0, 0, 7845, 7852, 3, 866, 433, 0, 7846, 7847, 3, 866, 433, 0, 7847, + 7848, 5, 83, 0, 0, 7848, 7849, 5, 149, 0, 0, 7849, 7850, 3, 866, 433, 0, + 7850, 7852, 1, 0, 0, 0, 7851, 7841, 1, 0, 0, 0, 7851, 7842, 1, 0, 0, 0, + 7851, 7843, 1, 0, 0, 0, 7851, 7846, 1, 0, 0, 0, 7852, 7853, 1, 0, 0, 0, + 7853, 7854, 5, 3, 0, 0, 7854, 865, 1, 0, 0, 0, 7855, 7860, 3, 862, 431, + 0, 7856, 7857, 5, 6, 0, 0, 7857, 7859, 3, 862, 431, 0, 7858, 7856, 1, 0, + 0, 0, 7859, 7862, 1, 0, 0, 0, 7860, 7858, 1, 0, 0, 0, 7860, 7861, 1, 0, + 0, 0, 7861, 867, 1, 0, 0, 0, 7862, 7860, 1, 0, 0, 0, 7863, 7864, 3, 1898, + 949, 0, 7864, 7865, 3, 864, 432, 0, 7865, 869, 1, 0, 0, 0, 7866, 7871, + 3, 868, 434, 0, 7867, 7868, 5, 6, 0, 0, 7868, 7870, 3, 868, 434, 0, 7869, + 7867, 1, 0, 0, 0, 7870, 7873, 1, 0, 0, 0, 7871, 7869, 1, 0, 0, 0, 7871, + 7872, 1, 0, 0, 0, 7872, 871, 1, 0, 0, 0, 7873, 7871, 1, 0, 0, 0, 7874, + 7876, 3, 876, 438, 0, 7875, 7874, 1, 0, 0, 0, 7876, 7877, 1, 0, 0, 0, 7877, + 7875, 1, 0, 0, 0, 7877, 7878, 1, 0, 0, 0, 7878, 7879, 1, 0, 0, 0, 7879, + 7880, 6, 436, -1, 0, 7880, 873, 1, 0, 0, 0, 7881, 7882, 5, 151, 0, 0, 7882, + 7883, 5, 80, 0, 0, 7883, 7884, 5, 78, 0, 0, 7884, 7917, 5, 657, 0, 0, 7885, + 7886, 5, 314, 0, 0, 7886, 7887, 5, 78, 0, 0, 7887, 7888, 5, 80, 0, 0, 7888, + 7889, 5, 78, 0, 0, 7889, 7917, 5, 657, 0, 0, 7890, 7917, 5, 344, 0, 0, + 7891, 7917, 5, 226, 0, 0, 7892, 7917, 5, 336, 0, 0, 7893, 7917, 5, 375, + 0, 0, 7894, 7895, 5, 209, 0, 0, 7895, 7896, 5, 325, 0, 0, 7896, 7917, 5, + 185, 0, 0, 7897, 7898, 5, 209, 0, 0, 7898, 7899, 5, 325, 0, 0, 7899, 7917, + 5, 238, 0, 0, 7900, 7901, 5, 325, 0, 0, 7901, 7917, 5, 185, 0, 0, 7902, + 7903, 5, 325, 0, 0, 7903, 7917, 5, 238, 0, 0, 7904, 7917, 5, 245, 0, 0, + 7905, 7906, 5, 77, 0, 0, 7906, 7917, 5, 245, 0, 0, 7907, 7908, 5, 172, + 0, 0, 7908, 7917, 3, 334, 167, 0, 7909, 7910, 5, 318, 0, 0, 7910, 7917, + 3, 334, 167, 0, 7911, 7912, 5, 658, 0, 0, 7912, 7917, 3, 566, 283, 0, 7913, + 7917, 3, 92, 46, 0, 7914, 7915, 5, 659, 0, 0, 7915, 7917, 3, 1924, 962, + 0, 7916, 7881, 1, 0, 0, 0, 7916, 7885, 1, 0, 0, 0, 7916, 7890, 1, 0, 0, + 0, 7916, 7891, 1, 0, 0, 0, 7916, 7892, 1, 0, 0, 0, 7916, 7893, 1, 0, 0, + 0, 7916, 7894, 1, 0, 0, 0, 7916, 7897, 1, 0, 0, 0, 7916, 7900, 1, 0, 0, + 0, 7916, 7902, 1, 0, 0, 0, 7916, 7904, 1, 0, 0, 0, 7916, 7905, 1, 0, 0, + 0, 7916, 7907, 1, 0, 0, 0, 7916, 7909, 1, 0, 0, 0, 7916, 7911, 1, 0, 0, + 0, 7916, 7913, 1, 0, 0, 0, 7916, 7914, 1, 0, 0, 0, 7917, 875, 1, 0, 0, + 0, 7918, 7919, 5, 36, 0, 0, 7919, 7932, 3, 878, 439, 0, 7920, 7921, 5, + 148, 0, 0, 7921, 7922, 5, 548, 0, 0, 7922, 7923, 3, 6, 3, 0, 7923, 7924, + 5, 653, 0, 0, 7924, 7932, 1, 0, 0, 0, 7925, 7926, 5, 242, 0, 0, 7926, 7932, + 3, 82, 41, 0, 7927, 7928, 5, 641, 0, 0, 7928, 7932, 3, 880, 440, 0, 7929, + 7932, 5, 105, 0, 0, 7930, 7932, 3, 874, 437, 0, 7931, 7918, 1, 0, 0, 0, + 7931, 7920, 1, 0, 0, 0, 7931, 7925, 1, 0, 0, 0, 7931, 7927, 1, 0, 0, 0, + 7931, 7929, 1, 0, 0, 0, 7931, 7930, 1, 0, 0, 0, 7932, 877, 1, 0, 0, 0, + 7933, 7939, 3, 1910, 955, 0, 7934, 7935, 3, 1910, 955, 0, 7935, 7936, 5, + 6, 0, 0, 7936, 7937, 3, 1910, 955, 0, 7937, 7939, 1, 0, 0, 0, 7938, 7933, + 1, 0, 0, 0, 7938, 7934, 1, 0, 0, 0, 7939, 879, 1, 0, 0, 0, 7940, 7941, + 5, 62, 0, 0, 7941, 7942, 5, 358, 0, 0, 7942, 7949, 3, 1662, 831, 0, 7943, + 7944, 5, 6, 0, 0, 7944, 7945, 5, 62, 0, 0, 7945, 7946, 5, 358, 0, 0, 7946, + 7948, 3, 1662, 831, 0, 7947, 7943, 1, 0, 0, 0, 7948, 7951, 1, 0, 0, 0, + 7949, 7947, 1, 0, 0, 0, 7949, 7950, 1, 0, 0, 0, 7950, 881, 1, 0, 0, 0, + 7951, 7949, 1, 0, 0, 0, 7952, 7953, 5, 106, 0, 0, 7953, 7954, 3, 502, 251, + 0, 7954, 883, 1, 0, 0, 0, 7955, 7956, 3, 854, 427, 0, 7956, 7957, 3, 858, + 429, 0, 7957, 885, 1, 0, 0, 0, 7958, 7963, 3, 884, 442, 0, 7959, 7960, + 5, 6, 0, 0, 7960, 7962, 3, 884, 442, 0, 7961, 7959, 1, 0, 0, 0, 7962, 7965, + 1, 0, 0, 0, 7963, 7961, 1, 0, 0, 0, 7963, 7964, 1, 0, 0, 0, 7964, 887, + 1, 0, 0, 0, 7965, 7963, 1, 0, 0, 0, 7966, 7967, 5, 140, 0, 0, 7967, 7968, + 5, 215, 0, 0, 7968, 7969, 3, 1898, 949, 0, 7969, 7976, 3, 834, 417, 0, + 7970, 7971, 5, 307, 0, 0, 7971, 7972, 5, 95, 0, 0, 7972, 7977, 3, 1898, + 949, 0, 7973, 7974, 5, 279, 0, 0, 7974, 7975, 5, 95, 0, 0, 7975, 7977, + 3, 1920, 960, 0, 7976, 7970, 1, 0, 0, 0, 7976, 7973, 1, 0, 0, 0, 7977, + 889, 1, 0, 0, 0, 7978, 7979, 5, 140, 0, 0, 7979, 7980, 5, 294, 0, 0, 7980, + 7981, 3, 1898, 949, 0, 7981, 7988, 3, 838, 419, 0, 7982, 7983, 5, 307, + 0, 0, 7983, 7984, 5, 95, 0, 0, 7984, 7989, 3, 1898, 949, 0, 7985, 7986, + 5, 279, 0, 0, 7986, 7987, 5, 95, 0, 0, 7987, 7989, 3, 1920, 960, 0, 7988, + 7982, 1, 0, 0, 0, 7988, 7985, 1, 0, 0, 0, 7989, 891, 1, 0, 0, 0, 7990, + 7992, 3, 874, 437, 0, 7991, 7990, 1, 0, 0, 0, 7992, 7993, 1, 0, 0, 0, 7993, + 7991, 1, 0, 0, 0, 7993, 7994, 1, 0, 0, 0, 7994, 893, 1, 0, 0, 0, 7995, + 7996, 5, 313, 0, 0, 7996, 895, 1, 0, 0, 0, 7997, 7998, 5, 195, 0, 0, 7998, + 7999, 5, 215, 0, 0, 7999, 8001, 3, 842, 421, 0, 8000, 8002, 3, 120, 60, + 0, 8001, 8000, 1, 0, 0, 0, 8001, 8002, 1, 0, 0, 0, 8002, 8040, 1, 0, 0, + 0, 8003, 8004, 5, 195, 0, 0, 8004, 8005, 5, 215, 0, 0, 8005, 8006, 5, 224, + 0, 0, 8006, 8007, 5, 558, 0, 0, 8007, 8009, 3, 842, 421, 0, 8008, 8010, + 3, 120, 60, 0, 8009, 8008, 1, 0, 0, 0, 8009, 8010, 1, 0, 0, 0, 8010, 8040, + 1, 0, 0, 0, 8011, 8012, 5, 195, 0, 0, 8012, 8013, 5, 294, 0, 0, 8013, 8015, + 3, 842, 421, 0, 8014, 8016, 3, 120, 60, 0, 8015, 8014, 1, 0, 0, 0, 8015, + 8016, 1, 0, 0, 0, 8016, 8040, 1, 0, 0, 0, 8017, 8018, 5, 195, 0, 0, 8018, + 8019, 5, 294, 0, 0, 8019, 8020, 5, 224, 0, 0, 8020, 8021, 5, 558, 0, 0, + 8021, 8023, 3, 842, 421, 0, 8022, 8024, 3, 120, 60, 0, 8023, 8022, 1, 0, + 0, 0, 8023, 8024, 1, 0, 0, 0, 8024, 8040, 1, 0, 0, 0, 8025, 8026, 5, 195, + 0, 0, 8026, 8027, 5, 640, 0, 0, 8027, 8029, 3, 842, 421, 0, 8028, 8030, + 3, 120, 60, 0, 8029, 8028, 1, 0, 0, 0, 8029, 8030, 1, 0, 0, 0, 8030, 8040, + 1, 0, 0, 0, 8031, 8032, 5, 195, 0, 0, 8032, 8033, 5, 640, 0, 0, 8033, 8034, + 5, 224, 0, 0, 8034, 8035, 5, 558, 0, 0, 8035, 8037, 3, 842, 421, 0, 8036, + 8038, 3, 120, 60, 0, 8037, 8036, 1, 0, 0, 0, 8037, 8038, 1, 0, 0, 0, 8038, + 8040, 1, 0, 0, 0, 8039, 7997, 1, 0, 0, 0, 8039, 8003, 1, 0, 0, 0, 8039, + 8011, 1, 0, 0, 0, 8039, 8017, 1, 0, 0, 0, 8039, 8025, 1, 0, 0, 0, 8039, + 8031, 1, 0, 0, 0, 8040, 897, 1, 0, 0, 0, 8041, 8042, 5, 195, 0, 0, 8042, + 8043, 5, 138, 0, 0, 8043, 8045, 3, 870, 435, 0, 8044, 8046, 3, 120, 60, + 0, 8045, 8044, 1, 0, 0, 0, 8045, 8046, 1, 0, 0, 0, 8046, 8056, 1, 0, 0, + 0, 8047, 8048, 5, 195, 0, 0, 8048, 8049, 5, 138, 0, 0, 8049, 8050, 5, 224, + 0, 0, 8050, 8051, 5, 558, 0, 0, 8051, 8053, 3, 870, 435, 0, 8052, 8054, + 3, 120, 60, 0, 8053, 8052, 1, 0, 0, 0, 8053, 8054, 1, 0, 0, 0, 8054, 8056, + 1, 0, 0, 0, 8055, 8041, 1, 0, 0, 0, 8055, 8047, 1, 0, 0, 0, 8056, 899, + 1, 0, 0, 0, 8057, 8058, 5, 195, 0, 0, 8058, 8059, 5, 275, 0, 0, 8059, 8061, + 3, 906, 453, 0, 8060, 8062, 3, 120, 60, 0, 8061, 8060, 1, 0, 0, 0, 8061, + 8062, 1, 0, 0, 0, 8062, 8072, 1, 0, 0, 0, 8063, 8064, 5, 195, 0, 0, 8064, + 8065, 5, 275, 0, 0, 8065, 8066, 5, 224, 0, 0, 8066, 8067, 5, 558, 0, 0, + 8067, 8069, 3, 906, 453, 0, 8068, 8070, 3, 120, 60, 0, 8069, 8068, 1, 0, + 0, 0, 8069, 8070, 1, 0, 0, 0, 8070, 8072, 1, 0, 0, 0, 8071, 8057, 1, 0, + 0, 0, 8071, 8063, 1, 0, 0, 0, 8072, 901, 1, 0, 0, 0, 8073, 8074, 5, 2, + 0, 0, 8074, 8075, 3, 1662, 831, 0, 8075, 8076, 5, 3, 0, 0, 8076, 8096, + 1, 0, 0, 0, 8077, 8078, 5, 2, 0, 0, 8078, 8079, 3, 1662, 831, 0, 8079, + 8080, 5, 6, 0, 0, 8080, 8081, 3, 1662, 831, 0, 8081, 8082, 5, 3, 0, 0, + 8082, 8096, 1, 0, 0, 0, 8083, 8084, 5, 2, 0, 0, 8084, 8085, 5, 569, 0, + 0, 8085, 8086, 5, 6, 0, 0, 8086, 8087, 3, 1662, 831, 0, 8087, 8088, 5, + 3, 0, 0, 8088, 8096, 1, 0, 0, 0, 8089, 8090, 5, 2, 0, 0, 8090, 8091, 3, + 1662, 831, 0, 8091, 8092, 5, 6, 0, 0, 8092, 8093, 5, 569, 0, 0, 8093, 8094, + 5, 3, 0, 0, 8094, 8096, 1, 0, 0, 0, 8095, 8073, 1, 0, 0, 0, 8095, 8077, + 1, 0, 0, 0, 8095, 8083, 1, 0, 0, 0, 8095, 8089, 1, 0, 0, 0, 8096, 903, + 1, 0, 0, 0, 8097, 8098, 3, 1924, 962, 0, 8098, 8099, 5, 11, 0, 0, 8099, + 8101, 1, 0, 0, 0, 8100, 8097, 1, 0, 0, 0, 8101, 8104, 1, 0, 0, 0, 8102, + 8100, 1, 0, 0, 0, 8102, 8103, 1, 0, 0, 0, 8103, 8105, 1, 0, 0, 0, 8104, + 8102, 1, 0, 0, 0, 8105, 8106, 3, 1820, 910, 0, 8106, 905, 1, 0, 0, 0, 8107, + 8112, 3, 908, 454, 0, 8108, 8109, 5, 6, 0, 0, 8109, 8111, 3, 908, 454, + 0, 8110, 8108, 1, 0, 0, 0, 8111, 8114, 1, 0, 0, 0, 8112, 8110, 1, 0, 0, + 0, 8112, 8113, 1, 0, 0, 0, 8113, 907, 1, 0, 0, 0, 8114, 8112, 1, 0, 0, + 0, 8115, 8116, 3, 904, 452, 0, 8116, 8117, 3, 902, 451, 0, 8117, 909, 1, + 0, 0, 0, 8118, 8119, 5, 57, 0, 0, 8119, 8120, 3, 912, 456, 0, 8120, 911, + 1, 0, 0, 0, 8121, 8123, 3, 914, 457, 0, 8122, 8121, 1, 0, 0, 0, 8123, 8124, + 1, 0, 0, 0, 8124, 8122, 1, 0, 0, 0, 8124, 8125, 1, 0, 0, 0, 8125, 913, + 1, 0, 0, 0, 8126, 8130, 3, 1910, 955, 0, 8127, 8128, 5, 242, 0, 0, 8128, + 8130, 3, 82, 41, 0, 8129, 8126, 1, 0, 0, 0, 8129, 8127, 1, 0, 0, 0, 8130, + 915, 1, 0, 0, 0, 8131, 8132, 5, 46, 0, 0, 8132, 8133, 5, 41, 0, 0, 8133, + 8134, 5, 2, 0, 0, 8134, 8135, 3, 1662, 831, 0, 8135, 8136, 5, 36, 0, 0, + 8136, 8137, 3, 1662, 831, 0, 8137, 8138, 5, 3, 0, 0, 8138, 8139, 5, 106, + 0, 0, 8139, 8140, 5, 215, 0, 0, 8140, 8142, 3, 844, 422, 0, 8141, 8143, + 3, 918, 459, 0, 8142, 8141, 1, 0, 0, 0, 8142, 8143, 1, 0, 0, 0, 8143, 8169, + 1, 0, 0, 0, 8144, 8145, 5, 46, 0, 0, 8145, 8146, 5, 41, 0, 0, 8146, 8147, + 5, 2, 0, 0, 8147, 8148, 3, 1662, 831, 0, 8148, 8149, 5, 36, 0, 0, 8149, + 8150, 3, 1662, 831, 0, 8150, 8151, 5, 3, 0, 0, 8151, 8152, 5, 377, 0, 0, + 8152, 8154, 5, 215, 0, 0, 8153, 8155, 3, 918, 459, 0, 8154, 8153, 1, 0, + 0, 0, 8154, 8155, 1, 0, 0, 0, 8155, 8169, 1, 0, 0, 0, 8156, 8157, 5, 46, + 0, 0, 8157, 8158, 5, 41, 0, 0, 8158, 8159, 5, 2, 0, 0, 8159, 8160, 3, 1662, + 831, 0, 8160, 8161, 5, 36, 0, 0, 8161, 8162, 3, 1662, 831, 0, 8162, 8163, + 5, 3, 0, 0, 8163, 8164, 5, 106, 0, 0, 8164, 8166, 5, 562, 0, 0, 8165, 8167, + 3, 918, 459, 0, 8166, 8165, 1, 0, 0, 0, 8166, 8167, 1, 0, 0, 0, 8167, 8169, + 1, 0, 0, 0, 8168, 8131, 1, 0, 0, 0, 8168, 8144, 1, 0, 0, 0, 8168, 8156, + 1, 0, 0, 0, 8169, 917, 1, 0, 0, 0, 8170, 8171, 5, 36, 0, 0, 8171, 8175, + 5, 227, 0, 0, 8172, 8173, 5, 36, 0, 0, 8173, 8175, 5, 143, 0, 0, 8174, + 8170, 1, 0, 0, 0, 8174, 8172, 1, 0, 0, 0, 8175, 919, 1, 0, 0, 0, 8176, + 8177, 5, 195, 0, 0, 8177, 8179, 5, 41, 0, 0, 8178, 8180, 3, 922, 461, 0, + 8179, 8178, 1, 0, 0, 0, 8179, 8180, 1, 0, 0, 0, 8180, 8181, 1, 0, 0, 0, + 8181, 8182, 5, 2, 0, 0, 8182, 8183, 3, 1662, 831, 0, 8183, 8184, 5, 36, + 0, 0, 8184, 8185, 3, 1662, 831, 0, 8185, 8187, 5, 3, 0, 0, 8186, 8188, + 3, 120, 60, 0, 8187, 8186, 1, 0, 0, 0, 8187, 8188, 1, 0, 0, 0, 8188, 921, + 1, 0, 0, 0, 8189, 8190, 5, 224, 0, 0, 8190, 8191, 5, 558, 0, 0, 8191, 923, + 1, 0, 0, 0, 8192, 8194, 5, 46, 0, 0, 8193, 8195, 3, 832, 416, 0, 8194, + 8193, 1, 0, 0, 0, 8194, 8195, 1, 0, 0, 0, 8195, 8196, 1, 0, 0, 0, 8196, + 8197, 5, 641, 0, 0, 8197, 8198, 5, 62, 0, 0, 8198, 8199, 3, 1662, 831, + 0, 8199, 8200, 5, 242, 0, 0, 8200, 8201, 3, 1892, 946, 0, 8201, 8202, 5, + 2, 0, 0, 8202, 8203, 3, 926, 463, 0, 8203, 8204, 5, 3, 0, 0, 8204, 925, + 1, 0, 0, 0, 8205, 8206, 5, 64, 0, 0, 8206, 8207, 5, 660, 0, 0, 8207, 8208, + 5, 106, 0, 0, 8208, 8209, 5, 215, 0, 0, 8209, 8210, 3, 844, 422, 0, 8210, + 8211, 5, 6, 0, 0, 8211, 8212, 5, 95, 0, 0, 8212, 8213, 5, 660, 0, 0, 8213, + 8214, 5, 106, 0, 0, 8214, 8215, 5, 215, 0, 0, 8215, 8216, 3, 844, 422, + 0, 8216, 8240, 1, 0, 0, 0, 8217, 8218, 5, 95, 0, 0, 8218, 8219, 5, 660, + 0, 0, 8219, 8220, 5, 106, 0, 0, 8220, 8221, 5, 215, 0, 0, 8221, 8222, 3, + 844, 422, 0, 8222, 8223, 5, 6, 0, 0, 8223, 8224, 5, 64, 0, 0, 8224, 8225, + 5, 660, 0, 0, 8225, 8226, 5, 106, 0, 0, 8226, 8227, 5, 215, 0, 0, 8227, + 8228, 3, 844, 422, 0, 8228, 8240, 1, 0, 0, 0, 8229, 8230, 5, 64, 0, 0, + 8230, 8231, 5, 660, 0, 0, 8231, 8232, 5, 106, 0, 0, 8232, 8233, 5, 215, + 0, 0, 8233, 8240, 3, 844, 422, 0, 8234, 8235, 5, 95, 0, 0, 8235, 8236, + 5, 660, 0, 0, 8236, 8237, 5, 106, 0, 0, 8237, 8238, 5, 215, 0, 0, 8238, + 8240, 3, 844, 422, 0, 8239, 8205, 1, 0, 0, 0, 8239, 8217, 1, 0, 0, 0, 8239, + 8229, 1, 0, 0, 0, 8239, 8234, 1, 0, 0, 0, 8240, 927, 1, 0, 0, 0, 8241, + 8242, 5, 195, 0, 0, 8242, 8244, 5, 641, 0, 0, 8243, 8245, 3, 922, 461, + 0, 8244, 8243, 1, 0, 0, 0, 8244, 8245, 1, 0, 0, 0, 8245, 8246, 1, 0, 0, + 0, 8246, 8247, 5, 62, 0, 0, 8247, 8248, 3, 1662, 831, 0, 8248, 8249, 5, + 242, 0, 0, 8249, 8251, 3, 1892, 946, 0, 8250, 8252, 3, 120, 60, 0, 8251, + 8250, 1, 0, 0, 0, 8251, 8252, 1, 0, 0, 0, 8252, 929, 1, 0, 0, 0, 8253, + 8254, 5, 304, 0, 0, 8254, 8256, 3, 932, 466, 0, 8255, 8257, 3, 802, 401, + 0, 8256, 8255, 1, 0, 0, 0, 8256, 8257, 1, 0, 0, 0, 8257, 8258, 1, 0, 0, + 0, 8258, 8259, 3, 1888, 944, 0, 8259, 8288, 1, 0, 0, 0, 8260, 8261, 5, + 304, 0, 0, 8261, 8263, 3, 934, 467, 0, 8262, 8264, 3, 802, 401, 0, 8263, + 8262, 1, 0, 0, 0, 8263, 8264, 1, 0, 0, 0, 8264, 8265, 1, 0, 0, 0, 8265, + 8266, 3, 1892, 946, 0, 8266, 8288, 1, 0, 0, 0, 8267, 8268, 5, 304, 0, 0, + 8268, 8269, 5, 2, 0, 0, 8269, 8270, 3, 936, 468, 0, 8270, 8271, 5, 3, 0, + 0, 8271, 8273, 3, 932, 466, 0, 8272, 8274, 3, 802, 401, 0, 8273, 8272, + 1, 0, 0, 0, 8273, 8274, 1, 0, 0, 0, 8274, 8275, 1, 0, 0, 0, 8275, 8276, + 3, 1888, 944, 0, 8276, 8288, 1, 0, 0, 0, 8277, 8278, 5, 304, 0, 0, 8278, + 8279, 5, 2, 0, 0, 8279, 8280, 3, 936, 468, 0, 8280, 8281, 5, 3, 0, 0, 8281, + 8283, 3, 934, 467, 0, 8282, 8284, 3, 802, 401, 0, 8283, 8282, 1, 0, 0, + 0, 8283, 8284, 1, 0, 0, 0, 8284, 8285, 1, 0, 0, 0, 8285, 8286, 3, 1892, + 946, 0, 8286, 8288, 1, 0, 0, 0, 8287, 8253, 1, 0, 0, 0, 8287, 8260, 1, + 0, 0, 0, 8287, 8267, 1, 0, 0, 0, 8287, 8277, 1, 0, 0, 0, 8288, 931, 1, + 0, 0, 0, 8289, 8290, 7, 50, 0, 0, 8290, 933, 1, 0, 0, 0, 8291, 8292, 7, + 51, 0, 0, 8292, 935, 1, 0, 0, 0, 8293, 8298, 3, 938, 469, 0, 8294, 8295, + 5, 6, 0, 0, 8295, 8297, 3, 938, 469, 0, 8296, 8294, 1, 0, 0, 0, 8297, 8300, + 1, 0, 0, 0, 8298, 8296, 1, 0, 0, 0, 8298, 8299, 1, 0, 0, 0, 8299, 937, + 1, 0, 0, 0, 8300, 8298, 1, 0, 0, 0, 8301, 8302, 7, 52, 0, 0, 8302, 939, + 1, 0, 0, 0, 8303, 8304, 5, 140, 0, 0, 8304, 8305, 5, 349, 0, 0, 8305, 8306, + 3, 1892, 946, 0, 8306, 8307, 5, 331, 0, 0, 8307, 8308, 3, 128, 64, 0, 8308, + 8316, 1, 0, 0, 0, 8309, 8310, 5, 140, 0, 0, 8310, 8311, 5, 349, 0, 0, 8311, + 8312, 3, 1892, 946, 0, 8312, 8313, 5, 311, 0, 0, 8313, 8314, 3, 128, 64, + 0, 8314, 8316, 1, 0, 0, 0, 8315, 8303, 1, 0, 0, 0, 8315, 8309, 1, 0, 0, + 0, 8316, 941, 1, 0, 0, 0, 8317, 8318, 5, 140, 0, 0, 8318, 8319, 5, 138, + 0, 0, 8319, 8320, 3, 868, 434, 0, 8320, 8321, 5, 307, 0, 0, 8321, 8322, + 5, 95, 0, 0, 8322, 8323, 3, 1892, 946, 0, 8323, 8805, 1, 0, 0, 0, 8324, + 8325, 5, 140, 0, 0, 8325, 8326, 5, 110, 0, 0, 8326, 8327, 3, 566, 283, + 0, 8327, 8328, 5, 307, 0, 0, 8328, 8329, 5, 95, 0, 0, 8329, 8330, 3, 1892, + 946, 0, 8330, 8805, 1, 0, 0, 0, 8331, 8332, 5, 140, 0, 0, 8332, 8333, 5, + 170, 0, 0, 8333, 8334, 3, 566, 283, 0, 8334, 8335, 5, 307, 0, 0, 8335, + 8336, 5, 95, 0, 0, 8336, 8337, 3, 1892, 946, 0, 8337, 8805, 1, 0, 0, 0, + 8338, 8339, 5, 140, 0, 0, 8339, 8340, 5, 179, 0, 0, 8340, 8341, 3, 1892, + 946, 0, 8341, 8342, 5, 307, 0, 0, 8342, 8343, 5, 95, 0, 0, 8343, 8344, + 3, 1892, 946, 0, 8344, 8805, 1, 0, 0, 0, 8345, 8346, 5, 140, 0, 0, 8346, + 8347, 5, 193, 0, 0, 8347, 8348, 3, 566, 283, 0, 8348, 8349, 5, 307, 0, + 0, 8349, 8350, 5, 95, 0, 0, 8350, 8351, 3, 1892, 946, 0, 8351, 8805, 1, + 0, 0, 0, 8352, 8353, 5, 140, 0, 0, 8353, 8354, 5, 193, 0, 0, 8354, 8355, + 3, 566, 283, 0, 8355, 8356, 5, 307, 0, 0, 8356, 8357, 5, 45, 0, 0, 8357, + 8358, 3, 1892, 946, 0, 8358, 8359, 5, 95, 0, 0, 8359, 8360, 3, 1892, 946, + 0, 8360, 8805, 1, 0, 0, 0, 8361, 8362, 5, 140, 0, 0, 8362, 8363, 5, 63, + 0, 0, 8363, 8364, 5, 177, 0, 0, 8364, 8365, 5, 379, 0, 0, 8365, 8366, 3, + 1892, 946, 0, 8366, 8367, 5, 307, 0, 0, 8367, 8368, 5, 95, 0, 0, 8368, + 8369, 3, 1892, 946, 0, 8369, 8805, 1, 0, 0, 0, 8370, 8371, 5, 140, 0, 0, + 8371, 8372, 5, 215, 0, 0, 8372, 8373, 3, 844, 422, 0, 8373, 8374, 5, 307, + 0, 0, 8374, 8375, 5, 95, 0, 0, 8375, 8376, 3, 1892, 946, 0, 8376, 8805, + 1, 0, 0, 0, 8377, 8378, 5, 140, 0, 0, 8378, 8379, 5, 66, 0, 0, 8379, 8380, + 3, 1918, 959, 0, 8380, 8381, 5, 307, 0, 0, 8381, 8382, 5, 95, 0, 0, 8382, + 8383, 3, 1918, 959, 0, 8383, 8805, 1, 0, 0, 0, 8384, 8386, 5, 140, 0, 0, + 8385, 8387, 3, 350, 175, 0, 8386, 8385, 1, 0, 0, 0, 8386, 8387, 1, 0, 0, + 0, 8387, 8388, 1, 0, 0, 0, 8388, 8389, 5, 242, 0, 0, 8389, 8390, 3, 1892, + 946, 0, 8390, 8391, 5, 307, 0, 0, 8391, 8392, 5, 95, 0, 0, 8392, 8393, + 3, 1892, 946, 0, 8393, 8805, 1, 0, 0, 0, 8394, 8395, 5, 140, 0, 0, 8395, + 8396, 5, 275, 0, 0, 8396, 8397, 5, 158, 0, 0, 8397, 8398, 3, 566, 283, + 0, 8398, 8399, 5, 101, 0, 0, 8399, 8400, 3, 1892, 946, 0, 8400, 8401, 5, + 307, 0, 0, 8401, 8402, 5, 95, 0, 0, 8402, 8403, 3, 1892, 946, 0, 8403, + 8805, 1, 0, 0, 0, 8404, 8405, 5, 140, 0, 0, 8405, 8406, 5, 275, 0, 0, 8406, + 8407, 5, 210, 0, 0, 8407, 8408, 3, 566, 283, 0, 8408, 8409, 5, 101, 0, + 0, 8409, 8410, 3, 1892, 946, 0, 8410, 8411, 5, 307, 0, 0, 8411, 8412, 5, + 95, 0, 0, 8412, 8413, 3, 1892, 946, 0, 8413, 8805, 1, 0, 0, 0, 8414, 8415, + 5, 140, 0, 0, 8415, 8416, 5, 643, 0, 0, 8416, 8417, 3, 1892, 946, 0, 8417, + 8418, 5, 80, 0, 0, 8418, 8419, 3, 1888, 944, 0, 8419, 8420, 5, 307, 0, + 0, 8420, 8421, 5, 95, 0, 0, 8421, 8422, 3, 1892, 946, 0, 8422, 8805, 1, + 0, 0, 0, 8423, 8424, 5, 140, 0, 0, 8424, 8425, 5, 643, 0, 0, 8425, 8426, + 5, 224, 0, 0, 8426, 8427, 5, 558, 0, 0, 8427, 8428, 3, 1892, 946, 0, 8428, + 8429, 5, 80, 0, 0, 8429, 8430, 3, 1888, 944, 0, 8430, 8431, 5, 307, 0, + 0, 8431, 8432, 5, 95, 0, 0, 8432, 8433, 3, 1892, 946, 0, 8433, 8805, 1, + 0, 0, 0, 8434, 8435, 5, 140, 0, 0, 8435, 8436, 5, 294, 0, 0, 8436, 8437, + 3, 844, 422, 0, 8437, 8438, 5, 307, 0, 0, 8438, 8439, 5, 95, 0, 0, 8439, + 8440, 3, 1892, 946, 0, 8440, 8805, 1, 0, 0, 0, 8441, 8442, 5, 140, 0, 0, + 8442, 8443, 5, 651, 0, 0, 8443, 8444, 3, 1892, 946, 0, 8444, 8445, 5, 307, + 0, 0, 8445, 8446, 5, 95, 0, 0, 8446, 8447, 3, 1892, 946, 0, 8447, 8805, + 1, 0, 0, 0, 8448, 8449, 5, 140, 0, 0, 8449, 8450, 5, 640, 0, 0, 8450, 8451, + 3, 844, 422, 0, 8451, 8452, 5, 307, 0, 0, 8452, 8453, 5, 95, 0, 0, 8453, + 8454, 3, 1892, 946, 0, 8454, 8805, 1, 0, 0, 0, 8455, 8456, 5, 140, 0, 0, + 8456, 8457, 5, 321, 0, 0, 8457, 8458, 3, 1892, 946, 0, 8458, 8459, 5, 307, + 0, 0, 8459, 8460, 5, 95, 0, 0, 8460, 8461, 3, 1892, 946, 0, 8461, 8805, + 1, 0, 0, 0, 8462, 8463, 5, 140, 0, 0, 8463, 8464, 5, 329, 0, 0, 8464, 8465, + 3, 1892, 946, 0, 8465, 8466, 5, 307, 0, 0, 8466, 8467, 5, 95, 0, 0, 8467, + 8468, 3, 1892, 946, 0, 8468, 8805, 1, 0, 0, 0, 8469, 8470, 5, 140, 0, 0, + 8470, 8471, 5, 650, 0, 0, 8471, 8472, 3, 1892, 946, 0, 8472, 8473, 5, 307, + 0, 0, 8473, 8474, 5, 95, 0, 0, 8474, 8475, 3, 1892, 946, 0, 8475, 8805, + 1, 0, 0, 0, 8476, 8477, 5, 140, 0, 0, 8477, 8478, 5, 93, 0, 0, 8478, 8479, + 3, 1618, 809, 0, 8479, 8480, 5, 307, 0, 0, 8480, 8481, 5, 95, 0, 0, 8481, + 8482, 3, 1892, 946, 0, 8482, 8805, 1, 0, 0, 0, 8483, 8484, 5, 140, 0, 0, + 8484, 8485, 5, 93, 0, 0, 8485, 8486, 5, 224, 0, 0, 8486, 8487, 5, 558, + 0, 0, 8487, 8488, 3, 1618, 809, 0, 8488, 8489, 5, 307, 0, 0, 8489, 8490, + 5, 95, 0, 0, 8490, 8491, 3, 1892, 946, 0, 8491, 8805, 1, 0, 0, 0, 8492, + 8493, 5, 140, 0, 0, 8493, 8494, 5, 326, 0, 0, 8494, 8495, 3, 1888, 944, + 0, 8495, 8496, 5, 307, 0, 0, 8496, 8497, 5, 95, 0, 0, 8497, 8498, 3, 1892, + 946, 0, 8498, 8805, 1, 0, 0, 0, 8499, 8500, 5, 140, 0, 0, 8500, 8501, 5, + 326, 0, 0, 8501, 8502, 5, 224, 0, 0, 8502, 8503, 5, 558, 0, 0, 8503, 8504, + 3, 1888, 944, 0, 8504, 8505, 5, 307, 0, 0, 8505, 8506, 5, 95, 0, 0, 8506, + 8507, 3, 1892, 946, 0, 8507, 8805, 1, 0, 0, 0, 8508, 8509, 5, 140, 0, 0, + 8509, 8510, 5, 374, 0, 0, 8510, 8511, 3, 1888, 944, 0, 8511, 8512, 5, 307, + 0, 0, 8512, 8513, 5, 95, 0, 0, 8513, 8514, 3, 1892, 946, 0, 8514, 8805, + 1, 0, 0, 0, 8515, 8516, 5, 140, 0, 0, 8516, 8517, 5, 374, 0, 0, 8517, 8518, + 5, 224, 0, 0, 8518, 8519, 5, 558, 0, 0, 8519, 8520, 3, 1888, 944, 0, 8520, + 8521, 5, 307, 0, 0, 8521, 8522, 5, 95, 0, 0, 8522, 8523, 3, 1892, 946, + 0, 8523, 8805, 1, 0, 0, 0, 8524, 8525, 5, 140, 0, 0, 8525, 8526, 5, 255, + 0, 0, 8526, 8527, 5, 374, 0, 0, 8527, 8528, 3, 1888, 944, 0, 8528, 8529, + 5, 307, 0, 0, 8529, 8530, 5, 95, 0, 0, 8530, 8531, 3, 1892, 946, 0, 8531, + 8805, 1, 0, 0, 0, 8532, 8533, 5, 140, 0, 0, 8533, 8534, 5, 255, 0, 0, 8534, + 8535, 5, 374, 0, 0, 8535, 8536, 5, 224, 0, 0, 8536, 8537, 5, 558, 0, 0, + 8537, 8538, 3, 1888, 944, 0, 8538, 8539, 5, 307, 0, 0, 8539, 8540, 5, 95, + 0, 0, 8540, 8541, 3, 1892, 946, 0, 8541, 8805, 1, 0, 0, 0, 8542, 8543, + 5, 140, 0, 0, 8543, 8544, 5, 230, 0, 0, 8544, 8545, 3, 1888, 944, 0, 8545, + 8546, 5, 307, 0, 0, 8546, 8547, 5, 95, 0, 0, 8547, 8548, 3, 1892, 946, + 0, 8548, 8805, 1, 0, 0, 0, 8549, 8550, 5, 140, 0, 0, 8550, 8551, 5, 230, + 0, 0, 8551, 8552, 5, 224, 0, 0, 8552, 8553, 5, 558, 0, 0, 8553, 8554, 3, + 1888, 944, 0, 8554, 8555, 5, 307, 0, 0, 8555, 8556, 5, 95, 0, 0, 8556, + 8557, 3, 1892, 946, 0, 8557, 8805, 1, 0, 0, 0, 8558, 8559, 5, 140, 0, 0, + 8559, 8560, 5, 63, 0, 0, 8560, 8561, 5, 93, 0, 0, 8561, 8562, 3, 1618, + 809, 0, 8562, 8563, 5, 307, 0, 0, 8563, 8564, 5, 95, 0, 0, 8564, 8565, + 3, 1892, 946, 0, 8565, 8805, 1, 0, 0, 0, 8566, 8567, 5, 140, 0, 0, 8567, + 8568, 5, 63, 0, 0, 8568, 8569, 5, 93, 0, 0, 8569, 8570, 5, 224, 0, 0, 8570, + 8571, 5, 558, 0, 0, 8571, 8572, 3, 1618, 809, 0, 8572, 8573, 5, 307, 0, + 0, 8573, 8574, 5, 95, 0, 0, 8574, 8575, 3, 1892, 946, 0, 8575, 8805, 1, + 0, 0, 0, 8576, 8577, 5, 140, 0, 0, 8577, 8578, 5, 93, 0, 0, 8578, 8579, + 3, 1618, 809, 0, 8579, 8581, 5, 307, 0, 0, 8580, 8582, 3, 944, 472, 0, + 8581, 8580, 1, 0, 0, 0, 8581, 8582, 1, 0, 0, 0, 8582, 8583, 1, 0, 0, 0, + 8583, 8584, 3, 1892, 946, 0, 8584, 8585, 5, 95, 0, 0, 8585, 8586, 3, 1892, + 946, 0, 8586, 8805, 1, 0, 0, 0, 8587, 8588, 5, 140, 0, 0, 8588, 8589, 5, + 93, 0, 0, 8589, 8590, 5, 224, 0, 0, 8590, 8591, 5, 558, 0, 0, 8591, 8592, + 3, 1618, 809, 0, 8592, 8594, 5, 307, 0, 0, 8593, 8595, 3, 944, 472, 0, + 8594, 8593, 1, 0, 0, 0, 8594, 8595, 1, 0, 0, 0, 8595, 8596, 1, 0, 0, 0, + 8596, 8597, 3, 1892, 946, 0, 8597, 8598, 5, 95, 0, 0, 8598, 8599, 3, 1892, + 946, 0, 8599, 8805, 1, 0, 0, 0, 8600, 8601, 5, 140, 0, 0, 8601, 8602, 5, + 374, 0, 0, 8602, 8603, 3, 1888, 944, 0, 8603, 8605, 5, 307, 0, 0, 8604, + 8606, 3, 944, 472, 0, 8605, 8604, 1, 0, 0, 0, 8605, 8606, 1, 0, 0, 0, 8606, + 8607, 1, 0, 0, 0, 8607, 8608, 3, 1892, 946, 0, 8608, 8609, 5, 95, 0, 0, + 8609, 8610, 3, 1892, 946, 0, 8610, 8805, 1, 0, 0, 0, 8611, 8612, 5, 140, + 0, 0, 8612, 8613, 5, 374, 0, 0, 8613, 8614, 5, 224, 0, 0, 8614, 8615, 5, + 558, 0, 0, 8615, 8616, 3, 1888, 944, 0, 8616, 8618, 5, 307, 0, 0, 8617, + 8619, 3, 944, 472, 0, 8618, 8617, 1, 0, 0, 0, 8618, 8619, 1, 0, 0, 0, 8619, + 8620, 1, 0, 0, 0, 8620, 8621, 3, 1892, 946, 0, 8621, 8622, 5, 95, 0, 0, + 8622, 8623, 3, 1892, 946, 0, 8623, 8805, 1, 0, 0, 0, 8624, 8625, 5, 140, + 0, 0, 8625, 8626, 5, 255, 0, 0, 8626, 8627, 5, 374, 0, 0, 8627, 8628, 3, + 1888, 944, 0, 8628, 8630, 5, 307, 0, 0, 8629, 8631, 3, 944, 472, 0, 8630, + 8629, 1, 0, 0, 0, 8630, 8631, 1, 0, 0, 0, 8631, 8632, 1, 0, 0, 0, 8632, + 8633, 3, 1892, 946, 0, 8633, 8634, 5, 95, 0, 0, 8634, 8635, 3, 1892, 946, + 0, 8635, 8805, 1, 0, 0, 0, 8636, 8637, 5, 140, 0, 0, 8637, 8638, 5, 255, + 0, 0, 8638, 8639, 5, 374, 0, 0, 8639, 8640, 5, 224, 0, 0, 8640, 8641, 5, + 558, 0, 0, 8641, 8642, 3, 1888, 944, 0, 8642, 8644, 5, 307, 0, 0, 8643, + 8645, 3, 944, 472, 0, 8644, 8643, 1, 0, 0, 0, 8644, 8645, 1, 0, 0, 0, 8645, + 8646, 1, 0, 0, 0, 8646, 8647, 3, 1892, 946, 0, 8647, 8648, 5, 95, 0, 0, + 8648, 8649, 3, 1892, 946, 0, 8649, 8805, 1, 0, 0, 0, 8650, 8651, 5, 140, + 0, 0, 8651, 8652, 5, 93, 0, 0, 8652, 8653, 3, 1618, 809, 0, 8653, 8654, + 5, 307, 0, 0, 8654, 8655, 5, 45, 0, 0, 8655, 8656, 3, 1892, 946, 0, 8656, + 8657, 5, 95, 0, 0, 8657, 8658, 3, 1892, 946, 0, 8658, 8805, 1, 0, 0, 0, + 8659, 8660, 5, 140, 0, 0, 8660, 8661, 5, 93, 0, 0, 8661, 8662, 5, 224, + 0, 0, 8662, 8663, 5, 558, 0, 0, 8663, 8664, 3, 1618, 809, 0, 8664, 8665, + 5, 307, 0, 0, 8665, 8666, 5, 45, 0, 0, 8666, 8667, 3, 1892, 946, 0, 8667, + 8668, 5, 95, 0, 0, 8668, 8669, 3, 1892, 946, 0, 8669, 8805, 1, 0, 0, 0, + 8670, 8671, 5, 140, 0, 0, 8671, 8672, 5, 63, 0, 0, 8672, 8673, 5, 93, 0, + 0, 8673, 8674, 3, 1618, 809, 0, 8674, 8676, 5, 307, 0, 0, 8675, 8677, 3, + 944, 472, 0, 8676, 8675, 1, 0, 0, 0, 8676, 8677, 1, 0, 0, 0, 8677, 8678, + 1, 0, 0, 0, 8678, 8679, 3, 1892, 946, 0, 8679, 8680, 5, 95, 0, 0, 8680, + 8681, 3, 1892, 946, 0, 8681, 8805, 1, 0, 0, 0, 8682, 8683, 5, 140, 0, 0, + 8683, 8684, 5, 63, 0, 0, 8684, 8685, 5, 93, 0, 0, 8685, 8686, 5, 224, 0, + 0, 8686, 8687, 5, 558, 0, 0, 8687, 8688, 3, 1618, 809, 0, 8688, 8690, 5, + 307, 0, 0, 8689, 8691, 3, 944, 472, 0, 8690, 8689, 1, 0, 0, 0, 8690, 8691, + 1, 0, 0, 0, 8691, 8692, 1, 0, 0, 0, 8692, 8693, 3, 1892, 946, 0, 8693, + 8694, 5, 95, 0, 0, 8694, 8695, 3, 1892, 946, 0, 8695, 8805, 1, 0, 0, 0, + 8696, 8697, 5, 140, 0, 0, 8697, 8698, 5, 319, 0, 0, 8698, 8699, 3, 1892, + 946, 0, 8699, 8700, 5, 80, 0, 0, 8700, 8701, 3, 1888, 944, 0, 8701, 8702, + 5, 307, 0, 0, 8702, 8703, 5, 95, 0, 0, 8703, 8704, 3, 1892, 946, 0, 8704, + 8805, 1, 0, 0, 0, 8705, 8706, 5, 140, 0, 0, 8706, 8707, 5, 355, 0, 0, 8707, + 8708, 3, 1892, 946, 0, 8708, 8709, 5, 80, 0, 0, 8709, 8710, 3, 1888, 944, + 0, 8710, 8711, 5, 307, 0, 0, 8711, 8712, 5, 95, 0, 0, 8712, 8713, 3, 1892, + 946, 0, 8713, 8805, 1, 0, 0, 0, 8714, 8715, 5, 140, 0, 0, 8715, 8716, 5, + 202, 0, 0, 8716, 8717, 5, 355, 0, 0, 8717, 8718, 3, 1892, 946, 0, 8718, + 8719, 5, 307, 0, 0, 8719, 8720, 5, 95, 0, 0, 8720, 8721, 3, 1892, 946, + 0, 8721, 8805, 1, 0, 0, 0, 8722, 8723, 5, 140, 0, 0, 8723, 8724, 5, 316, + 0, 0, 8724, 8725, 3, 1918, 959, 0, 8725, 8726, 5, 307, 0, 0, 8726, 8727, + 5, 95, 0, 0, 8727, 8728, 3, 1918, 959, 0, 8728, 8805, 1, 0, 0, 0, 8729, + 8730, 5, 140, 0, 0, 8730, 8731, 5, 100, 0, 0, 8731, 8732, 3, 1918, 959, + 0, 8732, 8733, 5, 307, 0, 0, 8733, 8734, 5, 95, 0, 0, 8734, 8735, 3, 1918, + 959, 0, 8735, 8805, 1, 0, 0, 0, 8736, 8737, 5, 140, 0, 0, 8737, 8738, 5, + 349, 0, 0, 8738, 8739, 3, 1892, 946, 0, 8739, 8740, 5, 307, 0, 0, 8740, + 8741, 5, 95, 0, 0, 8741, 8742, 3, 1892, 946, 0, 8742, 8805, 1, 0, 0, 0, + 8743, 8744, 5, 140, 0, 0, 8744, 8745, 5, 340, 0, 0, 8745, 8746, 3, 566, + 283, 0, 8746, 8747, 5, 307, 0, 0, 8747, 8748, 5, 95, 0, 0, 8748, 8749, + 3, 1892, 946, 0, 8749, 8805, 1, 0, 0, 0, 8750, 8751, 5, 140, 0, 0, 8751, + 8752, 5, 353, 0, 0, 8752, 8753, 5, 323, 0, 0, 8753, 8754, 5, 280, 0, 0, + 8754, 8755, 3, 566, 283, 0, 8755, 8756, 5, 307, 0, 0, 8756, 8757, 5, 95, + 0, 0, 8757, 8758, 3, 1892, 946, 0, 8758, 8805, 1, 0, 0, 0, 8759, 8760, + 5, 140, 0, 0, 8760, 8761, 5, 353, 0, 0, 8761, 8762, 5, 323, 0, 0, 8762, + 8763, 5, 189, 0, 0, 8763, 8764, 3, 566, 283, 0, 8764, 8765, 5, 307, 0, + 0, 8765, 8766, 5, 95, 0, 0, 8766, 8767, 3, 1892, 946, 0, 8767, 8805, 1, + 0, 0, 0, 8768, 8769, 5, 140, 0, 0, 8769, 8770, 5, 353, 0, 0, 8770, 8771, + 5, 323, 0, 0, 8771, 8772, 5, 351, 0, 0, 8772, 8773, 3, 566, 283, 0, 8773, + 8774, 5, 307, 0, 0, 8774, 8775, 5, 95, 0, 0, 8775, 8776, 3, 1892, 946, + 0, 8776, 8805, 1, 0, 0, 0, 8777, 8778, 5, 140, 0, 0, 8778, 8779, 5, 353, + 0, 0, 8779, 8780, 5, 323, 0, 0, 8780, 8781, 5, 165, 0, 0, 8781, 8782, 3, + 566, 283, 0, 8782, 8783, 5, 307, 0, 0, 8783, 8784, 5, 95, 0, 0, 8784, 8785, + 3, 1892, 946, 0, 8785, 8805, 1, 0, 0, 0, 8786, 8787, 5, 140, 0, 0, 8787, + 8788, 5, 358, 0, 0, 8788, 8789, 3, 566, 283, 0, 8789, 8790, 5, 307, 0, + 0, 8790, 8791, 5, 95, 0, 0, 8791, 8792, 3, 1892, 946, 0, 8792, 8805, 1, + 0, 0, 0, 8793, 8794, 5, 140, 0, 0, 8794, 8795, 5, 358, 0, 0, 8795, 8796, + 3, 566, 283, 0, 8796, 8797, 5, 307, 0, 0, 8797, 8798, 5, 145, 0, 0, 8798, + 8799, 3, 1892, 946, 0, 8799, 8800, 5, 95, 0, 0, 8800, 8802, 3, 1892, 946, + 0, 8801, 8803, 3, 120, 60, 0, 8802, 8801, 1, 0, 0, 0, 8802, 8803, 1, 0, + 0, 0, 8803, 8805, 1, 0, 0, 0, 8804, 8317, 1, 0, 0, 0, 8804, 8324, 1, 0, + 0, 0, 8804, 8331, 1, 0, 0, 0, 8804, 8338, 1, 0, 0, 0, 8804, 8345, 1, 0, + 0, 0, 8804, 8352, 1, 0, 0, 0, 8804, 8361, 1, 0, 0, 0, 8804, 8370, 1, 0, + 0, 0, 8804, 8377, 1, 0, 0, 0, 8804, 8384, 1, 0, 0, 0, 8804, 8394, 1, 0, + 0, 0, 8804, 8404, 1, 0, 0, 0, 8804, 8414, 1, 0, 0, 0, 8804, 8423, 1, 0, + 0, 0, 8804, 8434, 1, 0, 0, 0, 8804, 8441, 1, 0, 0, 0, 8804, 8448, 1, 0, + 0, 0, 8804, 8455, 1, 0, 0, 0, 8804, 8462, 1, 0, 0, 0, 8804, 8469, 1, 0, + 0, 0, 8804, 8476, 1, 0, 0, 0, 8804, 8483, 1, 0, 0, 0, 8804, 8492, 1, 0, + 0, 0, 8804, 8499, 1, 0, 0, 0, 8804, 8508, 1, 0, 0, 0, 8804, 8515, 1, 0, + 0, 0, 8804, 8524, 1, 0, 0, 0, 8804, 8532, 1, 0, 0, 0, 8804, 8542, 1, 0, + 0, 0, 8804, 8549, 1, 0, 0, 0, 8804, 8558, 1, 0, 0, 0, 8804, 8566, 1, 0, + 0, 0, 8804, 8576, 1, 0, 0, 0, 8804, 8587, 1, 0, 0, 0, 8804, 8600, 1, 0, + 0, 0, 8804, 8611, 1, 0, 0, 0, 8804, 8624, 1, 0, 0, 0, 8804, 8636, 1, 0, + 0, 0, 8804, 8650, 1, 0, 0, 0, 8804, 8659, 1, 0, 0, 0, 8804, 8670, 1, 0, + 0, 0, 8804, 8682, 1, 0, 0, 0, 8804, 8696, 1, 0, 0, 0, 8804, 8705, 1, 0, + 0, 0, 8804, 8714, 1, 0, 0, 0, 8804, 8722, 1, 0, 0, 0, 8804, 8729, 1, 0, + 0, 0, 8804, 8736, 1, 0, 0, 0, 8804, 8743, 1, 0, 0, 0, 8804, 8750, 1, 0, + 0, 0, 8804, 8759, 1, 0, 0, 0, 8804, 8768, 1, 0, 0, 0, 8804, 8777, 1, 0, + 0, 0, 8804, 8786, 1, 0, 0, 0, 8804, 8793, 1, 0, 0, 0, 8805, 943, 1, 0, + 0, 0, 8806, 8807, 5, 44, 0, 0, 8807, 945, 1, 0, 0, 0, 8808, 8809, 5, 331, + 0, 0, 8809, 8810, 5, 177, 0, 0, 8810, 947, 1, 0, 0, 0, 8811, 8812, 5, 140, + 0, 0, 8812, 8813, 5, 215, 0, 0, 8813, 8815, 3, 844, 422, 0, 8814, 8816, + 3, 950, 475, 0, 8815, 8814, 1, 0, 0, 0, 8815, 8816, 1, 0, 0, 0, 8816, 8817, + 1, 0, 0, 0, 8817, 8818, 5, 661, 0, 0, 8818, 8819, 5, 80, 0, 0, 8819, 8820, + 5, 208, 0, 0, 8820, 8821, 3, 1892, 946, 0, 8821, 8881, 1, 0, 0, 0, 8822, + 8823, 5, 140, 0, 0, 8823, 8824, 5, 294, 0, 0, 8824, 8826, 3, 844, 422, + 0, 8825, 8827, 3, 950, 475, 0, 8826, 8825, 1, 0, 0, 0, 8826, 8827, 1, 0, + 0, 0, 8827, 8828, 1, 0, 0, 0, 8828, 8829, 5, 661, 0, 0, 8829, 8830, 5, + 80, 0, 0, 8830, 8831, 5, 208, 0, 0, 8831, 8832, 3, 1892, 946, 0, 8832, + 8881, 1, 0, 0, 0, 8833, 8834, 5, 140, 0, 0, 8834, 8835, 5, 640, 0, 0, 8835, + 8837, 3, 844, 422, 0, 8836, 8838, 3, 950, 475, 0, 8837, 8836, 1, 0, 0, + 0, 8837, 8838, 1, 0, 0, 0, 8838, 8839, 1, 0, 0, 0, 8839, 8840, 5, 661, + 0, 0, 8840, 8841, 5, 80, 0, 0, 8841, 8842, 5, 208, 0, 0, 8842, 8843, 3, + 1892, 946, 0, 8843, 8881, 1, 0, 0, 0, 8844, 8845, 5, 140, 0, 0, 8845, 8846, + 5, 355, 0, 0, 8846, 8847, 3, 1892, 946, 0, 8847, 8848, 5, 80, 0, 0, 8848, + 8850, 3, 1888, 944, 0, 8849, 8851, 3, 950, 475, 0, 8850, 8849, 1, 0, 0, + 0, 8850, 8851, 1, 0, 0, 0, 8851, 8852, 1, 0, 0, 0, 8852, 8853, 5, 661, + 0, 0, 8853, 8854, 5, 80, 0, 0, 8854, 8855, 5, 208, 0, 0, 8855, 8856, 3, + 1892, 946, 0, 8856, 8881, 1, 0, 0, 0, 8857, 8858, 5, 140, 0, 0, 8858, 8859, + 5, 255, 0, 0, 8859, 8860, 5, 374, 0, 0, 8860, 8862, 3, 1888, 944, 0, 8861, + 8863, 3, 950, 475, 0, 8862, 8861, 1, 0, 0, 0, 8862, 8863, 1, 0, 0, 0, 8863, + 8864, 1, 0, 0, 0, 8864, 8865, 5, 661, 0, 0, 8865, 8866, 5, 80, 0, 0, 8866, + 8867, 5, 208, 0, 0, 8867, 8868, 3, 1892, 946, 0, 8868, 8881, 1, 0, 0, 0, + 8869, 8870, 5, 140, 0, 0, 8870, 8871, 5, 230, 0, 0, 8871, 8873, 3, 1888, + 944, 0, 8872, 8874, 3, 950, 475, 0, 8873, 8872, 1, 0, 0, 0, 8873, 8874, + 1, 0, 0, 0, 8874, 8875, 1, 0, 0, 0, 8875, 8876, 5, 661, 0, 0, 8876, 8877, + 5, 80, 0, 0, 8877, 8878, 5, 208, 0, 0, 8878, 8879, 3, 1892, 946, 0, 8879, + 8881, 1, 0, 0, 0, 8880, 8811, 1, 0, 0, 0, 8880, 8822, 1, 0, 0, 0, 8880, + 8833, 1, 0, 0, 0, 8880, 8844, 1, 0, 0, 0, 8880, 8857, 1, 0, 0, 0, 8880, + 8869, 1, 0, 0, 0, 8881, 949, 1, 0, 0, 0, 8882, 8883, 5, 266, 0, 0, 8883, + 951, 1, 0, 0, 0, 8884, 8885, 5, 140, 0, 0, 8885, 8886, 5, 138, 0, 0, 8886, + 8887, 3, 868, 434, 0, 8887, 8888, 5, 331, 0, 0, 8888, 8889, 5, 321, 0, + 0, 8889, 8890, 3, 1892, 946, 0, 8890, 9102, 1, 0, 0, 0, 8891, 8892, 5, + 140, 0, 0, 8892, 8893, 5, 110, 0, 0, 8893, 8894, 3, 566, 283, 0, 8894, + 8895, 5, 331, 0, 0, 8895, 8896, 5, 321, 0, 0, 8896, 8897, 3, 1892, 946, + 0, 8897, 9102, 1, 0, 0, 0, 8898, 8899, 5, 140, 0, 0, 8899, 8900, 5, 170, + 0, 0, 8900, 8901, 3, 566, 283, 0, 8901, 8902, 5, 331, 0, 0, 8902, 8903, + 5, 321, 0, 0, 8903, 8904, 3, 1892, 946, 0, 8904, 9102, 1, 0, 0, 0, 8905, + 8906, 5, 140, 0, 0, 8906, 8907, 5, 193, 0, 0, 8907, 8908, 3, 566, 283, + 0, 8908, 8909, 5, 331, 0, 0, 8909, 8910, 5, 321, 0, 0, 8910, 8911, 3, 1892, + 946, 0, 8911, 9102, 1, 0, 0, 0, 8912, 8913, 5, 140, 0, 0, 8913, 8914, 5, + 208, 0, 0, 8914, 8915, 3, 1892, 946, 0, 8915, 8916, 5, 331, 0, 0, 8916, + 8917, 5, 321, 0, 0, 8917, 8918, 3, 1892, 946, 0, 8918, 9102, 1, 0, 0, 0, + 8919, 8920, 5, 140, 0, 0, 8920, 8921, 5, 215, 0, 0, 8921, 8922, 3, 844, + 422, 0, 8922, 8923, 5, 331, 0, 0, 8923, 8924, 5, 321, 0, 0, 8924, 8925, + 3, 1892, 946, 0, 8925, 9102, 1, 0, 0, 0, 8926, 8927, 5, 140, 0, 0, 8927, + 8928, 5, 275, 0, 0, 8928, 8929, 3, 908, 454, 0, 8929, 8930, 5, 331, 0, + 0, 8930, 8931, 5, 321, 0, 0, 8931, 8932, 3, 1892, 946, 0, 8932, 9102, 1, + 0, 0, 0, 8933, 8934, 5, 140, 0, 0, 8934, 8935, 5, 275, 0, 0, 8935, 8936, + 5, 158, 0, 0, 8936, 8937, 3, 566, 283, 0, 8937, 8938, 5, 101, 0, 0, 8938, + 8939, 3, 1892, 946, 0, 8939, 8940, 5, 331, 0, 0, 8940, 8941, 5, 321, 0, + 0, 8941, 8942, 3, 1892, 946, 0, 8942, 9102, 1, 0, 0, 0, 8943, 8944, 5, + 140, 0, 0, 8944, 8945, 5, 275, 0, 0, 8945, 8946, 5, 210, 0, 0, 8946, 8947, + 3, 566, 283, 0, 8947, 8948, 5, 101, 0, 0, 8948, 8949, 3, 1892, 946, 0, + 8949, 8950, 5, 331, 0, 0, 8950, 8951, 5, 321, 0, 0, 8951, 8952, 3, 1892, + 946, 0, 8952, 9102, 1, 0, 0, 0, 8953, 8954, 5, 140, 0, 0, 8954, 8955, 5, + 294, 0, 0, 8955, 8956, 3, 844, 422, 0, 8956, 8957, 5, 331, 0, 0, 8957, + 8958, 5, 321, 0, 0, 8958, 8959, 3, 1892, 946, 0, 8959, 9102, 1, 0, 0, 0, + 8960, 8961, 5, 140, 0, 0, 8961, 8962, 5, 640, 0, 0, 8962, 8963, 3, 844, + 422, 0, 8963, 8964, 5, 331, 0, 0, 8964, 8965, 5, 321, 0, 0, 8965, 8966, + 3, 1892, 946, 0, 8966, 9102, 1, 0, 0, 0, 8967, 8968, 5, 140, 0, 0, 8968, + 8969, 5, 93, 0, 0, 8969, 8970, 3, 1618, 809, 0, 8970, 8971, 5, 331, 0, + 0, 8971, 8972, 5, 321, 0, 0, 8972, 8973, 3, 1892, 946, 0, 8973, 9102, 1, + 0, 0, 0, 8974, 8975, 5, 140, 0, 0, 8975, 8976, 5, 93, 0, 0, 8976, 8977, + 5, 224, 0, 0, 8977, 8978, 5, 558, 0, 0, 8978, 8979, 3, 1618, 809, 0, 8979, + 8980, 5, 331, 0, 0, 8980, 8981, 5, 321, 0, 0, 8981, 8982, 3, 1892, 946, + 0, 8982, 9102, 1, 0, 0, 0, 8983, 8984, 5, 140, 0, 0, 8984, 8985, 5, 340, + 0, 0, 8985, 8986, 3, 566, 283, 0, 8986, 8987, 5, 331, 0, 0, 8987, 8988, + 5, 321, 0, 0, 8988, 8989, 3, 1892, 946, 0, 8989, 9102, 1, 0, 0, 0, 8990, + 8991, 5, 140, 0, 0, 8991, 8992, 5, 353, 0, 0, 8992, 8993, 5, 323, 0, 0, + 8993, 8994, 5, 280, 0, 0, 8994, 8995, 3, 566, 283, 0, 8995, 8996, 5, 331, + 0, 0, 8996, 8997, 5, 321, 0, 0, 8997, 8998, 3, 1892, 946, 0, 8998, 9102, + 1, 0, 0, 0, 8999, 9000, 5, 140, 0, 0, 9000, 9001, 5, 353, 0, 0, 9001, 9002, + 5, 323, 0, 0, 9002, 9003, 5, 189, 0, 0, 9003, 9004, 3, 566, 283, 0, 9004, + 9005, 5, 331, 0, 0, 9005, 9006, 5, 321, 0, 0, 9006, 9007, 3, 1892, 946, + 0, 9007, 9102, 1, 0, 0, 0, 9008, 9009, 5, 140, 0, 0, 9009, 9010, 5, 353, + 0, 0, 9010, 9011, 5, 323, 0, 0, 9011, 9012, 5, 351, 0, 0, 9012, 9013, 3, + 566, 283, 0, 9013, 9014, 5, 331, 0, 0, 9014, 9015, 5, 321, 0, 0, 9015, + 9016, 3, 1892, 946, 0, 9016, 9102, 1, 0, 0, 0, 9017, 9018, 5, 140, 0, 0, + 9018, 9019, 5, 353, 0, 0, 9019, 9020, 5, 323, 0, 0, 9020, 9021, 5, 165, + 0, 0, 9021, 9022, 3, 566, 283, 0, 9022, 9023, 5, 331, 0, 0, 9023, 9024, + 5, 321, 0, 0, 9024, 9025, 3, 1892, 946, 0, 9025, 9102, 1, 0, 0, 0, 9026, + 9027, 5, 140, 0, 0, 9027, 9028, 5, 326, 0, 0, 9028, 9029, 3, 1888, 944, + 0, 9029, 9030, 5, 331, 0, 0, 9030, 9031, 5, 321, 0, 0, 9031, 9032, 3, 1892, + 946, 0, 9032, 9102, 1, 0, 0, 0, 9033, 9034, 5, 140, 0, 0, 9034, 9035, 5, + 326, 0, 0, 9035, 9036, 5, 224, 0, 0, 9036, 9037, 5, 558, 0, 0, 9037, 9038, + 3, 1888, 944, 0, 9038, 9039, 5, 331, 0, 0, 9039, 9040, 5, 321, 0, 0, 9040, + 9041, 3, 1892, 946, 0, 9041, 9102, 1, 0, 0, 0, 9042, 9043, 5, 140, 0, 0, + 9043, 9044, 5, 374, 0, 0, 9044, 9045, 3, 1888, 944, 0, 9045, 9046, 5, 331, + 0, 0, 9046, 9047, 5, 321, 0, 0, 9047, 9048, 3, 1892, 946, 0, 9048, 9102, + 1, 0, 0, 0, 9049, 9050, 5, 140, 0, 0, 9050, 9051, 5, 374, 0, 0, 9051, 9052, + 5, 224, 0, 0, 9052, 9053, 5, 558, 0, 0, 9053, 9054, 3, 1888, 944, 0, 9054, + 9055, 5, 331, 0, 0, 9055, 9056, 5, 321, 0, 0, 9056, 9057, 3, 1892, 946, + 0, 9057, 9102, 1, 0, 0, 0, 9058, 9059, 5, 140, 0, 0, 9059, 9060, 5, 255, + 0, 0, 9060, 9061, 5, 374, 0, 0, 9061, 9062, 3, 1888, 944, 0, 9062, 9063, + 5, 331, 0, 0, 9063, 9064, 5, 321, 0, 0, 9064, 9065, 3, 1892, 946, 0, 9065, + 9102, 1, 0, 0, 0, 9066, 9067, 5, 140, 0, 0, 9067, 9068, 5, 255, 0, 0, 9068, + 9069, 5, 374, 0, 0, 9069, 9070, 5, 224, 0, 0, 9070, 9071, 5, 558, 0, 0, + 9071, 9072, 3, 1888, 944, 0, 9072, 9073, 5, 331, 0, 0, 9073, 9074, 5, 321, + 0, 0, 9074, 9075, 3, 1892, 946, 0, 9075, 9102, 1, 0, 0, 0, 9076, 9077, + 5, 140, 0, 0, 9077, 9078, 5, 63, 0, 0, 9078, 9079, 5, 93, 0, 0, 9079, 9080, + 3, 1618, 809, 0, 9080, 9081, 5, 331, 0, 0, 9081, 9082, 5, 321, 0, 0, 9082, + 9083, 3, 1892, 946, 0, 9083, 9102, 1, 0, 0, 0, 9084, 9085, 5, 140, 0, 0, + 9085, 9086, 5, 63, 0, 0, 9086, 9087, 5, 93, 0, 0, 9087, 9088, 5, 224, 0, + 0, 9088, 9089, 5, 558, 0, 0, 9089, 9090, 3, 1618, 809, 0, 9090, 9091, 5, + 331, 0, 0, 9091, 9092, 5, 321, 0, 0, 9092, 9093, 3, 1892, 946, 0, 9093, + 9102, 1, 0, 0, 0, 9094, 9095, 5, 140, 0, 0, 9095, 9096, 5, 358, 0, 0, 9096, + 9097, 3, 566, 283, 0, 9097, 9098, 5, 331, 0, 0, 9098, 9099, 5, 321, 0, + 0, 9099, 9100, 3, 1892, 946, 0, 9100, 9102, 1, 0, 0, 0, 9101, 8884, 1, + 0, 0, 0, 9101, 8891, 1, 0, 0, 0, 9101, 8898, 1, 0, 0, 0, 9101, 8905, 1, + 0, 0, 0, 9101, 8912, 1, 0, 0, 0, 9101, 8919, 1, 0, 0, 0, 9101, 8926, 1, + 0, 0, 0, 9101, 8933, 1, 0, 0, 0, 9101, 8943, 1, 0, 0, 0, 9101, 8953, 1, + 0, 0, 0, 9101, 8960, 1, 0, 0, 0, 9101, 8967, 1, 0, 0, 0, 9101, 8974, 1, + 0, 0, 0, 9101, 8983, 1, 0, 0, 0, 9101, 8990, 1, 0, 0, 0, 9101, 8999, 1, + 0, 0, 0, 9101, 9008, 1, 0, 0, 0, 9101, 9017, 1, 0, 0, 0, 9101, 9026, 1, + 0, 0, 0, 9101, 9033, 1, 0, 0, 0, 9101, 9042, 1, 0, 0, 0, 9101, 9049, 1, + 0, 0, 0, 9101, 9058, 1, 0, 0, 0, 9101, 9066, 1, 0, 0, 0, 9101, 9076, 1, + 0, 0, 0, 9101, 9084, 1, 0, 0, 0, 9101, 9094, 1, 0, 0, 0, 9102, 953, 1, + 0, 0, 0, 9103, 9104, 5, 140, 0, 0, 9104, 9105, 5, 275, 0, 0, 9105, 9106, + 3, 908, 454, 0, 9106, 9107, 5, 331, 0, 0, 9107, 9108, 5, 2, 0, 0, 9108, + 9109, 3, 956, 478, 0, 9109, 9110, 5, 3, 0, 0, 9110, 955, 1, 0, 0, 0, 9111, + 9116, 3, 958, 479, 0, 9112, 9113, 5, 6, 0, 0, 9113, 9115, 3, 958, 479, + 0, 9114, 9112, 1, 0, 0, 0, 9115, 9118, 1, 0, 0, 0, 9116, 9114, 1, 0, 0, + 0, 9116, 9117, 1, 0, 0, 0, 9117, 957, 1, 0, 0, 0, 9118, 9116, 1, 0, 0, + 0, 9119, 9120, 3, 1932, 966, 0, 9120, 9121, 5, 10, 0, 0, 9121, 9122, 5, + 569, 0, 0, 9122, 9128, 1, 0, 0, 0, 9123, 9124, 3, 1932, 966, 0, 9124, 9125, + 5, 10, 0, 0, 9125, 9126, 3, 960, 480, 0, 9126, 9128, 1, 0, 0, 0, 9127, + 9119, 1, 0, 0, 0, 9127, 9123, 1, 0, 0, 0, 9128, 959, 1, 0, 0, 0, 9129, + 9135, 3, 858, 429, 0, 9130, 9135, 3, 1944, 972, 0, 9131, 9135, 3, 1826, + 913, 0, 9132, 9135, 3, 334, 167, 0, 9133, 9135, 3, 1910, 955, 0, 9134, + 9129, 1, 0, 0, 0, 9134, 9130, 1, 0, 0, 0, 9134, 9131, 1, 0, 0, 0, 9134, + 9132, 1, 0, 0, 0, 9134, 9133, 1, 0, 0, 0, 9135, 961, 1, 0, 0, 0, 9136, + 9137, 5, 140, 0, 0, 9137, 9138, 5, 358, 0, 0, 9138, 9139, 3, 566, 283, + 0, 9139, 9140, 5, 331, 0, 0, 9140, 9141, 5, 2, 0, 0, 9141, 9142, 3, 956, + 478, 0, 9142, 9143, 5, 3, 0, 0, 9143, 963, 1, 0, 0, 0, 9144, 9145, 5, 140, + 0, 0, 9145, 9146, 5, 138, 0, 0, 9146, 9147, 3, 868, 434, 0, 9147, 9148, + 5, 279, 0, 0, 9148, 9149, 5, 95, 0, 0, 9149, 9150, 3, 1920, 960, 0, 9150, + 9330, 1, 0, 0, 0, 9151, 9152, 5, 140, 0, 0, 9152, 9153, 5, 110, 0, 0, 9153, + 9154, 3, 566, 283, 0, 9154, 9155, 5, 279, 0, 0, 9155, 9156, 5, 95, 0, 0, + 9156, 9157, 3, 1920, 960, 0, 9157, 9330, 1, 0, 0, 0, 9158, 9159, 5, 140, + 0, 0, 9159, 9160, 5, 170, 0, 0, 9160, 9161, 3, 566, 283, 0, 9161, 9162, + 5, 279, 0, 0, 9162, 9163, 5, 95, 0, 0, 9163, 9164, 3, 1920, 960, 0, 9164, + 9330, 1, 0, 0, 0, 9165, 9166, 5, 140, 0, 0, 9166, 9167, 5, 179, 0, 0, 9167, + 9168, 3, 1892, 946, 0, 9168, 9169, 5, 279, 0, 0, 9169, 9170, 5, 95, 0, + 0, 9170, 9171, 3, 1920, 960, 0, 9171, 9330, 1, 0, 0, 0, 9172, 9173, 5, + 140, 0, 0, 9173, 9174, 5, 193, 0, 0, 9174, 9175, 3, 566, 283, 0, 9175, + 9176, 5, 279, 0, 0, 9176, 9177, 5, 95, 0, 0, 9177, 9178, 3, 1920, 960, + 0, 9178, 9330, 1, 0, 0, 0, 9179, 9180, 5, 140, 0, 0, 9180, 9181, 5, 215, + 0, 0, 9181, 9182, 3, 844, 422, 0, 9182, 9183, 5, 279, 0, 0, 9183, 9184, + 5, 95, 0, 0, 9184, 9185, 3, 1920, 960, 0, 9185, 9330, 1, 0, 0, 0, 9186, + 9188, 5, 140, 0, 0, 9187, 9189, 3, 350, 175, 0, 9188, 9187, 1, 0, 0, 0, + 9188, 9189, 1, 0, 0, 0, 9189, 9190, 1, 0, 0, 0, 9190, 9191, 5, 242, 0, + 0, 9191, 9192, 3, 1892, 946, 0, 9192, 9193, 5, 279, 0, 0, 9193, 9194, 5, + 95, 0, 0, 9194, 9195, 3, 1920, 960, 0, 9195, 9330, 1, 0, 0, 0, 9196, 9197, + 5, 140, 0, 0, 9197, 9198, 5, 243, 0, 0, 9198, 9199, 5, 271, 0, 0, 9199, + 9200, 3, 334, 167, 0, 9200, 9201, 5, 279, 0, 0, 9201, 9202, 5, 95, 0, 0, + 9202, 9203, 3, 1920, 960, 0, 9203, 9330, 1, 0, 0, 0, 9204, 9205, 5, 140, + 0, 0, 9205, 9206, 5, 275, 0, 0, 9206, 9207, 3, 908, 454, 0, 9207, 9208, + 5, 279, 0, 0, 9208, 9209, 5, 95, 0, 0, 9209, 9210, 3, 1920, 960, 0, 9210, + 9330, 1, 0, 0, 0, 9211, 9212, 5, 140, 0, 0, 9212, 9213, 5, 275, 0, 0, 9213, + 9214, 5, 158, 0, 0, 9214, 9215, 3, 566, 283, 0, 9215, 9216, 5, 101, 0, + 0, 9216, 9217, 3, 1892, 946, 0, 9217, 9218, 5, 279, 0, 0, 9218, 9219, 5, + 95, 0, 0, 9219, 9220, 3, 1920, 960, 0, 9220, 9330, 1, 0, 0, 0, 9221, 9222, + 5, 140, 0, 0, 9222, 9223, 5, 275, 0, 0, 9223, 9224, 5, 210, 0, 0, 9224, + 9225, 3, 566, 283, 0, 9225, 9226, 5, 101, 0, 0, 9226, 9227, 3, 1892, 946, + 0, 9227, 9228, 5, 279, 0, 0, 9228, 9229, 5, 95, 0, 0, 9229, 9230, 3, 1920, + 960, 0, 9230, 9330, 1, 0, 0, 0, 9231, 9232, 5, 140, 0, 0, 9232, 9233, 5, + 294, 0, 0, 9233, 9234, 3, 844, 422, 0, 9234, 9235, 5, 279, 0, 0, 9235, + 9236, 5, 95, 0, 0, 9236, 9237, 3, 1920, 960, 0, 9237, 9330, 1, 0, 0, 0, + 9238, 9239, 5, 140, 0, 0, 9239, 9240, 5, 640, 0, 0, 9240, 9241, 3, 844, + 422, 0, 9241, 9242, 5, 279, 0, 0, 9242, 9243, 5, 95, 0, 0, 9243, 9244, + 3, 1920, 960, 0, 9244, 9330, 1, 0, 0, 0, 9245, 9246, 5, 140, 0, 0, 9246, + 9247, 5, 321, 0, 0, 9247, 9248, 3, 1892, 946, 0, 9248, 9249, 5, 279, 0, + 0, 9249, 9250, 5, 95, 0, 0, 9250, 9251, 3, 1920, 960, 0, 9251, 9330, 1, + 0, 0, 0, 9252, 9253, 5, 140, 0, 0, 9253, 9254, 5, 358, 0, 0, 9254, 9255, + 3, 566, 283, 0, 9255, 9256, 5, 279, 0, 0, 9256, 9257, 5, 95, 0, 0, 9257, + 9258, 3, 1920, 960, 0, 9258, 9330, 1, 0, 0, 0, 9259, 9260, 5, 140, 0, 0, + 9260, 9261, 5, 349, 0, 0, 9261, 9262, 3, 1892, 946, 0, 9262, 9263, 5, 279, + 0, 0, 9263, 9264, 5, 95, 0, 0, 9264, 9265, 3, 1920, 960, 0, 9265, 9330, + 1, 0, 0, 0, 9266, 9267, 5, 140, 0, 0, 9267, 9268, 5, 340, 0, 0, 9268, 9269, + 3, 566, 283, 0, 9269, 9270, 5, 279, 0, 0, 9270, 9271, 5, 95, 0, 0, 9271, + 9272, 3, 1920, 960, 0, 9272, 9330, 1, 0, 0, 0, 9273, 9274, 5, 140, 0, 0, + 9274, 9275, 5, 353, 0, 0, 9275, 9276, 5, 323, 0, 0, 9276, 9277, 5, 189, + 0, 0, 9277, 9278, 3, 566, 283, 0, 9278, 9279, 5, 279, 0, 0, 9279, 9280, + 5, 95, 0, 0, 9280, 9281, 3, 1920, 960, 0, 9281, 9330, 1, 0, 0, 0, 9282, + 9283, 5, 140, 0, 0, 9283, 9284, 5, 353, 0, 0, 9284, 9285, 5, 323, 0, 0, + 9285, 9286, 5, 165, 0, 0, 9286, 9287, 3, 566, 283, 0, 9287, 9288, 5, 279, + 0, 0, 9288, 9289, 5, 95, 0, 0, 9289, 9290, 3, 1920, 960, 0, 9290, 9330, + 1, 0, 0, 0, 9291, 9292, 5, 140, 0, 0, 9292, 9293, 5, 63, 0, 0, 9293, 9294, + 5, 177, 0, 0, 9294, 9295, 5, 379, 0, 0, 9295, 9296, 3, 1892, 946, 0, 9296, + 9297, 5, 279, 0, 0, 9297, 9298, 5, 95, 0, 0, 9298, 9299, 3, 1920, 960, + 0, 9299, 9330, 1, 0, 0, 0, 9300, 9301, 5, 140, 0, 0, 9301, 9302, 5, 329, + 0, 0, 9302, 9303, 3, 1892, 946, 0, 9303, 9304, 5, 279, 0, 0, 9304, 9305, + 5, 95, 0, 0, 9305, 9306, 3, 1920, 960, 0, 9306, 9330, 1, 0, 0, 0, 9307, + 9308, 5, 140, 0, 0, 9308, 9309, 5, 202, 0, 0, 9309, 9310, 5, 355, 0, 0, + 9310, 9311, 3, 1892, 946, 0, 9311, 9312, 5, 279, 0, 0, 9312, 9313, 5, 95, + 0, 0, 9313, 9314, 3, 1920, 960, 0, 9314, 9330, 1, 0, 0, 0, 9315, 9316, + 5, 140, 0, 0, 9316, 9317, 5, 651, 0, 0, 9317, 9318, 3, 1892, 946, 0, 9318, + 9319, 5, 279, 0, 0, 9319, 9320, 5, 95, 0, 0, 9320, 9321, 3, 1920, 960, + 0, 9321, 9330, 1, 0, 0, 0, 9322, 9323, 5, 140, 0, 0, 9323, 9324, 5, 650, + 0, 0, 9324, 9325, 3, 1892, 946, 0, 9325, 9326, 5, 279, 0, 0, 9326, 9327, + 5, 95, 0, 0, 9327, 9328, 3, 1920, 960, 0, 9328, 9330, 1, 0, 0, 0, 9329, + 9144, 1, 0, 0, 0, 9329, 9151, 1, 0, 0, 0, 9329, 9158, 1, 0, 0, 0, 9329, + 9165, 1, 0, 0, 0, 9329, 9172, 1, 0, 0, 0, 9329, 9179, 1, 0, 0, 0, 9329, + 9186, 1, 0, 0, 0, 9329, 9196, 1, 0, 0, 0, 9329, 9204, 1, 0, 0, 0, 9329, + 9211, 1, 0, 0, 0, 9329, 9221, 1, 0, 0, 0, 9329, 9231, 1, 0, 0, 0, 9329, + 9238, 1, 0, 0, 0, 9329, 9245, 1, 0, 0, 0, 9329, 9252, 1, 0, 0, 0, 9329, + 9259, 1, 0, 0, 0, 9329, 9266, 1, 0, 0, 0, 9329, 9273, 1, 0, 0, 0, 9329, + 9282, 1, 0, 0, 0, 9329, 9291, 1, 0, 0, 0, 9329, 9300, 1, 0, 0, 0, 9329, + 9307, 1, 0, 0, 0, 9329, 9315, 1, 0, 0, 0, 9329, 9322, 1, 0, 0, 0, 9330, + 965, 1, 0, 0, 0, 9331, 9332, 5, 46, 0, 0, 9332, 9333, 5, 651, 0, 0, 9333, + 9335, 3, 1892, 946, 0, 9334, 9336, 3, 882, 441, 0, 9335, 9334, 1, 0, 0, + 0, 9335, 9336, 1, 0, 0, 0, 9336, 9355, 1, 0, 0, 0, 9337, 9338, 5, 46, 0, + 0, 9338, 9339, 5, 651, 0, 0, 9339, 9340, 3, 1892, 946, 0, 9340, 9341, 5, + 62, 0, 0, 9341, 9342, 5, 30, 0, 0, 9342, 9344, 5, 348, 0, 0, 9343, 9345, + 3, 882, 441, 0, 9344, 9343, 1, 0, 0, 0, 9344, 9345, 1, 0, 0, 0, 9345, 9355, + 1, 0, 0, 0, 9346, 9347, 5, 46, 0, 0, 9347, 9348, 5, 651, 0, 0, 9348, 9349, + 3, 1892, 946, 0, 9349, 9350, 5, 62, 0, 0, 9350, 9352, 3, 968, 484, 0, 9351, + 9353, 3, 882, 441, 0, 9352, 9351, 1, 0, 0, 0, 9352, 9353, 1, 0, 0, 0, 9353, + 9355, 1, 0, 0, 0, 9354, 9331, 1, 0, 0, 0, 9354, 9337, 1, 0, 0, 0, 9354, + 9346, 1, 0, 0, 0, 9355, 967, 1, 0, 0, 0, 9356, 9361, 3, 970, 485, 0, 9357, + 9358, 5, 6, 0, 0, 9358, 9360, 3, 970, 485, 0, 9359, 9357, 1, 0, 0, 0, 9360, + 9363, 1, 0, 0, 0, 9361, 9359, 1, 0, 0, 0, 9361, 9362, 1, 0, 0, 0, 9362, + 969, 1, 0, 0, 0, 9363, 9361, 1, 0, 0, 0, 9364, 9365, 5, 93, 0, 0, 9365, + 9367, 3, 1618, 809, 0, 9366, 9368, 3, 244, 122, 0, 9367, 9366, 1, 0, 0, + 0, 9367, 9368, 1, 0, 0, 0, 9368, 9370, 1, 0, 0, 0, 9369, 9371, 3, 972, + 486, 0, 9370, 9369, 1, 0, 0, 0, 9370, 9371, 1, 0, 0, 0, 9371, 9403, 1, + 0, 0, 0, 9372, 9373, 5, 93, 0, 0, 9373, 9374, 5, 68, 0, 0, 9374, 9377, + 5, 321, 0, 0, 9375, 9378, 3, 1924, 962, 0, 9376, 9378, 5, 113, 0, 0, 9377, + 9375, 1, 0, 0, 0, 9377, 9376, 1, 0, 0, 0, 9378, 9403, 1, 0, 0, 0, 9379, + 9381, 3, 1924, 962, 0, 9380, 9382, 3, 244, 122, 0, 9381, 9380, 1, 0, 0, + 0, 9381, 9382, 1, 0, 0, 0, 9382, 9384, 1, 0, 0, 0, 9383, 9385, 3, 972, + 486, 0, 9384, 9383, 1, 0, 0, 0, 9384, 9385, 1, 0, 0, 0, 9385, 9403, 1, + 0, 0, 0, 9386, 9387, 3, 1924, 962, 0, 9387, 9389, 3, 1874, 937, 0, 9388, + 9390, 3, 244, 122, 0, 9389, 9388, 1, 0, 0, 0, 9389, 9390, 1, 0, 0, 0, 9390, + 9392, 1, 0, 0, 0, 9391, 9393, 3, 972, 486, 0, 9392, 9391, 1, 0, 0, 0, 9392, + 9393, 1, 0, 0, 0, 9393, 9403, 1, 0, 0, 0, 9394, 9396, 3, 1618, 809, 0, + 9395, 9397, 3, 244, 122, 0, 9396, 9395, 1, 0, 0, 0, 9396, 9397, 1, 0, 0, + 0, 9397, 9399, 1, 0, 0, 0, 9398, 9400, 3, 972, 486, 0, 9399, 9398, 1, 0, + 0, 0, 9399, 9400, 1, 0, 0, 0, 9400, 9403, 1, 0, 0, 0, 9401, 9403, 5, 113, + 0, 0, 9402, 9364, 1, 0, 0, 0, 9402, 9372, 1, 0, 0, 0, 9402, 9379, 1, 0, + 0, 0, 9402, 9386, 1, 0, 0, 0, 9402, 9394, 1, 0, 0, 0, 9402, 9401, 1, 0, + 0, 0, 9403, 971, 1, 0, 0, 0, 9404, 9405, 5, 104, 0, 0, 9405, 9406, 5, 2, + 0, 0, 9406, 9407, 3, 1710, 855, 0, 9407, 9408, 5, 3, 0, 0, 9408, 973, 1, + 0, 0, 0, 9409, 9410, 5, 140, 0, 0, 9410, 9411, 5, 651, 0, 0, 9411, 9412, + 3, 1892, 946, 0, 9412, 9413, 5, 331, 0, 0, 9413, 9414, 3, 502, 251, 0, + 9414, 9434, 1, 0, 0, 0, 9415, 9416, 5, 140, 0, 0, 9416, 9417, 5, 651, 0, + 0, 9417, 9418, 3, 1892, 946, 0, 9418, 9419, 5, 135, 0, 0, 9419, 9420, 3, + 968, 484, 0, 9420, 9434, 1, 0, 0, 0, 9421, 9422, 5, 140, 0, 0, 9422, 9423, + 5, 651, 0, 0, 9423, 9424, 3, 1892, 946, 0, 9424, 9425, 5, 331, 0, 0, 9425, + 9426, 3, 968, 484, 0, 9426, 9434, 1, 0, 0, 0, 9427, 9428, 5, 140, 0, 0, + 9428, 9429, 5, 651, 0, 0, 9429, 9430, 3, 1892, 946, 0, 9430, 9431, 5, 195, + 0, 0, 9431, 9432, 3, 968, 484, 0, 9432, 9434, 1, 0, 0, 0, 9433, 9409, 1, + 0, 0, 0, 9433, 9415, 1, 0, 0, 0, 9433, 9421, 1, 0, 0, 0, 9433, 9427, 1, + 0, 0, 0, 9434, 975, 1, 0, 0, 0, 9435, 9436, 5, 46, 0, 0, 9436, 9437, 5, + 650, 0, 0, 9437, 9438, 3, 1892, 946, 0, 9438, 9439, 5, 166, 0, 0, 9439, + 9440, 3, 1910, 955, 0, 9440, 9441, 5, 651, 0, 0, 9441, 9443, 3, 978, 489, + 0, 9442, 9444, 3, 882, 441, 0, 9443, 9442, 1, 0, 0, 0, 9443, 9444, 1, 0, + 0, 0, 9444, 977, 1, 0, 0, 0, 9445, 9450, 3, 980, 490, 0, 9446, 9447, 5, + 6, 0, 0, 9447, 9449, 3, 980, 490, 0, 9448, 9446, 1, 0, 0, 0, 9449, 9452, + 1, 0, 0, 0, 9450, 9448, 1, 0, 0, 0, 9450, 9451, 1, 0, 0, 0, 9451, 979, + 1, 0, 0, 0, 9452, 9450, 1, 0, 0, 0, 9453, 9454, 3, 1932, 966, 0, 9454, + 981, 1, 0, 0, 0, 9455, 9456, 5, 140, 0, 0, 9456, 9457, 5, 650, 0, 0, 9457, + 9458, 3, 1892, 946, 0, 9458, 9459, 5, 331, 0, 0, 9459, 9460, 3, 502, 251, + 0, 9460, 9501, 1, 0, 0, 0, 9461, 9462, 5, 140, 0, 0, 9462, 9463, 5, 650, + 0, 0, 9463, 9464, 3, 1892, 946, 0, 9464, 9465, 5, 166, 0, 0, 9465, 9466, + 3, 1910, 955, 0, 9466, 9501, 1, 0, 0, 0, 9467, 9468, 5, 140, 0, 0, 9468, + 9469, 5, 650, 0, 0, 9469, 9470, 3, 1892, 946, 0, 9470, 9471, 5, 303, 0, + 0, 9471, 9473, 5, 651, 0, 0, 9472, 9474, 3, 882, 441, 0, 9473, 9472, 1, + 0, 0, 0, 9473, 9474, 1, 0, 0, 0, 9474, 9501, 1, 0, 0, 0, 9475, 9476, 5, + 140, 0, 0, 9476, 9477, 5, 650, 0, 0, 9477, 9478, 3, 1892, 946, 0, 9478, + 9479, 5, 331, 0, 0, 9479, 9480, 5, 651, 0, 0, 9480, 9482, 3, 978, 489, + 0, 9481, 9483, 3, 882, 441, 0, 9482, 9481, 1, 0, 0, 0, 9482, 9483, 1, 0, + 0, 0, 9483, 9501, 1, 0, 0, 0, 9484, 9485, 5, 140, 0, 0, 9485, 9486, 5, + 650, 0, 0, 9486, 9487, 3, 1892, 946, 0, 9487, 9488, 5, 197, 0, 0, 9488, + 9501, 1, 0, 0, 0, 9489, 9490, 5, 140, 0, 0, 9490, 9491, 5, 650, 0, 0, 9491, + 9492, 3, 1892, 946, 0, 9492, 9493, 5, 190, 0, 0, 9493, 9501, 1, 0, 0, 0, + 9494, 9495, 5, 140, 0, 0, 9495, 9496, 5, 650, 0, 0, 9496, 9497, 3, 1892, + 946, 0, 9497, 9498, 5, 664, 0, 0, 9498, 9499, 3, 502, 251, 0, 9499, 9501, + 1, 0, 0, 0, 9500, 9455, 1, 0, 0, 0, 9500, 9461, 1, 0, 0, 0, 9500, 9467, + 1, 0, 0, 0, 9500, 9475, 1, 0, 0, 0, 9500, 9484, 1, 0, 0, 0, 9500, 9489, + 1, 0, 0, 0, 9500, 9494, 1, 0, 0, 0, 9501, 983, 1, 0, 0, 0, 9502, 9503, + 5, 195, 0, 0, 9503, 9504, 5, 650, 0, 0, 9504, 9506, 3, 1892, 946, 0, 9505, + 9507, 3, 120, 60, 0, 9506, 9505, 1, 0, 0, 0, 9506, 9507, 1, 0, 0, 0, 9507, + 9517, 1, 0, 0, 0, 9508, 9509, 5, 195, 0, 0, 9509, 9510, 5, 650, 0, 0, 9510, + 9511, 5, 224, 0, 0, 9511, 9512, 5, 558, 0, 0, 9512, 9514, 3, 1892, 946, + 0, 9513, 9515, 3, 120, 60, 0, 9514, 9513, 1, 0, 0, 0, 9514, 9515, 1, 0, + 0, 0, 9515, 9517, 1, 0, 0, 0, 9516, 9502, 1, 0, 0, 0, 9516, 9508, 1, 0, + 0, 0, 9517, 985, 1, 0, 0, 0, 9518, 9520, 5, 46, 0, 0, 9519, 9521, 3, 832, + 416, 0, 9520, 9519, 1, 0, 0, 0, 9520, 9521, 1, 0, 0, 0, 9521, 9522, 1, + 0, 0, 0, 9522, 9523, 5, 319, 0, 0, 9523, 9524, 3, 1892, 946, 0, 9524, 9525, + 5, 36, 0, 0, 9525, 9526, 5, 80, 0, 0, 9526, 9527, 3, 996, 498, 0, 9527, + 9528, 5, 95, 0, 0, 9528, 9530, 3, 1888, 944, 0, 9529, 9531, 3, 1638, 819, + 0, 9530, 9529, 1, 0, 0, 0, 9530, 9531, 1, 0, 0, 0, 9531, 9532, 1, 0, 0, + 0, 9532, 9534, 5, 57, 0, 0, 9533, 9535, 3, 998, 499, 0, 9534, 9533, 1, + 0, 0, 0, 9534, 9535, 1, 0, 0, 0, 9535, 9536, 1, 0, 0, 0, 9536, 9537, 3, + 988, 494, 0, 9537, 987, 1, 0, 0, 0, 9538, 9545, 5, 267, 0, 0, 9539, 9545, + 3, 992, 496, 0, 9540, 9541, 5, 2, 0, 0, 9541, 9542, 3, 990, 495, 0, 9542, + 9543, 5, 3, 0, 0, 9543, 9545, 1, 0, 0, 0, 9544, 9538, 1, 0, 0, 0, 9544, + 9539, 1, 0, 0, 0, 9544, 9540, 1, 0, 0, 0, 9545, 989, 1, 0, 0, 0, 9546, + 9548, 3, 994, 497, 0, 9547, 9546, 1, 0, 0, 0, 9547, 9548, 1, 0, 0, 0, 9548, + 9555, 1, 0, 0, 0, 9549, 9551, 5, 7, 0, 0, 9550, 9552, 3, 994, 497, 0, 9551, + 9550, 1, 0, 0, 0, 9551, 9552, 1, 0, 0, 0, 9552, 9554, 1, 0, 0, 0, 9553, + 9549, 1, 0, 0, 0, 9554, 9557, 1, 0, 0, 0, 9555, 9553, 1, 0, 0, 0, 9555, + 9556, 1, 0, 0, 0, 9556, 991, 1, 0, 0, 0, 9557, 9555, 1, 0, 0, 0, 9558, + 9564, 3, 1496, 748, 0, 9559, 9564, 3, 1436, 718, 0, 9560, 9564, 3, 1478, + 739, 0, 9561, 9564, 3, 1464, 732, 0, 9562, 9564, 3, 1000, 500, 0, 9563, + 9558, 1, 0, 0, 0, 9563, 9559, 1, 0, 0, 0, 9563, 9560, 1, 0, 0, 0, 9563, + 9561, 1, 0, 0, 0, 9563, 9562, 1, 0, 0, 0, 9564, 993, 1, 0, 0, 0, 9565, + 9566, 3, 992, 496, 0, 9566, 995, 1, 0, 0, 0, 9567, 9568, 7, 53, 0, 0, 9568, + 997, 1, 0, 0, 0, 9569, 9570, 7, 54, 0, 0, 9570, 999, 1, 0, 0, 0, 9571, + 9572, 5, 268, 0, 0, 9572, 9574, 3, 1924, 962, 0, 9573, 9575, 3, 1002, 501, + 0, 9574, 9573, 1, 0, 0, 0, 9574, 9575, 1, 0, 0, 0, 9575, 1001, 1, 0, 0, + 0, 9576, 9577, 5, 6, 0, 0, 9577, 9578, 3, 1910, 955, 0, 9578, 1003, 1, + 0, 0, 0, 9579, 9580, 5, 247, 0, 0, 9580, 9581, 3, 1924, 962, 0, 9581, 1005, + 1, 0, 0, 0, 9582, 9583, 5, 364, 0, 0, 9583, 9587, 3, 1924, 962, 0, 9584, + 9585, 5, 364, 0, 0, 9585, 9587, 5, 9, 0, 0, 9586, 9582, 1, 0, 0, 0, 9586, + 9584, 1, 0, 0, 0, 9587, 1007, 1, 0, 0, 0, 9588, 9590, 5, 131, 0, 0, 9589, + 9591, 3, 1010, 505, 0, 9590, 9589, 1, 0, 0, 0, 9590, 9591, 1, 0, 0, 0, + 9591, 9593, 1, 0, 0, 0, 9592, 9594, 3, 1018, 509, 0, 9593, 9592, 1, 0, + 0, 0, 9593, 9594, 1, 0, 0, 0, 9594, 9658, 1, 0, 0, 0, 9595, 9597, 5, 148, + 0, 0, 9596, 9598, 3, 1010, 505, 0, 9597, 9596, 1, 0, 0, 0, 9597, 9598, + 1, 0, 0, 0, 9598, 9600, 1, 0, 0, 0, 9599, 9601, 3, 1016, 508, 0, 9600, + 9599, 1, 0, 0, 0, 9600, 9601, 1, 0, 0, 0, 9601, 9658, 1, 0, 0, 0, 9602, + 9603, 5, 338, 0, 0, 9603, 9605, 5, 354, 0, 0, 9604, 9606, 3, 1016, 508, + 0, 9605, 9604, 1, 0, 0, 0, 9605, 9606, 1, 0, 0, 0, 9606, 9658, 1, 0, 0, + 0, 9607, 9609, 5, 163, 0, 0, 9608, 9610, 3, 1010, 505, 0, 9609, 9608, 1, + 0, 0, 0, 9609, 9610, 1, 0, 0, 0, 9610, 9612, 1, 0, 0, 0, 9611, 9613, 3, + 1018, 509, 0, 9612, 9611, 1, 0, 0, 0, 9612, 9613, 1, 0, 0, 0, 9613, 9658, + 1, 0, 0, 0, 9614, 9616, 5, 653, 0, 0, 9615, 9617, 3, 1010, 505, 0, 9616, + 9615, 1, 0, 0, 0, 9616, 9617, 1, 0, 0, 0, 9617, 9619, 1, 0, 0, 0, 9618, + 9620, 3, 1018, 509, 0, 9619, 9618, 1, 0, 0, 0, 9619, 9620, 1, 0, 0, 0, + 9620, 9658, 1, 0, 0, 0, 9621, 9623, 5, 317, 0, 0, 9622, 9624, 3, 1010, + 505, 0, 9623, 9622, 1, 0, 0, 0, 9623, 9624, 1, 0, 0, 0, 9624, 9626, 1, + 0, 0, 0, 9625, 9627, 3, 1018, 509, 0, 9626, 9625, 1, 0, 0, 0, 9626, 9627, + 1, 0, 0, 0, 9627, 9658, 1, 0, 0, 0, 9628, 9629, 5, 320, 0, 0, 9629, 9658, + 3, 1924, 962, 0, 9630, 9631, 5, 306, 0, 0, 9631, 9632, 5, 320, 0, 0, 9632, + 9658, 3, 1924, 962, 0, 9633, 9634, 5, 306, 0, 0, 9634, 9658, 3, 1924, 962, + 0, 9635, 9637, 5, 317, 0, 0, 9636, 9638, 3, 1010, 505, 0, 9637, 9636, 1, + 0, 0, 0, 9637, 9638, 1, 0, 0, 0, 9638, 9639, 1, 0, 0, 0, 9639, 9640, 5, + 95, 0, 0, 9640, 9641, 5, 320, 0, 0, 9641, 9658, 3, 1924, 962, 0, 9642, + 9644, 5, 317, 0, 0, 9643, 9645, 3, 1010, 505, 0, 9644, 9643, 1, 0, 0, 0, + 9644, 9645, 1, 0, 0, 0, 9645, 9646, 1, 0, 0, 0, 9646, 9647, 5, 95, 0, 0, + 9647, 9658, 3, 1924, 962, 0, 9648, 9649, 5, 288, 0, 0, 9649, 9650, 5, 354, + 0, 0, 9650, 9658, 3, 1910, 955, 0, 9651, 9652, 5, 163, 0, 0, 9652, 9653, + 5, 289, 0, 0, 9653, 9658, 3, 1910, 955, 0, 9654, 9655, 5, 317, 0, 0, 9655, + 9656, 5, 289, 0, 0, 9656, 9658, 3, 1910, 955, 0, 9657, 9588, 1, 0, 0, 0, + 9657, 9595, 1, 0, 0, 0, 9657, 9602, 1, 0, 0, 0, 9657, 9607, 1, 0, 0, 0, + 9657, 9614, 1, 0, 0, 0, 9657, 9621, 1, 0, 0, 0, 9657, 9628, 1, 0, 0, 0, + 9657, 9630, 1, 0, 0, 0, 9657, 9633, 1, 0, 0, 0, 9657, 9635, 1, 0, 0, 0, + 9657, 9642, 1, 0, 0, 0, 9657, 9648, 1, 0, 0, 0, 9657, 9651, 1, 0, 0, 0, + 9657, 9654, 1, 0, 0, 0, 9658, 1009, 1, 0, 0, 0, 9659, 9660, 7, 55, 0, 0, + 9660, 1011, 1, 0, 0, 0, 9661, 9662, 5, 239, 0, 0, 9662, 9663, 5, 246, 0, + 0, 9663, 9672, 3, 74, 37, 0, 9664, 9665, 5, 298, 0, 0, 9665, 9672, 5, 81, + 0, 0, 9666, 9667, 5, 298, 0, 0, 9667, 9672, 5, 380, 0, 0, 9668, 9672, 5, + 54, 0, 0, 9669, 9670, 5, 77, 0, 0, 9670, 9672, 5, 54, 0, 0, 9671, 9661, + 1, 0, 0, 0, 9671, 9664, 1, 0, 0, 0, 9671, 9666, 1, 0, 0, 0, 9671, 9668, + 1, 0, 0, 0, 9671, 9669, 1, 0, 0, 0, 9672, 1013, 1, 0, 0, 0, 9673, 9680, + 3, 1012, 506, 0, 9674, 9676, 5, 6, 0, 0, 9675, 9674, 1, 0, 0, 0, 9675, + 9676, 1, 0, 0, 0, 9676, 9677, 1, 0, 0, 0, 9677, 9679, 3, 1012, 506, 0, + 9678, 9675, 1, 0, 0, 0, 9679, 9682, 1, 0, 0, 0, 9680, 9678, 1, 0, 0, 0, + 9680, 9681, 1, 0, 0, 0, 9681, 1015, 1, 0, 0, 0, 9682, 9680, 1, 0, 0, 0, + 9683, 9684, 3, 1014, 507, 0, 9684, 1017, 1, 0, 0, 0, 9685, 9687, 5, 33, + 0, 0, 9686, 9688, 5, 266, 0, 0, 9687, 9686, 1, 0, 0, 0, 9687, 9688, 1, + 0, 0, 0, 9688, 9689, 1, 0, 0, 0, 9689, 9690, 5, 155, 0, 0, 9690, 1019, + 1, 0, 0, 0, 9691, 9694, 5, 46, 0, 0, 9692, 9693, 5, 82, 0, 0, 9693, 9695, + 5, 309, 0, 0, 9694, 9692, 1, 0, 0, 0, 9694, 9695, 1, 0, 0, 0, 9695, 9697, + 1, 0, 0, 0, 9696, 9698, 3, 198, 99, 0, 9697, 9696, 1, 0, 0, 0, 9697, 9698, + 1, 0, 0, 0, 9698, 9716, 1, 0, 0, 0, 9699, 9700, 5, 374, 0, 0, 9700, 9702, + 3, 1888, 944, 0, 9701, 9703, 3, 244, 122, 0, 9702, 9701, 1, 0, 0, 0, 9702, + 9703, 1, 0, 0, 0, 9703, 9705, 1, 0, 0, 0, 9704, 9706, 3, 130, 65, 0, 9705, + 9704, 1, 0, 0, 0, 9705, 9706, 1, 0, 0, 0, 9706, 9717, 1, 0, 0, 0, 9707, + 9708, 5, 301, 0, 0, 9708, 9709, 5, 374, 0, 0, 9709, 9710, 3, 1888, 944, + 0, 9710, 9711, 5, 2, 0, 0, 9711, 9712, 3, 246, 123, 0, 9712, 9714, 5, 3, + 0, 0, 9713, 9715, 3, 130, 65, 0, 9714, 9713, 1, 0, 0, 0, 9714, 9715, 1, + 0, 0, 0, 9715, 9717, 1, 0, 0, 0, 9716, 9699, 1, 0, 0, 0, 9716, 9707, 1, + 0, 0, 0, 9717, 9718, 1, 0, 0, 0, 9718, 9719, 5, 36, 0, 0, 9719, 9721, 3, + 1496, 748, 0, 9720, 9722, 3, 1024, 512, 0, 9721, 9720, 1, 0, 0, 0, 9721, + 9722, 1, 0, 0, 0, 9722, 9724, 1, 0, 0, 0, 9723, 9725, 3, 1022, 511, 0, + 9724, 9723, 1, 0, 0, 0, 9724, 9725, 1, 0, 0, 0, 9725, 1021, 1, 0, 0, 0, + 9726, 9727, 5, 106, 0, 0, 9727, 9728, 5, 266, 0, 0, 9728, 9729, 5, 321, + 0, 0, 9729, 9730, 5, 109, 0, 0, 9730, 1023, 1, 0, 0, 0, 9731, 9733, 5, + 106, 0, 0, 9732, 9734, 7, 56, 0, 0, 9733, 9732, 1, 0, 0, 0, 9733, 9734, + 1, 0, 0, 0, 9734, 9735, 1, 0, 0, 0, 9735, 9736, 5, 42, 0, 0, 9736, 9737, + 5, 276, 0, 0, 9737, 1025, 1, 0, 0, 0, 9738, 9739, 5, 248, 0, 0, 9739, 9740, + 3, 1896, 948, 0, 9740, 1027, 1, 0, 0, 0, 9741, 9742, 5, 140, 0, 0, 9742, + 9743, 5, 392, 0, 0, 9743, 9744, 3, 1924, 962, 0, 9744, 9745, 3, 1030, 515, + 0, 9745, 1029, 1, 0, 0, 0, 9746, 9747, 3, 1032, 516, 0, 9747, 9748, 3, + 1034, 517, 0, 9748, 9766, 1, 0, 0, 0, 9749, 9750, 5, 331, 0, 0, 9750, 9752, + 5, 394, 0, 0, 9751, 9753, 3, 1346, 673, 0, 9752, 9751, 1, 0, 0, 0, 9752, + 9753, 1, 0, 0, 0, 9753, 9754, 1, 0, 0, 0, 9754, 9766, 3, 76, 38, 0, 9755, + 9756, 5, 331, 0, 0, 9756, 9758, 5, 395, 0, 0, 9757, 9759, 3, 1346, 673, + 0, 9758, 9757, 1, 0, 0, 0, 9758, 9759, 1, 0, 0, 0, 9759, 9760, 1, 0, 0, + 0, 9760, 9761, 3, 76, 38, 0, 9761, 9762, 5, 62, 0, 0, 9762, 9763, 5, 321, + 0, 0, 9763, 9764, 3, 1924, 962, 0, 9764, 9766, 1, 0, 0, 0, 9765, 9746, + 1, 0, 0, 0, 9765, 9749, 1, 0, 0, 0, 9765, 9755, 1, 0, 0, 0, 9766, 1031, + 1, 0, 0, 0, 9767, 9768, 7, 57, 0, 0, 9768, 1033, 1, 0, 0, 0, 9769, 9770, + 5, 93, 0, 0, 9770, 9786, 3, 1036, 518, 0, 9771, 9772, 5, 321, 0, 0, 9772, + 9786, 3, 1890, 945, 0, 9773, 9774, 5, 215, 0, 0, 9774, 9786, 3, 1044, 522, + 0, 9775, 9776, 5, 30, 0, 0, 9776, 9777, 5, 348, 0, 0, 9777, 9778, 5, 68, + 0, 0, 9778, 9779, 5, 321, 0, 0, 9779, 9786, 3, 1890, 945, 0, 9780, 9781, + 5, 30, 0, 0, 9781, 9782, 5, 216, 0, 0, 9782, 9783, 5, 68, 0, 0, 9783, 9784, + 5, 321, 0, 0, 9784, 9786, 3, 1890, 945, 0, 9785, 9769, 1, 0, 0, 0, 9785, + 9771, 1, 0, 0, 0, 9785, 9773, 1, 0, 0, 0, 9785, 9775, 1, 0, 0, 0, 9785, + 9780, 1, 0, 0, 0, 9786, 1035, 1, 0, 0, 0, 9787, 9792, 3, 1038, 519, 0, + 9788, 9789, 5, 6, 0, 0, 9789, 9791, 3, 1038, 519, 0, 9790, 9788, 1, 0, + 0, 0, 9791, 9794, 1, 0, 0, 0, 9792, 9790, 1, 0, 0, 0, 9792, 9793, 1, 0, + 0, 0, 9793, 1037, 1, 0, 0, 0, 9794, 9792, 1, 0, 0, 0, 9795, 9798, 3, 1924, + 962, 0, 9796, 9797, 5, 11, 0, 0, 9797, 9799, 3, 1924, 962, 0, 9798, 9796, + 1, 0, 0, 0, 9798, 9799, 1, 0, 0, 0, 9799, 1039, 1, 0, 0, 0, 9800, 9803, + 3, 1888, 944, 0, 9801, 9803, 3, 1042, 521, 0, 9802, 9800, 1, 0, 0, 0, 9802, + 9801, 1, 0, 0, 0, 9803, 1041, 1, 0, 0, 0, 9804, 9805, 5, 852, 0, 0, 9805, + 1043, 1, 0, 0, 0, 9806, 9811, 3, 1046, 523, 0, 9807, 9808, 5, 6, 0, 0, + 9808, 9810, 3, 1046, 523, 0, 9809, 9807, 1, 0, 0, 0, 9810, 9813, 1, 0, + 0, 0, 9811, 9809, 1, 0, 0, 0, 9811, 9812, 1, 0, 0, 0, 9812, 1045, 1, 0, + 0, 0, 9813, 9811, 1, 0, 0, 0, 9814, 9815, 3, 1048, 524, 0, 9815, 9816, + 3, 838, 419, 0, 9816, 1047, 1, 0, 0, 0, 9817, 9820, 3, 1924, 962, 0, 9818, + 9819, 5, 11, 0, 0, 9819, 9821, 3, 1924, 962, 0, 9820, 9818, 1, 0, 0, 0, + 9820, 9821, 1, 0, 0, 0, 9821, 1049, 1, 0, 0, 0, 9822, 9823, 5, 46, 0, 0, + 9823, 9824, 5, 392, 0, 0, 9824, 9826, 3, 1888, 944, 0, 9825, 9827, 3, 1052, + 526, 0, 9826, 9825, 1, 0, 0, 0, 9826, 9827, 1, 0, 0, 0, 9827, 1051, 1, + 0, 0, 0, 9828, 9833, 3, 1054, 527, 0, 9829, 9830, 5, 6, 0, 0, 9830, 9832, + 3, 1054, 527, 0, 9831, 9829, 1, 0, 0, 0, 9832, 9835, 1, 0, 0, 0, 9833, + 9831, 1, 0, 0, 0, 9833, 9834, 1, 0, 0, 0, 9834, 1053, 1, 0, 0, 0, 9835, + 9833, 1, 0, 0, 0, 9836, 9839, 3, 1056, 528, 0, 9837, 9839, 3, 1058, 529, + 0, 9838, 9836, 1, 0, 0, 0, 9838, 9837, 1, 0, 0, 0, 9839, 1055, 1, 0, 0, + 0, 9840, 9842, 5, 331, 0, 0, 9841, 9840, 1, 0, 0, 0, 9841, 9842, 1, 0, + 0, 0, 9842, 9843, 1, 0, 0, 0, 9843, 9848, 5, 394, 0, 0, 9844, 9846, 5, + 10, 0, 0, 9845, 9844, 1, 0, 0, 0, 9845, 9846, 1, 0, 0, 0, 9846, 9847, 1, + 0, 0, 0, 9847, 9849, 7, 58, 0, 0, 9848, 9845, 1, 0, 0, 0, 9848, 9849, 1, + 0, 0, 0, 9849, 1057, 1, 0, 0, 0, 9850, 9851, 5, 470, 0, 0, 9851, 9852, + 5, 471, 0, 0, 9852, 1059, 1, 0, 0, 0, 9853, 9854, 7, 59, 0, 0, 9854, 9855, + 5, 392, 0, 0, 9855, 9863, 3, 1924, 962, 0, 9856, 9859, 5, 272, 0, 0, 9857, + 9858, 5, 466, 0, 0, 9858, 9860, 3, 1910, 955, 0, 9859, 9857, 1, 0, 0, 0, + 9859, 9860, 1, 0, 0, 0, 9860, 9861, 1, 0, 0, 0, 9861, 9862, 5, 467, 0, + 0, 9862, 9864, 3, 1910, 955, 0, 9863, 9856, 1, 0, 0, 0, 9863, 9864, 1, + 0, 0, 0, 9864, 1061, 1, 0, 0, 0, 9865, 9866, 5, 195, 0, 0, 9866, 9868, + 5, 392, 0, 0, 9867, 9869, 3, 922, 461, 0, 9868, 9867, 1, 0, 0, 0, 9868, + 9869, 1, 0, 0, 0, 9869, 9870, 1, 0, 0, 0, 9870, 9871, 3, 1924, 962, 0, + 9871, 1063, 1, 0, 0, 0, 9872, 9873, 5, 140, 0, 0, 9873, 9874, 5, 209, 0, + 0, 9874, 9875, 5, 321, 0, 0, 9875, 9877, 3, 1924, 962, 0, 9876, 9878, 3, + 1066, 533, 0, 9877, 9876, 1, 0, 0, 0, 9878, 9879, 1, 0, 0, 0, 9879, 9877, + 1, 0, 0, 0, 9879, 9880, 1, 0, 0, 0, 9880, 1065, 1, 0, 0, 0, 9881, 9882, + 5, 307, 0, 0, 9882, 9883, 5, 95, 0, 0, 9883, 9902, 3, 1924, 962, 0, 9884, + 9885, 5, 279, 0, 0, 9885, 9886, 5, 95, 0, 0, 9886, 9902, 3, 1924, 962, + 0, 9887, 9891, 5, 396, 0, 0, 9888, 9892, 5, 53, 0, 0, 9889, 9892, 5, 330, + 0, 0, 9890, 9892, 3, 1910, 955, 0, 9891, 9888, 1, 0, 0, 0, 9891, 9889, + 1, 0, 0, 0, 9891, 9890, 1, 0, 0, 0, 9892, 9902, 1, 0, 0, 0, 9893, 9894, + 5, 408, 0, 0, 9894, 9902, 7, 60, 0, 0, 9895, 9896, 5, 409, 0, 0, 9896, + 9902, 3, 1910, 955, 0, 9897, 9898, 5, 404, 0, 0, 9898, 9902, 3, 1910, 955, + 0, 9899, 9900, 5, 401, 0, 0, 9900, 9902, 3, 1910, 955, 0, 9901, 9881, 1, + 0, 0, 0, 9901, 9884, 1, 0, 0, 0, 9901, 9887, 1, 0, 0, 0, 9901, 9893, 1, + 0, 0, 0, 9901, 9895, 1, 0, 0, 0, 9901, 9897, 1, 0, 0, 0, 9901, 9899, 1, + 0, 0, 0, 9902, 1067, 1, 0, 0, 0, 9903, 9904, 5, 140, 0, 0, 9904, 9905, + 5, 209, 0, 0, 9905, 9906, 5, 374, 0, 0, 9906, 9908, 3, 1888, 944, 0, 9907, + 9909, 5, 213, 0, 0, 9908, 9907, 1, 0, 0, 0, 9908, 9909, 1, 0, 0, 0, 9909, + 9914, 1, 0, 0, 0, 9910, 9911, 5, 36, 0, 0, 9911, 9915, 3, 1496, 748, 0, + 9912, 9913, 5, 472, 0, 0, 9913, 9915, 5, 391, 0, 0, 9914, 9910, 1, 0, 0, + 0, 9914, 9912, 1, 0, 0, 0, 9914, 9915, 1, 0, 0, 0, 9915, 1069, 1, 0, 0, + 0, 9916, 9917, 5, 46, 0, 0, 9917, 9918, 5, 209, 0, 0, 9918, 9920, 5, 321, + 0, 0, 9919, 9921, 3, 522, 261, 0, 9920, 9919, 1, 0, 0, 0, 9920, 9921, 1, + 0, 0, 0, 9921, 9922, 1, 0, 0, 0, 9922, 9932, 3, 1924, 962, 0, 9923, 9933, + 3, 1072, 536, 0, 9924, 9933, 3, 1078, 539, 0, 9925, 9933, 3, 1080, 540, + 0, 9926, 9933, 3, 1082, 541, 0, 9927, 9933, 3, 1084, 542, 0, 9928, 9933, + 3, 1086, 543, 0, 9929, 9933, 3, 1088, 544, 0, 9930, 9933, 3, 1090, 545, + 0, 9931, 9933, 3, 1076, 538, 0, 9932, 9923, 1, 0, 0, 0, 9932, 9924, 1, + 0, 0, 0, 9932, 9925, 1, 0, 0, 0, 9932, 9926, 1, 0, 0, 0, 9932, 9927, 1, + 0, 0, 0, 9932, 9928, 1, 0, 0, 0, 9932, 9929, 1, 0, 0, 0, 9932, 9930, 1, + 0, 0, 0, 9932, 9931, 1, 0, 0, 0, 9933, 1071, 1, 0, 0, 0, 9934, 9938, 5, + 64, 0, 0, 9935, 9936, 5, 177, 0, 0, 9936, 9939, 5, 154, 0, 0, 9937, 9939, + 5, 178, 0, 0, 9938, 9935, 1, 0, 0, 0, 9938, 9937, 1, 0, 0, 0, 9939, 9940, + 1, 0, 0, 0, 9940, 9941, 5, 179, 0, 0, 9941, 9942, 3, 1910, 955, 0, 9942, + 9943, 3, 1924, 962, 0, 9943, 9944, 3, 1910, 955, 0, 9944, 9945, 5, 396, + 0, 0, 9945, 9948, 3, 1092, 546, 0, 9946, 9947, 5, 397, 0, 0, 9947, 9949, + 3, 1094, 547, 0, 9948, 9946, 1, 0, 0, 0, 9948, 9949, 1, 0, 0, 0, 9949, + 9954, 1, 0, 0, 0, 9950, 9951, 5, 46, 0, 0, 9951, 9952, 5, 209, 0, 0, 9952, + 9953, 5, 179, 0, 0, 9953, 9955, 3, 522, 261, 0, 9954, 9950, 1, 0, 0, 0, + 9954, 9955, 1, 0, 0, 0, 9955, 9958, 1, 0, 0, 0, 9956, 9957, 5, 398, 0, + 0, 9957, 9959, 3, 1910, 955, 0, 9958, 9956, 1, 0, 0, 0, 9958, 9959, 1, + 0, 0, 0, 9959, 1073, 1, 0, 0, 0, 9960, 9961, 5, 195, 0, 0, 9961, 9963, + 5, 321, 0, 0, 9962, 9964, 3, 922, 461, 0, 9963, 9962, 1, 0, 0, 0, 9963, + 9964, 1, 0, 0, 0, 9964, 9965, 1, 0, 0, 0, 9965, 9970, 3, 1888, 944, 0, + 9966, 9967, 5, 6, 0, 0, 9967, 9969, 3, 1888, 944, 0, 9968, 9966, 1, 0, + 0, 0, 9969, 9972, 1, 0, 0, 0, 9970, 9968, 1, 0, 0, 0, 9970, 9971, 1, 0, + 0, 0, 9971, 9976, 1, 0, 0, 0, 9972, 9970, 1, 0, 0, 0, 9973, 9974, 5, 195, + 0, 0, 9974, 9975, 5, 209, 0, 0, 9975, 9977, 5, 179, 0, 0, 9976, 9973, 1, + 0, 0, 0, 9976, 9977, 1, 0, 0, 0, 9977, 9979, 1, 0, 0, 0, 9978, 9980, 7, + 12, 0, 0, 9979, 9978, 1, 0, 0, 0, 9979, 9980, 1, 0, 0, 0, 9980, 1075, 1, + 0, 0, 0, 9981, 9982, 5, 64, 0, 0, 9982, 9983, 5, 179, 0, 0, 9983, 9984, + 3, 1910, 955, 0, 9984, 9985, 3, 1924, 962, 0, 9985, 9986, 3, 1910, 955, + 0, 9986, 9987, 5, 396, 0, 0, 9987, 9990, 3, 1092, 546, 0, 9988, 9989, 5, + 397, 0, 0, 9989, 9991, 3, 1094, 547, 0, 9990, 9988, 1, 0, 0, 0, 9990, 9991, + 1, 0, 0, 0, 9991, 9996, 1, 0, 0, 0, 9992, 9993, 5, 46, 0, 0, 9993, 9994, + 5, 209, 0, 0, 9994, 9995, 5, 179, 0, 0, 9995, 9997, 3, 522, 261, 0, 9996, + 9992, 1, 0, 0, 0, 9996, 9997, 1, 0, 0, 0, 9997, 10000, 1, 0, 0, 0, 9998, + 9999, 5, 398, 0, 0, 9999, 10001, 3, 1910, 955, 0, 10000, 9998, 1, 0, 0, + 0, 10000, 10001, 1, 0, 0, 0, 10001, 1077, 1, 0, 0, 0, 10002, 10003, 5, + 64, 0, 0, 10003, 10004, 5, 399, 0, 0, 10004, 10005, 5, 400, 0, 0, 10005, + 10006, 5, 179, 0, 0, 10006, 10007, 3, 1910, 955, 0, 10007, 10008, 5, 401, + 0, 0, 10008, 10011, 3, 1910, 955, 0, 10009, 10010, 5, 491, 0, 0, 10010, + 10012, 3, 1908, 954, 0, 10011, 10009, 1, 0, 0, 0, 10011, 10012, 1, 0, 0, + 0, 10012, 10013, 1, 0, 0, 0, 10013, 10014, 5, 396, 0, 0, 10014, 10015, + 3, 1910, 955, 0, 10015, 1079, 1, 0, 0, 0, 10016, 10017, 5, 64, 0, 0, 10017, + 10018, 5, 402, 0, 0, 10018, 10019, 5, 179, 0, 0, 10019, 10022, 3, 1910, + 955, 0, 10020, 10021, 5, 321, 0, 0, 10021, 10023, 3, 1910, 955, 0, 10022, + 10020, 1, 0, 0, 0, 10022, 10023, 1, 0, 0, 0, 10023, 10024, 1, 0, 0, 0, + 10024, 10025, 5, 401, 0, 0, 10025, 10028, 3, 1910, 955, 0, 10026, 10027, + 5, 491, 0, 0, 10027, 10029, 3, 1908, 954, 0, 10028, 10026, 1, 0, 0, 0, + 10028, 10029, 1, 0, 0, 0, 10029, 10030, 1, 0, 0, 0, 10030, 10031, 5, 396, + 0, 0, 10031, 10032, 3, 1092, 546, 0, 10032, 10033, 5, 404, 0, 0, 10033, + 10034, 3, 1910, 955, 0, 10034, 1081, 1, 0, 0, 0, 10035, 10036, 5, 64, 0, + 0, 10036, 10037, 5, 403, 0, 0, 10037, 10038, 5, 179, 0, 0, 10038, 10039, + 3, 1910, 955, 0, 10039, 10040, 5, 401, 0, 0, 10040, 10043, 3, 1910, 955, + 0, 10041, 10042, 5, 491, 0, 0, 10042, 10044, 3, 1908, 954, 0, 10043, 10041, + 1, 0, 0, 0, 10043, 10044, 1, 0, 0, 0, 10044, 10045, 1, 0, 0, 0, 10045, + 10046, 5, 396, 0, 0, 10046, 10047, 3, 1092, 546, 0, 10047, 10048, 5, 404, + 0, 0, 10048, 10049, 3, 1910, 955, 0, 10049, 1083, 1, 0, 0, 0, 10050, 10051, + 5, 64, 0, 0, 10051, 10052, 5, 405, 0, 0, 10052, 10053, 5, 396, 0, 0, 10053, + 10054, 3, 1092, 546, 0, 10054, 1085, 1, 0, 0, 0, 10055, 10056, 5, 64, 0, + 0, 10056, 10057, 5, 406, 0, 0, 10057, 10058, 5, 396, 0, 0, 10058, 10061, + 3, 1092, 546, 0, 10059, 10060, 5, 401, 0, 0, 10060, 10062, 3, 1910, 955, + 0, 10061, 10059, 1, 0, 0, 0, 10061, 10062, 1, 0, 0, 0, 10062, 10065, 1, + 0, 0, 0, 10063, 10064, 5, 408, 0, 0, 10064, 10066, 3, 1096, 548, 0, 10065, + 10063, 1, 0, 0, 0, 10065, 10066, 1, 0, 0, 0, 10066, 10069, 1, 0, 0, 0, + 10067, 10068, 5, 409, 0, 0, 10068, 10070, 3, 1910, 955, 0, 10069, 10067, + 1, 0, 0, 0, 10069, 10070, 1, 0, 0, 0, 10070, 1087, 1, 0, 0, 0, 10071, 10072, + 5, 64, 0, 0, 10072, 10073, 5, 407, 0, 0, 10073, 10074, 5, 396, 0, 0, 10074, + 10077, 3, 1092, 546, 0, 10075, 10076, 5, 401, 0, 0, 10076, 10078, 3, 1910, + 955, 0, 10077, 10075, 1, 0, 0, 0, 10077, 10078, 1, 0, 0, 0, 10078, 10081, + 1, 0, 0, 0, 10079, 10080, 5, 408, 0, 0, 10080, 10082, 3, 1096, 548, 0, + 10081, 10079, 1, 0, 0, 0, 10081, 10082, 1, 0, 0, 0, 10082, 10085, 1, 0, + 0, 0, 10083, 10084, 5, 409, 0, 0, 10084, 10086, 3, 1910, 955, 0, 10085, + 10083, 1, 0, 0, 0, 10085, 10086, 1, 0, 0, 0, 10086, 1089, 1, 0, 0, 0, 10087, + 10088, 5, 64, 0, 0, 10088, 10089, 5, 492, 0, 0, 10089, 10090, 5, 179, 0, + 0, 10090, 10093, 3, 1910, 955, 0, 10091, 10092, 5, 321, 0, 0, 10092, 10094, + 3, 1910, 955, 0, 10093, 10091, 1, 0, 0, 0, 10093, 10094, 1, 0, 0, 0, 10094, + 10098, 1, 0, 0, 0, 10095, 10096, 3, 1924, 962, 0, 10096, 10097, 3, 1910, + 955, 0, 10097, 10099, 1, 0, 0, 0, 10098, 10095, 1, 0, 0, 0, 10098, 10099, + 1, 0, 0, 0, 10099, 10102, 1, 0, 0, 0, 10100, 10101, 5, 396, 0, 0, 10101, + 10103, 3, 1092, 546, 0, 10102, 10100, 1, 0, 0, 0, 10102, 10103, 1, 0, 0, + 0, 10103, 1091, 1, 0, 0, 0, 10104, 10108, 5, 53, 0, 0, 10105, 10108, 5, + 410, 0, 0, 10106, 10108, 3, 1910, 955, 0, 10107, 10104, 1, 0, 0, 0, 10107, + 10105, 1, 0, 0, 0, 10107, 10106, 1, 0, 0, 0, 10108, 1093, 1, 0, 0, 0, 10109, + 10112, 5, 410, 0, 0, 10110, 10112, 3, 1910, 955, 0, 10111, 10109, 1, 0, + 0, 0, 10111, 10110, 1, 0, 0, 0, 10112, 1095, 1, 0, 0, 0, 10113, 10114, + 7, 60, 0, 0, 10114, 1097, 1, 0, 0, 0, 10115, 10118, 5, 46, 0, 0, 10116, + 10117, 5, 82, 0, 0, 10117, 10119, 5, 309, 0, 0, 10118, 10116, 1, 0, 0, + 0, 10118, 10119, 1, 0, 0, 0, 10119, 10120, 1, 0, 0, 0, 10120, 10121, 5, + 209, 0, 0, 10121, 10122, 5, 215, 0, 0, 10122, 10123, 3, 1888, 944, 0, 10123, + 10125, 5, 2, 0, 0, 10124, 10126, 3, 1100, 550, 0, 10125, 10124, 1, 0, 0, + 0, 10125, 10126, 1, 0, 0, 0, 10126, 10127, 1, 0, 0, 0, 10127, 10128, 5, + 3, 0, 0, 10128, 10129, 5, 314, 0, 0, 10129, 10130, 3, 1662, 831, 0, 10130, + 10131, 7, 47, 0, 0, 10131, 10132, 5, 519, 0, 0, 10132, 10133, 3, 1910, + 955, 0, 10133, 10134, 5, 396, 0, 0, 10134, 10137, 3, 1092, 546, 0, 10135, + 10136, 5, 635, 0, 0, 10136, 10138, 3, 1908, 954, 0, 10137, 10135, 1, 0, + 0, 0, 10137, 10138, 1, 0, 0, 0, 10138, 10141, 1, 0, 0, 0, 10139, 10140, + 5, 443, 0, 0, 10140, 10142, 3, 1908, 954, 0, 10141, 10139, 1, 0, 0, 0, + 10141, 10142, 1, 0, 0, 0, 10142, 10148, 1, 0, 0, 0, 10143, 10144, 5, 636, + 0, 0, 10144, 10146, 3, 1908, 954, 0, 10145, 10147, 7, 61, 0, 0, 10146, + 10145, 1, 0, 0, 0, 10146, 10147, 1, 0, 0, 0, 10147, 10149, 1, 0, 0, 0, + 10148, 10143, 1, 0, 0, 0, 10148, 10149, 1, 0, 0, 0, 10149, 1099, 1, 0, + 0, 0, 10150, 10155, 3, 1662, 831, 0, 10151, 10152, 5, 6, 0, 0, 10152, 10154, + 3, 1662, 831, 0, 10153, 10151, 1, 0, 0, 0, 10154, 10157, 1, 0, 0, 0, 10155, + 10153, 1, 0, 0, 0, 10155, 10156, 1, 0, 0, 0, 10156, 1101, 1, 0, 0, 0, 10157, + 10155, 1, 0, 0, 0, 10158, 10163, 3, 1104, 552, 0, 10159, 10160, 5, 6, 0, + 0, 10160, 10162, 3, 1104, 552, 0, 10161, 10159, 1, 0, 0, 0, 10162, 10165, + 1, 0, 0, 0, 10163, 10161, 1, 0, 0, 0, 10163, 10164, 1, 0, 0, 0, 10164, + 10168, 1, 0, 0, 0, 10165, 10163, 1, 0, 0, 0, 10166, 10168, 1, 0, 0, 0, + 10167, 10158, 1, 0, 0, 0, 10167, 10166, 1, 0, 0, 0, 10168, 1103, 1, 0, + 0, 0, 10169, 10170, 3, 1924, 962, 0, 10170, 10171, 3, 1662, 831, 0, 10171, + 1105, 1, 0, 0, 0, 10172, 10173, 5, 46, 0, 0, 10173, 10174, 5, 209, 0, 0, + 10174, 10175, 5, 417, 0, 0, 10175, 10176, 3, 1888, 944, 0, 10176, 10177, + 5, 64, 0, 0, 10177, 10180, 3, 1910, 955, 0, 10178, 10179, 5, 547, 0, 0, + 10179, 10181, 3, 1888, 944, 0, 10180, 10178, 1, 0, 0, 0, 10180, 10181, + 1, 0, 0, 0, 10181, 10182, 1, 0, 0, 0, 10182, 10183, 5, 396, 0, 0, 10183, + 10189, 3, 1092, 546, 0, 10184, 10185, 5, 546, 0, 0, 10185, 10186, 5, 2, + 0, 0, 10186, 10187, 3, 1204, 602, 0, 10187, 10188, 5, 3, 0, 0, 10188, 10190, + 1, 0, 0, 0, 10189, 10184, 1, 0, 0, 0, 10189, 10190, 1, 0, 0, 0, 10190, + 10207, 1, 0, 0, 0, 10191, 10192, 5, 46, 0, 0, 10192, 10193, 5, 209, 0, + 0, 10193, 10194, 5, 417, 0, 0, 10194, 10195, 3, 1888, 944, 0, 10195, 10196, + 5, 215, 0, 0, 10196, 10197, 3, 1888, 944, 0, 10197, 10198, 5, 396, 0, 0, + 10198, 10199, 3, 1092, 546, 0, 10199, 10200, 5, 421, 0, 0, 10200, 10201, + 5, 474, 0, 0, 10201, 10202, 5, 546, 0, 0, 10202, 10203, 5, 2, 0, 0, 10203, + 10204, 3, 1204, 602, 0, 10204, 10205, 5, 3, 0, 0, 10205, 10207, 1, 0, 0, + 0, 10206, 10172, 1, 0, 0, 0, 10206, 10191, 1, 0, 0, 0, 10207, 1107, 1, + 0, 0, 0, 10208, 10209, 5, 46, 0, 0, 10209, 10210, 5, 209, 0, 0, 10210, + 10212, 5, 93, 0, 0, 10211, 10213, 3, 522, 261, 0, 10212, 10211, 1, 0, 0, + 0, 10212, 10213, 1, 0, 0, 0, 10213, 10214, 1, 0, 0, 0, 10214, 10215, 3, + 1888, 944, 0, 10215, 10216, 5, 2, 0, 0, 10216, 10217, 3, 1110, 555, 0, + 10217, 10224, 5, 3, 0, 0, 10218, 10219, 5, 623, 0, 0, 10219, 10220, 5, + 149, 0, 0, 10220, 10221, 5, 2, 0, 0, 10221, 10222, 3, 1110, 555, 0, 10222, + 10223, 5, 3, 0, 0, 10223, 10225, 1, 0, 0, 0, 10224, 10218, 1, 0, 0, 0, + 10224, 10225, 1, 0, 0, 0, 10225, 10226, 1, 0, 0, 0, 10226, 10227, 3, 1116, + 558, 0, 10227, 10228, 5, 250, 0, 0, 10228, 10235, 3, 1910, 955, 0, 10229, + 10230, 5, 93, 0, 0, 10230, 10231, 5, 512, 0, 0, 10231, 10232, 5, 2, 0, + 0, 10232, 10233, 3, 1126, 563, 0, 10233, 10234, 5, 3, 0, 0, 10234, 10236, + 1, 0, 0, 0, 10235, 10229, 1, 0, 0, 0, 10235, 10236, 1, 0, 0, 0, 10236, + 1109, 1, 0, 0, 0, 10237, 10242, 3, 1112, 556, 0, 10238, 10239, 5, 6, 0, + 0, 10239, 10241, 3, 1112, 556, 0, 10240, 10238, 1, 0, 0, 0, 10241, 10244, + 1, 0, 0, 0, 10242, 10240, 1, 0, 0, 0, 10242, 10243, 1, 0, 0, 0, 10243, + 1111, 1, 0, 0, 0, 10244, 10242, 1, 0, 0, 0, 10245, 10246, 3, 1924, 962, + 0, 10246, 10247, 3, 1114, 557, 0, 10247, 1113, 1, 0, 0, 0, 10248, 10251, + 3, 1662, 831, 0, 10249, 10251, 5, 626, 0, 0, 10250, 10248, 1, 0, 0, 0, + 10250, 10249, 1, 0, 0, 0, 10251, 1115, 1, 0, 0, 0, 10252, 10253, 5, 610, + 0, 0, 10253, 10254, 5, 36, 0, 0, 10254, 10268, 3, 1124, 562, 0, 10255, + 10256, 3, 1118, 559, 0, 10256, 10257, 5, 610, 0, 0, 10257, 10258, 5, 36, + 0, 0, 10258, 10259, 3, 1124, 562, 0, 10259, 10268, 1, 0, 0, 0, 10260, 10261, + 5, 610, 0, 0, 10261, 10262, 5, 36, 0, 0, 10262, 10263, 5, 613, 0, 0, 10263, + 10264, 3, 1910, 955, 0, 10264, 10265, 5, 614, 0, 0, 10265, 10266, 3, 1910, + 955, 0, 10266, 10268, 1, 0, 0, 0, 10267, 10252, 1, 0, 0, 0, 10267, 10255, + 1, 0, 0, 0, 10267, 10260, 1, 0, 0, 0, 10268, 1117, 1, 0, 0, 0, 10269, 10270, + 5, 577, 0, 0, 10270, 10271, 5, 780, 0, 0, 10271, 10281, 5, 627, 0, 0, 10272, + 10273, 5, 615, 0, 0, 10273, 10274, 5, 618, 0, 0, 10274, 10275, 5, 149, + 0, 0, 10275, 10279, 3, 1910, 955, 0, 10276, 10277, 5, 619, 0, 0, 10277, + 10278, 5, 149, 0, 0, 10278, 10280, 3, 1910, 955, 0, 10279, 10276, 1, 0, + 0, 0, 10279, 10280, 1, 0, 0, 0, 10280, 10282, 1, 0, 0, 0, 10281, 10272, + 1, 0, 0, 0, 10281, 10282, 1, 0, 0, 0, 10282, 10288, 1, 0, 0, 0, 10283, + 10284, 5, 616, 0, 0, 10284, 10285, 5, 617, 0, 0, 10285, 10286, 5, 618, + 0, 0, 10286, 10287, 5, 149, 0, 0, 10287, 10289, 3, 1910, 955, 0, 10288, + 10283, 1, 0, 0, 0, 10288, 10289, 1, 0, 0, 0, 10289, 10295, 1, 0, 0, 0, + 10290, 10291, 5, 625, 0, 0, 10291, 10292, 5, 622, 0, 0, 10292, 10293, 5, + 618, 0, 0, 10293, 10294, 5, 149, 0, 0, 10294, 10296, 3, 1910, 955, 0, 10295, + 10290, 1, 0, 0, 0, 10295, 10296, 1, 0, 0, 0, 10296, 10301, 1, 0, 0, 0, + 10297, 10298, 5, 621, 0, 0, 10298, 10299, 5, 618, 0, 0, 10299, 10300, 5, + 149, 0, 0, 10300, 10302, 3, 1910, 955, 0, 10301, 10297, 1, 0, 0, 0, 10301, + 10302, 1, 0, 0, 0, 10302, 10307, 1, 0, 0, 0, 10303, 10304, 5, 78, 0, 0, + 10304, 10305, 5, 620, 0, 0, 10305, 10306, 5, 36, 0, 0, 10306, 10308, 3, + 1910, 955, 0, 10307, 10303, 1, 0, 0, 0, 10307, 10308, 1, 0, 0, 0, 10308, + 10322, 1, 0, 0, 0, 10309, 10310, 5, 577, 0, 0, 10310, 10311, 5, 780, 0, + 0, 10311, 10312, 5, 611, 0, 0, 10312, 10319, 3, 1910, 955, 0, 10313, 10314, + 5, 106, 0, 0, 10314, 10315, 5, 612, 0, 0, 10315, 10316, 5, 2, 0, 0, 10316, + 10317, 3, 1120, 560, 0, 10317, 10318, 5, 3, 0, 0, 10318, 10320, 1, 0, 0, + 0, 10319, 10313, 1, 0, 0, 0, 10319, 10320, 1, 0, 0, 0, 10320, 10322, 1, + 0, 0, 0, 10321, 10269, 1, 0, 0, 0, 10321, 10309, 1, 0, 0, 0, 10322, 1119, + 1, 0, 0, 0, 10323, 10328, 3, 1122, 561, 0, 10324, 10325, 5, 6, 0, 0, 10325, + 10327, 3, 1122, 561, 0, 10326, 10324, 1, 0, 0, 0, 10327, 10330, 1, 0, 0, + 0, 10328, 10326, 1, 0, 0, 0, 10328, 10329, 1, 0, 0, 0, 10329, 1121, 1, + 0, 0, 0, 10330, 10328, 1, 0, 0, 0, 10331, 10332, 3, 1910, 955, 0, 10332, + 10333, 5, 10, 0, 0, 10333, 10334, 3, 1910, 955, 0, 10334, 1123, 1, 0, 0, + 0, 10335, 10336, 7, 62, 0, 0, 10336, 1125, 1, 0, 0, 0, 10337, 10342, 3, + 1128, 564, 0, 10338, 10339, 5, 6, 0, 0, 10339, 10341, 3, 1128, 564, 0, + 10340, 10338, 1, 0, 0, 0, 10341, 10344, 1, 0, 0, 0, 10342, 10340, 1, 0, + 0, 0, 10342, 10343, 1, 0, 0, 0, 10343, 1127, 1, 0, 0, 0, 10344, 10342, + 1, 0, 0, 0, 10345, 10346, 3, 1910, 955, 0, 10346, 10347, 5, 10, 0, 0, 10347, + 10348, 3, 1910, 955, 0, 10348, 1129, 1, 0, 0, 0, 10349, 10352, 5, 46, 0, + 0, 10350, 10351, 5, 82, 0, 0, 10351, 10353, 5, 309, 0, 0, 10352, 10350, + 1, 0, 0, 0, 10352, 10353, 1, 0, 0, 0, 10353, 10354, 1, 0, 0, 0, 10354, + 10356, 5, 209, 0, 0, 10355, 10357, 5, 416, 0, 0, 10356, 10355, 1, 0, 0, + 0, 10356, 10357, 1, 0, 0, 0, 10357, 10358, 1, 0, 0, 0, 10358, 10359, 5, + 374, 0, 0, 10359, 10363, 3, 1888, 944, 0, 10360, 10361, 5, 224, 0, 0, 10361, + 10362, 5, 77, 0, 0, 10362, 10364, 5, 558, 0, 0, 10363, 10360, 1, 0, 0, + 0, 10363, 10364, 1, 0, 0, 0, 10364, 10369, 1, 0, 0, 0, 10365, 10366, 5, + 2, 0, 0, 10366, 10367, 3, 1890, 945, 0, 10367, 10368, 5, 3, 0, 0, 10368, + 10370, 1, 0, 0, 0, 10369, 10365, 1, 0, 0, 0, 10369, 10370, 1, 0, 0, 0, + 10370, 10371, 1, 0, 0, 0, 10371, 10372, 5, 36, 0, 0, 10372, 10373, 3, 1496, + 748, 0, 10373, 1131, 1, 0, 0, 0, 10374, 10375, 5, 195, 0, 0, 10375, 10376, + 5, 209, 0, 0, 10376, 10378, 5, 374, 0, 0, 10377, 10379, 3, 922, 461, 0, + 10378, 10377, 1, 0, 0, 0, 10378, 10379, 1, 0, 0, 0, 10379, 10380, 1, 0, + 0, 0, 10380, 10382, 3, 1888, 944, 0, 10381, 10383, 3, 120, 60, 0, 10382, + 10381, 1, 0, 0, 0, 10382, 10383, 1, 0, 0, 0, 10383, 1133, 1, 0, 0, 0, 10384, + 10385, 5, 140, 0, 0, 10385, 10386, 5, 223, 0, 0, 10386, 10387, 5, 415, + 0, 0, 10387, 10389, 3, 1924, 962, 0, 10388, 10390, 3, 1136, 568, 0, 10389, + 10388, 1, 0, 0, 0, 10390, 10391, 1, 0, 0, 0, 10391, 10389, 1, 0, 0, 0, + 10391, 10392, 1, 0, 0, 0, 10392, 1135, 1, 0, 0, 0, 10393, 10394, 5, 503, + 0, 0, 10394, 10413, 3, 1910, 955, 0, 10395, 10396, 5, 467, 0, 0, 10396, + 10413, 3, 1910, 955, 0, 10397, 10398, 5, 396, 0, 0, 10398, 10413, 3, 1910, + 955, 0, 10399, 10408, 5, 505, 0, 0, 10400, 10405, 5, 97, 0, 0, 10401, 10402, + 7, 63, 0, 0, 10402, 10403, 5, 680, 0, 0, 10403, 10404, 5, 122, 0, 0, 10404, + 10406, 3, 1910, 955, 0, 10405, 10401, 1, 0, 0, 0, 10405, 10406, 1, 0, 0, + 0, 10406, 10409, 1, 0, 0, 0, 10407, 10409, 5, 60, 0, 0, 10408, 10400, 1, + 0, 0, 0, 10408, 10407, 1, 0, 0, 0, 10408, 10409, 1, 0, 0, 0, 10409, 10413, + 1, 0, 0, 0, 10410, 10413, 5, 190, 0, 0, 10411, 10413, 5, 197, 0, 0, 10412, + 10393, 1, 0, 0, 0, 10412, 10395, 1, 0, 0, 0, 10412, 10397, 1, 0, 0, 0, + 10412, 10399, 1, 0, 0, 0, 10412, 10410, 1, 0, 0, 0, 10412, 10411, 1, 0, + 0, 0, 10413, 1137, 1, 0, 0, 0, 10414, 10415, 5, 140, 0, 0, 10415, 10416, + 5, 412, 0, 0, 10416, 10417, 5, 643, 0, 0, 10417, 10418, 3, 1924, 962, 0, + 10418, 10419, 3, 1142, 571, 0, 10419, 1139, 1, 0, 0, 0, 10420, 10421, 5, + 140, 0, 0, 10421, 10422, 5, 255, 0, 0, 10422, 10423, 5, 374, 0, 0, 10423, + 10472, 3, 1888, 944, 0, 10424, 10425, 5, 420, 0, 0, 10425, 10426, 5, 303, + 0, 0, 10426, 10473, 7, 27, 0, 0, 10427, 10428, 5, 140, 0, 0, 10428, 10429, + 5, 836, 0, 0, 10429, 10473, 3, 1924, 962, 0, 10430, 10431, 5, 140, 0, 0, + 10431, 10438, 5, 838, 0, 0, 10432, 10439, 5, 30, 0, 0, 10433, 10439, 5, + 842, 0, 0, 10434, 10435, 5, 240, 0, 0, 10435, 10436, 5, 836, 0, 0, 10436, + 10439, 3, 1924, 962, 0, 10437, 10439, 5, 420, 0, 0, 10438, 10432, 1, 0, + 0, 0, 10438, 10433, 1, 0, 0, 0, 10438, 10434, 1, 0, 0, 0, 10438, 10437, + 1, 0, 0, 0, 10439, 10473, 1, 0, 0, 0, 10440, 10442, 5, 140, 0, 0, 10441, + 10443, 5, 840, 0, 0, 10442, 10441, 1, 0, 0, 0, 10442, 10443, 1, 0, 0, 0, + 10443, 10444, 1, 0, 0, 0, 10444, 10445, 5, 837, 0, 0, 10445, 10446, 5, + 2, 0, 0, 10446, 10451, 3, 1924, 962, 0, 10447, 10448, 5, 6, 0, 0, 10448, + 10450, 3, 1924, 962, 0, 10449, 10447, 1, 0, 0, 0, 10450, 10453, 1, 0, 0, + 0, 10451, 10449, 1, 0, 0, 0, 10451, 10452, 1, 0, 0, 0, 10452, 10454, 1, + 0, 0, 0, 10453, 10451, 1, 0, 0, 0, 10454, 10455, 5, 3, 0, 0, 10455, 10473, + 1, 0, 0, 0, 10456, 10457, 5, 140, 0, 0, 10457, 10458, 5, 837, 0, 0, 10458, + 10473, 7, 64, 0, 0, 10459, 10460, 5, 577, 0, 0, 10460, 10461, 5, 246, 0, + 0, 10461, 10462, 5, 325, 0, 0, 10462, 10466, 7, 14, 0, 0, 10463, 10464, + 5, 390, 0, 0, 10464, 10465, 5, 358, 0, 0, 10465, 10467, 7, 15, 0, 0, 10466, + 10463, 1, 0, 0, 0, 10466, 10467, 1, 0, 0, 0, 10467, 10470, 1, 0, 0, 0, + 10468, 10469, 5, 62, 0, 0, 10469, 10471, 5, 455, 0, 0, 10470, 10468, 1, + 0, 0, 0, 10470, 10471, 1, 0, 0, 0, 10471, 10473, 1, 0, 0, 0, 10472, 10424, + 1, 0, 0, 0, 10472, 10427, 1, 0, 0, 0, 10472, 10430, 1, 0, 0, 0, 10472, + 10440, 1, 0, 0, 0, 10472, 10456, 1, 0, 0, 0, 10472, 10459, 1, 0, 0, 0, + 10473, 1141, 1, 0, 0, 0, 10474, 10475, 5, 307, 0, 0, 10475, 10476, 5, 95, + 0, 0, 10476, 10491, 3, 1924, 962, 0, 10477, 10478, 5, 279, 0, 0, 10478, + 10479, 5, 95, 0, 0, 10479, 10491, 3, 1924, 962, 0, 10480, 10481, 5, 331, + 0, 0, 10481, 10482, 5, 2, 0, 0, 10482, 10483, 3, 1144, 572, 0, 10483, 10484, + 5, 3, 0, 0, 10484, 10491, 1, 0, 0, 0, 10485, 10486, 5, 101, 0, 0, 10486, + 10487, 5, 2, 0, 0, 10487, 10488, 3, 1180, 590, 0, 10488, 10489, 5, 3, 0, + 0, 10489, 10491, 1, 0, 0, 0, 10490, 10474, 1, 0, 0, 0, 10490, 10477, 1, + 0, 0, 0, 10490, 10480, 1, 0, 0, 0, 10490, 10485, 1, 0, 0, 0, 10491, 1143, + 1, 0, 0, 0, 10492, 10497, 3, 1146, 573, 0, 10493, 10494, 5, 6, 0, 0, 10494, + 10496, 3, 1146, 573, 0, 10495, 10493, 1, 0, 0, 0, 10496, 10499, 1, 0, 0, + 0, 10497, 10495, 1, 0, 0, 0, 10497, 10498, 1, 0, 0, 0, 10498, 1145, 1, + 0, 0, 0, 10499, 10497, 1, 0, 0, 0, 10500, 10501, 3, 1924, 962, 0, 10501, + 10502, 3, 1662, 831, 0, 10502, 1147, 1, 0, 0, 0, 10503, 10504, 5, 140, + 0, 0, 10504, 10505, 5, 413, 0, 0, 10505, 10506, 5, 643, 0, 0, 10506, 10507, + 3, 1924, 962, 0, 10507, 10508, 5, 101, 0, 0, 10508, 10509, 5, 2, 0, 0, + 10509, 10510, 3, 1710, 855, 0, 10510, 10511, 5, 3, 0, 0, 10511, 1149, 1, + 0, 0, 0, 10512, 10513, 5, 605, 0, 0, 10513, 10514, 5, 412, 0, 0, 10514, + 10515, 5, 643, 0, 0, 10515, 10516, 3, 1924, 962, 0, 10516, 10517, 5, 80, + 0, 0, 10517, 10518, 3, 1888, 944, 0, 10518, 10519, 5, 2, 0, 0, 10519, 10520, + 3, 1152, 576, 0, 10520, 10526, 5, 3, 0, 0, 10521, 10522, 5, 101, 0, 0, + 10522, 10523, 5, 2, 0, 0, 10523, 10524, 3, 1152, 576, 0, 10524, 10525, + 5, 3, 0, 0, 10525, 10527, 1, 0, 0, 0, 10526, 10521, 1, 0, 0, 0, 10526, + 10527, 1, 0, 0, 0, 10527, 10528, 1, 0, 0, 0, 10528, 10529, 5, 95, 0, 0, + 10529, 10532, 3, 1156, 578, 0, 10530, 10531, 5, 644, 0, 0, 10531, 10533, + 3, 1908, 954, 0, 10532, 10530, 1, 0, 0, 0, 10532, 10533, 1, 0, 0, 0, 10533, + 1151, 1, 0, 0, 0, 10534, 10539, 3, 1154, 577, 0, 10535, 10536, 5, 6, 0, + 0, 10536, 10538, 3, 1154, 577, 0, 10537, 10535, 1, 0, 0, 0, 10538, 10541, + 1, 0, 0, 0, 10539, 10537, 1, 0, 0, 0, 10539, 10540, 1, 0, 0, 0, 10540, + 1153, 1, 0, 0, 0, 10541, 10539, 1, 0, 0, 0, 10542, 10543, 3, 1888, 944, + 0, 10543, 1155, 1, 0, 0, 0, 10544, 10549, 3, 1158, 579, 0, 10545, 10546, + 5, 6, 0, 0, 10546, 10548, 3, 1158, 579, 0, 10547, 10545, 1, 0, 0, 0, 10548, + 10551, 1, 0, 0, 0, 10549, 10547, 1, 0, 0, 0, 10549, 10550, 1, 0, 0, 0, + 10550, 1157, 1, 0, 0, 0, 10551, 10549, 1, 0, 0, 0, 10552, 10553, 5, 316, + 0, 0, 10553, 10556, 3, 1888, 944, 0, 10554, 10556, 3, 1924, 962, 0, 10555, + 10552, 1, 0, 0, 0, 10555, 10554, 1, 0, 0, 0, 10556, 1159, 1, 0, 0, 0, 10557, + 10558, 5, 605, 0, 0, 10558, 10559, 5, 413, 0, 0, 10559, 10560, 5, 643, + 0, 0, 10560, 10561, 3, 1924, 962, 0, 10561, 10563, 5, 80, 0, 0, 10562, + 10564, 5, 93, 0, 0, 10563, 10562, 1, 0, 0, 0, 10563, 10564, 1, 0, 0, 0, + 10564, 10565, 1, 0, 0, 0, 10565, 10566, 3, 1162, 581, 0, 10566, 10567, + 5, 95, 0, 0, 10567, 10568, 3, 1156, 578, 0, 10568, 1161, 1, 0, 0, 0, 10569, + 10574, 3, 1888, 944, 0, 10570, 10571, 5, 6, 0, 0, 10571, 10573, 3, 1888, + 944, 0, 10572, 10570, 1, 0, 0, 0, 10573, 10576, 1, 0, 0, 0, 10574, 10572, + 1, 0, 0, 0, 10574, 10575, 1, 0, 0, 0, 10575, 1163, 1, 0, 0, 0, 10576, 10574, + 1, 0, 0, 0, 10577, 10578, 5, 46, 0, 0, 10578, 10579, 5, 223, 0, 0, 10579, + 10580, 5, 415, 0, 0, 10580, 10581, 3, 1924, 962, 0, 10581, 10584, 5, 358, + 0, 0, 10582, 10585, 3, 1910, 955, 0, 10583, 10585, 3, 1924, 962, 0, 10584, + 10582, 1, 0, 0, 0, 10584, 10583, 1, 0, 0, 0, 10585, 10589, 1, 0, 0, 0, + 10586, 10588, 3, 1166, 583, 0, 10587, 10586, 1, 0, 0, 0, 10588, 10591, + 1, 0, 0, 0, 10589, 10587, 1, 0, 0, 0, 10589, 10590, 1, 0, 0, 0, 10590, + 1165, 1, 0, 0, 0, 10591, 10589, 1, 0, 0, 0, 10592, 10593, 5, 507, 0, 0, + 10593, 10619, 3, 1910, 955, 0, 10594, 10595, 5, 508, 0, 0, 10595, 10619, + 3, 1908, 954, 0, 10596, 10597, 5, 509, 0, 0, 10597, 10619, 3, 1910, 955, + 0, 10598, 10599, 5, 510, 0, 0, 10599, 10619, 3, 1910, 955, 0, 10600, 10601, + 5, 511, 0, 0, 10601, 10619, 3, 1910, 955, 0, 10602, 10603, 5, 467, 0, 0, + 10603, 10619, 3, 1910, 955, 0, 10604, 10605, 5, 503, 0, 0, 10605, 10619, + 3, 1910, 955, 0, 10606, 10607, 5, 504, 0, 0, 10607, 10619, 3, 1910, 955, + 0, 10608, 10611, 5, 396, 0, 0, 10609, 10612, 5, 53, 0, 0, 10610, 10612, + 3, 1910, 955, 0, 10611, 10609, 1, 0, 0, 0, 10611, 10610, 1, 0, 0, 0, 10612, + 10619, 1, 0, 0, 0, 10613, 10614, 5, 505, 0, 0, 10614, 10616, 7, 58, 0, + 0, 10615, 10617, 3, 1168, 584, 0, 10616, 10615, 1, 0, 0, 0, 10616, 10617, + 1, 0, 0, 0, 10617, 10619, 1, 0, 0, 0, 10618, 10592, 1, 0, 0, 0, 10618, + 10594, 1, 0, 0, 0, 10618, 10596, 1, 0, 0, 0, 10618, 10598, 1, 0, 0, 0, + 10618, 10600, 1, 0, 0, 0, 10618, 10602, 1, 0, 0, 0, 10618, 10604, 1, 0, + 0, 0, 10618, 10606, 1, 0, 0, 0, 10618, 10608, 1, 0, 0, 0, 10618, 10613, + 1, 0, 0, 0, 10619, 1167, 1, 0, 0, 0, 10620, 10621, 5, 639, 0, 0, 10621, + 10622, 5, 680, 0, 0, 10622, 10623, 5, 122, 0, 0, 10623, 10629, 3, 1910, + 955, 0, 10624, 10625, 5, 203, 0, 0, 10625, 10626, 5, 680, 0, 0, 10626, + 10627, 5, 122, 0, 0, 10627, 10629, 3, 1910, 955, 0, 10628, 10620, 1, 0, + 0, 0, 10628, 10624, 1, 0, 0, 0, 10629, 1169, 1, 0, 0, 0, 10630, 10633, + 5, 46, 0, 0, 10631, 10632, 5, 82, 0, 0, 10632, 10634, 5, 309, 0, 0, 10633, + 10631, 1, 0, 0, 0, 10633, 10634, 1, 0, 0, 0, 10634, 10635, 1, 0, 0, 0, + 10635, 10636, 5, 462, 0, 0, 10636, 10637, 3, 1924, 962, 0, 10637, 10638, + 5, 242, 0, 0, 10638, 10639, 5, 485, 0, 0, 10639, 10640, 5, 64, 0, 0, 10640, + 10644, 3, 1910, 955, 0, 10641, 10643, 3, 1172, 586, 0, 10642, 10641, 1, + 0, 0, 0, 10643, 10646, 1, 0, 0, 0, 10644, 10642, 1, 0, 0, 0, 10644, 10645, + 1, 0, 0, 0, 10645, 1171, 1, 0, 0, 0, 10646, 10644, 1, 0, 0, 0, 10647, 10648, + 5, 501, 0, 0, 10648, 10661, 3, 1910, 955, 0, 10649, 10651, 3, 1924, 962, + 0, 10650, 10652, 5, 36, 0, 0, 10651, 10650, 1, 0, 0, 0, 10651, 10652, 1, + 0, 0, 0, 10652, 10653, 1, 0, 0, 0, 10653, 10654, 3, 1910, 955, 0, 10654, + 10661, 1, 0, 0, 0, 10655, 10658, 5, 396, 0, 0, 10656, 10659, 5, 53, 0, + 0, 10657, 10659, 3, 1910, 955, 0, 10658, 10656, 1, 0, 0, 0, 10658, 10657, + 1, 0, 0, 0, 10659, 10661, 1, 0, 0, 0, 10660, 10647, 1, 0, 0, 0, 10660, + 10649, 1, 0, 0, 0, 10660, 10655, 1, 0, 0, 0, 10661, 1173, 1, 0, 0, 0, 10662, + 10663, 5, 46, 0, 0, 10663, 10664, 5, 412, 0, 0, 10664, 10666, 5, 643, 0, + 0, 10665, 10667, 3, 522, 261, 0, 10666, 10665, 1, 0, 0, 0, 10666, 10667, + 1, 0, 0, 0, 10667, 10668, 1, 0, 0, 0, 10668, 10669, 3, 1924, 962, 0, 10669, + 10670, 5, 106, 0, 0, 10670, 10671, 5, 2, 0, 0, 10671, 10672, 3, 1176, 588, + 0, 10672, 10673, 5, 3, 0, 0, 10673, 10674, 5, 101, 0, 0, 10674, 10675, + 5, 2, 0, 0, 10675, 10676, 3, 1180, 590, 0, 10676, 10677, 5, 3, 0, 0, 10677, + 1175, 1, 0, 0, 0, 10678, 10683, 3, 1178, 589, 0, 10679, 10680, 5, 6, 0, + 0, 10680, 10682, 3, 1178, 589, 0, 10681, 10679, 1, 0, 0, 0, 10682, 10685, + 1, 0, 0, 0, 10683, 10681, 1, 0, 0, 0, 10683, 10684, 1, 0, 0, 0, 10684, + 1177, 1, 0, 0, 0, 10685, 10683, 1, 0, 0, 0, 10686, 10687, 3, 1924, 962, + 0, 10687, 10688, 3, 1662, 831, 0, 10688, 1179, 1, 0, 0, 0, 10689, 10690, + 3, 1710, 855, 0, 10690, 1181, 1, 0, 0, 0, 10691, 10692, 5, 46, 0, 0, 10692, + 10693, 5, 417, 0, 0, 10693, 10694, 3, 1888, 944, 0, 10694, 10695, 5, 64, + 0, 0, 10695, 10698, 3, 1184, 592, 0, 10696, 10697, 5, 418, 0, 0, 10697, + 10699, 3, 1888, 944, 0, 10698, 10696, 1, 0, 0, 0, 10698, 10699, 1, 0, 0, + 0, 10699, 10700, 1, 0, 0, 0, 10700, 10701, 5, 215, 0, 0, 10701, 10706, + 3, 1888, 944, 0, 10702, 10703, 5, 2, 0, 0, 10703, 10704, 3, 1208, 604, + 0, 10704, 10705, 5, 3, 0, 0, 10705, 10707, 1, 0, 0, 0, 10706, 10702, 1, + 0, 0, 0, 10706, 10707, 1, 0, 0, 0, 10707, 10710, 1, 0, 0, 0, 10708, 10709, + 5, 314, 0, 0, 10709, 10711, 3, 1662, 831, 0, 10710, 10708, 1, 0, 0, 0, + 10710, 10711, 1, 0, 0, 0, 10711, 10714, 1, 0, 0, 0, 10712, 10713, 5, 419, + 0, 0, 10713, 10715, 3, 1188, 594, 0, 10714, 10712, 1, 0, 0, 0, 10714, 10715, + 1, 0, 0, 0, 10715, 10716, 1, 0, 0, 0, 10716, 10717, 5, 396, 0, 0, 10717, + 10720, 3, 1186, 593, 0, 10718, 10719, 5, 420, 0, 0, 10719, 10721, 7, 14, + 0, 0, 10720, 10718, 1, 0, 0, 0, 10720, 10721, 1, 0, 0, 0, 10721, 10724, + 1, 0, 0, 0, 10722, 10723, 5, 421, 0, 0, 10723, 10725, 3, 1190, 595, 0, + 10724, 10722, 1, 0, 0, 0, 10724, 10725, 1, 0, 0, 0, 10725, 10728, 1, 0, + 0, 0, 10726, 10727, 5, 422, 0, 0, 10727, 10729, 3, 1192, 596, 0, 10728, + 10726, 1, 0, 0, 0, 10728, 10729, 1, 0, 0, 0, 10729, 10732, 1, 0, 0, 0, + 10730, 10731, 5, 423, 0, 0, 10731, 10733, 3, 1196, 598, 0, 10732, 10730, + 1, 0, 0, 0, 10732, 10733, 1, 0, 0, 0, 10733, 10736, 1, 0, 0, 0, 10734, + 10735, 5, 424, 0, 0, 10735, 10737, 3, 1910, 955, 0, 10736, 10734, 1, 0, + 0, 0, 10736, 10737, 1, 0, 0, 0, 10737, 10740, 1, 0, 0, 0, 10738, 10739, + 5, 425, 0, 0, 10739, 10741, 3, 1198, 599, 0, 10740, 10738, 1, 0, 0, 0, + 10740, 10741, 1, 0, 0, 0, 10741, 10747, 1, 0, 0, 0, 10742, 10743, 5, 546, + 0, 0, 10743, 10744, 5, 2, 0, 0, 10744, 10745, 3, 1204, 602, 0, 10745, 10746, + 5, 3, 0, 0, 10746, 10748, 1, 0, 0, 0, 10747, 10742, 1, 0, 0, 0, 10747, + 10748, 1, 0, 0, 0, 10748, 1183, 1, 0, 0, 0, 10749, 10756, 3, 1888, 944, + 0, 10750, 10751, 5, 2, 0, 0, 10751, 10752, 3, 1496, 748, 0, 10752, 10753, + 5, 3, 0, 0, 10753, 10756, 1, 0, 0, 0, 10754, 10756, 3, 1910, 955, 0, 10755, + 10749, 1, 0, 0, 0, 10755, 10750, 1, 0, 0, 0, 10755, 10754, 1, 0, 0, 0, + 10756, 1185, 1, 0, 0, 0, 10757, 10760, 5, 53, 0, 0, 10758, 10760, 3, 1910, + 955, 0, 10759, 10757, 1, 0, 0, 0, 10759, 10758, 1, 0, 0, 0, 10760, 1187, + 1, 0, 0, 0, 10761, 10764, 3, 1910, 955, 0, 10762, 10763, 5, 8, 0, 0, 10763, + 10765, 3, 1910, 955, 0, 10764, 10762, 1, 0, 0, 0, 10764, 10765, 1, 0, 0, + 0, 10765, 1189, 1, 0, 0, 0, 10766, 10767, 7, 65, 0, 0, 10767, 1191, 1, + 0, 0, 0, 10768, 10769, 5, 2, 0, 0, 10769, 10770, 3, 1194, 597, 0, 10770, + 10771, 5, 3, 0, 0, 10771, 1193, 1, 0, 0, 0, 10772, 10773, 7, 66, 0, 0, + 10773, 1195, 1, 0, 0, 0, 10774, 10775, 5, 2, 0, 0, 10775, 10776, 3, 1910, + 955, 0, 10776, 10777, 5, 3, 0, 0, 10777, 1197, 1, 0, 0, 0, 10778, 10786, + 5, 53, 0, 0, 10779, 10780, 5, 53, 0, 0, 10780, 10781, 5, 59, 0, 0, 10781, + 10782, 5, 2, 0, 0, 10782, 10783, 3, 1200, 600, 0, 10783, 10784, 5, 3, 0, + 0, 10784, 10786, 1, 0, 0, 0, 10785, 10778, 1, 0, 0, 0, 10785, 10779, 1, + 0, 0, 0, 10786, 1199, 1, 0, 0, 0, 10787, 10792, 3, 1202, 601, 0, 10788, + 10789, 5, 6, 0, 0, 10789, 10791, 3, 1202, 601, 0, 10790, 10788, 1, 0, 0, + 0, 10791, 10794, 1, 0, 0, 0, 10792, 10790, 1, 0, 0, 0, 10792, 10793, 1, + 0, 0, 0, 10793, 1201, 1, 0, 0, 0, 10794, 10792, 1, 0, 0, 0, 10795, 10796, + 3, 1924, 962, 0, 10796, 10797, 3, 1910, 955, 0, 10797, 1203, 1, 0, 0, 0, + 10798, 10803, 3, 1206, 603, 0, 10799, 10800, 5, 6, 0, 0, 10800, 10802, + 3, 1206, 603, 0, 10801, 10799, 1, 0, 0, 0, 10802, 10805, 1, 0, 0, 0, 10803, + 10801, 1, 0, 0, 0, 10803, 10804, 1, 0, 0, 0, 10804, 1205, 1, 0, 0, 0, 10805, + 10803, 1, 0, 0, 0, 10806, 10807, 5, 434, 0, 0, 10807, 10841, 3, 1910, 955, + 0, 10808, 10809, 5, 435, 0, 0, 10809, 10841, 3, 1910, 955, 0, 10810, 10811, + 5, 436, 0, 0, 10811, 10841, 3, 1910, 955, 0, 10812, 10813, 5, 437, 0, 0, + 10813, 10841, 7, 14, 0, 0, 10814, 10815, 5, 438, 0, 0, 10815, 10841, 3, + 1908, 954, 0, 10816, 10817, 5, 439, 0, 0, 10817, 10841, 3, 1908, 954, 0, + 10818, 10819, 5, 636, 0, 0, 10819, 10841, 3, 1910, 955, 0, 10820, 10821, + 5, 637, 0, 0, 10821, 10841, 3, 1910, 955, 0, 10822, 10823, 5, 440, 0, 0, + 10823, 10841, 3, 1908, 954, 0, 10824, 10825, 5, 441, 0, 0, 10825, 10841, + 3, 1908, 954, 0, 10826, 10827, 5, 442, 0, 0, 10827, 10841, 3, 1910, 955, + 0, 10828, 10829, 5, 443, 0, 0, 10829, 10841, 3, 1908, 954, 0, 10830, 10831, + 5, 475, 0, 0, 10831, 10841, 3, 1910, 955, 0, 10832, 10833, 5, 476, 0, 0, + 10833, 10841, 3, 1910, 955, 0, 10834, 10835, 5, 477, 0, 0, 10835, 10841, + 3, 1910, 955, 0, 10836, 10837, 5, 478, 0, 0, 10837, 10841, 7, 67, 0, 0, + 10838, 10839, 5, 479, 0, 0, 10839, 10841, 7, 68, 0, 0, 10840, 10806, 1, + 0, 0, 0, 10840, 10808, 1, 0, 0, 0, 10840, 10810, 1, 0, 0, 0, 10840, 10812, + 1, 0, 0, 0, 10840, 10814, 1, 0, 0, 0, 10840, 10816, 1, 0, 0, 0, 10840, + 10818, 1, 0, 0, 0, 10840, 10820, 1, 0, 0, 0, 10840, 10822, 1, 0, 0, 0, + 10840, 10824, 1, 0, 0, 0, 10840, 10826, 1, 0, 0, 0, 10840, 10828, 1, 0, + 0, 0, 10840, 10830, 1, 0, 0, 0, 10840, 10832, 1, 0, 0, 0, 10840, 10834, + 1, 0, 0, 0, 10840, 10836, 1, 0, 0, 0, 10840, 10838, 1, 0, 0, 0, 10841, + 1207, 1, 0, 0, 0, 10842, 10847, 3, 1210, 605, 0, 10843, 10844, 5, 6, 0, + 0, 10844, 10846, 3, 1210, 605, 0, 10845, 10843, 1, 0, 0, 0, 10846, 10849, + 1, 0, 0, 0, 10847, 10845, 1, 0, 0, 0, 10847, 10848, 1, 0, 0, 0, 10848, + 1209, 1, 0, 0, 0, 10849, 10847, 1, 0, 0, 0, 10850, 10858, 3, 1662, 831, + 0, 10851, 10852, 3, 1924, 962, 0, 10852, 10853, 3, 1662, 831, 0, 10853, + 10858, 1, 0, 0, 0, 10854, 10855, 3, 1924, 962, 0, 10855, 10856, 3, 1924, + 962, 0, 10856, 10858, 1, 0, 0, 0, 10857, 10850, 1, 0, 0, 0, 10857, 10851, + 1, 0, 0, 0, 10857, 10854, 1, 0, 0, 0, 10858, 1211, 1, 0, 0, 0, 10859, 10860, + 5, 46, 0, 0, 10860, 10861, 5, 413, 0, 0, 10861, 10862, 5, 643, 0, 0, 10862, + 10871, 3, 1924, 962, 0, 10863, 10864, 5, 106, 0, 0, 10864, 10865, 5, 2, + 0, 0, 10865, 10866, 3, 1176, 588, 0, 10866, 10869, 5, 3, 0, 0, 10867, 10868, + 5, 36, 0, 0, 10868, 10870, 3, 1924, 962, 0, 10869, 10867, 1, 0, 0, 0, 10869, + 10870, 1, 0, 0, 0, 10870, 10872, 1, 0, 0, 0, 10871, 10863, 1, 0, 0, 0, + 10871, 10872, 1, 0, 0, 0, 10872, 10873, 1, 0, 0, 0, 10873, 10874, 5, 101, + 0, 0, 10874, 10875, 5, 2, 0, 0, 10875, 10876, 3, 1710, 855, 0, 10876, 10877, + 5, 3, 0, 0, 10877, 1213, 1, 0, 0, 0, 10878, 10879, 7, 59, 0, 0, 10879, + 10880, 5, 223, 0, 0, 10880, 10881, 5, 415, 0, 0, 10881, 10882, 3, 1924, + 962, 0, 10882, 1215, 1, 0, 0, 0, 10883, 10884, 5, 606, 0, 0, 10884, 10885, + 5, 412, 0, 0, 10885, 10886, 5, 643, 0, 0, 10886, 10887, 3, 1924, 962, 0, + 10887, 10888, 5, 80, 0, 0, 10888, 10889, 3, 1888, 944, 0, 10889, 10890, + 5, 2, 0, 0, 10890, 10891, 3, 1152, 576, 0, 10891, 10892, 5, 3, 0, 0, 10892, + 10893, 5, 64, 0, 0, 10893, 10894, 3, 1156, 578, 0, 10894, 1217, 1, 0, 0, + 0, 10895, 10896, 5, 606, 0, 0, 10896, 10897, 5, 413, 0, 0, 10897, 10898, + 5, 643, 0, 0, 10898, 10899, 3, 1224, 612, 0, 10899, 10901, 5, 80, 0, 0, + 10900, 10902, 5, 93, 0, 0, 10901, 10900, 1, 0, 0, 0, 10901, 10902, 1, 0, + 0, 0, 10902, 10903, 1, 0, 0, 0, 10903, 10904, 3, 1162, 581, 0, 10904, 10905, + 5, 64, 0, 0, 10905, 10906, 3, 1220, 610, 0, 10906, 1219, 1, 0, 0, 0, 10907, + 10912, 3, 1222, 611, 0, 10908, 10909, 5, 6, 0, 0, 10909, 10911, 3, 1222, + 611, 0, 10910, 10908, 1, 0, 0, 0, 10911, 10914, 1, 0, 0, 0, 10912, 10910, + 1, 0, 0, 0, 10912, 10913, 1, 0, 0, 0, 10913, 1221, 1, 0, 0, 0, 10914, 10912, + 1, 0, 0, 0, 10915, 10920, 3, 1920, 960, 0, 10916, 10917, 5, 316, 0, 0, + 10917, 10920, 3, 1920, 960, 0, 10918, 10920, 5, 86, 0, 0, 10919, 10915, + 1, 0, 0, 0, 10919, 10916, 1, 0, 0, 0, 10919, 10918, 1, 0, 0, 0, 10920, + 1223, 1, 0, 0, 0, 10921, 10922, 3, 1924, 962, 0, 10922, 1225, 1, 0, 0, + 0, 10923, 10924, 5, 195, 0, 0, 10924, 10925, 5, 223, 0, 0, 10925, 10927, + 5, 415, 0, 0, 10926, 10928, 3, 922, 461, 0, 10927, 10926, 1, 0, 0, 0, 10927, + 10928, 1, 0, 0, 0, 10928, 10929, 1, 0, 0, 0, 10929, 10931, 3, 1924, 962, + 0, 10930, 10932, 5, 152, 0, 0, 10931, 10930, 1, 0, 0, 0, 10931, 10932, + 1, 0, 0, 0, 10932, 1227, 1, 0, 0, 0, 10933, 10934, 5, 195, 0, 0, 10934, + 10936, 5, 462, 0, 0, 10935, 10937, 3, 922, 461, 0, 10936, 10935, 1, 0, + 0, 0, 10936, 10937, 1, 0, 0, 0, 10937, 10938, 1, 0, 0, 0, 10938, 10939, + 3, 1924, 962, 0, 10939, 1229, 1, 0, 0, 0, 10940, 10941, 5, 195, 0, 0, 10941, + 10942, 5, 412, 0, 0, 10942, 10944, 5, 643, 0, 0, 10943, 10945, 3, 922, + 461, 0, 10944, 10943, 1, 0, 0, 0, 10944, 10945, 1, 0, 0, 0, 10945, 10946, + 1, 0, 0, 0, 10946, 10947, 3, 1924, 962, 0, 10947, 1231, 1, 0, 0, 0, 10948, + 10949, 5, 195, 0, 0, 10949, 10951, 5, 417, 0, 0, 10950, 10952, 3, 922, + 461, 0, 10951, 10950, 1, 0, 0, 0, 10951, 10952, 1, 0, 0, 0, 10952, 10953, + 1, 0, 0, 0, 10953, 10954, 3, 1888, 944, 0, 10954, 1233, 1, 0, 0, 0, 10955, + 10956, 5, 195, 0, 0, 10956, 10957, 5, 413, 0, 0, 10957, 10959, 5, 643, + 0, 0, 10958, 10960, 3, 922, 461, 0, 10959, 10958, 1, 0, 0, 0, 10959, 10960, + 1, 0, 0, 0, 10960, 10961, 1, 0, 0, 0, 10961, 10963, 3, 1924, 962, 0, 10962, + 10964, 7, 12, 0, 0, 10963, 10962, 1, 0, 0, 0, 10963, 10964, 1, 0, 0, 0, + 10964, 1235, 1, 0, 0, 0, 10965, 10966, 5, 140, 0, 0, 10966, 10967, 5, 93, + 0, 0, 10967, 10968, 3, 1888, 944, 0, 10968, 10969, 5, 463, 0, 0, 10969, + 10970, 5, 64, 0, 0, 10970, 10974, 3, 1888, 944, 0, 10971, 10973, 3, 1238, + 619, 0, 10972, 10971, 1, 0, 0, 0, 10973, 10976, 1, 0, 0, 0, 10974, 10972, + 1, 0, 0, 0, 10974, 10975, 1, 0, 0, 0, 10975, 1237, 1, 0, 0, 0, 10976, 10974, + 1, 0, 0, 0, 10977, 10978, 7, 16, 0, 0, 10978, 1239, 1, 0, 0, 0, 10979, + 10980, 5, 140, 0, 0, 10980, 10981, 5, 100, 0, 0, 10981, 10983, 3, 1920, + 960, 0, 10982, 10984, 5, 106, 0, 0, 10983, 10982, 1, 0, 0, 0, 10983, 10984, + 1, 0, 0, 0, 10984, 10986, 1, 0, 0, 0, 10985, 10987, 3, 1242, 621, 0, 10986, + 10985, 1, 0, 0, 0, 10987, 10988, 1, 0, 0, 0, 10988, 10986, 1, 0, 0, 0, + 10988, 10989, 1, 0, 0, 0, 10989, 1241, 1, 0, 0, 0, 10990, 11030, 5, 494, + 0, 0, 10991, 11030, 5, 495, 0, 0, 10992, 11030, 5, 488, 0, 0, 10993, 11030, + 5, 489, 0, 0, 10994, 10995, 5, 500, 0, 0, 10995, 10996, 5, 133, 0, 0, 10996, + 11030, 7, 1, 0, 0, 10997, 11000, 5, 284, 0, 0, 10998, 11001, 3, 1910, 955, + 0, 10999, 11001, 5, 190, 0, 0, 11000, 10998, 1, 0, 0, 0, 11000, 10999, + 1, 0, 0, 0, 11001, 11030, 1, 0, 0, 0, 11002, 11003, 5, 369, 0, 0, 11003, + 11004, 5, 366, 0, 0, 11004, 11030, 3, 1910, 955, 0, 11005, 11006, 5, 307, + 0, 0, 11006, 11007, 5, 95, 0, 0, 11007, 11030, 3, 1924, 962, 0, 11008, + 11009, 5, 166, 0, 0, 11009, 11012, 5, 74, 0, 0, 11010, 11013, 3, 1908, + 954, 0, 11011, 11013, 5, 497, 0, 0, 11012, 11010, 1, 0, 0, 0, 11012, 11011, + 1, 0, 0, 0, 11013, 11030, 1, 0, 0, 0, 11014, 11015, 5, 330, 0, 0, 11015, + 11016, 5, 499, 0, 0, 11016, 11030, 3, 1908, 954, 0, 11017, 11018, 5, 311, + 0, 0, 11018, 11019, 5, 330, 0, 0, 11019, 11030, 5, 499, 0, 0, 11020, 11021, + 5, 331, 0, 0, 11021, 11022, 3, 1924, 962, 0, 11022, 11023, 5, 95, 0, 0, + 11023, 11024, 3, 1710, 855, 0, 11024, 11030, 1, 0, 0, 0, 11025, 11026, + 5, 311, 0, 0, 11026, 11030, 3, 1924, 962, 0, 11027, 11028, 5, 498, 0, 0, + 11028, 11030, 3, 1924, 962, 0, 11029, 10990, 1, 0, 0, 0, 11029, 10991, + 1, 0, 0, 0, 11029, 10992, 1, 0, 0, 0, 11029, 10993, 1, 0, 0, 0, 11029, + 10994, 1, 0, 0, 0, 11029, 10997, 1, 0, 0, 0, 11029, 11002, 1, 0, 0, 0, + 11029, 11005, 1, 0, 0, 0, 11029, 11008, 1, 0, 0, 0, 11029, 11014, 1, 0, + 0, 0, 11029, 11017, 1, 0, 0, 0, 11029, 11020, 1, 0, 0, 0, 11029, 11025, + 1, 0, 0, 0, 11029, 11027, 1, 0, 0, 0, 11030, 1243, 1, 0, 0, 0, 11031, 11032, + 7, 69, 0, 0, 11032, 11040, 5, 461, 0, 0, 11033, 11038, 3, 1888, 944, 0, + 11034, 11035, 5, 2, 0, 0, 11035, 11036, 3, 1890, 945, 0, 11036, 11037, + 5, 3, 0, 0, 11037, 11039, 1, 0, 0, 0, 11038, 11034, 1, 0, 0, 0, 11038, + 11039, 1, 0, 0, 0, 11039, 11041, 1, 0, 0, 0, 11040, 11033, 1, 0, 0, 0, + 11040, 11041, 1, 0, 0, 0, 11041, 11044, 1, 0, 0, 0, 11042, 11043, 5, 506, + 0, 0, 11043, 11045, 3, 1908, 954, 0, 11044, 11042, 1, 0, 0, 0, 11044, 11045, + 1, 0, 0, 0, 11045, 1245, 1, 0, 0, 0, 11046, 11049, 5, 458, 0, 0, 11047, + 11050, 3, 1910, 955, 0, 11048, 11050, 3, 1908, 954, 0, 11049, 11047, 1, + 0, 0, 0, 11049, 11048, 1, 0, 0, 0, 11050, 11052, 1, 0, 0, 0, 11051, 11053, + 3, 1910, 955, 0, 11052, 11051, 1, 0, 0, 0, 11052, 11053, 1, 0, 0, 0, 11053, + 1247, 1, 0, 0, 0, 11054, 11055, 5, 159, 0, 0, 11055, 11056, 3, 1924, 962, + 0, 11056, 1249, 1, 0, 0, 0, 11057, 11058, 5, 236, 0, 0, 11058, 11059, 5, + 71, 0, 0, 11059, 11060, 3, 1888, 944, 0, 11060, 11061, 3, 1252, 626, 0, + 11061, 1251, 1, 0, 0, 0, 11062, 11065, 3, 1496, 748, 0, 11063, 11065, 3, + 1596, 798, 0, 11064, 11062, 1, 0, 0, 0, 11064, 11063, 1, 0, 0, 0, 11065, + 1253, 1, 0, 0, 0, 11066, 11068, 5, 89, 0, 0, 11067, 11069, 3, 1538, 769, + 0, 11068, 11067, 1, 0, 0, 0, 11068, 11069, 1, 0, 0, 0, 11069, 11070, 1, + 0, 0, 0, 11070, 11071, 3, 1878, 939, 0, 11071, 11072, 5, 71, 0, 0, 11072, + 11074, 3, 1888, 944, 0, 11073, 11075, 3, 1598, 799, 0, 11074, 11073, 1, + 0, 0, 0, 11074, 11075, 1, 0, 0, 0, 11075, 1255, 1, 0, 0, 0, 11076, 11077, + 5, 331, 0, 0, 11077, 11078, 5, 330, 0, 0, 11078, 11079, 5, 107, 0, 0, 11079, + 11088, 3, 1924, 962, 0, 11080, 11081, 5, 331, 0, 0, 11081, 11082, 5, 330, + 0, 0, 11082, 11083, 5, 107, 0, 0, 11083, 11088, 5, 53, 0, 0, 11084, 11085, + 5, 311, 0, 0, 11085, 11086, 5, 330, 0, 0, 11086, 11088, 5, 107, 0, 0, 11087, + 11076, 1, 0, 0, 0, 11087, 11080, 1, 0, 0, 0, 11087, 11084, 1, 0, 0, 0, + 11088, 1257, 1, 0, 0, 0, 11089, 11090, 5, 331, 0, 0, 11090, 11091, 5, 330, + 0, 0, 11091, 11092, 5, 156, 0, 0, 11092, 11093, 5, 36, 0, 0, 11093, 11094, + 5, 354, 0, 0, 11094, 11095, 3, 1014, 507, 0, 11095, 1259, 1, 0, 0, 0, 11096, + 11097, 5, 333, 0, 0, 11097, 11098, 5, 674, 0, 0, 11098, 11100, 5, 64, 0, + 0, 11099, 11101, 5, 93, 0, 0, 11100, 11099, 1, 0, 0, 0, 11100, 11101, 1, + 0, 0, 0, 11101, 11102, 1, 0, 0, 0, 11102, 11105, 3, 1888, 944, 0, 11103, + 11104, 5, 122, 0, 0, 11104, 11106, 3, 1910, 955, 0, 11105, 11103, 1, 0, + 0, 0, 11105, 11106, 1, 0, 0, 0, 11106, 11109, 1, 0, 0, 0, 11107, 11108, + 5, 74, 0, 0, 11108, 11110, 3, 1908, 954, 0, 11109, 11107, 1, 0, 0, 0, 11109, + 11110, 1, 0, 0, 0, 11110, 1261, 1, 0, 0, 0, 11111, 11112, 5, 333, 0, 0, + 11112, 11116, 5, 454, 0, 0, 11113, 11114, 5, 64, 0, 0, 11114, 11115, 5, + 177, 0, 0, 11115, 11117, 5, 154, 0, 0, 11116, 11113, 1, 0, 0, 0, 11116, + 11117, 1, 0, 0, 0, 11117, 11121, 1, 0, 0, 0, 11118, 11120, 3, 1264, 632, + 0, 11119, 11118, 1, 0, 0, 0, 11120, 11123, 1, 0, 0, 0, 11121, 11119, 1, + 0, 0, 0, 11121, 11122, 1, 0, 0, 0, 11122, 1263, 1, 0, 0, 0, 11123, 11121, + 1, 0, 0, 0, 11124, 11125, 5, 122, 0, 0, 11125, 11147, 3, 1910, 955, 0, + 11126, 11127, 5, 106, 0, 0, 11127, 11128, 5, 392, 0, 0, 11128, 11147, 3, + 1910, 955, 0, 11129, 11130, 5, 74, 0, 0, 11130, 11147, 3, 1908, 954, 0, + 11131, 11132, 5, 466, 0, 0, 11132, 11137, 3, 1910, 955, 0, 11133, 11134, + 5, 6, 0, 0, 11134, 11136, 3, 1910, 955, 0, 11135, 11133, 1, 0, 0, 0, 11136, + 11139, 1, 0, 0, 0, 11137, 11135, 1, 0, 0, 0, 11137, 11138, 1, 0, 0, 0, + 11138, 11147, 1, 0, 0, 0, 11139, 11137, 1, 0, 0, 0, 11140, 11144, 5, 396, + 0, 0, 11141, 11145, 5, 53, 0, 0, 11142, 11145, 5, 330, 0, 0, 11143, 11145, + 3, 1910, 955, 0, 11144, 11141, 1, 0, 0, 0, 11144, 11142, 1, 0, 0, 0, 11144, + 11143, 1, 0, 0, 0, 11145, 11147, 1, 0, 0, 0, 11146, 11124, 1, 0, 0, 0, + 11146, 11126, 1, 0, 0, 0, 11146, 11129, 1, 0, 0, 0, 11146, 11131, 1, 0, + 0, 0, 11146, 11140, 1, 0, 0, 0, 11147, 1265, 1, 0, 0, 0, 11148, 11149, + 5, 333, 0, 0, 11149, 11152, 5, 455, 0, 0, 11150, 11151, 5, 122, 0, 0, 11151, + 11153, 3, 1910, 955, 0, 11152, 11150, 1, 0, 0, 0, 11152, 11153, 1, 0, 0, + 0, 11153, 1267, 1, 0, 0, 0, 11154, 11155, 5, 333, 0, 0, 11155, 11156, 5, + 209, 0, 0, 11156, 11157, 5, 93, 0, 0, 11157, 11159, 3, 1888, 944, 0, 11158, + 11160, 5, 282, 0, 0, 11159, 11158, 1, 0, 0, 0, 11159, 11160, 1, 0, 0, 0, + 11160, 1269, 1, 0, 0, 0, 11161, 11162, 5, 333, 0, 0, 11162, 11165, 5, 456, + 0, 0, 11163, 11164, 5, 80, 0, 0, 11164, 11166, 3, 1272, 636, 0, 11165, + 11163, 1, 0, 0, 0, 11165, 11166, 1, 0, 0, 0, 11166, 11169, 1, 0, 0, 0, + 11167, 11168, 5, 62, 0, 0, 11168, 11170, 3, 1274, 637, 0, 11169, 11167, + 1, 0, 0, 0, 11169, 11170, 1, 0, 0, 0, 11170, 11173, 1, 0, 0, 0, 11171, + 11172, 5, 74, 0, 0, 11172, 11174, 3, 1908, 954, 0, 11173, 11171, 1, 0, + 0, 0, 11173, 11174, 1, 0, 0, 0, 11174, 11185, 1, 0, 0, 0, 11175, 11176, + 5, 333, 0, 0, 11176, 11177, 5, 456, 0, 0, 11177, 11178, 5, 62, 0, 0, 11178, + 11179, 3, 1274, 637, 0, 11179, 11182, 1, 0, 0, 0, 11180, 11181, 5, 74, + 0, 0, 11181, 11183, 3, 1908, 954, 0, 11182, 11180, 1, 0, 0, 0, 11182, 11183, + 1, 0, 0, 0, 11183, 11185, 1, 0, 0, 0, 11184, 11161, 1, 0, 0, 0, 11184, + 11175, 1, 0, 0, 0, 11185, 1271, 1, 0, 0, 0, 11186, 11187, 5, 179, 0, 0, + 11187, 11204, 3, 1924, 962, 0, 11188, 11189, 5, 321, 0, 0, 11189, 11204, + 3, 1888, 944, 0, 11190, 11192, 5, 93, 0, 0, 11191, 11190, 1, 0, 0, 0, 11191, + 11192, 1, 0, 0, 0, 11192, 11193, 1, 0, 0, 0, 11193, 11204, 3, 1888, 944, + 0, 11194, 11195, 5, 215, 0, 0, 11195, 11201, 3, 1888, 944, 0, 11196, 11198, + 5, 2, 0, 0, 11197, 11199, 3, 1208, 604, 0, 11198, 11197, 1, 0, 0, 0, 11198, + 11199, 1, 0, 0, 0, 11199, 11200, 1, 0, 0, 0, 11200, 11202, 5, 3, 0, 0, + 11201, 11196, 1, 0, 0, 0, 11201, 11202, 1, 0, 0, 0, 11202, 11204, 1, 0, + 0, 0, 11203, 11186, 1, 0, 0, 0, 11203, 11188, 1, 0, 0, 0, 11203, 11191, + 1, 0, 0, 0, 11203, 11194, 1, 0, 0, 0, 11204, 1273, 1, 0, 0, 0, 11205, 11209, + 3, 1924, 962, 0, 11206, 11207, 5, 316, 0, 0, 11207, 11209, 3, 1924, 962, + 0, 11208, 11205, 1, 0, 0, 0, 11208, 11206, 1, 0, 0, 0, 11209, 1275, 1, + 0, 0, 0, 11210, 11211, 5, 333, 0, 0, 11211, 11214, 5, 417, 0, 0, 11212, + 11215, 3, 1888, 944, 0, 11213, 11215, 5, 30, 0, 0, 11214, 11212, 1, 0, + 0, 0, 11214, 11213, 1, 0, 0, 0, 11215, 1277, 1, 0, 0, 0, 11216, 11217, + 5, 333, 0, 0, 11217, 11218, 5, 294, 0, 0, 11218, 11220, 3, 1888, 944, 0, + 11219, 11221, 3, 838, 419, 0, 11220, 11219, 1, 0, 0, 0, 11220, 11221, 1, + 0, 0, 0, 11221, 1279, 1, 0, 0, 0, 11222, 11223, 5, 333, 0, 0, 11223, 11227, + 5, 655, 0, 0, 11224, 11225, 5, 64, 0, 0, 11225, 11226, 5, 179, 0, 0, 11226, + 11228, 3, 1924, 962, 0, 11227, 11224, 1, 0, 0, 0, 11227, 11228, 1, 0, 0, + 0, 11228, 11231, 1, 0, 0, 0, 11229, 11230, 5, 122, 0, 0, 11230, 11232, + 3, 1910, 955, 0, 11231, 11229, 1, 0, 0, 0, 11231, 11232, 1, 0, 0, 0, 11232, + 11235, 1, 0, 0, 0, 11233, 11234, 5, 74, 0, 0, 11234, 11236, 3, 1908, 954, + 0, 11235, 11233, 1, 0, 0, 0, 11235, 11236, 1, 0, 0, 0, 11236, 1281, 1, + 0, 0, 0, 11237, 11238, 5, 333, 0, 0, 11238, 11239, 5, 93, 0, 0, 11239, + 11240, 3, 1888, 944, 0, 11240, 1283, 1, 0, 0, 0, 11241, 11242, 5, 333, + 0, 0, 11242, 11243, 5, 348, 0, 0, 11243, 11244, 5, 64, 0, 0, 11244, 11245, + 5, 321, 0, 0, 11245, 11246, 3, 1924, 962, 0, 11246, 11247, 5, 11, 0, 0, + 11247, 11250, 3, 1924, 962, 0, 11248, 11249, 5, 122, 0, 0, 11249, 11251, + 3, 1910, 955, 0, 11250, 11248, 1, 0, 0, 0, 11250, 11251, 1, 0, 0, 0, 11251, + 11254, 1, 0, 0, 0, 11252, 11253, 5, 74, 0, 0, 11253, 11255, 3, 1908, 954, + 0, 11254, 11252, 1, 0, 0, 0, 11254, 11255, 1, 0, 0, 0, 11255, 1285, 1, + 0, 0, 0, 11256, 11257, 5, 333, 0, 0, 11257, 11258, 5, 374, 0, 0, 11258, + 11259, 3, 1888, 944, 0, 11259, 1287, 1, 0, 0, 0, 11260, 11261, 5, 444, + 0, 0, 11261, 11262, 5, 2, 0, 0, 11262, 11263, 3, 1910, 955, 0, 11263, 11264, + 5, 3, 0, 0, 11264, 11265, 5, 95, 0, 0, 11265, 11266, 3, 1910, 955, 0, 11266, + 11270, 3, 1290, 645, 0, 11267, 11269, 3, 1292, 646, 0, 11268, 11267, 1, + 0, 0, 0, 11269, 11272, 1, 0, 0, 0, 11270, 11268, 1, 0, 0, 0, 11270, 11271, + 1, 0, 0, 0, 11271, 1289, 1, 0, 0, 0, 11272, 11270, 1, 0, 0, 0, 11273, 11276, + 5, 396, 0, 0, 11274, 11277, 5, 53, 0, 0, 11275, 11277, 3, 1910, 955, 0, + 11276, 11274, 1, 0, 0, 0, 11276, 11275, 1, 0, 0, 0, 11277, 1291, 1, 0, + 0, 0, 11278, 11298, 3, 1294, 647, 0, 11279, 11298, 3, 1296, 648, 0, 11280, + 11298, 3, 1298, 649, 0, 11281, 11298, 3, 1300, 650, 0, 11282, 11298, 3, + 1302, 651, 0, 11283, 11298, 3, 1304, 652, 0, 11284, 11298, 3, 1306, 653, + 0, 11285, 11298, 3, 1308, 654, 0, 11286, 11298, 3, 1310, 655, 0, 11287, + 11298, 3, 1312, 656, 0, 11288, 11298, 3, 1314, 657, 0, 11289, 11298, 3, + 1316, 658, 0, 11290, 11298, 3, 1318, 659, 0, 11291, 11298, 3, 1320, 660, + 0, 11292, 11298, 3, 1322, 661, 0, 11293, 11298, 3, 1324, 662, 0, 11294, + 11298, 3, 1326, 663, 0, 11295, 11298, 3, 1330, 665, 0, 11296, 11298, 3, + 1332, 666, 0, 11297, 11278, 1, 0, 0, 0, 11297, 11279, 1, 0, 0, 0, 11297, + 11280, 1, 0, 0, 0, 11297, 11281, 1, 0, 0, 0, 11297, 11282, 1, 0, 0, 0, + 11297, 11283, 1, 0, 0, 0, 11297, 11284, 1, 0, 0, 0, 11297, 11285, 1, 0, + 0, 0, 11297, 11286, 1, 0, 0, 0, 11297, 11287, 1, 0, 0, 0, 11297, 11288, + 1, 0, 0, 0, 11297, 11289, 1, 0, 0, 0, 11297, 11290, 1, 0, 0, 0, 11297, + 11291, 1, 0, 0, 0, 11297, 11292, 1, 0, 0, 0, 11297, 11293, 1, 0, 0, 0, + 11297, 11294, 1, 0, 0, 0, 11297, 11295, 1, 0, 0, 0, 11297, 11296, 1, 0, + 0, 0, 11298, 1293, 1, 0, 0, 0, 11299, 11300, 5, 780, 0, 0, 11300, 11301, + 7, 70, 0, 0, 11301, 1295, 1, 0, 0, 0, 11302, 11303, 5, 282, 0, 0, 11303, + 11304, 5, 149, 0, 0, 11304, 11305, 5, 2, 0, 0, 11305, 11306, 3, 246, 123, + 0, 11306, 11308, 5, 3, 0, 0, 11307, 11309, 5, 639, 0, 0, 11308, 11307, + 1, 0, 0, 0, 11308, 11309, 1, 0, 0, 0, 11309, 1297, 1, 0, 0, 0, 11310, 11312, + 5, 445, 0, 0, 11311, 11313, 5, 130, 0, 0, 11312, 11311, 1, 0, 0, 0, 11312, + 11313, 1, 0, 0, 0, 11313, 1299, 1, 0, 0, 0, 11314, 11315, 5, 220, 0, 0, + 11315, 1301, 1, 0, 0, 0, 11316, 11318, 5, 187, 0, 0, 11317, 11319, 5, 36, + 0, 0, 11318, 11317, 1, 0, 0, 0, 11318, 11319, 1, 0, 0, 0, 11319, 11320, + 1, 0, 0, 0, 11320, 11321, 3, 1910, 955, 0, 11321, 1303, 1, 0, 0, 0, 11322, + 11323, 5, 520, 0, 0, 11323, 11324, 3, 1910, 955, 0, 11324, 1305, 1, 0, + 0, 0, 11325, 11327, 5, 199, 0, 0, 11326, 11328, 5, 420, 0, 0, 11327, 11326, + 1, 0, 0, 0, 11327, 11328, 1, 0, 0, 0, 11328, 1307, 1, 0, 0, 0, 11329, 11330, + 5, 436, 0, 0, 11330, 11331, 3, 1910, 955, 0, 11331, 1309, 1, 0, 0, 0, 11332, + 11333, 7, 71, 0, 0, 11333, 1311, 1, 0, 0, 0, 11334, 11335, 5, 446, 0, 0, + 11335, 1313, 1, 0, 0, 0, 11336, 11337, 5, 78, 0, 0, 11337, 11338, 5, 36, + 0, 0, 11338, 11339, 3, 1910, 955, 0, 11339, 1315, 1, 0, 0, 0, 11340, 11341, + 5, 201, 0, 0, 11341, 1317, 1, 0, 0, 0, 11342, 11343, 5, 447, 0, 0, 11343, + 1319, 1, 0, 0, 0, 11344, 11345, 5, 448, 0, 0, 11345, 1321, 1, 0, 0, 0, + 11346, 11347, 5, 659, 0, 0, 11347, 11348, 7, 14, 0, 0, 11348, 1323, 1, + 0, 0, 0, 11349, 11351, 5, 449, 0, 0, 11350, 11352, 5, 36, 0, 0, 11351, + 11350, 1, 0, 0, 0, 11351, 11352, 1, 0, 0, 0, 11352, 11353, 1, 0, 0, 0, + 11353, 11355, 3, 1908, 954, 0, 11354, 11356, 3, 1328, 664, 0, 11355, 11354, + 1, 0, 0, 0, 11355, 11356, 1, 0, 0, 0, 11356, 1325, 1, 0, 0, 0, 11357, 11359, + 5, 450, 0, 0, 11358, 11360, 5, 36, 0, 0, 11359, 11358, 1, 0, 0, 0, 11359, + 11360, 1, 0, 0, 0, 11360, 11361, 1, 0, 0, 0, 11361, 11363, 3, 1908, 954, + 0, 11362, 11364, 3, 1328, 664, 0, 11363, 11362, 1, 0, 0, 0, 11363, 11364, + 1, 0, 0, 0, 11364, 1327, 1, 0, 0, 0, 11365, 11366, 7, 72, 0, 0, 11366, + 1329, 1, 0, 0, 0, 11367, 11369, 3, 1924, 962, 0, 11368, 11370, 5, 36, 0, + 0, 11369, 11368, 1, 0, 0, 0, 11369, 11370, 1, 0, 0, 0, 11370, 11371, 1, + 0, 0, 0, 11371, 11372, 3, 1910, 955, 0, 11372, 1331, 1, 0, 0, 0, 11373, + 11374, 5, 208, 0, 0, 11374, 11375, 3, 1910, 955, 0, 11375, 1333, 1, 0, + 0, 0, 11376, 11377, 5, 457, 0, 0, 11377, 11378, 3, 1924, 962, 0, 11378, + 1335, 1, 0, 0, 0, 11379, 11380, 5, 46, 0, 0, 11380, 11381, 5, 179, 0, 0, + 11381, 11383, 3, 1892, 946, 0, 11382, 11384, 3, 16, 8, 0, 11383, 11382, + 1, 0, 0, 0, 11383, 11384, 1, 0, 0, 0, 11384, 11386, 1, 0, 0, 0, 11385, + 11387, 3, 1338, 669, 0, 11386, 11385, 1, 0, 0, 0, 11386, 11387, 1, 0, 0, + 0, 11387, 1337, 1, 0, 0, 0, 11388, 11389, 3, 1340, 670, 0, 11389, 1339, + 1, 0, 0, 0, 11390, 11392, 3, 1342, 671, 0, 11391, 11390, 1, 0, 0, 0, 11392, + 11393, 1, 0, 0, 0, 11393, 11391, 1, 0, 0, 0, 11393, 11394, 1, 0, 0, 0, + 11394, 1341, 1, 0, 0, 0, 11395, 11397, 3, 1344, 672, 0, 11396, 11398, 3, + 1346, 673, 0, 11397, 11396, 1, 0, 0, 0, 11397, 11398, 1, 0, 0, 0, 11398, + 11403, 1, 0, 0, 0, 11399, 11404, 3, 1916, 958, 0, 11400, 11404, 3, 76, + 38, 0, 11401, 11404, 5, 53, 0, 0, 11402, 11404, 5, 497, 0, 0, 11403, 11399, + 1, 0, 0, 0, 11403, 11400, 1, 0, 0, 0, 11403, 11401, 1, 0, 0, 0, 11403, + 11402, 1, 0, 0, 0, 11404, 11411, 1, 0, 0, 0, 11405, 11406, 5, 239, 0, 0, + 11406, 11407, 5, 246, 0, 0, 11407, 11411, 7, 73, 0, 0, 11408, 11409, 5, + 43, 0, 0, 11409, 11411, 7, 13, 0, 0, 11410, 11395, 1, 0, 0, 0, 11410, 11405, + 1, 0, 0, 0, 11410, 11408, 1, 0, 0, 0, 11411, 1343, 1, 0, 0, 0, 11412, 11421, + 3, 1934, 967, 0, 11413, 11414, 5, 166, 0, 0, 11414, 11421, 5, 74, 0, 0, + 11415, 11421, 5, 198, 0, 0, 11416, 11421, 5, 250, 0, 0, 11417, 11421, 5, + 279, 0, 0, 11418, 11421, 5, 349, 0, 0, 11419, 11421, 5, 351, 0, 0, 11420, + 11412, 1, 0, 0, 0, 11420, 11413, 1, 0, 0, 0, 11420, 11415, 1, 0, 0, 0, + 11420, 11416, 1, 0, 0, 0, 11420, 11417, 1, 0, 0, 0, 11420, 11418, 1, 0, + 0, 0, 11420, 11419, 1, 0, 0, 0, 11421, 1345, 1, 0, 0, 0, 11422, 11423, + 5, 10, 0, 0, 11423, 1347, 1, 0, 0, 0, 11424, 11425, 5, 140, 0, 0, 11425, + 11426, 5, 179, 0, 0, 11426, 11448, 3, 1892, 946, 0, 11427, 11429, 5, 106, + 0, 0, 11428, 11430, 3, 1338, 669, 0, 11429, 11428, 1, 0, 0, 0, 11429, 11430, + 1, 0, 0, 0, 11430, 11449, 1, 0, 0, 0, 11431, 11433, 3, 1338, 669, 0, 11432, + 11431, 1, 0, 0, 0, 11432, 11433, 1, 0, 0, 0, 11433, 11449, 1, 0, 0, 0, + 11434, 11435, 5, 331, 0, 0, 11435, 11436, 5, 349, 0, 0, 11436, 11449, 3, + 1892, 946, 0, 11437, 11438, 5, 303, 0, 0, 11438, 11439, 5, 110, 0, 0, 11439, + 11449, 5, 373, 0, 0, 11440, 11441, 5, 43, 0, 0, 11441, 11449, 7, 22, 0, + 0, 11442, 11443, 5, 166, 0, 0, 11443, 11446, 5, 74, 0, 0, 11444, 11447, + 3, 1908, 954, 0, 11445, 11447, 5, 497, 0, 0, 11446, 11444, 1, 0, 0, 0, + 11446, 11445, 1, 0, 0, 0, 11447, 11449, 1, 0, 0, 0, 11448, 11427, 1, 0, + 0, 0, 11448, 11432, 1, 0, 0, 0, 11448, 11434, 1, 0, 0, 0, 11448, 11437, + 1, 0, 0, 0, 11448, 11440, 1, 0, 0, 0, 11448, 11442, 1, 0, 0, 0, 11449, + 1349, 1, 0, 0, 0, 11450, 11451, 5, 140, 0, 0, 11451, 11452, 5, 179, 0, + 0, 11452, 11453, 3, 1892, 946, 0, 11453, 11454, 3, 90, 45, 0, 11454, 1351, + 1, 0, 0, 0, 11455, 11456, 5, 195, 0, 0, 11456, 11457, 5, 179, 0, 0, 11457, + 11458, 3, 1892, 946, 0, 11458, 1353, 1, 0, 0, 0, 11459, 11464, 3, 1356, + 678, 0, 11460, 11461, 5, 6, 0, 0, 11461, 11463, 3, 1356, 678, 0, 11462, + 11460, 1, 0, 0, 0, 11463, 11466, 1, 0, 0, 0, 11464, 11462, 1, 0, 0, 0, + 11464, 11465, 1, 0, 0, 0, 11465, 1355, 1, 0, 0, 0, 11466, 11464, 1, 0, + 0, 0, 11467, 11468, 5, 213, 0, 0, 11468, 1357, 1, 0, 0, 0, 11469, 11470, + 5, 140, 0, 0, 11470, 11471, 5, 110, 0, 0, 11471, 11472, 3, 566, 283, 0, + 11472, 11473, 5, 303, 0, 0, 11473, 11474, 5, 373, 0, 0, 11474, 1359, 1, + 0, 0, 0, 11475, 11476, 5, 140, 0, 0, 11476, 11477, 5, 347, 0, 0, 11477, + 11478, 7, 74, 0, 0, 11478, 11479, 3, 64, 32, 0, 11479, 1361, 1, 0, 0, 0, + 11480, 11481, 5, 46, 0, 0, 11481, 11482, 5, 193, 0, 0, 11482, 11484, 3, + 566, 283, 0, 11483, 11485, 3, 1366, 683, 0, 11484, 11483, 1, 0, 0, 0, 11484, + 11485, 1, 0, 0, 0, 11485, 11486, 1, 0, 0, 0, 11486, 11487, 3, 1662, 831, + 0, 11487, 11488, 3, 220, 110, 0, 11488, 1363, 1, 0, 0, 0, 11489, 11490, + 5, 140, 0, 0, 11490, 11491, 5, 193, 0, 0, 11491, 11514, 3, 566, 283, 0, + 11492, 11515, 3, 118, 59, 0, 11493, 11494, 5, 195, 0, 0, 11494, 11495, + 5, 77, 0, 0, 11495, 11515, 5, 78, 0, 0, 11496, 11497, 5, 331, 0, 0, 11497, + 11498, 5, 77, 0, 0, 11498, 11515, 5, 78, 0, 0, 11499, 11500, 5, 135, 0, + 0, 11500, 11515, 3, 238, 119, 0, 11501, 11502, 5, 195, 0, 0, 11502, 11505, + 5, 45, 0, 0, 11503, 11504, 5, 224, 0, 0, 11504, 11506, 5, 558, 0, 0, 11505, + 11503, 1, 0, 0, 0, 11505, 11506, 1, 0, 0, 0, 11506, 11507, 1, 0, 0, 0, + 11507, 11509, 3, 1892, 946, 0, 11508, 11510, 3, 120, 60, 0, 11509, 11508, + 1, 0, 0, 0, 11509, 11510, 1, 0, 0, 0, 11510, 11515, 1, 0, 0, 0, 11511, + 11512, 5, 370, 0, 0, 11512, 11513, 5, 45, 0, 0, 11513, 11515, 3, 1892, + 946, 0, 11514, 11492, 1, 0, 0, 0, 11514, 11493, 1, 0, 0, 0, 11514, 11496, + 1, 0, 0, 0, 11514, 11499, 1, 0, 0, 0, 11514, 11501, 1, 0, 0, 0, 11514, + 11511, 1, 0, 0, 0, 11515, 1365, 1, 0, 0, 0, 11516, 11517, 5, 36, 0, 0, + 11517, 1367, 1, 0, 0, 0, 11518, 11519, 5, 140, 0, 0, 11519, 11520, 5, 353, + 0, 0, 11520, 11521, 5, 323, 0, 0, 11521, 11522, 5, 189, 0, 0, 11522, 11523, + 3, 566, 283, 0, 11523, 11524, 3, 502, 251, 0, 11524, 1369, 1, 0, 0, 0, + 11525, 11526, 5, 140, 0, 0, 11526, 11527, 5, 353, 0, 0, 11527, 11528, 5, + 323, 0, 0, 11528, 11529, 5, 165, 0, 0, 11529, 11530, 3, 566, 283, 0, 11530, + 11531, 5, 135, 0, 0, 11531, 11532, 5, 252, 0, 0, 11532, 11533, 5, 62, 0, + 0, 11533, 11534, 3, 1890, 945, 0, 11534, 11535, 3, 1372, 686, 0, 11535, + 11536, 3, 564, 282, 0, 11536, 11598, 1, 0, 0, 0, 11537, 11538, 5, 140, + 0, 0, 11538, 11539, 5, 353, 0, 0, 11539, 11540, 5, 323, 0, 0, 11540, 11541, + 5, 165, 0, 0, 11541, 11542, 3, 566, 283, 0, 11542, 11543, 5, 140, 0, 0, + 11543, 11544, 5, 252, 0, 0, 11544, 11545, 5, 62, 0, 0, 11545, 11546, 3, + 1890, 945, 0, 11546, 11547, 3, 1372, 686, 0, 11547, 11548, 3, 564, 282, + 0, 11548, 11598, 1, 0, 0, 0, 11549, 11550, 5, 140, 0, 0, 11550, 11551, + 5, 353, 0, 0, 11551, 11552, 5, 323, 0, 0, 11552, 11553, 5, 165, 0, 0, 11553, + 11554, 3, 566, 283, 0, 11554, 11555, 5, 140, 0, 0, 11555, 11556, 5, 252, + 0, 0, 11556, 11557, 5, 309, 0, 0, 11557, 11558, 3, 566, 283, 0, 11558, + 11559, 3, 1372, 686, 0, 11559, 11560, 3, 566, 283, 0, 11560, 11598, 1, + 0, 0, 0, 11561, 11562, 5, 140, 0, 0, 11562, 11563, 5, 353, 0, 0, 11563, + 11564, 5, 323, 0, 0, 11564, 11565, 5, 165, 0, 0, 11565, 11566, 3, 566, + 283, 0, 11566, 11567, 5, 140, 0, 0, 11567, 11568, 5, 252, 0, 0, 11568, + 11569, 5, 62, 0, 0, 11569, 11570, 3, 1890, 945, 0, 11570, 11571, 5, 309, + 0, 0, 11571, 11572, 3, 566, 283, 0, 11572, 11573, 3, 1372, 686, 0, 11573, + 11574, 3, 566, 283, 0, 11574, 11598, 1, 0, 0, 0, 11575, 11576, 5, 140, + 0, 0, 11576, 11577, 5, 353, 0, 0, 11577, 11578, 5, 323, 0, 0, 11578, 11579, + 5, 165, 0, 0, 11579, 11580, 3, 566, 283, 0, 11580, 11581, 5, 195, 0, 0, + 11581, 11582, 5, 252, 0, 0, 11582, 11583, 5, 62, 0, 0, 11583, 11584, 3, + 1890, 945, 0, 11584, 11598, 1, 0, 0, 0, 11585, 11586, 5, 140, 0, 0, 11586, + 11587, 5, 353, 0, 0, 11587, 11588, 5, 323, 0, 0, 11588, 11589, 5, 165, + 0, 0, 11589, 11590, 3, 566, 283, 0, 11590, 11591, 5, 195, 0, 0, 11591, + 11592, 5, 252, 0, 0, 11592, 11593, 5, 224, 0, 0, 11593, 11594, 5, 558, + 0, 0, 11594, 11595, 5, 62, 0, 0, 11595, 11596, 3, 1890, 945, 0, 11596, + 11598, 1, 0, 0, 0, 11597, 11525, 1, 0, 0, 0, 11597, 11537, 1, 0, 0, 0, + 11597, 11549, 1, 0, 0, 0, 11597, 11561, 1, 0, 0, 0, 11597, 11575, 1, 0, + 0, 0, 11597, 11585, 1, 0, 0, 0, 11598, 1371, 1, 0, 0, 0, 11599, 11600, + 5, 106, 0, 0, 11600, 1373, 1, 0, 0, 0, 11601, 11603, 5, 46, 0, 0, 11602, + 11604, 3, 530, 265, 0, 11603, 11602, 1, 0, 0, 0, 11603, 11604, 1, 0, 0, + 0, 11604, 11605, 1, 0, 0, 0, 11605, 11606, 5, 170, 0, 0, 11606, 11607, + 3, 566, 283, 0, 11607, 11608, 5, 62, 0, 0, 11608, 11609, 3, 1910, 955, + 0, 11609, 11610, 5, 95, 0, 0, 11610, 11611, 3, 1910, 955, 0, 11611, 11612, + 5, 64, 0, 0, 11612, 11613, 3, 566, 283, 0, 11613, 1375, 1, 0, 0, 0, 11614, + 11616, 5, 160, 0, 0, 11615, 11617, 3, 1398, 699, 0, 11616, 11615, 1, 0, + 0, 0, 11616, 11617, 1, 0, 0, 0, 11617, 11618, 1, 0, 0, 0, 11618, 11620, + 3, 1888, 944, 0, 11619, 11621, 3, 1378, 689, 0, 11620, 11619, 1, 0, 0, + 0, 11620, 11621, 1, 0, 0, 0, 11621, 11635, 1, 0, 0, 0, 11622, 11624, 5, + 160, 0, 0, 11623, 11625, 3, 1398, 699, 0, 11624, 11623, 1, 0, 0, 0, 11624, + 11625, 1, 0, 0, 0, 11625, 11635, 1, 0, 0, 0, 11626, 11628, 5, 160, 0, 0, + 11627, 11629, 3, 1398, 699, 0, 11628, 11627, 1, 0, 0, 0, 11628, 11629, + 1, 0, 0, 0, 11629, 11630, 1, 0, 0, 0, 11630, 11631, 3, 1892, 946, 0, 11631, + 11632, 5, 80, 0, 0, 11632, 11633, 3, 1888, 944, 0, 11633, 11635, 1, 0, + 0, 0, 11634, 11614, 1, 0, 0, 0, 11634, 11622, 1, 0, 0, 0, 11634, 11626, + 1, 0, 0, 0, 11635, 1377, 1, 0, 0, 0, 11636, 11637, 5, 101, 0, 0, 11637, + 11638, 3, 1892, 946, 0, 11638, 1379, 1, 0, 0, 0, 11639, 11641, 5, 368, + 0, 0, 11640, 11642, 3, 1400, 700, 0, 11641, 11640, 1, 0, 0, 0, 11641, 11642, + 1, 0, 0, 0, 11642, 11644, 1, 0, 0, 0, 11643, 11645, 3, 1402, 701, 0, 11644, + 11643, 1, 0, 0, 0, 11644, 11645, 1, 0, 0, 0, 11645, 11647, 1, 0, 0, 0, + 11646, 11648, 3, 1398, 699, 0, 11647, 11646, 1, 0, 0, 0, 11647, 11648, + 1, 0, 0, 0, 11648, 11650, 1, 0, 0, 0, 11649, 11651, 3, 1396, 698, 0, 11650, + 11649, 1, 0, 0, 0, 11650, 11651, 1, 0, 0, 0, 11651, 11653, 1, 0, 0, 0, + 11652, 11654, 3, 1410, 705, 0, 11653, 11652, 1, 0, 0, 0, 11653, 11654, + 1, 0, 0, 0, 11654, 11679, 1, 0, 0, 0, 11655, 11656, 5, 368, 0, 0, 11656, + 11657, 5, 2, 0, 0, 11657, 11658, 3, 1386, 693, 0, 11658, 11660, 5, 3, 0, + 0, 11659, 11661, 3, 1410, 705, 0, 11660, 11659, 1, 0, 0, 0, 11660, 11661, + 1, 0, 0, 0, 11661, 11679, 1, 0, 0, 0, 11662, 11664, 5, 368, 0, 0, 11663, + 11665, 3, 1382, 691, 0, 11664, 11663, 1, 0, 0, 0, 11664, 11665, 1, 0, 0, + 0, 11665, 11667, 1, 0, 0, 0, 11666, 11668, 3, 1888, 944, 0, 11667, 11666, + 1, 0, 0, 0, 11667, 11668, 1, 0, 0, 0, 11668, 11673, 1, 0, 0, 0, 11669, + 11670, 5, 95, 0, 0, 11670, 11671, 3, 1908, 954, 0, 11671, 11672, 5, 849, + 0, 0, 11672, 11674, 1, 0, 0, 0, 11673, 11669, 1, 0, 0, 0, 11673, 11674, + 1, 0, 0, 0, 11674, 11676, 1, 0, 0, 0, 11675, 11677, 5, 846, 0, 0, 11676, + 11675, 1, 0, 0, 0, 11676, 11677, 1, 0, 0, 0, 11677, 11679, 1, 0, 0, 0, + 11678, 11639, 1, 0, 0, 0, 11678, 11655, 1, 0, 0, 0, 11678, 11662, 1, 0, + 0, 0, 11679, 1381, 1, 0, 0, 0, 11680, 11688, 5, 115, 0, 0, 11681, 11682, + 5, 848, 0, 0, 11682, 11688, 5, 81, 0, 0, 11683, 11684, 5, 186, 0, 0, 11684, + 11688, 5, 81, 0, 0, 11685, 11688, 5, 304, 0, 0, 11686, 11688, 5, 847, 0, + 0, 11687, 11680, 1, 0, 0, 0, 11687, 11681, 1, 0, 0, 0, 11687, 11683, 1, + 0, 0, 0, 11687, 11685, 1, 0, 0, 0, 11687, 11686, 1, 0, 0, 0, 11688, 1383, + 1, 0, 0, 0, 11689, 11691, 3, 1388, 694, 0, 11690, 11692, 3, 1398, 699, + 0, 11691, 11690, 1, 0, 0, 0, 11691, 11692, 1, 0, 0, 0, 11692, 11700, 1, + 0, 0, 0, 11693, 11698, 3, 1888, 944, 0, 11694, 11695, 5, 2, 0, 0, 11695, + 11696, 3, 246, 123, 0, 11696, 11697, 5, 3, 0, 0, 11697, 11699, 1, 0, 0, + 0, 11698, 11694, 1, 0, 0, 0, 11698, 11699, 1, 0, 0, 0, 11699, 11701, 1, + 0, 0, 0, 11700, 11693, 1, 0, 0, 0, 11700, 11701, 1, 0, 0, 0, 11701, 11706, + 1, 0, 0, 0, 11702, 11703, 5, 287, 0, 0, 11703, 11707, 5, 674, 0, 0, 11704, + 11705, 5, 30, 0, 0, 11705, 11707, 5, 674, 0, 0, 11706, 11702, 1, 0, 0, + 0, 11706, 11704, 1, 0, 0, 0, 11706, 11707, 1, 0, 0, 0, 11707, 1385, 1, + 0, 0, 0, 11708, 11713, 3, 1390, 695, 0, 11709, 11710, 5, 6, 0, 0, 11710, + 11712, 3, 1390, 695, 0, 11711, 11709, 1, 0, 0, 0, 11712, 11715, 1, 0, 0, + 0, 11713, 11711, 1, 0, 0, 0, 11713, 11714, 1, 0, 0, 0, 11714, 1387, 1, + 0, 0, 0, 11715, 11713, 1, 0, 0, 0, 11716, 11717, 7, 69, 0, 0, 11717, 1389, + 1, 0, 0, 0, 11718, 11720, 3, 1392, 696, 0, 11719, 11721, 3, 1394, 697, + 0, 11720, 11719, 1, 0, 0, 0, 11720, 11721, 1, 0, 0, 0, 11721, 1391, 1, + 0, 0, 0, 11722, 11725, 3, 1930, 965, 0, 11723, 11725, 3, 1388, 694, 0, + 11724, 11722, 1, 0, 0, 0, 11724, 11723, 1, 0, 0, 0, 11725, 1393, 1, 0, + 0, 0, 11726, 11729, 3, 76, 38, 0, 11727, 11729, 3, 334, 167, 0, 11728, + 11726, 1, 0, 0, 0, 11728, 11727, 1, 0, 0, 0, 11729, 1395, 1, 0, 0, 0, 11730, + 11731, 3, 1388, 694, 0, 11731, 1397, 1, 0, 0, 0, 11732, 11733, 5, 130, + 0, 0, 11733, 1399, 1, 0, 0, 0, 11734, 11735, 5, 115, 0, 0, 11735, 1401, + 1, 0, 0, 0, 11736, 11737, 5, 114, 0, 0, 11737, 1403, 1, 0, 0, 0, 11738, + 11739, 5, 2, 0, 0, 11739, 11740, 3, 1890, 945, 0, 11740, 11741, 5, 3, 0, + 0, 11741, 1405, 1, 0, 0, 0, 11742, 11744, 3, 1888, 944, 0, 11743, 11745, + 3, 1404, 702, 0, 11744, 11743, 1, 0, 0, 0, 11744, 11745, 1, 0, 0, 0, 11745, + 1407, 1, 0, 0, 0, 11746, 11751, 3, 1406, 703, 0, 11747, 11748, 5, 6, 0, + 0, 11748, 11750, 3, 1406, 703, 0, 11749, 11747, 1, 0, 0, 0, 11750, 11753, + 1, 0, 0, 0, 11751, 11749, 1, 0, 0, 0, 11751, 11752, 1, 0, 0, 0, 11752, + 1409, 1, 0, 0, 0, 11753, 11751, 1, 0, 0, 0, 11754, 11755, 3, 1408, 704, + 0, 11755, 1411, 1, 0, 0, 0, 11756, 11757, 5, 207, 0, 0, 11757, 11775, 3, + 1414, 707, 0, 11758, 11759, 5, 207, 0, 0, 11759, 11761, 3, 1388, 694, 0, + 11760, 11762, 3, 1398, 699, 0, 11761, 11760, 1, 0, 0, 0, 11761, 11762, + 1, 0, 0, 0, 11762, 11763, 1, 0, 0, 0, 11763, 11764, 3, 1414, 707, 0, 11764, + 11775, 1, 0, 0, 0, 11765, 11766, 5, 207, 0, 0, 11766, 11767, 5, 130, 0, + 0, 11767, 11775, 3, 1414, 707, 0, 11768, 11769, 5, 207, 0, 0, 11769, 11770, + 5, 2, 0, 0, 11770, 11771, 3, 1416, 708, 0, 11771, 11772, 5, 3, 0, 0, 11772, + 11773, 3, 1414, 707, 0, 11773, 11775, 1, 0, 0, 0, 11774, 11756, 1, 0, 0, + 0, 11774, 11758, 1, 0, 0, 0, 11774, 11765, 1, 0, 0, 0, 11774, 11768, 1, + 0, 0, 0, 11775, 1413, 1, 0, 0, 0, 11776, 11786, 3, 1496, 748, 0, 11777, + 11786, 3, 1436, 718, 0, 11778, 11786, 3, 1478, 739, 0, 11779, 11786, 3, + 1464, 732, 0, 11780, 11786, 3, 1488, 744, 0, 11781, 11786, 3, 302, 151, + 0, 11782, 11786, 3, 314, 157, 0, 11783, 11786, 3, 318, 159, 0, 11784, 11786, + 3, 1430, 715, 0, 11785, 11776, 1, 0, 0, 0, 11785, 11777, 1, 0, 0, 0, 11785, + 11778, 1, 0, 0, 0, 11785, 11779, 1, 0, 0, 0, 11785, 11780, 1, 0, 0, 0, + 11785, 11781, 1, 0, 0, 0, 11785, 11782, 1, 0, 0, 0, 11785, 11783, 1, 0, + 0, 0, 11785, 11784, 1, 0, 0, 0, 11786, 1415, 1, 0, 0, 0, 11787, 11792, + 3, 1418, 709, 0, 11788, 11789, 5, 6, 0, 0, 11789, 11791, 3, 1418, 709, + 0, 11790, 11788, 1, 0, 0, 0, 11791, 11794, 1, 0, 0, 0, 11792, 11790, 1, + 0, 0, 0, 11792, 11793, 1, 0, 0, 0, 11793, 1417, 1, 0, 0, 0, 11794, 11792, + 1, 0, 0, 0, 11795, 11797, 3, 1420, 710, 0, 11796, 11798, 3, 1422, 711, + 0, 11797, 11796, 1, 0, 0, 0, 11797, 11798, 1, 0, 0, 0, 11798, 1419, 1, + 0, 0, 0, 11799, 11802, 3, 1930, 965, 0, 11800, 11802, 3, 1388, 694, 0, + 11801, 11799, 1, 0, 0, 0, 11801, 11800, 1, 0, 0, 0, 11802, 1421, 1, 0, + 0, 0, 11803, 11806, 3, 76, 38, 0, 11804, 11806, 3, 334, 167, 0, 11805, + 11803, 1, 0, 0, 0, 11805, 11804, 1, 0, 0, 0, 11806, 1423, 1, 0, 0, 0, 11807, + 11808, 5, 288, 0, 0, 11808, 11810, 3, 1892, 946, 0, 11809, 11811, 3, 1426, + 713, 0, 11810, 11809, 1, 0, 0, 0, 11810, 11811, 1, 0, 0, 0, 11811, 11812, + 1, 0, 0, 0, 11812, 11813, 5, 36, 0, 0, 11813, 11814, 3, 1428, 714, 0, 11814, + 1425, 1, 0, 0, 0, 11815, 11816, 5, 2, 0, 0, 11816, 11817, 3, 1836, 918, + 0, 11817, 11818, 5, 3, 0, 0, 11818, 1427, 1, 0, 0, 0, 11819, 11825, 3, + 1496, 748, 0, 11820, 11825, 3, 1436, 718, 0, 11821, 11825, 3, 1478, 739, + 0, 11822, 11825, 3, 1464, 732, 0, 11823, 11825, 3, 1454, 727, 0, 11824, + 11819, 1, 0, 0, 0, 11824, 11820, 1, 0, 0, 0, 11824, 11821, 1, 0, 0, 0, + 11824, 11822, 1, 0, 0, 0, 11824, 11823, 1, 0, 0, 0, 11825, 1429, 1, 0, + 0, 0, 11826, 11827, 5, 206, 0, 0, 11827, 11829, 3, 1892, 946, 0, 11828, + 11830, 3, 1432, 716, 0, 11829, 11828, 1, 0, 0, 0, 11829, 11830, 1, 0, 0, + 0, 11830, 11865, 1, 0, 0, 0, 11831, 11833, 5, 46, 0, 0, 11832, 11834, 3, + 198, 99, 0, 11833, 11832, 1, 0, 0, 0, 11833, 11834, 1, 0, 0, 0, 11834, + 11835, 1, 0, 0, 0, 11835, 11836, 5, 93, 0, 0, 11836, 11837, 3, 304, 152, + 0, 11837, 11838, 5, 36, 0, 0, 11838, 11839, 5, 206, 0, 0, 11839, 11841, + 3, 1892, 946, 0, 11840, 11842, 3, 1432, 716, 0, 11841, 11840, 1, 0, 0, + 0, 11841, 11842, 1, 0, 0, 0, 11842, 11844, 1, 0, 0, 0, 11843, 11845, 3, + 312, 156, 0, 11844, 11843, 1, 0, 0, 0, 11844, 11845, 1, 0, 0, 0, 11845, + 11865, 1, 0, 0, 0, 11846, 11848, 5, 46, 0, 0, 11847, 11849, 3, 198, 99, + 0, 11848, 11847, 1, 0, 0, 0, 11848, 11849, 1, 0, 0, 0, 11849, 11850, 1, + 0, 0, 0, 11850, 11851, 5, 93, 0, 0, 11851, 11852, 5, 224, 0, 0, 11852, + 11853, 5, 77, 0, 0, 11853, 11854, 5, 558, 0, 0, 11854, 11855, 3, 304, 152, + 0, 11855, 11856, 5, 36, 0, 0, 11856, 11857, 5, 206, 0, 0, 11857, 11859, + 3, 1892, 946, 0, 11858, 11860, 3, 1432, 716, 0, 11859, 11858, 1, 0, 0, + 0, 11859, 11860, 1, 0, 0, 0, 11860, 11862, 1, 0, 0, 0, 11861, 11863, 3, + 312, 156, 0, 11862, 11861, 1, 0, 0, 0, 11862, 11863, 1, 0, 0, 0, 11863, + 11865, 1, 0, 0, 0, 11864, 11826, 1, 0, 0, 0, 11864, 11831, 1, 0, 0, 0, + 11864, 11846, 1, 0, 0, 0, 11865, 1431, 1, 0, 0, 0, 11866, 11867, 5, 2, + 0, 0, 11867, 11868, 3, 1830, 915, 0, 11868, 11869, 5, 3, 0, 0, 11869, 1433, + 1, 0, 0, 0, 11870, 11871, 5, 181, 0, 0, 11871, 11881, 3, 1892, 946, 0, + 11872, 11873, 5, 181, 0, 0, 11873, 11874, 5, 288, 0, 0, 11874, 11881, 3, + 1892, 946, 0, 11875, 11876, 5, 181, 0, 0, 11876, 11881, 5, 30, 0, 0, 11877, + 11878, 5, 181, 0, 0, 11878, 11879, 5, 288, 0, 0, 11879, 11881, 5, 30, 0, + 0, 11880, 11870, 1, 0, 0, 0, 11880, 11872, 1, 0, 0, 0, 11880, 11875, 1, + 0, 0, 0, 11880, 11877, 1, 0, 0, 0, 11881, 1435, 1, 0, 0, 0, 11882, 11884, + 3, 1522, 761, 0, 11883, 11882, 1, 0, 0, 0, 11883, 11884, 1, 0, 0, 0, 11884, + 11885, 1, 0, 0, 0, 11885, 11886, 5, 236, 0, 0, 11886, 11887, 5, 71, 0, + 0, 11887, 11888, 3, 1438, 719, 0, 11888, 11890, 3, 1440, 720, 0, 11889, + 11891, 3, 1448, 724, 0, 11890, 11889, 1, 0, 0, 0, 11890, 11891, 1, 0, 0, + 0, 11891, 11893, 1, 0, 0, 0, 11892, 11894, 3, 1452, 726, 0, 11893, 11892, + 1, 0, 0, 0, 11893, 11894, 1, 0, 0, 0, 11894, 1437, 1, 0, 0, 0, 11895, 11898, + 3, 1888, 944, 0, 11896, 11897, 5, 36, 0, 0, 11897, 11899, 3, 1924, 962, + 0, 11898, 11896, 1, 0, 0, 0, 11898, 11899, 1, 0, 0, 0, 11899, 1439, 1, + 0, 0, 0, 11900, 11920, 3, 1496, 748, 0, 11901, 11902, 5, 662, 0, 0, 11902, + 11903, 3, 1442, 721, 0, 11903, 11904, 5, 649, 0, 0, 11904, 11905, 3, 1496, + 748, 0, 11905, 11920, 1, 0, 0, 0, 11906, 11907, 5, 2, 0, 0, 11907, 11908, + 3, 1444, 722, 0, 11908, 11913, 5, 3, 0, 0, 11909, 11910, 5, 662, 0, 0, + 11910, 11911, 3, 1442, 721, 0, 11911, 11912, 5, 649, 0, 0, 11912, 11914, + 1, 0, 0, 0, 11913, 11909, 1, 0, 0, 0, 11913, 11914, 1, 0, 0, 0, 11914, + 11915, 1, 0, 0, 0, 11915, 11916, 3, 1496, 748, 0, 11916, 11920, 1, 0, 0, + 0, 11917, 11918, 5, 53, 0, 0, 11918, 11920, 5, 585, 0, 0, 11919, 11900, + 1, 0, 0, 0, 11919, 11901, 1, 0, 0, 0, 11919, 11906, 1, 0, 0, 0, 11919, + 11917, 1, 0, 0, 0, 11920, 1441, 1, 0, 0, 0, 11921, 11922, 7, 75, 0, 0, + 11922, 1443, 1, 0, 0, 0, 11923, 11928, 3, 1446, 723, 0, 11924, 11925, 5, + 6, 0, 0, 11925, 11927, 3, 1446, 723, 0, 11926, 11924, 1, 0, 0, 0, 11927, + 11930, 1, 0, 0, 0, 11928, 11926, 1, 0, 0, 0, 11928, 11929, 1, 0, 0, 0, + 11929, 1445, 1, 0, 0, 0, 11930, 11928, 1, 0, 0, 0, 11931, 11932, 3, 1924, + 962, 0, 11932, 11933, 3, 1876, 938, 0, 11933, 1447, 1, 0, 0, 0, 11934, + 11935, 5, 80, 0, 0, 11935, 11937, 5, 663, 0, 0, 11936, 11938, 3, 1450, + 725, 0, 11937, 11936, 1, 0, 0, 0, 11937, 11938, 1, 0, 0, 0, 11938, 11939, + 1, 0, 0, 0, 11939, 11947, 5, 57, 0, 0, 11940, 11941, 5, 367, 0, 0, 11941, + 11942, 5, 331, 0, 0, 11942, 11944, 3, 1480, 740, 0, 11943, 11945, 3, 1638, + 819, 0, 11944, 11943, 1, 0, 0, 0, 11944, 11945, 1, 0, 0, 0, 11945, 11948, + 1, 0, 0, 0, 11946, 11948, 5, 267, 0, 0, 11947, 11940, 1, 0, 0, 0, 11947, + 11946, 1, 0, 0, 0, 11948, 1449, 1, 0, 0, 0, 11949, 11950, 5, 2, 0, 0, 11950, + 11951, 3, 808, 404, 0, 11951, 11953, 5, 3, 0, 0, 11952, 11954, 3, 1638, + 819, 0, 11953, 11952, 1, 0, 0, 0, 11953, 11954, 1, 0, 0, 0, 11954, 11959, + 1, 0, 0, 0, 11955, 11956, 5, 80, 0, 0, 11956, 11957, 5, 45, 0, 0, 11957, + 11959, 3, 1892, 946, 0, 11958, 11949, 1, 0, 0, 0, 11958, 11955, 1, 0, 0, + 0, 11959, 1451, 1, 0, 0, 0, 11960, 11961, 5, 88, 0, 0, 11961, 11962, 3, + 1880, 940, 0, 11962, 1453, 1, 0, 0, 0, 11963, 11965, 3, 1514, 757, 0, 11964, + 11963, 1, 0, 0, 0, 11964, 11965, 1, 0, 0, 0, 11965, 11966, 1, 0, 0, 0, + 11966, 11967, 5, 257, 0, 0, 11967, 11969, 5, 71, 0, 0, 11968, 11970, 5, + 81, 0, 0, 11969, 11968, 1, 0, 0, 0, 11969, 11970, 1, 0, 0, 0, 11970, 11971, + 1, 0, 0, 0, 11971, 11973, 3, 1888, 944, 0, 11972, 11974, 3, 1606, 803, + 0, 11973, 11972, 1, 0, 0, 0, 11973, 11974, 1, 0, 0, 0, 11974, 11975, 1, + 0, 0, 0, 11975, 11978, 5, 101, 0, 0, 11976, 11979, 3, 1498, 749, 0, 11977, + 11979, 3, 1888, 944, 0, 11978, 11976, 1, 0, 0, 0, 11978, 11977, 1, 0, 0, + 0, 11979, 11981, 1, 0, 0, 0, 11980, 11982, 3, 1606, 803, 0, 11981, 11980, + 1, 0, 0, 0, 11981, 11982, 1, 0, 0, 0, 11982, 11983, 1, 0, 0, 0, 11983, + 11984, 5, 80, 0, 0, 11984, 11992, 3, 1710, 855, 0, 11985, 11987, 3, 1456, + 728, 0, 11986, 11985, 1, 0, 0, 0, 11987, 11988, 1, 0, 0, 0, 11988, 11986, + 1, 0, 0, 0, 11988, 11989, 1, 0, 0, 0, 11989, 11993, 1, 0, 0, 0, 11990, + 11991, 5, 472, 0, 0, 11991, 11993, 5, 473, 0, 0, 11992, 11986, 1, 0, 0, + 0, 11992, 11990, 1, 0, 0, 0, 11993, 1455, 1, 0, 0, 0, 11994, 11998, 3, + 1458, 729, 0, 11995, 11998, 3, 1460, 730, 0, 11996, 11998, 3, 1462, 731, + 0, 11997, 11994, 1, 0, 0, 0, 11997, 11995, 1, 0, 0, 0, 11997, 11996, 1, + 0, 0, 0, 11998, 1457, 1, 0, 0, 0, 11999, 12000, 5, 103, 0, 0, 12000, 12001, + 5, 77, 0, 0, 12001, 12004, 5, 254, 0, 0, 12002, 12003, 5, 33, 0, 0, 12003, + 12005, 3, 1710, 855, 0, 12004, 12002, 1, 0, 0, 0, 12004, 12005, 1, 0, 0, + 0, 12005, 12007, 1, 0, 0, 0, 12006, 12008, 5, 94, 0, 0, 12007, 12006, 1, + 0, 0, 0, 12007, 12008, 1, 0, 0, 0, 12008, 12009, 1, 0, 0, 0, 12009, 12014, + 5, 236, 0, 0, 12010, 12011, 5, 2, 0, 0, 12011, 12012, 3, 1444, 722, 0, + 12012, 12013, 5, 3, 0, 0, 12013, 12015, 1, 0, 0, 0, 12014, 12010, 1, 0, + 0, 0, 12014, 12015, 1, 0, 0, 0, 12015, 12016, 1, 0, 0, 0, 12016, 12017, + 3, 1596, 798, 0, 12017, 1459, 1, 0, 0, 0, 12018, 12019, 5, 103, 0, 0, 12019, + 12022, 5, 254, 0, 0, 12020, 12021, 5, 33, 0, 0, 12021, 12023, 3, 1710, + 855, 0, 12022, 12020, 1, 0, 0, 0, 12022, 12023, 1, 0, 0, 0, 12023, 12025, + 1, 0, 0, 0, 12024, 12026, 5, 94, 0, 0, 12025, 12024, 1, 0, 0, 0, 12025, + 12026, 1, 0, 0, 0, 12026, 12027, 1, 0, 0, 0, 12027, 12028, 5, 367, 0, 0, + 12028, 12029, 5, 331, 0, 0, 12029, 12030, 3, 1480, 740, 0, 12030, 1461, + 1, 0, 0, 0, 12031, 12032, 5, 103, 0, 0, 12032, 12035, 5, 254, 0, 0, 12033, + 12034, 5, 33, 0, 0, 12034, 12036, 3, 1710, 855, 0, 12035, 12033, 1, 0, + 0, 0, 12035, 12036, 1, 0, 0, 0, 12036, 12038, 1, 0, 0, 0, 12037, 12039, + 5, 94, 0, 0, 12038, 12037, 1, 0, 0, 0, 12038, 12039, 1, 0, 0, 0, 12039, + 12040, 1, 0, 0, 0, 12040, 12041, 5, 186, 0, 0, 12041, 1463, 1, 0, 0, 0, + 12042, 12044, 3, 1522, 761, 0, 12043, 12042, 1, 0, 0, 0, 12043, 12044, + 1, 0, 0, 0, 12044, 12045, 1, 0, 0, 0, 12045, 12047, 5, 186, 0, 0, 12046, + 12048, 5, 64, 0, 0, 12047, 12046, 1, 0, 0, 0, 12047, 12048, 1, 0, 0, 0, + 12048, 12049, 1, 0, 0, 0, 12049, 12051, 3, 1622, 811, 0, 12050, 12052, + 3, 1466, 733, 0, 12051, 12050, 1, 0, 0, 0, 12051, 12052, 1, 0, 0, 0, 12052, + 12054, 1, 0, 0, 0, 12053, 12055, 3, 1640, 820, 0, 12054, 12053, 1, 0, 0, + 0, 12054, 12055, 1, 0, 0, 0, 12055, 12057, 1, 0, 0, 0, 12056, 12058, 3, + 1452, 726, 0, 12057, 12056, 1, 0, 0, 0, 12057, 12058, 1, 0, 0, 0, 12058, + 1465, 1, 0, 0, 0, 12059, 12060, 5, 101, 0, 0, 12060, 12061, 3, 1600, 800, + 0, 12061, 1467, 1, 0, 0, 0, 12062, 12064, 5, 251, 0, 0, 12063, 12065, 3, + 1532, 766, 0, 12064, 12063, 1, 0, 0, 0, 12064, 12065, 1, 0, 0, 0, 12065, + 12066, 1, 0, 0, 0, 12066, 12068, 3, 1620, 810, 0, 12067, 12069, 3, 1470, + 735, 0, 12068, 12067, 1, 0, 0, 0, 12068, 12069, 1, 0, 0, 0, 12069, 12071, + 1, 0, 0, 0, 12070, 12072, 3, 1474, 737, 0, 12071, 12070, 1, 0, 0, 0, 12071, + 12072, 1, 0, 0, 0, 12072, 1469, 1, 0, 0, 0, 12073, 12074, 5, 68, 0, 0, + 12074, 12075, 3, 1472, 736, 0, 12075, 12076, 5, 260, 0, 0, 12076, 1471, + 1, 0, 0, 0, 12077, 12078, 5, 133, 0, 0, 12078, 12090, 7, 76, 0, 0, 12079, + 12080, 5, 577, 0, 0, 12080, 12090, 7, 76, 0, 0, 12081, 12086, 5, 332, 0, + 0, 12082, 12083, 5, 367, 0, 0, 12083, 12087, 5, 205, 0, 0, 12084, 12085, + 5, 577, 0, 0, 12085, 12087, 5, 205, 0, 0, 12086, 12082, 1, 0, 0, 0, 12086, + 12084, 1, 0, 0, 0, 12086, 12087, 1, 0, 0, 0, 12087, 12090, 1, 0, 0, 0, + 12088, 12090, 5, 205, 0, 0, 12089, 12077, 1, 0, 0, 0, 12089, 12079, 1, + 0, 0, 0, 12089, 12081, 1, 0, 0, 0, 12089, 12088, 1, 0, 0, 0, 12090, 1473, + 1, 0, 0, 0, 12091, 12092, 5, 269, 0, 0, 12092, 1475, 1, 0, 0, 0, 12093, + 12097, 5, 269, 0, 0, 12094, 12095, 5, 664, 0, 0, 12095, 12097, 5, 665, + 0, 0, 12096, 12093, 1, 0, 0, 0, 12096, 12094, 1, 0, 0, 0, 12097, 1477, + 1, 0, 0, 0, 12098, 12100, 3, 1522, 761, 0, 12099, 12098, 1, 0, 0, 0, 12099, + 12100, 1, 0, 0, 0, 12100, 12101, 1, 0, 0, 0, 12101, 12102, 5, 367, 0, 0, + 12102, 12103, 3, 1622, 811, 0, 12103, 12104, 5, 331, 0, 0, 12104, 12106, + 3, 1480, 740, 0, 12105, 12107, 3, 1598, 799, 0, 12106, 12105, 1, 0, 0, + 0, 12106, 12107, 1, 0, 0, 0, 12107, 12109, 1, 0, 0, 0, 12108, 12110, 3, + 1640, 820, 0, 12109, 12108, 1, 0, 0, 0, 12109, 12110, 1, 0, 0, 0, 12110, + 12112, 1, 0, 0, 0, 12111, 12113, 3, 1452, 726, 0, 12112, 12111, 1, 0, 0, + 0, 12112, 12113, 1, 0, 0, 0, 12113, 1479, 1, 0, 0, 0, 12114, 12119, 3, + 1482, 741, 0, 12115, 12116, 5, 6, 0, 0, 12116, 12118, 3, 1482, 741, 0, + 12117, 12115, 1, 0, 0, 0, 12118, 12121, 1, 0, 0, 0, 12119, 12117, 1, 0, + 0, 0, 12119, 12120, 1, 0, 0, 0, 12120, 1481, 1, 0, 0, 0, 12121, 12119, + 1, 0, 0, 0, 12122, 12123, 3, 1484, 742, 0, 12123, 12124, 5, 10, 0, 0, 12124, + 12125, 3, 1710, 855, 0, 12125, 12133, 1, 0, 0, 0, 12126, 12127, 5, 2, 0, + 0, 12127, 12128, 3, 1486, 743, 0, 12128, 12129, 5, 3, 0, 0, 12129, 12130, + 5, 10, 0, 0, 12130, 12131, 3, 1710, 855, 0, 12131, 12133, 1, 0, 0, 0, 12132, + 12122, 1, 0, 0, 0, 12132, 12126, 1, 0, 0, 0, 12133, 1483, 1, 0, 0, 0, 12134, + 12135, 3, 1924, 962, 0, 12135, 12136, 3, 1876, 938, 0, 12136, 1485, 1, + 0, 0, 0, 12137, 12142, 3, 1484, 742, 0, 12138, 12139, 5, 6, 0, 0, 12139, + 12141, 3, 1484, 742, 0, 12140, 12138, 1, 0, 0, 0, 12141, 12144, 1, 0, 0, + 0, 12142, 12140, 1, 0, 0, 0, 12142, 12143, 1, 0, 0, 0, 12143, 1487, 1, + 0, 0, 0, 12144, 12142, 1, 0, 0, 0, 12145, 12146, 5, 182, 0, 0, 12146, 12147, + 3, 1490, 745, 0, 12147, 12148, 3, 1492, 746, 0, 12148, 12150, 5, 175, 0, + 0, 12149, 12151, 3, 1494, 747, 0, 12150, 12149, 1, 0, 0, 0, 12150, 12151, + 1, 0, 0, 0, 12151, 12152, 1, 0, 0, 0, 12152, 12153, 5, 62, 0, 0, 12153, + 12154, 3, 1496, 748, 0, 12154, 1489, 1, 0, 0, 0, 12155, 12156, 3, 1892, + 946, 0, 12156, 1491, 1, 0, 0, 0, 12157, 12158, 5, 266, 0, 0, 12158, 12163, + 5, 322, 0, 0, 12159, 12163, 5, 322, 0, 0, 12160, 12163, 5, 108, 0, 0, 12161, + 12163, 5, 235, 0, 0, 12162, 12157, 1, 0, 0, 0, 12162, 12159, 1, 0, 0, 0, + 12162, 12160, 1, 0, 0, 0, 12162, 12161, 1, 0, 0, 0, 12163, 12166, 1, 0, + 0, 0, 12164, 12162, 1, 0, 0, 0, 12164, 12165, 1, 0, 0, 0, 12165, 1493, + 1, 0, 0, 0, 12166, 12164, 1, 0, 0, 0, 12167, 12168, 5, 106, 0, 0, 12168, + 12172, 5, 221, 0, 0, 12169, 12170, 5, 377, 0, 0, 12170, 12172, 5, 221, + 0, 0, 12171, 12167, 1, 0, 0, 0, 12171, 12169, 1, 0, 0, 0, 12172, 1495, + 1, 0, 0, 0, 12173, 12176, 3, 1500, 750, 0, 12174, 12176, 3, 1498, 749, + 0, 12175, 12173, 1, 0, 0, 0, 12175, 12174, 1, 0, 0, 0, 12176, 1497, 1, + 0, 0, 0, 12177, 12178, 5, 2, 0, 0, 12178, 12179, 3, 1500, 750, 0, 12179, + 12180, 5, 3, 0, 0, 12180, 12186, 1, 0, 0, 0, 12181, 12182, 5, 2, 0, 0, + 12182, 12183, 3, 1498, 749, 0, 12183, 12184, 5, 3, 0, 0, 12184, 12186, + 1, 0, 0, 0, 12185, 12177, 1, 0, 0, 0, 12185, 12181, 1, 0, 0, 0, 12186, + 1499, 1, 0, 0, 0, 12187, 12189, 3, 1502, 751, 0, 12188, 12190, 3, 1540, + 770, 0, 12189, 12188, 1, 0, 0, 0, 12189, 12190, 1, 0, 0, 0, 12190, 12199, + 1, 0, 0, 0, 12191, 12193, 3, 1584, 792, 0, 12192, 12194, 3, 1550, 775, + 0, 12193, 12192, 1, 0, 0, 0, 12193, 12194, 1, 0, 0, 0, 12194, 12200, 1, + 0, 0, 0, 12195, 12197, 3, 1548, 774, 0, 12196, 12198, 3, 1586, 793, 0, + 12197, 12196, 1, 0, 0, 0, 12197, 12198, 1, 0, 0, 0, 12198, 12200, 1, 0, + 0, 0, 12199, 12191, 1, 0, 0, 0, 12199, 12195, 1, 0, 0, 0, 12199, 12200, + 1, 0, 0, 0, 12200, 12217, 1, 0, 0, 0, 12201, 12202, 3, 1514, 757, 0, 12202, + 12204, 3, 1502, 751, 0, 12203, 12205, 3, 1540, 770, 0, 12204, 12203, 1, + 0, 0, 0, 12204, 12205, 1, 0, 0, 0, 12205, 12214, 1, 0, 0, 0, 12206, 12208, + 3, 1584, 792, 0, 12207, 12209, 3, 1550, 775, 0, 12208, 12207, 1, 0, 0, + 0, 12208, 12209, 1, 0, 0, 0, 12209, 12215, 1, 0, 0, 0, 12210, 12212, 3, + 1548, 774, 0, 12211, 12213, 3, 1586, 793, 0, 12212, 12211, 1, 0, 0, 0, + 12212, 12213, 1, 0, 0, 0, 12213, 12215, 1, 0, 0, 0, 12214, 12206, 1, 0, + 0, 0, 12214, 12210, 1, 0, 0, 0, 12214, 12215, 1, 0, 0, 0, 12215, 12217, + 1, 0, 0, 0, 12216, 12187, 1, 0, 0, 0, 12216, 12201, 1, 0, 0, 0, 12217, + 1501, 1, 0, 0, 0, 12218, 12226, 3, 1504, 752, 0, 12219, 12221, 7, 77, 0, + 0, 12220, 12222, 3, 1534, 767, 0, 12221, 12220, 1, 0, 0, 0, 12221, 12222, + 1, 0, 0, 0, 12222, 12223, 1, 0, 0, 0, 12223, 12225, 3, 1504, 752, 0, 12224, + 12219, 1, 0, 0, 0, 12225, 12228, 1, 0, 0, 0, 12226, 12224, 1, 0, 0, 0, + 12226, 12227, 1, 0, 0, 0, 12227, 1503, 1, 0, 0, 0, 12228, 12226, 1, 0, + 0, 0, 12229, 12237, 3, 1506, 753, 0, 12230, 12232, 5, 70, 0, 0, 12231, + 12233, 3, 1534, 767, 0, 12232, 12231, 1, 0, 0, 0, 12232, 12233, 1, 0, 0, + 0, 12233, 12234, 1, 0, 0, 0, 12234, 12236, 3, 1506, 753, 0, 12235, 12230, + 1, 0, 0, 0, 12236, 12239, 1, 0, 0, 0, 12237, 12235, 1, 0, 0, 0, 12237, + 12238, 1, 0, 0, 0, 12238, 1505, 1, 0, 0, 0, 12239, 12237, 1, 0, 0, 0, 12240, + 12260, 5, 89, 0, 0, 12241, 12243, 3, 1538, 769, 0, 12242, 12241, 1, 0, + 0, 0, 12242, 12243, 1, 0, 0, 0, 12243, 12245, 1, 0, 0, 0, 12244, 12246, + 3, 1524, 762, 0, 12245, 12244, 1, 0, 0, 0, 12245, 12246, 1, 0, 0, 0, 12246, + 12248, 1, 0, 0, 0, 12247, 12249, 3, 1878, 939, 0, 12248, 12247, 1, 0, 0, + 0, 12248, 12249, 1, 0, 0, 0, 12249, 12261, 1, 0, 0, 0, 12250, 12252, 3, + 1526, 763, 0, 12251, 12250, 1, 0, 0, 0, 12251, 12252, 1, 0, 0, 0, 12252, + 12254, 1, 0, 0, 0, 12253, 12255, 3, 1524, 762, 0, 12254, 12253, 1, 0, 0, + 0, 12254, 12255, 1, 0, 0, 0, 12255, 12256, 1, 0, 0, 0, 12256, 12261, 3, + 1880, 940, 0, 12257, 12258, 3, 1536, 768, 0, 12258, 12259, 3, 1880, 940, + 0, 12259, 12261, 1, 0, 0, 0, 12260, 12242, 1, 0, 0, 0, 12260, 12251, 1, + 0, 0, 0, 12260, 12257, 1, 0, 0, 0, 12261, 12263, 1, 0, 0, 0, 12262, 12264, + 3, 1508, 754, 0, 12263, 12262, 1, 0, 0, 0, 12263, 12264, 1, 0, 0, 0, 12264, + 12266, 1, 0, 0, 0, 12265, 12267, 3, 1524, 762, 0, 12266, 12265, 1, 0, 0, + 0, 12266, 12267, 1, 0, 0, 0, 12267, 12269, 1, 0, 0, 0, 12268, 12270, 3, + 1598, 799, 0, 12269, 12268, 1, 0, 0, 0, 12269, 12270, 1, 0, 0, 0, 12270, + 12272, 1, 0, 0, 0, 12271, 12273, 3, 1638, 819, 0, 12272, 12271, 1, 0, 0, + 0, 12272, 12273, 1, 0, 0, 0, 12273, 12275, 1, 0, 0, 0, 12274, 12276, 3, + 1512, 756, 0, 12275, 12274, 1, 0, 0, 0, 12275, 12276, 1, 0, 0, 0, 12276, + 12278, 1, 0, 0, 0, 12277, 12279, 3, 1568, 784, 0, 12278, 12277, 1, 0, 0, + 0, 12278, 12279, 1, 0, 0, 0, 12279, 12281, 1, 0, 0, 0, 12280, 12282, 3, + 1582, 791, 0, 12281, 12280, 1, 0, 0, 0, 12281, 12282, 1, 0, 0, 0, 12282, + 12284, 1, 0, 0, 0, 12283, 12285, 3, 1510, 755, 0, 12284, 12283, 1, 0, 0, + 0, 12284, 12285, 1, 0, 0, 0, 12285, 12287, 1, 0, 0, 0, 12286, 12288, 3, + 1790, 895, 0, 12287, 12286, 1, 0, 0, 0, 12287, 12288, 1, 0, 0, 0, 12288, + 12294, 1, 0, 0, 0, 12289, 12294, 3, 1596, 798, 0, 12290, 12291, 5, 93, + 0, 0, 12291, 12294, 3, 1618, 809, 0, 12292, 12294, 3, 1498, 749, 0, 12293, + 12240, 1, 0, 0, 0, 12293, 12289, 1, 0, 0, 0, 12293, 12290, 1, 0, 0, 0, + 12293, 12292, 1, 0, 0, 0, 12294, 1507, 1, 0, 0, 0, 12295, 12296, 5, 203, + 0, 0, 12296, 12297, 5, 2, 0, 0, 12297, 12298, 3, 246, 123, 0, 12298, 12299, + 5, 3, 0, 0, 12299, 1509, 1, 0, 0, 0, 12300, 12301, 5, 385, 0, 0, 12301, + 12302, 3, 1710, 855, 0, 12302, 1511, 1, 0, 0, 0, 12303, 12304, 5, 338, + 0, 0, 12304, 12305, 5, 106, 0, 0, 12305, 12307, 3, 1710, 855, 0, 12306, + 12303, 1, 0, 0, 0, 12306, 12307, 1, 0, 0, 0, 12307, 12308, 1, 0, 0, 0, + 12308, 12309, 5, 386, 0, 0, 12309, 12310, 5, 149, 0, 0, 12310, 12311, 3, + 1710, 855, 0, 12311, 1513, 1, 0, 0, 0, 12312, 12314, 5, 106, 0, 0, 12313, + 12315, 5, 301, 0, 0, 12314, 12313, 1, 0, 0, 0, 12314, 12315, 1, 0, 0, 0, + 12315, 12316, 1, 0, 0, 0, 12316, 12317, 3, 1516, 758, 0, 12317, 1515, 1, + 0, 0, 0, 12318, 12323, 3, 1518, 759, 0, 12319, 12320, 5, 6, 0, 0, 12320, + 12322, 3, 1518, 759, 0, 12321, 12319, 1, 0, 0, 0, 12322, 12325, 1, 0, 0, + 0, 12323, 12321, 1, 0, 0, 0, 12323, 12324, 1, 0, 0, 0, 12324, 1517, 1, + 0, 0, 0, 12325, 12323, 1, 0, 0, 0, 12326, 12328, 3, 1892, 946, 0, 12327, + 12329, 3, 1404, 702, 0, 12328, 12327, 1, 0, 0, 0, 12328, 12329, 1, 0, 0, + 0, 12329, 12330, 1, 0, 0, 0, 12330, 12332, 5, 36, 0, 0, 12331, 12333, 3, + 1520, 760, 0, 12332, 12331, 1, 0, 0, 0, 12332, 12333, 1, 0, 0, 0, 12333, + 12334, 1, 0, 0, 0, 12334, 12335, 5, 2, 0, 0, 12335, 12336, 3, 1428, 714, + 0, 12336, 12337, 5, 3, 0, 0, 12337, 1519, 1, 0, 0, 0, 12338, 12342, 5, + 255, 0, 0, 12339, 12340, 5, 77, 0, 0, 12340, 12342, 5, 255, 0, 0, 12341, + 12338, 1, 0, 0, 0, 12341, 12339, 1, 0, 0, 0, 12342, 1521, 1, 0, 0, 0, 12343, + 12344, 3, 1514, 757, 0, 12344, 1523, 1, 0, 0, 0, 12345, 12351, 5, 71, 0, + 0, 12346, 12348, 3, 1528, 764, 0, 12347, 12346, 1, 0, 0, 0, 12347, 12348, + 1, 0, 0, 0, 12348, 12349, 1, 0, 0, 0, 12349, 12352, 3, 1530, 765, 0, 12350, + 12352, 3, 2118, 1059, 0, 12351, 12347, 1, 0, 0, 0, 12351, 12350, 1, 0, + 0, 0, 12352, 1525, 1, 0, 0, 0, 12353, 12354, 5, 387, 0, 0, 12354, 12355, + 3, 1908, 954, 0, 12355, 1527, 1, 0, 0, 0, 12356, 12357, 5, 344, 0, 0, 12357, + 1529, 1, 0, 0, 0, 12358, 12360, 7, 78, 0, 0, 12359, 12358, 1, 0, 0, 0, + 12359, 12360, 1, 0, 0, 0, 12360, 12361, 1, 0, 0, 0, 12361, 12363, 7, 21, + 0, 0, 12362, 12364, 3, 1532, 766, 0, 12363, 12362, 1, 0, 0, 0, 12363, 12364, + 1, 0, 0, 0, 12364, 12365, 1, 0, 0, 0, 12365, 12375, 3, 1888, 944, 0, 12366, + 12368, 5, 365, 0, 0, 12367, 12369, 3, 1532, 766, 0, 12368, 12367, 1, 0, + 0, 0, 12368, 12369, 1, 0, 0, 0, 12369, 12370, 1, 0, 0, 0, 12370, 12375, + 3, 1888, 944, 0, 12371, 12372, 5, 93, 0, 0, 12372, 12375, 3, 1888, 944, + 0, 12373, 12375, 3, 1888, 944, 0, 12374, 12359, 1, 0, 0, 0, 12374, 12366, + 1, 0, 0, 0, 12374, 12371, 1, 0, 0, 0, 12374, 12373, 1, 0, 0, 0, 12375, + 1531, 1, 0, 0, 0, 12376, 12377, 5, 93, 0, 0, 12377, 1533, 1, 0, 0, 0, 12378, + 12379, 7, 79, 0, 0, 12379, 1535, 1, 0, 0, 0, 12380, 12386, 5, 56, 0, 0, + 12381, 12382, 5, 80, 0, 0, 12382, 12383, 5, 2, 0, 0, 12383, 12384, 3, 1830, + 915, 0, 12384, 12385, 5, 3, 0, 0, 12385, 12387, 1, 0, 0, 0, 12386, 12381, + 1, 0, 0, 0, 12386, 12387, 1, 0, 0, 0, 12387, 1537, 1, 0, 0, 0, 12388, 12389, + 5, 30, 0, 0, 12389, 1539, 1, 0, 0, 0, 12390, 12391, 3, 1542, 771, 0, 12391, + 1541, 1, 0, 0, 0, 12392, 12393, 5, 83, 0, 0, 12393, 12394, 5, 149, 0, 0, + 12394, 12395, 3, 1544, 772, 0, 12395, 1543, 1, 0, 0, 0, 12396, 12401, 3, + 1546, 773, 0, 12397, 12398, 5, 6, 0, 0, 12398, 12400, 3, 1546, 773, 0, + 12399, 12397, 1, 0, 0, 0, 12400, 12403, 1, 0, 0, 0, 12401, 12399, 1, 0, + 0, 0, 12401, 12402, 1, 0, 0, 0, 12402, 1545, 1, 0, 0, 0, 12403, 12401, + 1, 0, 0, 0, 12404, 12410, 3, 1710, 855, 0, 12405, 12406, 5, 101, 0, 0, + 12406, 12411, 3, 1826, 913, 0, 12407, 12409, 3, 822, 411, 0, 12408, 12407, + 1, 0, 0, 0, 12408, 12409, 1, 0, 0, 0, 12409, 12411, 1, 0, 0, 0, 12410, + 12405, 1, 0, 0, 0, 12410, 12408, 1, 0, 0, 0, 12411, 12413, 1, 0, 0, 0, + 12412, 12414, 3, 824, 412, 0, 12413, 12412, 1, 0, 0, 0, 12413, 12414, 1, + 0, 0, 0, 12414, 1547, 1, 0, 0, 0, 12415, 12417, 3, 1552, 776, 0, 12416, + 12418, 3, 1554, 777, 0, 12417, 12416, 1, 0, 0, 0, 12417, 12418, 1, 0, 0, + 0, 12418, 12424, 1, 0, 0, 0, 12419, 12421, 3, 1554, 777, 0, 12420, 12422, + 3, 1552, 776, 0, 12421, 12420, 1, 0, 0, 0, 12421, 12422, 1, 0, 0, 0, 12422, + 12424, 1, 0, 0, 0, 12423, 12415, 1, 0, 0, 0, 12423, 12419, 1, 0, 0, 0, + 12424, 1549, 1, 0, 0, 0, 12425, 12426, 3, 1548, 774, 0, 12426, 1551, 1, + 0, 0, 0, 12427, 12428, 5, 74, 0, 0, 12428, 12431, 3, 1556, 778, 0, 12429, + 12430, 5, 6, 0, 0, 12430, 12432, 3, 1558, 779, 0, 12431, 12429, 1, 0, 0, + 0, 12431, 12432, 1, 0, 0, 0, 12432, 12451, 1, 0, 0, 0, 12433, 12434, 5, + 61, 0, 0, 12434, 12448, 3, 1566, 783, 0, 12435, 12436, 3, 1560, 780, 0, + 12436, 12440, 3, 1564, 782, 0, 12437, 12441, 5, 81, 0, 0, 12438, 12439, + 5, 106, 0, 0, 12439, 12441, 5, 666, 0, 0, 12440, 12437, 1, 0, 0, 0, 12440, + 12438, 1, 0, 0, 0, 12441, 12449, 1, 0, 0, 0, 12442, 12446, 3, 1564, 782, + 0, 12443, 12447, 5, 81, 0, 0, 12444, 12445, 5, 106, 0, 0, 12445, 12447, + 5, 666, 0, 0, 12446, 12443, 1, 0, 0, 0, 12446, 12444, 1, 0, 0, 0, 12447, + 12449, 1, 0, 0, 0, 12448, 12435, 1, 0, 0, 0, 12448, 12442, 1, 0, 0, 0, + 12449, 12451, 1, 0, 0, 0, 12450, 12427, 1, 0, 0, 0, 12450, 12433, 1, 0, + 0, 0, 12451, 1553, 1, 0, 0, 0, 12452, 12457, 5, 79, 0, 0, 12453, 12458, + 3, 1558, 779, 0, 12454, 12455, 3, 1560, 780, 0, 12455, 12456, 3, 1564, + 782, 0, 12456, 12458, 1, 0, 0, 0, 12457, 12453, 1, 0, 0, 0, 12457, 12454, + 1, 0, 0, 0, 12458, 1555, 1, 0, 0, 0, 12459, 12462, 3, 1710, 855, 0, 12460, + 12462, 5, 30, 0, 0, 12461, 12459, 1, 0, 0, 0, 12461, 12460, 1, 0, 0, 0, + 12462, 1557, 1, 0, 0, 0, 12463, 12464, 3, 1710, 855, 0, 12464, 1559, 1, + 0, 0, 0, 12465, 12471, 3, 1756, 878, 0, 12466, 12467, 5, 12, 0, 0, 12467, + 12471, 3, 1562, 781, 0, 12468, 12469, 5, 13, 0, 0, 12469, 12471, 3, 1562, + 781, 0, 12470, 12465, 1, 0, 0, 0, 12470, 12466, 1, 0, 0, 0, 12470, 12468, + 1, 0, 0, 0, 12471, 1561, 1, 0, 0, 0, 12472, 12475, 3, 1908, 954, 0, 12473, + 12475, 3, 1906, 953, 0, 12474, 12472, 1, 0, 0, 0, 12474, 12473, 1, 0, 0, + 0, 12475, 1563, 1, 0, 0, 0, 12476, 12477, 7, 80, 0, 0, 12477, 1565, 1, + 0, 0, 0, 12478, 12479, 7, 81, 0, 0, 12479, 1567, 1, 0, 0, 0, 12480, 12481, + 5, 66, 0, 0, 12481, 12482, 5, 149, 0, 0, 12482, 12483, 3, 1570, 785, 0, + 12483, 1569, 1, 0, 0, 0, 12484, 12489, 3, 1572, 786, 0, 12485, 12486, 5, + 6, 0, 0, 12486, 12488, 3, 1572, 786, 0, 12487, 12485, 1, 0, 0, 0, 12488, + 12491, 1, 0, 0, 0, 12489, 12487, 1, 0, 0, 0, 12489, 12490, 1, 0, 0, 0, + 12490, 12494, 1, 0, 0, 0, 12491, 12489, 1, 0, 0, 0, 12492, 12494, 5, 30, + 0, 0, 12493, 12484, 1, 0, 0, 0, 12493, 12492, 1, 0, 0, 0, 12494, 1571, + 1, 0, 0, 0, 12495, 12501, 3, 1710, 855, 0, 12496, 12501, 3, 1574, 787, + 0, 12497, 12501, 3, 1578, 789, 0, 12498, 12501, 3, 1576, 788, 0, 12499, + 12501, 3, 1580, 790, 0, 12500, 12495, 1, 0, 0, 0, 12500, 12496, 1, 0, 0, + 0, 12500, 12497, 1, 0, 0, 0, 12500, 12498, 1, 0, 0, 0, 12500, 12499, 1, + 0, 0, 0, 12501, 1573, 1, 0, 0, 0, 12502, 12503, 5, 2, 0, 0, 12503, 12504, + 5, 3, 0, 0, 12504, 1575, 1, 0, 0, 0, 12505, 12506, 5, 667, 0, 0, 12506, + 12507, 5, 2, 0, 0, 12507, 12508, 3, 1830, 915, 0, 12508, 12509, 5, 3, 0, + 0, 12509, 1577, 1, 0, 0, 0, 12510, 12511, 5, 668, 0, 0, 12511, 12512, 5, + 2, 0, 0, 12512, 12513, 3, 1830, 915, 0, 12513, 12514, 5, 3, 0, 0, 12514, + 1579, 1, 0, 0, 0, 12515, 12516, 5, 669, 0, 0, 12516, 12517, 5, 670, 0, + 0, 12517, 12518, 5, 2, 0, 0, 12518, 12519, 3, 1570, 785, 0, 12519, 12520, + 5, 3, 0, 0, 12520, 1581, 1, 0, 0, 0, 12521, 12522, 5, 67, 0, 0, 12522, + 12523, 3, 1710, 855, 0, 12523, 1583, 1, 0, 0, 0, 12524, 12529, 3, 1588, + 794, 0, 12525, 12526, 5, 62, 0, 0, 12526, 12527, 5, 298, 0, 0, 12527, 12529, + 5, 81, 0, 0, 12528, 12524, 1, 0, 0, 0, 12528, 12525, 1, 0, 0, 0, 12529, + 1585, 1, 0, 0, 0, 12530, 12531, 3, 1584, 792, 0, 12531, 1587, 1, 0, 0, + 0, 12532, 12534, 3, 1590, 795, 0, 12533, 12532, 1, 0, 0, 0, 12534, 12535, + 1, 0, 0, 0, 12535, 12533, 1, 0, 0, 0, 12535, 12536, 1, 0, 0, 0, 12536, + 1589, 1, 0, 0, 0, 12537, 12539, 3, 1592, 796, 0, 12538, 12540, 3, 1594, + 797, 0, 12539, 12538, 1, 0, 0, 0, 12539, 12540, 1, 0, 0, 0, 12540, 12542, + 1, 0, 0, 0, 12541, 12543, 3, 1476, 738, 0, 12542, 12541, 1, 0, 0, 0, 12542, + 12543, 1, 0, 0, 0, 12543, 1591, 1, 0, 0, 0, 12544, 12554, 5, 62, 0, 0, + 12545, 12546, 5, 266, 0, 0, 12546, 12548, 5, 240, 0, 0, 12547, 12545, 1, + 0, 0, 0, 12547, 12548, 1, 0, 0, 0, 12548, 12549, 1, 0, 0, 0, 12549, 12555, + 5, 367, 0, 0, 12550, 12552, 5, 240, 0, 0, 12551, 12550, 1, 0, 0, 0, 12551, + 12552, 1, 0, 0, 0, 12552, 12553, 1, 0, 0, 0, 12553, 12555, 5, 332, 0, 0, + 12554, 12547, 1, 0, 0, 0, 12554, 12551, 1, 0, 0, 0, 12555, 1593, 1, 0, + 0, 0, 12556, 12557, 5, 272, 0, 0, 12557, 12558, 3, 1886, 943, 0, 12558, + 1595, 1, 0, 0, 0, 12559, 12560, 5, 585, 0, 0, 12560, 12561, 5, 2, 0, 0, + 12561, 12562, 3, 1830, 915, 0, 12562, 12570, 5, 3, 0, 0, 12563, 12564, + 5, 6, 0, 0, 12564, 12565, 5, 2, 0, 0, 12565, 12566, 3, 1830, 915, 0, 12566, + 12567, 5, 3, 0, 0, 12567, 12569, 1, 0, 0, 0, 12568, 12563, 1, 0, 0, 0, + 12569, 12572, 1, 0, 0, 0, 12570, 12568, 1, 0, 0, 0, 12570, 12571, 1, 0, + 0, 0, 12571, 1597, 1, 0, 0, 0, 12572, 12570, 1, 0, 0, 0, 12573, 12574, + 5, 64, 0, 0, 12574, 12575, 3, 1600, 800, 0, 12575, 1599, 1, 0, 0, 0, 12576, + 12581, 3, 1602, 801, 0, 12577, 12578, 5, 6, 0, 0, 12578, 12580, 3, 1602, + 801, 0, 12579, 12577, 1, 0, 0, 0, 12580, 12583, 1, 0, 0, 0, 12581, 12579, + 1, 0, 0, 0, 12581, 12582, 1, 0, 0, 0, 12582, 1601, 1, 0, 0, 0, 12583, 12581, + 1, 0, 0, 0, 12584, 12586, 3, 1618, 809, 0, 12585, 12587, 3, 1608, 804, + 0, 12586, 12585, 1, 0, 0, 0, 12586, 12587, 1, 0, 0, 0, 12587, 12589, 1, + 0, 0, 0, 12588, 12590, 3, 1624, 812, 0, 12589, 12588, 1, 0, 0, 0, 12589, + 12590, 1, 0, 0, 0, 12590, 12643, 1, 0, 0, 0, 12591, 12593, 3, 1628, 814, + 0, 12592, 12594, 3, 1612, 806, 0, 12593, 12592, 1, 0, 0, 0, 12593, 12594, + 1, 0, 0, 0, 12594, 12643, 1, 0, 0, 0, 12595, 12597, 3, 1648, 824, 0, 12596, + 12598, 3, 1608, 804, 0, 12597, 12596, 1, 0, 0, 0, 12597, 12598, 1, 0, 0, + 0, 12598, 12643, 1, 0, 0, 0, 12599, 12601, 3, 1498, 749, 0, 12600, 12602, + 3, 1608, 804, 0, 12601, 12600, 1, 0, 0, 0, 12601, 12602, 1, 0, 0, 0, 12602, + 12643, 1, 0, 0, 0, 12603, 12616, 5, 72, 0, 0, 12604, 12606, 3, 1648, 824, + 0, 12605, 12607, 3, 1608, 804, 0, 12606, 12605, 1, 0, 0, 0, 12606, 12607, + 1, 0, 0, 0, 12607, 12617, 1, 0, 0, 0, 12608, 12610, 3, 1628, 814, 0, 12609, + 12611, 3, 1612, 806, 0, 12610, 12609, 1, 0, 0, 0, 12610, 12611, 1, 0, 0, + 0, 12611, 12617, 1, 0, 0, 0, 12612, 12614, 3, 1498, 749, 0, 12613, 12615, + 3, 1608, 804, 0, 12614, 12613, 1, 0, 0, 0, 12614, 12615, 1, 0, 0, 0, 12615, + 12617, 1, 0, 0, 0, 12616, 12604, 1, 0, 0, 0, 12616, 12608, 1, 0, 0, 0, + 12616, 12612, 1, 0, 0, 0, 12617, 12643, 1, 0, 0, 0, 12618, 12619, 5, 2, + 0, 0, 12619, 12636, 3, 1602, 801, 0, 12620, 12621, 5, 112, 0, 0, 12621, + 12622, 5, 120, 0, 0, 12622, 12637, 3, 1602, 801, 0, 12623, 12625, 5, 123, + 0, 0, 12624, 12626, 3, 1614, 807, 0, 12625, 12624, 1, 0, 0, 0, 12625, 12626, + 1, 0, 0, 0, 12626, 12627, 1, 0, 0, 0, 12627, 12628, 5, 120, 0, 0, 12628, + 12637, 3, 1602, 801, 0, 12629, 12631, 3, 1614, 807, 0, 12630, 12629, 1, + 0, 0, 0, 12630, 12631, 1, 0, 0, 0, 12631, 12632, 1, 0, 0, 0, 12632, 12633, + 5, 120, 0, 0, 12633, 12634, 3, 1602, 801, 0, 12634, 12635, 3, 1616, 808, + 0, 12635, 12637, 1, 0, 0, 0, 12636, 12620, 1, 0, 0, 0, 12636, 12623, 1, + 0, 0, 0, 12636, 12630, 1, 0, 0, 0, 12636, 12637, 1, 0, 0, 0, 12637, 12638, + 1, 0, 0, 0, 12638, 12640, 5, 3, 0, 0, 12639, 12641, 3, 1608, 804, 0, 12640, + 12639, 1, 0, 0, 0, 12640, 12641, 1, 0, 0, 0, 12641, 12643, 1, 0, 0, 0, + 12642, 12584, 1, 0, 0, 0, 12642, 12591, 1, 0, 0, 0, 12642, 12595, 1, 0, + 0, 0, 12642, 12599, 1, 0, 0, 0, 12642, 12603, 1, 0, 0, 0, 12642, 12618, + 1, 0, 0, 0, 12643, 12647, 1, 0, 0, 0, 12644, 12646, 3, 1604, 802, 0, 12645, + 12644, 1, 0, 0, 0, 12646, 12649, 1, 0, 0, 0, 12647, 12645, 1, 0, 0, 0, + 12647, 12648, 1, 0, 0, 0, 12648, 1603, 1, 0, 0, 0, 12649, 12647, 1, 0, + 0, 0, 12650, 12652, 3, 1614, 807, 0, 12651, 12650, 1, 0, 0, 0, 12651, 12652, + 1, 0, 0, 0, 12652, 12653, 1, 0, 0, 0, 12653, 12654, 5, 120, 0, 0, 12654, + 12655, 3, 1602, 801, 0, 12655, 12656, 3, 1616, 808, 0, 12656, 12667, 1, + 0, 0, 0, 12657, 12658, 5, 112, 0, 0, 12658, 12659, 5, 120, 0, 0, 12659, + 12667, 3, 1602, 801, 0, 12660, 12662, 5, 123, 0, 0, 12661, 12663, 3, 1614, + 807, 0, 12662, 12661, 1, 0, 0, 0, 12662, 12663, 1, 0, 0, 0, 12663, 12664, + 1, 0, 0, 0, 12664, 12665, 5, 120, 0, 0, 12665, 12667, 3, 1602, 801, 0, + 12666, 12651, 1, 0, 0, 0, 12666, 12657, 1, 0, 0, 0, 12666, 12660, 1, 0, + 0, 0, 12667, 1605, 1, 0, 0, 0, 12668, 12670, 5, 36, 0, 0, 12669, 12668, + 1, 0, 0, 0, 12669, 12670, 1, 0, 0, 0, 12670, 12671, 1, 0, 0, 0, 12671, + 12676, 3, 1924, 962, 0, 12672, 12673, 5, 2, 0, 0, 12673, 12674, 3, 1890, + 945, 0, 12674, 12675, 5, 3, 0, 0, 12675, 12677, 1, 0, 0, 0, 12676, 12672, + 1, 0, 0, 0, 12676, 12677, 1, 0, 0, 0, 12677, 1607, 1, 0, 0, 0, 12678, 12679, + 3, 1610, 805, 0, 12679, 1609, 1, 0, 0, 0, 12680, 12682, 5, 36, 0, 0, 12681, + 12680, 1, 0, 0, 0, 12681, 12682, 1, 0, 0, 0, 12682, 12683, 1, 0, 0, 0, + 12683, 12688, 3, 1926, 963, 0, 12684, 12685, 5, 2, 0, 0, 12685, 12686, + 3, 1890, 945, 0, 12686, 12687, 5, 3, 0, 0, 12687, 12689, 1, 0, 0, 0, 12688, + 12684, 1, 0, 0, 0, 12688, 12689, 1, 0, 0, 0, 12689, 1611, 1, 0, 0, 0, 12690, + 12703, 3, 1606, 803, 0, 12691, 12693, 5, 36, 0, 0, 12692, 12694, 3, 1924, + 962, 0, 12693, 12692, 1, 0, 0, 0, 12693, 12694, 1, 0, 0, 0, 12694, 12697, + 1, 0, 0, 0, 12695, 12697, 3, 1924, 962, 0, 12696, 12691, 1, 0, 0, 0, 12696, + 12695, 1, 0, 0, 0, 12697, 12698, 1, 0, 0, 0, 12698, 12699, 5, 2, 0, 0, + 12699, 12700, 3, 1644, 822, 0, 12700, 12701, 5, 3, 0, 0, 12701, 12703, + 1, 0, 0, 0, 12702, 12690, 1, 0, 0, 0, 12702, 12696, 1, 0, 0, 0, 12703, + 1613, 1, 0, 0, 0, 12704, 12706, 7, 82, 0, 0, 12705, 12707, 5, 125, 0, 0, + 12706, 12705, 1, 0, 0, 0, 12706, 12707, 1, 0, 0, 0, 12707, 1615, 1, 0, + 0, 0, 12708, 12709, 5, 101, 0, 0, 12709, 12710, 5, 2, 0, 0, 12710, 12711, + 3, 1890, 945, 0, 12711, 12712, 5, 3, 0, 0, 12712, 12716, 1, 0, 0, 0, 12713, + 12714, 5, 80, 0, 0, 12714, 12716, 3, 1710, 855, 0, 12715, 12708, 1, 0, + 0, 0, 12715, 12713, 1, 0, 0, 0, 12716, 1617, 1, 0, 0, 0, 12717, 12719, + 3, 1888, 944, 0, 12718, 12720, 5, 9, 0, 0, 12719, 12718, 1, 0, 0, 0, 12719, + 12720, 1, 0, 0, 0, 12720, 12730, 1, 0, 0, 0, 12721, 12727, 5, 81, 0, 0, + 12722, 12728, 3, 1888, 944, 0, 12723, 12724, 5, 2, 0, 0, 12724, 12725, + 3, 1888, 944, 0, 12725, 12726, 5, 3, 0, 0, 12726, 12728, 1, 0, 0, 0, 12727, + 12722, 1, 0, 0, 0, 12727, 12723, 1, 0, 0, 0, 12728, 12730, 1, 0, 0, 0, + 12729, 12717, 1, 0, 0, 0, 12729, 12721, 1, 0, 0, 0, 12730, 1619, 1, 0, + 0, 0, 12731, 12736, 3, 1618, 809, 0, 12732, 12733, 5, 6, 0, 0, 12733, 12735, + 3, 1618, 809, 0, 12734, 12732, 1, 0, 0, 0, 12735, 12738, 1, 0, 0, 0, 12736, + 12734, 1, 0, 0, 0, 12736, 12737, 1, 0, 0, 0, 12737, 1621, 1, 0, 0, 0, 12738, + 12736, 1, 0, 0, 0, 12739, 12744, 3, 1618, 809, 0, 12740, 12742, 5, 36, + 0, 0, 12741, 12740, 1, 0, 0, 0, 12741, 12742, 1, 0, 0, 0, 12742, 12743, + 1, 0, 0, 0, 12743, 12745, 3, 1924, 962, 0, 12744, 12741, 1, 0, 0, 0, 12744, + 12745, 1, 0, 0, 0, 12745, 1623, 1, 0, 0, 0, 12746, 12747, 5, 671, 0, 0, + 12747, 12748, 3, 1898, 949, 0, 12748, 12749, 5, 2, 0, 0, 12749, 12750, + 3, 1830, 915, 0, 12750, 12752, 5, 3, 0, 0, 12751, 12753, 3, 1626, 813, + 0, 12752, 12751, 1, 0, 0, 0, 12752, 12753, 1, 0, 0, 0, 12753, 1625, 1, + 0, 0, 0, 12754, 12755, 5, 308, 0, 0, 12755, 12756, 5, 2, 0, 0, 12756, 12757, + 3, 1710, 855, 0, 12757, 12758, 5, 3, 0, 0, 12758, 1627, 1, 0, 0, 0, 12759, + 12761, 3, 1764, 882, 0, 12760, 12762, 3, 1636, 818, 0, 12761, 12760, 1, + 0, 0, 0, 12761, 12762, 1, 0, 0, 0, 12762, 12772, 1, 0, 0, 0, 12763, 12764, + 5, 318, 0, 0, 12764, 12765, 5, 64, 0, 0, 12765, 12766, 5, 2, 0, 0, 12766, + 12767, 3, 1632, 816, 0, 12767, 12769, 5, 3, 0, 0, 12768, 12770, 3, 1636, + 818, 0, 12769, 12768, 1, 0, 0, 0, 12769, 12770, 1, 0, 0, 0, 12770, 12772, + 1, 0, 0, 0, 12771, 12759, 1, 0, 0, 0, 12771, 12763, 1, 0, 0, 0, 12772, + 1629, 1, 0, 0, 0, 12773, 12775, 3, 1764, 882, 0, 12774, 12776, 3, 1634, + 817, 0, 12775, 12774, 1, 0, 0, 0, 12775, 12776, 1, 0, 0, 0, 12776, 1631, + 1, 0, 0, 0, 12777, 12782, 3, 1630, 815, 0, 12778, 12779, 5, 6, 0, 0, 12779, + 12781, 3, 1630, 815, 0, 12780, 12778, 1, 0, 0, 0, 12781, 12784, 1, 0, 0, + 0, 12782, 12780, 1, 0, 0, 0, 12782, 12783, 1, 0, 0, 0, 12783, 1633, 1, + 0, 0, 0, 12784, 12782, 1, 0, 0, 0, 12785, 12786, 5, 36, 0, 0, 12786, 12787, + 5, 2, 0, 0, 12787, 12788, 3, 1644, 822, 0, 12788, 12789, 5, 3, 0, 0, 12789, + 1635, 1, 0, 0, 0, 12790, 12791, 5, 106, 0, 0, 12791, 12792, 5, 672, 0, + 0, 12792, 1637, 1, 0, 0, 0, 12793, 12794, 5, 104, 0, 0, 12794, 12795, 3, + 1710, 855, 0, 12795, 1639, 1, 0, 0, 0, 12796, 12801, 5, 104, 0, 0, 12797, + 12798, 5, 604, 0, 0, 12798, 12799, 5, 272, 0, 0, 12799, 12802, 3, 1490, + 745, 0, 12800, 12802, 3, 1710, 855, 0, 12801, 12797, 1, 0, 0, 0, 12801, + 12800, 1, 0, 0, 0, 12802, 1641, 1, 0, 0, 0, 12803, 12804, 3, 1644, 822, + 0, 12804, 1643, 1, 0, 0, 0, 12805, 12810, 3, 1646, 823, 0, 12806, 12807, + 5, 6, 0, 0, 12807, 12809, 3, 1646, 823, 0, 12808, 12806, 1, 0, 0, 0, 12809, + 12812, 1, 0, 0, 0, 12810, 12808, 1, 0, 0, 0, 12810, 12811, 1, 0, 0, 0, + 12811, 1645, 1, 0, 0, 0, 12812, 12810, 1, 0, 0, 0, 12813, 12814, 3, 1924, + 962, 0, 12814, 12816, 3, 1662, 831, 0, 12815, 12817, 3, 122, 61, 0, 12816, + 12815, 1, 0, 0, 0, 12816, 12817, 1, 0, 0, 0, 12817, 1647, 1, 0, 0, 0, 12818, + 12819, 5, 673, 0, 0, 12819, 12835, 5, 2, 0, 0, 12820, 12821, 3, 1756, 878, + 0, 12821, 12822, 3, 1782, 891, 0, 12822, 12823, 5, 674, 0, 0, 12823, 12824, + 3, 1650, 825, 0, 12824, 12836, 1, 0, 0, 0, 12825, 12826, 5, 675, 0, 0, + 12826, 12827, 5, 2, 0, 0, 12827, 12828, 3, 1658, 829, 0, 12828, 12829, + 5, 3, 0, 0, 12829, 12830, 5, 6, 0, 0, 12830, 12831, 3, 1756, 878, 0, 12831, + 12832, 3, 1782, 891, 0, 12832, 12833, 5, 674, 0, 0, 12833, 12834, 3, 1650, + 825, 0, 12834, 12836, 1, 0, 0, 0, 12835, 12820, 1, 0, 0, 0, 12835, 12825, + 1, 0, 0, 0, 12836, 12837, 1, 0, 0, 0, 12837, 12838, 5, 3, 0, 0, 12838, + 1649, 1, 0, 0, 0, 12839, 12844, 3, 1652, 826, 0, 12840, 12841, 5, 6, 0, + 0, 12841, 12843, 3, 1652, 826, 0, 12842, 12840, 1, 0, 0, 0, 12843, 12846, + 1, 0, 0, 0, 12844, 12842, 1, 0, 0, 0, 12844, 12845, 1, 0, 0, 0, 12845, + 1651, 1, 0, 0, 0, 12846, 12844, 1, 0, 0, 0, 12847, 12854, 3, 1924, 962, + 0, 12848, 12850, 3, 1662, 831, 0, 12849, 12851, 3, 1654, 827, 0, 12850, + 12849, 1, 0, 0, 0, 12850, 12851, 1, 0, 0, 0, 12851, 12855, 1, 0, 0, 0, + 12852, 12853, 5, 62, 0, 0, 12853, 12855, 5, 672, 0, 0, 12854, 12848, 1, + 0, 0, 0, 12854, 12852, 1, 0, 0, 0, 12855, 1653, 1, 0, 0, 0, 12856, 12858, + 3, 1656, 828, 0, 12857, 12856, 1, 0, 0, 0, 12858, 12859, 1, 0, 0, 0, 12859, + 12857, 1, 0, 0, 0, 12859, 12860, 1, 0, 0, 0, 12860, 1655, 1, 0, 0, 0, 12861, + 12862, 5, 53, 0, 0, 12862, 12870, 3, 1710, 855, 0, 12863, 12864, 3, 1934, + 967, 0, 12864, 12865, 3, 1710, 855, 0, 12865, 12870, 1, 0, 0, 0, 12866, + 12867, 5, 77, 0, 0, 12867, 12870, 5, 78, 0, 0, 12868, 12870, 5, 78, 0, + 0, 12869, 12861, 1, 0, 0, 0, 12869, 12863, 1, 0, 0, 0, 12869, 12866, 1, + 0, 0, 0, 12869, 12868, 1, 0, 0, 0, 12870, 1657, 1, 0, 0, 0, 12871, 12876, + 3, 1660, 830, 0, 12872, 12873, 5, 6, 0, 0, 12873, 12875, 3, 1660, 830, + 0, 12874, 12872, 1, 0, 0, 0, 12875, 12878, 1, 0, 0, 0, 12876, 12874, 1, + 0, 0, 0, 12876, 12877, 1, 0, 0, 0, 12877, 1659, 1, 0, 0, 0, 12878, 12876, + 1, 0, 0, 0, 12879, 12880, 3, 1754, 877, 0, 12880, 12881, 5, 36, 0, 0, 12881, + 12882, 3, 1932, 966, 0, 12882, 12886, 1, 0, 0, 0, 12883, 12884, 5, 53, + 0, 0, 12884, 12886, 3, 1754, 877, 0, 12885, 12879, 1, 0, 0, 0, 12885, 12883, + 1, 0, 0, 0, 12886, 1661, 1, 0, 0, 0, 12887, 12889, 5, 578, 0, 0, 12888, + 12887, 1, 0, 0, 0, 12888, 12889, 1, 0, 0, 0, 12889, 12890, 1, 0, 0, 0, + 12890, 12901, 3, 1666, 833, 0, 12891, 12893, 3, 1664, 832, 0, 12892, 12891, + 1, 0, 0, 0, 12892, 12893, 1, 0, 0, 0, 12893, 12902, 1, 0, 0, 0, 12894, + 12899, 5, 35, 0, 0, 12895, 12896, 5, 4, 0, 0, 12896, 12897, 3, 1908, 954, + 0, 12897, 12898, 5, 5, 0, 0, 12898, 12900, 1, 0, 0, 0, 12899, 12895, 1, + 0, 0, 0, 12899, 12900, 1, 0, 0, 0, 12900, 12902, 1, 0, 0, 0, 12901, 12892, + 1, 0, 0, 0, 12901, 12894, 1, 0, 0, 0, 12902, 12909, 1, 0, 0, 0, 12903, + 12904, 3, 1888, 944, 0, 12904, 12905, 5, 27, 0, 0, 12905, 12906, 7, 83, + 0, 0, 12906, 12909, 1, 0, 0, 0, 12907, 12909, 5, 482, 0, 0, 12908, 12888, + 1, 0, 0, 0, 12908, 12903, 1, 0, 0, 0, 12908, 12907, 1, 0, 0, 0, 12909, + 1663, 1, 0, 0, 0, 12910, 12912, 5, 4, 0, 0, 12911, 12913, 3, 1908, 954, + 0, 12912, 12911, 1, 0, 0, 0, 12912, 12913, 1, 0, 0, 0, 12913, 12914, 1, + 0, 0, 0, 12914, 12916, 5, 5, 0, 0, 12915, 12910, 1, 0, 0, 0, 12916, 12917, + 1, 0, 0, 0, 12917, 12915, 1, 0, 0, 0, 12917, 12918, 1, 0, 0, 0, 12918, + 1665, 1, 0, 0, 0, 12919, 12937, 3, 1674, 837, 0, 12920, 12937, 3, 1678, + 839, 0, 12921, 12937, 3, 1682, 841, 0, 12922, 12937, 3, 1690, 845, 0, 12923, + 12937, 3, 1668, 834, 0, 12924, 12937, 3, 1698, 849, 0, 12925, 12933, 3, + 1700, 850, 0, 12926, 12928, 3, 1704, 852, 0, 12927, 12926, 1, 0, 0, 0, + 12927, 12928, 1, 0, 0, 0, 12928, 12934, 1, 0, 0, 0, 12929, 12930, 5, 2, + 0, 0, 12930, 12931, 3, 1908, 954, 0, 12931, 12932, 5, 3, 0, 0, 12932, 12934, + 1, 0, 0, 0, 12933, 12927, 1, 0, 0, 0, 12933, 12929, 1, 0, 0, 0, 12934, + 12937, 1, 0, 0, 0, 12935, 12937, 3, 1670, 835, 0, 12936, 12919, 1, 0, 0, + 0, 12936, 12920, 1, 0, 0, 0, 12936, 12921, 1, 0, 0, 0, 12936, 12922, 1, + 0, 0, 0, 12936, 12923, 1, 0, 0, 0, 12936, 12924, 1, 0, 0, 0, 12936, 12925, + 1, 0, 0, 0, 12936, 12935, 1, 0, 0, 0, 12937, 1667, 1, 0, 0, 0, 12938, 12943, + 5, 388, 0, 0, 12939, 12943, 5, 389, 0, 0, 12940, 12941, 5, 108, 0, 0, 12941, + 12943, 5, 372, 0, 0, 12942, 12938, 1, 0, 0, 0, 12942, 12939, 1, 0, 0, 0, + 12942, 12940, 1, 0, 0, 0, 12943, 12944, 1, 0, 0, 0, 12944, 12945, 5, 2, + 0, 0, 12945, 12946, 3, 1908, 954, 0, 12946, 12947, 5, 3, 0, 0, 12947, 1669, + 1, 0, 0, 0, 12948, 12949, 5, 174, 0, 0, 12949, 1671, 1, 0, 0, 0, 12950, + 12955, 3, 1678, 839, 0, 12951, 12955, 3, 1684, 842, 0, 12952, 12955, 3, + 1692, 846, 0, 12953, 12955, 3, 1698, 849, 0, 12954, 12950, 1, 0, 0, 0, + 12954, 12951, 1, 0, 0, 0, 12954, 12952, 1, 0, 0, 0, 12954, 12953, 1, 0, + 0, 0, 12955, 1673, 1, 0, 0, 0, 12956, 12961, 3, 1946, 973, 0, 12957, 12961, + 3, 1928, 964, 0, 12958, 12961, 5, 121, 0, 0, 12959, 12961, 5, 128, 0, 0, + 12960, 12956, 1, 0, 0, 0, 12960, 12957, 1, 0, 0, 0, 12960, 12958, 1, 0, + 0, 0, 12960, 12959, 1, 0, 0, 0, 12961, 12963, 1, 0, 0, 0, 12962, 12964, + 3, 568, 284, 0, 12963, 12962, 1, 0, 0, 0, 12963, 12964, 1, 0, 0, 0, 12964, + 12966, 1, 0, 0, 0, 12965, 12967, 3, 1676, 838, 0, 12966, 12965, 1, 0, 0, + 0, 12966, 12967, 1, 0, 0, 0, 12967, 1675, 1, 0, 0, 0, 12968, 12969, 5, + 2, 0, 0, 12969, 12970, 3, 1830, 915, 0, 12970, 12971, 5, 3, 0, 0, 12971, + 1677, 1, 0, 0, 0, 12972, 12997, 5, 563, 0, 0, 12973, 12997, 5, 564, 0, + 0, 12974, 12997, 5, 579, 0, 0, 12975, 12997, 5, 550, 0, 0, 12976, 12997, + 5, 576, 0, 0, 12977, 12979, 5, 560, 0, 0, 12978, 12980, 3, 1680, 840, 0, + 12979, 12978, 1, 0, 0, 0, 12979, 12980, 1, 0, 0, 0, 12980, 12997, 1, 0, + 0, 0, 12981, 12982, 5, 194, 0, 0, 12982, 12997, 5, 575, 0, 0, 12983, 12985, + 5, 557, 0, 0, 12984, 12986, 3, 1676, 838, 0, 12985, 12984, 1, 0, 0, 0, + 12985, 12986, 1, 0, 0, 0, 12986, 12997, 1, 0, 0, 0, 12987, 12989, 5, 556, + 0, 0, 12988, 12990, 3, 1676, 838, 0, 12989, 12988, 1, 0, 0, 0, 12989, 12990, + 1, 0, 0, 0, 12990, 12997, 1, 0, 0, 0, 12991, 12993, 5, 571, 0, 0, 12992, + 12994, 3, 1676, 838, 0, 12993, 12992, 1, 0, 0, 0, 12993, 12994, 1, 0, 0, + 0, 12994, 12997, 1, 0, 0, 0, 12995, 12997, 5, 552, 0, 0, 12996, 12972, + 1, 0, 0, 0, 12996, 12973, 1, 0, 0, 0, 12996, 12974, 1, 0, 0, 0, 12996, + 12975, 1, 0, 0, 0, 12996, 12976, 1, 0, 0, 0, 12996, 12977, 1, 0, 0, 0, + 12996, 12981, 1, 0, 0, 0, 12996, 12983, 1, 0, 0, 0, 12996, 12987, 1, 0, + 0, 0, 12996, 12991, 1, 0, 0, 0, 12996, 12995, 1, 0, 0, 0, 12997, 1679, + 1, 0, 0, 0, 12998, 12999, 5, 2, 0, 0, 12999, 13000, 3, 1908, 954, 0, 13000, + 13001, 5, 3, 0, 0, 13001, 1681, 1, 0, 0, 0, 13002, 13005, 3, 1686, 843, + 0, 13003, 13005, 3, 1688, 844, 0, 13004, 13002, 1, 0, 0, 0, 13004, 13003, + 1, 0, 0, 0, 13005, 1683, 1, 0, 0, 0, 13006, 13009, 3, 1686, 843, 0, 13007, + 13009, 3, 1688, 844, 0, 13008, 13006, 1, 0, 0, 0, 13008, 13007, 1, 0, 0, + 0, 13009, 1685, 1, 0, 0, 0, 13010, 13012, 5, 551, 0, 0, 13011, 13013, 3, + 1696, 848, 0, 13012, 13011, 1, 0, 0, 0, 13012, 13013, 1, 0, 0, 0, 13013, + 13014, 1, 0, 0, 0, 13014, 13015, 5, 2, 0, 0, 13015, 13016, 3, 1830, 915, + 0, 13016, 13017, 5, 3, 0, 0, 13017, 1687, 1, 0, 0, 0, 13018, 13020, 5, + 551, 0, 0, 13019, 13021, 3, 1696, 848, 0, 13020, 13019, 1, 0, 0, 0, 13020, + 13021, 1, 0, 0, 0, 13021, 1689, 1, 0, 0, 0, 13022, 13030, 3, 1694, 847, + 0, 13023, 13026, 5, 2, 0, 0, 13024, 13027, 3, 1908, 954, 0, 13025, 13027, + 3, 1924, 962, 0, 13026, 13024, 1, 0, 0, 0, 13026, 13025, 1, 0, 0, 0, 13027, + 13028, 1, 0, 0, 0, 13028, 13029, 5, 3, 0, 0, 13029, 13031, 1, 0, 0, 0, + 13030, 13023, 1, 0, 0, 0, 13030, 13031, 1, 0, 0, 0, 13031, 1691, 1, 0, + 0, 0, 13032, 13040, 3, 1694, 847, 0, 13033, 13036, 5, 2, 0, 0, 13034, 13037, + 3, 1908, 954, 0, 13035, 13037, 3, 1924, 962, 0, 13036, 13034, 1, 0, 0, + 0, 13036, 13035, 1, 0, 0, 0, 13037, 13038, 1, 0, 0, 0, 13038, 13039, 5, + 3, 0, 0, 13039, 13041, 1, 0, 0, 0, 13040, 13033, 1, 0, 0, 0, 13040, 13041, + 1, 0, 0, 0, 13041, 1693, 1, 0, 0, 0, 13042, 13044, 7, 84, 0, 0, 13043, + 13045, 3, 1696, 848, 0, 13044, 13043, 1, 0, 0, 0, 13044, 13045, 1, 0, 0, + 0, 13045, 13053, 1, 0, 0, 0, 13046, 13053, 5, 586, 0, 0, 13047, 13048, + 5, 567, 0, 0, 13048, 13050, 7, 85, 0, 0, 13049, 13051, 3, 1696, 848, 0, + 13050, 13049, 1, 0, 0, 0, 13050, 13051, 1, 0, 0, 0, 13051, 13053, 1, 0, + 0, 0, 13052, 13042, 1, 0, 0, 0, 13052, 13046, 1, 0, 0, 0, 13052, 13047, + 1, 0, 0, 0, 13053, 1695, 1, 0, 0, 0, 13054, 13055, 5, 372, 0, 0, 13055, + 1697, 1, 0, 0, 0, 13056, 13061, 7, 86, 0, 0, 13057, 13058, 5, 2, 0, 0, + 13058, 13059, 3, 1908, 954, 0, 13059, 13060, 5, 3, 0, 0, 13060, 13062, + 1, 0, 0, 0, 13061, 13057, 1, 0, 0, 0, 13061, 13062, 1, 0, 0, 0, 13062, + 13064, 1, 0, 0, 0, 13063, 13065, 3, 1702, 851, 0, 13064, 13063, 1, 0, 0, + 0, 13064, 13065, 1, 0, 0, 0, 13065, 1699, 1, 0, 0, 0, 13066, 13067, 5, + 565, 0, 0, 13067, 1701, 1, 0, 0, 0, 13068, 13069, 5, 106, 0, 0, 13069, + 13070, 5, 581, 0, 0, 13070, 13075, 5, 384, 0, 0, 13071, 13072, 5, 377, + 0, 0, 13072, 13073, 5, 581, 0, 0, 13073, 13075, 5, 384, 0, 0, 13074, 13068, + 1, 0, 0, 0, 13074, 13071, 1, 0, 0, 0, 13075, 1703, 1, 0, 0, 0, 13076, 13102, + 5, 382, 0, 0, 13077, 13102, 5, 261, 0, 0, 13078, 13102, 5, 180, 0, 0, 13079, + 13102, 5, 222, 0, 0, 13080, 13102, 5, 258, 0, 0, 13081, 13102, 3, 1706, + 853, 0, 13082, 13083, 5, 382, 0, 0, 13083, 13084, 5, 95, 0, 0, 13084, 13102, + 5, 261, 0, 0, 13085, 13086, 5, 180, 0, 0, 13086, 13090, 5, 95, 0, 0, 13087, + 13091, 5, 222, 0, 0, 13088, 13091, 5, 258, 0, 0, 13089, 13091, 3, 1706, + 853, 0, 13090, 13087, 1, 0, 0, 0, 13090, 13088, 1, 0, 0, 0, 13090, 13089, + 1, 0, 0, 0, 13091, 13102, 1, 0, 0, 0, 13092, 13093, 5, 222, 0, 0, 13093, + 13096, 5, 95, 0, 0, 13094, 13097, 5, 258, 0, 0, 13095, 13097, 3, 1706, + 853, 0, 13096, 13094, 1, 0, 0, 0, 13096, 13095, 1, 0, 0, 0, 13097, 13102, + 1, 0, 0, 0, 13098, 13099, 5, 258, 0, 0, 13099, 13100, 5, 95, 0, 0, 13100, + 13102, 3, 1706, 853, 0, 13101, 13076, 1, 0, 0, 0, 13101, 13077, 1, 0, 0, + 0, 13101, 13078, 1, 0, 0, 0, 13101, 13079, 1, 0, 0, 0, 13101, 13080, 1, + 0, 0, 0, 13101, 13081, 1, 0, 0, 0, 13101, 13082, 1, 0, 0, 0, 13101, 13085, + 1, 0, 0, 0, 13101, 13092, 1, 0, 0, 0, 13101, 13098, 1, 0, 0, 0, 13102, + 1705, 1, 0, 0, 0, 13103, 13108, 5, 324, 0, 0, 13104, 13105, 5, 2, 0, 0, + 13105, 13106, 3, 1908, 954, 0, 13106, 13107, 5, 3, 0, 0, 13107, 13109, + 1, 0, 0, 0, 13108, 13104, 1, 0, 0, 0, 13108, 13109, 1, 0, 0, 0, 13109, + 1707, 1, 0, 0, 0, 13110, 13111, 5, 201, 0, 0, 13111, 13112, 3, 1710, 855, + 0, 13112, 1709, 1, 0, 0, 0, 13113, 13114, 3, 1712, 856, 0, 13114, 1711, + 1, 0, 0, 0, 13115, 13117, 3, 1714, 857, 0, 13116, 13118, 3, 1824, 912, + 0, 13117, 13116, 1, 0, 0, 0, 13117, 13118, 1, 0, 0, 0, 13118, 1713, 1, + 0, 0, 0, 13119, 13124, 3, 1716, 858, 0, 13120, 13121, 7, 87, 0, 0, 13121, + 13123, 3, 1716, 858, 0, 13122, 13120, 1, 0, 0, 0, 13123, 13126, 1, 0, 0, + 0, 13124, 13122, 1, 0, 0, 0, 13124, 13125, 1, 0, 0, 0, 13125, 1715, 1, + 0, 0, 0, 13126, 13124, 1, 0, 0, 0, 13127, 13132, 3, 1718, 859, 0, 13128, + 13129, 5, 82, 0, 0, 13129, 13131, 3, 1718, 859, 0, 13130, 13128, 1, 0, + 0, 0, 13131, 13134, 1, 0, 0, 0, 13132, 13130, 1, 0, 0, 0, 13132, 13133, + 1, 0, 0, 0, 13133, 1717, 1, 0, 0, 0, 13134, 13132, 1, 0, 0, 0, 13135, 13140, + 3, 1720, 860, 0, 13136, 13137, 5, 33, 0, 0, 13137, 13139, 3, 1720, 860, + 0, 13138, 13136, 1, 0, 0, 0, 13139, 13142, 1, 0, 0, 0, 13140, 13138, 1, + 0, 0, 0, 13140, 13141, 1, 0, 0, 0, 13141, 1719, 1, 0, 0, 0, 13142, 13140, + 1, 0, 0, 0, 13143, 13155, 3, 1722, 861, 0, 13144, 13146, 5, 77, 0, 0, 13145, + 13144, 1, 0, 0, 0, 13145, 13146, 1, 0, 0, 0, 13146, 13147, 1, 0, 0, 0, + 13147, 13149, 5, 549, 0, 0, 13148, 13150, 5, 92, 0, 0, 13149, 13148, 1, + 0, 0, 0, 13149, 13150, 1, 0, 0, 0, 13150, 13151, 1, 0, 0, 0, 13151, 13152, + 3, 1722, 861, 0, 13152, 13153, 5, 33, 0, 0, 13153, 13154, 3, 1722, 861, + 0, 13154, 13156, 1, 0, 0, 0, 13155, 13145, 1, 0, 0, 0, 13155, 13156, 1, + 0, 0, 0, 13156, 1721, 1, 0, 0, 0, 13157, 13163, 3, 1724, 862, 0, 13158, + 13160, 5, 77, 0, 0, 13159, 13158, 1, 0, 0, 0, 13159, 13160, 1, 0, 0, 0, + 13160, 13161, 1, 0, 0, 0, 13161, 13162, 5, 68, 0, 0, 13162, 13164, 3, 1856, + 928, 0, 13163, 13159, 1, 0, 0, 0, 13163, 13164, 1, 0, 0, 0, 13164, 1723, + 1, 0, 0, 0, 13165, 13167, 5, 77, 0, 0, 13166, 13165, 1, 0, 0, 0, 13166, + 13167, 1, 0, 0, 0, 13167, 13168, 1, 0, 0, 0, 13168, 13169, 3, 1726, 863, + 0, 13169, 1725, 1, 0, 0, 0, 13170, 13172, 3, 1728, 864, 0, 13171, 13173, + 7, 88, 0, 0, 13172, 13171, 1, 0, 0, 0, 13172, 13173, 1, 0, 0, 0, 13173, + 1727, 1, 0, 0, 0, 13174, 13198, 3, 1730, 865, 0, 13175, 13177, 5, 118, + 0, 0, 13176, 13178, 5, 77, 0, 0, 13177, 13176, 1, 0, 0, 0, 13177, 13178, + 1, 0, 0, 0, 13178, 13196, 1, 0, 0, 0, 13179, 13197, 5, 78, 0, 0, 13180, + 13197, 5, 97, 0, 0, 13181, 13197, 5, 60, 0, 0, 13182, 13197, 5, 363, 0, + 0, 13183, 13184, 5, 56, 0, 0, 13184, 13185, 5, 64, 0, 0, 13185, 13197, + 3, 1710, 855, 0, 13186, 13187, 5, 272, 0, 0, 13187, 13188, 5, 2, 0, 0, + 13188, 13189, 3, 1836, 918, 0, 13189, 13190, 5, 3, 0, 0, 13190, 13197, + 1, 0, 0, 0, 13191, 13197, 5, 192, 0, 0, 13192, 13194, 3, 1846, 923, 0, + 13193, 13192, 1, 0, 0, 0, 13193, 13194, 1, 0, 0, 0, 13194, 13195, 1, 0, + 0, 0, 13195, 13197, 5, 677, 0, 0, 13196, 13179, 1, 0, 0, 0, 13196, 13180, + 1, 0, 0, 0, 13196, 13181, 1, 0, 0, 0, 13196, 13182, 1, 0, 0, 0, 13196, + 13183, 1, 0, 0, 0, 13196, 13186, 1, 0, 0, 0, 13196, 13191, 1, 0, 0, 0, + 13196, 13193, 1, 0, 0, 0, 13197, 13199, 1, 0, 0, 0, 13198, 13175, 1, 0, + 0, 0, 13198, 13199, 1, 0, 0, 0, 13199, 1729, 1, 0, 0, 0, 13200, 13212, + 3, 1732, 866, 0, 13201, 13202, 7, 89, 0, 0, 13202, 13213, 3, 1732, 866, + 0, 13203, 13204, 3, 1828, 914, 0, 13204, 13210, 3, 1818, 909, 0, 13205, + 13211, 3, 1498, 749, 0, 13206, 13207, 5, 2, 0, 0, 13207, 13208, 3, 1710, + 855, 0, 13208, 13209, 5, 3, 0, 0, 13209, 13211, 1, 0, 0, 0, 13210, 13205, + 1, 0, 0, 0, 13210, 13206, 1, 0, 0, 0, 13211, 13213, 1, 0, 0, 0, 13212, + 13201, 1, 0, 0, 0, 13212, 13203, 1, 0, 0, 0, 13212, 13213, 1, 0, 0, 0, + 13213, 1731, 1, 0, 0, 0, 13214, 13216, 7, 90, 0, 0, 13215, 13214, 1, 0, + 0, 0, 13215, 13216, 1, 0, 0, 0, 13216, 13217, 1, 0, 0, 0, 13217, 13218, + 3, 1734, 867, 0, 13218, 1733, 1, 0, 0, 0, 13219, 13233, 3, 1736, 868, 0, + 13220, 13222, 5, 77, 0, 0, 13221, 13220, 1, 0, 0, 0, 13221, 13222, 1, 0, + 0, 0, 13222, 13227, 1, 0, 0, 0, 13223, 13228, 5, 122, 0, 0, 13224, 13228, + 5, 116, 0, 0, 13225, 13226, 5, 129, 0, 0, 13226, 13228, 5, 95, 0, 0, 13227, + 13223, 1, 0, 0, 0, 13227, 13224, 1, 0, 0, 0, 13227, 13225, 1, 0, 0, 0, + 13228, 13229, 1, 0, 0, 0, 13229, 13231, 3, 1736, 868, 0, 13230, 13232, + 3, 1708, 854, 0, 13231, 13230, 1, 0, 0, 0, 13231, 13232, 1, 0, 0, 0, 13232, + 13234, 1, 0, 0, 0, 13233, 13221, 1, 0, 0, 0, 13233, 13234, 1, 0, 0, 0, + 13234, 1735, 1, 0, 0, 0, 13235, 13241, 3, 1738, 869, 0, 13236, 13237, 3, + 1824, 912, 0, 13237, 13238, 3, 1738, 869, 0, 13238, 13240, 1, 0, 0, 0, + 13239, 13236, 1, 0, 0, 0, 13240, 13243, 1, 0, 0, 0, 13241, 13239, 1, 0, + 0, 0, 13241, 13242, 1, 0, 0, 0, 13242, 1737, 1, 0, 0, 0, 13243, 13241, + 1, 0, 0, 0, 13244, 13246, 3, 1824, 912, 0, 13245, 13244, 1, 0, 0, 0, 13245, + 13246, 1, 0, 0, 0, 13246, 13247, 1, 0, 0, 0, 13247, 13248, 3, 1740, 870, + 0, 13248, 1739, 1, 0, 0, 0, 13249, 13254, 3, 1742, 871, 0, 13250, 13251, + 7, 91, 0, 0, 13251, 13253, 3, 1742, 871, 0, 13252, 13250, 1, 0, 0, 0, 13253, + 13256, 1, 0, 0, 0, 13254, 13252, 1, 0, 0, 0, 13254, 13255, 1, 0, 0, 0, + 13255, 1741, 1, 0, 0, 0, 13256, 13254, 1, 0, 0, 0, 13257, 13262, 3, 1744, + 872, 0, 13258, 13259, 7, 92, 0, 0, 13259, 13261, 3, 1744, 872, 0, 13260, + 13258, 1, 0, 0, 0, 13261, 13264, 1, 0, 0, 0, 13262, 13260, 1, 0, 0, 0, + 13262, 13263, 1, 0, 0, 0, 13263, 1743, 1, 0, 0, 0, 13264, 13262, 1, 0, + 0, 0, 13265, 13268, 3, 1746, 873, 0, 13266, 13267, 5, 15, 0, 0, 13267, + 13269, 3, 1710, 855, 0, 13268, 13266, 1, 0, 0, 0, 13268, 13269, 1, 0, 0, + 0, 13269, 1745, 1, 0, 0, 0, 13270, 13272, 7, 91, 0, 0, 13271, 13270, 1, + 0, 0, 0, 13271, 13272, 1, 0, 0, 0, 13272, 13273, 1, 0, 0, 0, 13273, 13274, + 3, 1748, 874, 0, 13274, 1747, 1, 0, 0, 0, 13275, 13280, 3, 1750, 875, 0, + 13276, 13277, 5, 144, 0, 0, 13277, 13278, 5, 581, 0, 0, 13278, 13279, 5, + 384, 0, 0, 13279, 13281, 3, 1710, 855, 0, 13280, 13276, 1, 0, 0, 0, 13280, + 13281, 1, 0, 0, 0, 13281, 1749, 1, 0, 0, 0, 13282, 13285, 3, 1752, 876, + 0, 13283, 13284, 5, 43, 0, 0, 13284, 13286, 3, 566, 283, 0, 13285, 13283, + 1, 0, 0, 0, 13285, 13286, 1, 0, 0, 0, 13286, 1751, 1, 0, 0, 0, 13287, 13292, + 3, 1756, 878, 0, 13288, 13289, 5, 26, 0, 0, 13289, 13291, 3, 1662, 831, + 0, 13290, 13288, 1, 0, 0, 0, 13291, 13294, 1, 0, 0, 0, 13292, 13290, 1, + 0, 0, 0, 13292, 13293, 1, 0, 0, 0, 13293, 1753, 1, 0, 0, 0, 13294, 13292, + 1, 0, 0, 0, 13295, 13296, 6, 877, -1, 0, 13296, 13303, 3, 1756, 878, 0, + 13297, 13298, 7, 91, 0, 0, 13298, 13303, 3, 1754, 877, 9, 13299, 13300, + 3, 1824, 912, 0, 13300, 13301, 3, 1754, 877, 3, 13301, 13303, 1, 0, 0, + 0, 13302, 13295, 1, 0, 0, 0, 13302, 13297, 1, 0, 0, 0, 13302, 13299, 1, + 0, 0, 0, 13303, 13343, 1, 0, 0, 0, 13304, 13305, 10, 8, 0, 0, 13305, 13306, + 5, 15, 0, 0, 13306, 13342, 3, 1754, 877, 9, 13307, 13308, 10, 7, 0, 0, + 13308, 13309, 7, 92, 0, 0, 13309, 13342, 3, 1754, 877, 8, 13310, 13311, + 10, 6, 0, 0, 13311, 13312, 7, 91, 0, 0, 13312, 13342, 3, 1754, 877, 7, + 13313, 13314, 10, 5, 0, 0, 13314, 13315, 3, 1824, 912, 0, 13315, 13316, + 3, 1754, 877, 6, 13316, 13342, 1, 0, 0, 0, 13317, 13318, 10, 4, 0, 0, 13318, + 13319, 7, 89, 0, 0, 13319, 13342, 3, 1754, 877, 5, 13320, 13321, 10, 10, + 0, 0, 13321, 13322, 5, 26, 0, 0, 13322, 13342, 3, 1662, 831, 0, 13323, + 13324, 10, 2, 0, 0, 13324, 13342, 3, 1824, 912, 0, 13325, 13326, 10, 1, + 0, 0, 13326, 13328, 5, 118, 0, 0, 13327, 13329, 5, 77, 0, 0, 13328, 13327, + 1, 0, 0, 0, 13328, 13329, 1, 0, 0, 0, 13329, 13339, 1, 0, 0, 0, 13330, + 13331, 5, 56, 0, 0, 13331, 13332, 5, 64, 0, 0, 13332, 13340, 3, 1754, 877, + 0, 13333, 13334, 5, 272, 0, 0, 13334, 13335, 5, 2, 0, 0, 13335, 13336, + 3, 1836, 918, 0, 13336, 13337, 5, 3, 0, 0, 13337, 13340, 1, 0, 0, 0, 13338, + 13340, 5, 192, 0, 0, 13339, 13330, 1, 0, 0, 0, 13339, 13333, 1, 0, 0, 0, + 13339, 13338, 1, 0, 0, 0, 13340, 13342, 1, 0, 0, 0, 13341, 13304, 1, 0, + 0, 0, 13341, 13307, 1, 0, 0, 0, 13341, 13310, 1, 0, 0, 0, 13341, 13313, + 1, 0, 0, 0, 13341, 13317, 1, 0, 0, 0, 13341, 13320, 1, 0, 0, 0, 13341, + 13323, 1, 0, 0, 0, 13341, 13325, 1, 0, 0, 0, 13342, 13345, 1, 0, 0, 0, + 13343, 13341, 1, 0, 0, 0, 13343, 13344, 1, 0, 0, 0, 13344, 1755, 1, 0, + 0, 0, 13345, 13343, 1, 0, 0, 0, 13346, 13347, 5, 558, 0, 0, 13347, 13383, + 3, 1498, 749, 0, 13348, 13351, 5, 35, 0, 0, 13349, 13352, 3, 1498, 749, + 0, 13350, 13352, 3, 1838, 919, 0, 13351, 13349, 1, 0, 0, 0, 13351, 13350, + 1, 0, 0, 0, 13352, 13383, 1, 0, 0, 0, 13353, 13354, 5, 28, 0, 0, 13354, + 13383, 3, 1876, 938, 0, 13355, 13356, 5, 669, 0, 0, 13356, 13357, 5, 2, + 0, 0, 13357, 13358, 3, 1830, 915, 0, 13358, 13359, 5, 3, 0, 0, 13359, 13383, + 1, 0, 0, 0, 13360, 13361, 5, 99, 0, 0, 13361, 13383, 3, 1498, 749, 0, 13362, + 13383, 3, 1868, 934, 0, 13363, 13383, 3, 1900, 950, 0, 13364, 13383, 3, + 1758, 879, 0, 13365, 13366, 5, 2, 0, 0, 13366, 13367, 3, 1710, 855, 0, + 13367, 13368, 5, 3, 0, 0, 13368, 13369, 3, 1876, 938, 0, 13369, 13383, + 1, 0, 0, 0, 13370, 13383, 3, 1858, 929, 0, 13371, 13383, 3, 1762, 881, + 0, 13372, 13374, 3, 1498, 749, 0, 13373, 13375, 3, 1874, 937, 0, 13374, + 13373, 1, 0, 0, 0, 13374, 13375, 1, 0, 0, 0, 13375, 13383, 1, 0, 0, 0, + 13376, 13383, 3, 1814, 907, 0, 13377, 13383, 3, 1816, 908, 0, 13378, 13379, + 3, 1812, 906, 0, 13379, 13380, 5, 127, 0, 0, 13380, 13381, 3, 1812, 906, + 0, 13381, 13383, 1, 0, 0, 0, 13382, 13346, 1, 0, 0, 0, 13382, 13348, 1, + 0, 0, 0, 13382, 13353, 1, 0, 0, 0, 13382, 13355, 1, 0, 0, 0, 13382, 13360, + 1, 0, 0, 0, 13382, 13362, 1, 0, 0, 0, 13382, 13363, 1, 0, 0, 0, 13382, + 13364, 1, 0, 0, 0, 13382, 13365, 1, 0, 0, 0, 13382, 13370, 1, 0, 0, 0, + 13382, 13371, 1, 0, 0, 0, 13382, 13372, 1, 0, 0, 0, 13382, 13376, 1, 0, + 0, 0, 13382, 13377, 1, 0, 0, 0, 13382, 13378, 1, 0, 0, 0, 13383, 1757, + 1, 0, 0, 0, 13384, 13385, 5, 878, 0, 0, 13385, 1759, 1, 0, 0, 0, 13386, + 13387, 3, 1898, 949, 0, 13387, 13409, 5, 2, 0, 0, 13388, 13392, 3, 1832, + 916, 0, 13389, 13390, 5, 6, 0, 0, 13390, 13391, 5, 102, 0, 0, 13391, 13393, + 3, 1834, 917, 0, 13392, 13389, 1, 0, 0, 0, 13392, 13393, 1, 0, 0, 0, 13393, + 13395, 1, 0, 0, 0, 13394, 13396, 3, 1540, 770, 0, 13395, 13394, 1, 0, 0, + 0, 13395, 13396, 1, 0, 0, 0, 13396, 13410, 1, 0, 0, 0, 13397, 13398, 5, + 102, 0, 0, 13398, 13400, 3, 1834, 917, 0, 13399, 13401, 3, 1540, 770, 0, + 13400, 13399, 1, 0, 0, 0, 13400, 13401, 1, 0, 0, 0, 13401, 13410, 1, 0, + 0, 0, 13402, 13403, 7, 79, 0, 0, 13403, 13405, 3, 1832, 916, 0, 13404, + 13406, 3, 1540, 770, 0, 13405, 13404, 1, 0, 0, 0, 13405, 13406, 1, 0, 0, + 0, 13406, 13410, 1, 0, 0, 0, 13407, 13410, 5, 9, 0, 0, 13408, 13410, 1, + 0, 0, 0, 13409, 13388, 1, 0, 0, 0, 13409, 13397, 1, 0, 0, 0, 13409, 13402, + 1, 0, 0, 0, 13409, 13407, 1, 0, 0, 0, 13409, 13408, 1, 0, 0, 0, 13410, + 13411, 1, 0, 0, 0, 13411, 13412, 5, 3, 0, 0, 13412, 1761, 1, 0, 0, 0, 13413, + 13415, 3, 1760, 880, 0, 13414, 13416, 3, 1786, 893, 0, 13415, 13414, 1, + 0, 0, 0, 13415, 13416, 1, 0, 0, 0, 13416, 13418, 1, 0, 0, 0, 13417, 13419, + 3, 1788, 894, 0, 13418, 13417, 1, 0, 0, 0, 13418, 13419, 1, 0, 0, 0, 13419, + 13421, 1, 0, 0, 0, 13420, 13422, 3, 1796, 898, 0, 13421, 13420, 1, 0, 0, + 0, 13421, 13422, 1, 0, 0, 0, 13422, 13425, 1, 0, 0, 0, 13423, 13425, 3, + 1766, 883, 0, 13424, 13413, 1, 0, 0, 0, 13424, 13423, 1, 0, 0, 0, 13425, + 1763, 1, 0, 0, 0, 13426, 13429, 3, 1760, 880, 0, 13427, 13429, 3, 1766, + 883, 0, 13428, 13426, 1, 0, 0, 0, 13428, 13427, 1, 0, 0, 0, 13429, 1765, + 1, 0, 0, 0, 13430, 13431, 5, 110, 0, 0, 13431, 13432, 5, 62, 0, 0, 13432, + 13433, 5, 2, 0, 0, 13433, 13434, 3, 1710, 855, 0, 13434, 13435, 5, 3, 0, + 0, 13435, 13614, 1, 0, 0, 0, 13436, 13614, 5, 48, 0, 0, 13437, 13442, 5, + 50, 0, 0, 13438, 13439, 5, 2, 0, 0, 13439, 13440, 3, 1908, 954, 0, 13440, + 13441, 5, 3, 0, 0, 13441, 13443, 1, 0, 0, 0, 13442, 13438, 1, 0, 0, 0, + 13442, 13443, 1, 0, 0, 0, 13443, 13614, 1, 0, 0, 0, 13444, 13449, 5, 51, + 0, 0, 13445, 13446, 5, 2, 0, 0, 13446, 13447, 3, 1908, 954, 0, 13447, 13448, + 5, 3, 0, 0, 13448, 13450, 1, 0, 0, 0, 13449, 13445, 1, 0, 0, 0, 13449, + 13450, 1, 0, 0, 0, 13450, 13614, 1, 0, 0, 0, 13451, 13456, 5, 75, 0, 0, + 13452, 13453, 5, 2, 0, 0, 13453, 13454, 3, 1908, 954, 0, 13454, 13455, + 5, 3, 0, 0, 13455, 13457, 1, 0, 0, 0, 13456, 13452, 1, 0, 0, 0, 13456, + 13457, 1, 0, 0, 0, 13457, 13614, 1, 0, 0, 0, 13458, 13463, 5, 76, 0, 0, + 13459, 13460, 5, 2, 0, 0, 13460, 13461, 3, 1908, 954, 0, 13461, 13462, + 5, 3, 0, 0, 13462, 13464, 1, 0, 0, 0, 13463, 13459, 1, 0, 0, 0, 13463, + 13464, 1, 0, 0, 0, 13464, 13614, 1, 0, 0, 0, 13465, 13614, 5, 49, 0, 0, + 13466, 13614, 5, 52, 0, 0, 13467, 13614, 5, 90, 0, 0, 13468, 13614, 5, + 100, 0, 0, 13469, 13614, 5, 47, 0, 0, 13470, 13614, 5, 113, 0, 0, 13471, + 13472, 5, 41, 0, 0, 13472, 13473, 5, 2, 0, 0, 13473, 13474, 3, 1710, 855, + 0, 13474, 13475, 5, 36, 0, 0, 13475, 13476, 3, 1662, 831, 0, 13476, 13477, + 5, 3, 0, 0, 13477, 13614, 1, 0, 0, 0, 13478, 13479, 5, 559, 0, 0, 13479, + 13481, 5, 2, 0, 0, 13480, 13482, 3, 1842, 921, 0, 13481, 13480, 1, 0, 0, + 0, 13481, 13482, 1, 0, 0, 0, 13482, 13483, 1, 0, 0, 0, 13483, 13614, 5, + 3, 0, 0, 13484, 13485, 5, 688, 0, 0, 13485, 13486, 5, 2, 0, 0, 13486, 13489, + 3, 1710, 855, 0, 13487, 13488, 5, 6, 0, 0, 13488, 13490, 3, 1846, 923, + 0, 13489, 13487, 1, 0, 0, 0, 13489, 13490, 1, 0, 0, 0, 13490, 13491, 1, + 0, 0, 0, 13491, 13492, 5, 3, 0, 0, 13492, 13614, 1, 0, 0, 0, 13493, 13494, + 5, 572, 0, 0, 13494, 13495, 5, 2, 0, 0, 13495, 13496, 3, 1848, 924, 0, + 13496, 13497, 5, 3, 0, 0, 13497, 13614, 1, 0, 0, 0, 13498, 13499, 5, 574, + 0, 0, 13499, 13501, 5, 2, 0, 0, 13500, 13502, 3, 1850, 925, 0, 13501, 13500, + 1, 0, 0, 0, 13501, 13502, 1, 0, 0, 0, 13502, 13503, 1, 0, 0, 0, 13503, + 13614, 5, 3, 0, 0, 13504, 13505, 5, 580, 0, 0, 13505, 13506, 5, 2, 0, 0, + 13506, 13507, 3, 1852, 926, 0, 13507, 13508, 5, 3, 0, 0, 13508, 13614, + 1, 0, 0, 0, 13509, 13510, 5, 583, 0, 0, 13510, 13511, 5, 2, 0, 0, 13511, + 13512, 3, 1710, 855, 0, 13512, 13513, 5, 36, 0, 0, 13513, 13514, 3, 1662, + 831, 0, 13514, 13515, 5, 3, 0, 0, 13515, 13614, 1, 0, 0, 0, 13516, 13517, + 5, 584, 0, 0, 13517, 13519, 5, 2, 0, 0, 13518, 13520, 7, 93, 0, 0, 13519, + 13518, 1, 0, 0, 0, 13519, 13520, 1, 0, 0, 0, 13520, 13521, 1, 0, 0, 0, + 13521, 13522, 3, 1854, 927, 0, 13522, 13523, 5, 3, 0, 0, 13523, 13614, + 1, 0, 0, 0, 13524, 13525, 5, 570, 0, 0, 13525, 13526, 5, 2, 0, 0, 13526, + 13527, 3, 1710, 855, 0, 13527, 13528, 5, 6, 0, 0, 13528, 13529, 3, 1710, + 855, 0, 13529, 13530, 5, 3, 0, 0, 13530, 13614, 1, 0, 0, 0, 13531, 13532, + 5, 555, 0, 0, 13532, 13533, 5, 2, 0, 0, 13533, 13534, 3, 1830, 915, 0, + 13534, 13535, 5, 3, 0, 0, 13535, 13614, 1, 0, 0, 0, 13536, 13537, 5, 561, + 0, 0, 13537, 13538, 5, 2, 0, 0, 13538, 13539, 3, 1830, 915, 0, 13539, 13540, + 5, 3, 0, 0, 13540, 13614, 1, 0, 0, 0, 13541, 13542, 5, 566, 0, 0, 13542, + 13543, 5, 2, 0, 0, 13543, 13544, 3, 1830, 915, 0, 13544, 13545, 5, 3, 0, + 0, 13545, 13614, 1, 0, 0, 0, 13546, 13547, 5, 595, 0, 0, 13547, 13548, + 5, 2, 0, 0, 13548, 13549, 3, 1830, 915, 0, 13549, 13550, 5, 3, 0, 0, 13550, + 13614, 1, 0, 0, 0, 13551, 13552, 5, 596, 0, 0, 13552, 13553, 5, 2, 0, 0, + 13553, 13554, 5, 263, 0, 0, 13554, 13560, 3, 1932, 966, 0, 13555, 13558, + 5, 6, 0, 0, 13556, 13559, 3, 1772, 886, 0, 13557, 13559, 3, 1830, 915, + 0, 13558, 13556, 1, 0, 0, 0, 13558, 13557, 1, 0, 0, 0, 13559, 13561, 1, + 0, 0, 0, 13560, 13555, 1, 0, 0, 0, 13560, 13561, 1, 0, 0, 0, 13561, 13562, + 1, 0, 0, 0, 13562, 13563, 5, 3, 0, 0, 13563, 13614, 1, 0, 0, 0, 13564, + 13565, 5, 597, 0, 0, 13565, 13566, 5, 2, 0, 0, 13566, 13567, 3, 1756, 878, + 0, 13567, 13568, 3, 1782, 891, 0, 13568, 13569, 5, 3, 0, 0, 13569, 13614, + 1, 0, 0, 0, 13570, 13571, 5, 598, 0, 0, 13571, 13572, 5, 2, 0, 0, 13572, + 13573, 3, 1774, 887, 0, 13573, 13574, 5, 3, 0, 0, 13574, 13614, 1, 0, 0, + 0, 13575, 13576, 5, 599, 0, 0, 13576, 13577, 5, 2, 0, 0, 13577, 13578, + 3, 1778, 889, 0, 13578, 13580, 3, 1710, 855, 0, 13579, 13581, 3, 1780, + 890, 0, 13580, 13579, 1, 0, 0, 0, 13580, 13581, 1, 0, 0, 0, 13581, 13582, + 1, 0, 0, 0, 13582, 13583, 5, 3, 0, 0, 13583, 13614, 1, 0, 0, 0, 13584, + 13585, 5, 600, 0, 0, 13585, 13586, 5, 2, 0, 0, 13586, 13587, 5, 263, 0, + 0, 13587, 13590, 3, 1932, 966, 0, 13588, 13589, 5, 6, 0, 0, 13589, 13591, + 3, 1710, 855, 0, 13590, 13588, 1, 0, 0, 0, 13590, 13591, 1, 0, 0, 0, 13591, + 13592, 1, 0, 0, 0, 13592, 13593, 5, 3, 0, 0, 13593, 13614, 1, 0, 0, 0, + 13594, 13595, 5, 601, 0, 0, 13595, 13596, 5, 2, 0, 0, 13596, 13597, 5, + 381, 0, 0, 13597, 13598, 3, 1710, 855, 0, 13598, 13599, 5, 6, 0, 0, 13599, + 13601, 3, 1768, 884, 0, 13600, 13602, 3, 1770, 885, 0, 13601, 13600, 1, + 0, 0, 0, 13601, 13602, 1, 0, 0, 0, 13602, 13603, 1, 0, 0, 0, 13603, 13604, + 5, 3, 0, 0, 13604, 13614, 1, 0, 0, 0, 13605, 13606, 5, 602, 0, 0, 13606, + 13607, 5, 2, 0, 0, 13607, 13608, 3, 1778, 889, 0, 13608, 13609, 3, 1710, + 855, 0, 13609, 13610, 5, 36, 0, 0, 13610, 13611, 3, 1666, 833, 0, 13611, + 13612, 5, 3, 0, 0, 13612, 13614, 1, 0, 0, 0, 13613, 13430, 1, 0, 0, 0, + 13613, 13436, 1, 0, 0, 0, 13613, 13437, 1, 0, 0, 0, 13613, 13444, 1, 0, + 0, 0, 13613, 13451, 1, 0, 0, 0, 13613, 13458, 1, 0, 0, 0, 13613, 13465, + 1, 0, 0, 0, 13613, 13466, 1, 0, 0, 0, 13613, 13467, 1, 0, 0, 0, 13613, + 13468, 1, 0, 0, 0, 13613, 13469, 1, 0, 0, 0, 13613, 13470, 1, 0, 0, 0, + 13613, 13471, 1, 0, 0, 0, 13613, 13478, 1, 0, 0, 0, 13613, 13484, 1, 0, + 0, 0, 13613, 13493, 1, 0, 0, 0, 13613, 13498, 1, 0, 0, 0, 13613, 13504, + 1, 0, 0, 0, 13613, 13509, 1, 0, 0, 0, 13613, 13516, 1, 0, 0, 0, 13613, + 13524, 1, 0, 0, 0, 13613, 13531, 1, 0, 0, 0, 13613, 13536, 1, 0, 0, 0, + 13613, 13541, 1, 0, 0, 0, 13613, 13546, 1, 0, 0, 0, 13613, 13551, 1, 0, + 0, 0, 13613, 13564, 1, 0, 0, 0, 13613, 13570, 1, 0, 0, 0, 13613, 13575, + 1, 0, 0, 0, 13613, 13584, 1, 0, 0, 0, 13613, 13594, 1, 0, 0, 0, 13613, + 13605, 1, 0, 0, 0, 13614, 1767, 1, 0, 0, 0, 13615, 13616, 5, 373, 0, 0, + 13616, 13621, 3, 1710, 855, 0, 13617, 13618, 5, 373, 0, 0, 13618, 13619, + 5, 266, 0, 0, 13619, 13621, 5, 649, 0, 0, 13620, 13615, 1, 0, 0, 0, 13620, + 13617, 1, 0, 0, 0, 13621, 1769, 1, 0, 0, 0, 13622, 13623, 5, 6, 0, 0, 13623, + 13624, 5, 337, 0, 0, 13624, 13633, 5, 383, 0, 0, 13625, 13626, 5, 6, 0, + 0, 13626, 13627, 5, 337, 0, 0, 13627, 13633, 5, 266, 0, 0, 13628, 13629, + 5, 6, 0, 0, 13629, 13630, 5, 337, 0, 0, 13630, 13631, 5, 266, 0, 0, 13631, + 13633, 5, 649, 0, 0, 13632, 13622, 1, 0, 0, 0, 13632, 13625, 1, 0, 0, 0, + 13632, 13628, 1, 0, 0, 0, 13633, 1771, 1, 0, 0, 0, 13634, 13635, 5, 587, + 0, 0, 13635, 13636, 5, 2, 0, 0, 13636, 13637, 3, 1774, 887, 0, 13637, 13638, + 5, 3, 0, 0, 13638, 1773, 1, 0, 0, 0, 13639, 13644, 3, 1776, 888, 0, 13640, + 13641, 5, 6, 0, 0, 13641, 13643, 3, 1776, 888, 0, 13642, 13640, 1, 0, 0, + 0, 13643, 13646, 1, 0, 0, 0, 13644, 13642, 1, 0, 0, 0, 13644, 13645, 1, + 0, 0, 0, 13645, 1775, 1, 0, 0, 0, 13646, 13644, 1, 0, 0, 0, 13647, 13650, + 3, 1710, 855, 0, 13648, 13649, 5, 36, 0, 0, 13649, 13651, 3, 1932, 966, + 0, 13650, 13648, 1, 0, 0, 0, 13650, 13651, 1, 0, 0, 0, 13651, 1777, 1, + 0, 0, 0, 13652, 13653, 7, 94, 0, 0, 13653, 1779, 1, 0, 0, 0, 13654, 13655, + 5, 290, 0, 0, 13655, 13659, 5, 376, 0, 0, 13656, 13657, 5, 345, 0, 0, 13657, + 13659, 5, 376, 0, 0, 13658, 13654, 1, 0, 0, 0, 13658, 13656, 1, 0, 0, 0, + 13659, 1781, 1, 0, 0, 0, 13660, 13661, 5, 283, 0, 0, 13661, 13676, 3, 1756, + 878, 0, 13662, 13663, 5, 283, 0, 0, 13663, 13664, 3, 1756, 878, 0, 13664, + 13665, 3, 1784, 892, 0, 13665, 13676, 1, 0, 0, 0, 13666, 13667, 5, 283, + 0, 0, 13667, 13668, 3, 1784, 892, 0, 13668, 13669, 3, 1756, 878, 0, 13669, + 13676, 1, 0, 0, 0, 13670, 13671, 5, 283, 0, 0, 13671, 13672, 3, 1784, 892, + 0, 13672, 13673, 3, 1756, 878, 0, 13673, 13674, 3, 1784, 892, 0, 13674, + 13676, 1, 0, 0, 0, 13675, 13660, 1, 0, 0, 0, 13675, 13662, 1, 0, 0, 0, + 13675, 13666, 1, 0, 0, 0, 13675, 13670, 1, 0, 0, 0, 13676, 1783, 1, 0, + 0, 0, 13677, 13678, 5, 149, 0, 0, 13678, 13679, 7, 95, 0, 0, 13679, 1785, + 1, 0, 0, 0, 13680, 13681, 5, 678, 0, 0, 13681, 13682, 5, 66, 0, 0, 13682, + 13683, 5, 2, 0, 0, 13683, 13684, 3, 1542, 771, 0, 13684, 13685, 5, 3, 0, + 0, 13685, 1787, 1, 0, 0, 0, 13686, 13687, 5, 679, 0, 0, 13687, 13688, 5, + 2, 0, 0, 13688, 13689, 5, 104, 0, 0, 13689, 13690, 3, 1710, 855, 0, 13690, + 13691, 5, 3, 0, 0, 13691, 1789, 1, 0, 0, 0, 13692, 13693, 5, 105, 0, 0, + 13693, 13694, 3, 1792, 896, 0, 13694, 1791, 1, 0, 0, 0, 13695, 13700, 3, + 1794, 897, 0, 13696, 13697, 5, 6, 0, 0, 13697, 13699, 3, 1794, 897, 0, + 13698, 13696, 1, 0, 0, 0, 13699, 13702, 1, 0, 0, 0, 13700, 13698, 1, 0, + 0, 0, 13700, 13701, 1, 0, 0, 0, 13701, 1793, 1, 0, 0, 0, 13702, 13700, + 1, 0, 0, 0, 13703, 13704, 3, 1924, 962, 0, 13704, 13705, 5, 36, 0, 0, 13705, + 13706, 3, 1798, 899, 0, 13706, 1795, 1, 0, 0, 0, 13707, 13710, 5, 126, + 0, 0, 13708, 13711, 3, 1798, 899, 0, 13709, 13711, 3, 1924, 962, 0, 13710, + 13708, 1, 0, 0, 0, 13710, 13709, 1, 0, 0, 0, 13711, 1797, 1, 0, 0, 0, 13712, + 13714, 5, 2, 0, 0, 13713, 13715, 3, 1800, 900, 0, 13714, 13713, 1, 0, 0, + 0, 13714, 13715, 1, 0, 0, 0, 13715, 13717, 1, 0, 0, 0, 13716, 13718, 3, + 1802, 901, 0, 13717, 13716, 1, 0, 0, 0, 13717, 13718, 1, 0, 0, 0, 13718, + 13720, 1, 0, 0, 0, 13719, 13721, 3, 1540, 770, 0, 13720, 13719, 1, 0, 0, + 0, 13720, 13721, 1, 0, 0, 0, 13721, 13723, 1, 0, 0, 0, 13722, 13724, 3, + 1804, 902, 0, 13723, 13722, 1, 0, 0, 0, 13723, 13724, 1, 0, 0, 0, 13724, + 13725, 1, 0, 0, 0, 13725, 13726, 5, 3, 0, 0, 13726, 1799, 1, 0, 0, 0, 13727, + 13728, 3, 1924, 962, 0, 13728, 1801, 1, 0, 0, 0, 13729, 13730, 5, 282, + 0, 0, 13730, 13731, 5, 149, 0, 0, 13731, 13732, 3, 1830, 915, 0, 13732, + 1803, 1, 0, 0, 0, 13733, 13734, 5, 297, 0, 0, 13734, 13736, 3, 1806, 903, + 0, 13735, 13737, 3, 1810, 905, 0, 13736, 13735, 1, 0, 0, 0, 13736, 13737, + 1, 0, 0, 0, 13737, 13749, 1, 0, 0, 0, 13738, 13739, 5, 318, 0, 0, 13739, + 13741, 3, 1806, 903, 0, 13740, 13742, 3, 1810, 905, 0, 13741, 13740, 1, + 0, 0, 0, 13741, 13742, 1, 0, 0, 0, 13742, 13749, 1, 0, 0, 0, 13743, 13744, + 5, 680, 0, 0, 13744, 13746, 3, 1806, 903, 0, 13745, 13747, 3, 1810, 905, + 0, 13746, 13745, 1, 0, 0, 0, 13746, 13747, 1, 0, 0, 0, 13747, 13749, 1, + 0, 0, 0, 13748, 13733, 1, 0, 0, 0, 13748, 13738, 1, 0, 0, 0, 13748, 13743, + 1, 0, 0, 0, 13749, 1805, 1, 0, 0, 0, 13750, 13757, 3, 1808, 904, 0, 13751, + 13752, 5, 549, 0, 0, 13752, 13753, 3, 1808, 904, 0, 13753, 13754, 5, 33, + 0, 0, 13754, 13755, 3, 1808, 904, 0, 13755, 13757, 1, 0, 0, 0, 13756, 13750, + 1, 0, 0, 0, 13756, 13751, 1, 0, 0, 0, 13757, 1807, 1, 0, 0, 0, 13758, 13759, + 5, 360, 0, 0, 13759, 13766, 7, 96, 0, 0, 13760, 13761, 5, 604, 0, 0, 13761, + 13766, 5, 577, 0, 0, 13762, 13763, 3, 1710, 855, 0, 13763, 13764, 7, 96, + 0, 0, 13764, 13766, 1, 0, 0, 0, 13765, 13758, 1, 0, 0, 0, 13765, 13760, + 1, 0, 0, 0, 13765, 13762, 1, 0, 0, 0, 13766, 1809, 1, 0, 0, 0, 13767, 13774, + 5, 203, 0, 0, 13768, 13769, 5, 604, 0, 0, 13769, 13775, 5, 577, 0, 0, 13770, + 13775, 5, 66, 0, 0, 13771, 13775, 5, 666, 0, 0, 13772, 13773, 5, 266, 0, + 0, 13773, 13775, 5, 681, 0, 0, 13774, 13768, 1, 0, 0, 0, 13774, 13770, + 1, 0, 0, 0, 13774, 13771, 1, 0, 0, 0, 13774, 13772, 1, 0, 0, 0, 13775, + 1811, 1, 0, 0, 0, 13776, 13777, 5, 577, 0, 0, 13777, 13779, 5, 2, 0, 0, + 13778, 13780, 3, 1830, 915, 0, 13779, 13778, 1, 0, 0, 0, 13779, 13780, + 1, 0, 0, 0, 13780, 13781, 1, 0, 0, 0, 13781, 13789, 5, 3, 0, 0, 13782, + 13783, 5, 2, 0, 0, 13783, 13784, 3, 1830, 915, 0, 13784, 13785, 5, 6, 0, + 0, 13785, 13786, 3, 1710, 855, 0, 13786, 13787, 5, 3, 0, 0, 13787, 13789, + 1, 0, 0, 0, 13788, 13776, 1, 0, 0, 0, 13788, 13782, 1, 0, 0, 0, 13789, + 1813, 1, 0, 0, 0, 13790, 13791, 5, 577, 0, 0, 13791, 13793, 5, 2, 0, 0, + 13792, 13794, 3, 1830, 915, 0, 13793, 13792, 1, 0, 0, 0, 13793, 13794, + 1, 0, 0, 0, 13794, 13795, 1, 0, 0, 0, 13795, 13796, 5, 3, 0, 0, 13796, + 1815, 1, 0, 0, 0, 13797, 13798, 5, 2, 0, 0, 13798, 13799, 3, 1830, 915, + 0, 13799, 13800, 5, 6, 0, 0, 13800, 13801, 3, 1710, 855, 0, 13801, 13802, + 5, 3, 0, 0, 13802, 1817, 1, 0, 0, 0, 13803, 13804, 7, 97, 0, 0, 13804, + 1819, 1, 0, 0, 0, 13805, 13808, 5, 29, 0, 0, 13806, 13808, 3, 1822, 911, + 0, 13807, 13805, 1, 0, 0, 0, 13807, 13806, 1, 0, 0, 0, 13808, 1821, 1, + 0, 0, 0, 13809, 13810, 7, 98, 0, 0, 13810, 1823, 1, 0, 0, 0, 13811, 13818, + 5, 29, 0, 0, 13812, 13813, 5, 275, 0, 0, 13813, 13814, 5, 2, 0, 0, 13814, + 13815, 3, 904, 452, 0, 13815, 13816, 5, 3, 0, 0, 13816, 13818, 1, 0, 0, + 0, 13817, 13811, 1, 0, 0, 0, 13817, 13812, 1, 0, 0, 0, 13818, 1825, 1, + 0, 0, 0, 13819, 13826, 3, 1820, 910, 0, 13820, 13821, 5, 275, 0, 0, 13821, + 13822, 5, 2, 0, 0, 13822, 13823, 3, 904, 452, 0, 13823, 13824, 5, 3, 0, + 0, 13824, 13826, 1, 0, 0, 0, 13825, 13819, 1, 0, 0, 0, 13825, 13820, 1, + 0, 0, 0, 13826, 1827, 1, 0, 0, 0, 13827, 13840, 3, 1820, 910, 0, 13828, + 13829, 5, 275, 0, 0, 13829, 13830, 5, 2, 0, 0, 13830, 13831, 3, 904, 452, + 0, 13831, 13832, 5, 3, 0, 0, 13832, 13840, 1, 0, 0, 0, 13833, 13840, 5, + 122, 0, 0, 13834, 13835, 5, 77, 0, 0, 13835, 13840, 5, 122, 0, 0, 13836, + 13840, 5, 116, 0, 0, 13837, 13838, 5, 77, 0, 0, 13838, 13840, 5, 116, 0, + 0, 13839, 13827, 1, 0, 0, 0, 13839, 13828, 1, 0, 0, 0, 13839, 13833, 1, + 0, 0, 0, 13839, 13834, 1, 0, 0, 0, 13839, 13836, 1, 0, 0, 0, 13839, 13837, + 1, 0, 0, 0, 13840, 1829, 1, 0, 0, 0, 13841, 13846, 3, 1710, 855, 0, 13842, + 13843, 5, 6, 0, 0, 13843, 13845, 3, 1710, 855, 0, 13844, 13842, 1, 0, 0, + 0, 13845, 13848, 1, 0, 0, 0, 13846, 13844, 1, 0, 0, 0, 13846, 13847, 1, + 0, 0, 0, 13847, 1831, 1, 0, 0, 0, 13848, 13846, 1, 0, 0, 0, 13849, 13854, + 3, 1834, 917, 0, 13850, 13851, 5, 6, 0, 0, 13851, 13853, 3, 1834, 917, + 0, 13852, 13850, 1, 0, 0, 0, 13853, 13856, 1, 0, 0, 0, 13854, 13852, 1, + 0, 0, 0, 13854, 13855, 1, 0, 0, 0, 13855, 1833, 1, 0, 0, 0, 13856, 13854, + 1, 0, 0, 0, 13857, 13863, 3, 1710, 855, 0, 13858, 13859, 3, 854, 427, 0, + 13859, 13860, 7, 99, 0, 0, 13860, 13861, 3, 1710, 855, 0, 13861, 13863, + 1, 0, 0, 0, 13862, 13857, 1, 0, 0, 0, 13862, 13858, 1, 0, 0, 0, 13863, + 1835, 1, 0, 0, 0, 13864, 13869, 3, 1662, 831, 0, 13865, 13866, 5, 6, 0, + 0, 13866, 13868, 3, 1662, 831, 0, 13867, 13865, 1, 0, 0, 0, 13868, 13871, + 1, 0, 0, 0, 13869, 13867, 1, 0, 0, 0, 13869, 13870, 1, 0, 0, 0, 13870, + 1837, 1, 0, 0, 0, 13871, 13869, 1, 0, 0, 0, 13872, 13875, 5, 4, 0, 0, 13873, + 13876, 3, 1830, 915, 0, 13874, 13876, 3, 1840, 920, 0, 13875, 13873, 1, + 0, 0, 0, 13875, 13874, 1, 0, 0, 0, 13875, 13876, 1, 0, 0, 0, 13876, 13877, + 1, 0, 0, 0, 13877, 13878, 5, 5, 0, 0, 13878, 1839, 1, 0, 0, 0, 13879, 13884, + 3, 1838, 919, 0, 13880, 13881, 5, 6, 0, 0, 13881, 13883, 3, 1838, 919, + 0, 13882, 13880, 1, 0, 0, 0, 13883, 13886, 1, 0, 0, 0, 13884, 13882, 1, + 0, 0, 0, 13884, 13885, 1, 0, 0, 0, 13885, 1841, 1, 0, 0, 0, 13886, 13884, + 1, 0, 0, 0, 13887, 13888, 3, 1844, 922, 0, 13888, 13889, 5, 64, 0, 0, 13889, + 13890, 3, 1710, 855, 0, 13890, 1843, 1, 0, 0, 0, 13891, 13900, 3, 1934, + 967, 0, 13892, 13900, 5, 382, 0, 0, 13893, 13900, 5, 261, 0, 0, 13894, + 13900, 5, 180, 0, 0, 13895, 13900, 5, 222, 0, 0, 13896, 13900, 5, 258, + 0, 0, 13897, 13900, 5, 324, 0, 0, 13898, 13900, 3, 1910, 955, 0, 13899, + 13891, 1, 0, 0, 0, 13899, 13892, 1, 0, 0, 0, 13899, 13893, 1, 0, 0, 0, + 13899, 13894, 1, 0, 0, 0, 13899, 13895, 1, 0, 0, 0, 13899, 13896, 1, 0, + 0, 0, 13899, 13897, 1, 0, 0, 0, 13899, 13898, 1, 0, 0, 0, 13900, 1845, + 1, 0, 0, 0, 13901, 13902, 7, 100, 0, 0, 13902, 1847, 1, 0, 0, 0, 13903, + 13904, 3, 1710, 855, 0, 13904, 13905, 5, 84, 0, 0, 13905, 13906, 3, 1710, + 855, 0, 13906, 13907, 5, 64, 0, 0, 13907, 13910, 3, 1710, 855, 0, 13908, + 13909, 5, 62, 0, 0, 13909, 13911, 3, 1710, 855, 0, 13910, 13908, 1, 0, + 0, 0, 13910, 13911, 1, 0, 0, 0, 13911, 1849, 1, 0, 0, 0, 13912, 13913, + 3, 1754, 877, 0, 13913, 13914, 5, 68, 0, 0, 13914, 13915, 3, 1754, 877, + 0, 13915, 1851, 1, 0, 0, 0, 13916, 13917, 3, 1710, 855, 0, 13917, 13918, + 5, 64, 0, 0, 13918, 13919, 3, 1710, 855, 0, 13919, 13920, 5, 62, 0, 0, + 13920, 13921, 3, 1710, 855, 0, 13921, 13944, 1, 0, 0, 0, 13922, 13923, + 3, 1710, 855, 0, 13923, 13924, 5, 62, 0, 0, 13924, 13925, 3, 1710, 855, + 0, 13925, 13926, 5, 64, 0, 0, 13926, 13927, 3, 1710, 855, 0, 13927, 13944, + 1, 0, 0, 0, 13928, 13929, 3, 1710, 855, 0, 13929, 13930, 5, 64, 0, 0, 13930, + 13931, 3, 1710, 855, 0, 13931, 13944, 1, 0, 0, 0, 13932, 13933, 3, 1710, + 855, 0, 13933, 13934, 5, 62, 0, 0, 13934, 13935, 3, 1710, 855, 0, 13935, + 13944, 1, 0, 0, 0, 13936, 13937, 3, 1710, 855, 0, 13937, 13938, 5, 129, + 0, 0, 13938, 13939, 3, 1710, 855, 0, 13939, 13940, 5, 201, 0, 0, 13940, + 13941, 3, 1710, 855, 0, 13941, 13944, 1, 0, 0, 0, 13942, 13944, 3, 1830, + 915, 0, 13943, 13916, 1, 0, 0, 0, 13943, 13922, 1, 0, 0, 0, 13943, 13928, + 1, 0, 0, 0, 13943, 13932, 1, 0, 0, 0, 13943, 13936, 1, 0, 0, 0, 13943, + 13942, 1, 0, 0, 0, 13944, 1853, 1, 0, 0, 0, 13945, 13946, 3, 1710, 855, + 0, 13946, 13947, 5, 64, 0, 0, 13947, 13948, 3, 1830, 915, 0, 13948, 13953, + 1, 0, 0, 0, 13949, 13950, 5, 64, 0, 0, 13950, 13953, 3, 1830, 915, 0, 13951, + 13953, 3, 1830, 915, 0, 13952, 13945, 1, 0, 0, 0, 13952, 13949, 1, 0, 0, + 0, 13952, 13951, 1, 0, 0, 0, 13953, 1855, 1, 0, 0, 0, 13954, 13960, 3, + 1498, 749, 0, 13955, 13956, 5, 2, 0, 0, 13956, 13957, 3, 1830, 915, 0, + 13957, 13958, 5, 3, 0, 0, 13958, 13960, 1, 0, 0, 0, 13959, 13954, 1, 0, + 0, 0, 13959, 13955, 1, 0, 0, 0, 13960, 1857, 1, 0, 0, 0, 13961, 13963, + 5, 40, 0, 0, 13962, 13964, 3, 1866, 933, 0, 13963, 13962, 1, 0, 0, 0, 13963, + 13964, 1, 0, 0, 0, 13964, 13965, 1, 0, 0, 0, 13965, 13967, 3, 1860, 930, + 0, 13966, 13968, 3, 1864, 932, 0, 13967, 13966, 1, 0, 0, 0, 13967, 13968, + 1, 0, 0, 0, 13968, 13969, 1, 0, 0, 0, 13969, 13970, 5, 653, 0, 0, 13970, + 1859, 1, 0, 0, 0, 13971, 13973, 3, 1862, 931, 0, 13972, 13971, 1, 0, 0, + 0, 13973, 13974, 1, 0, 0, 0, 13974, 13972, 1, 0, 0, 0, 13974, 13975, 1, + 0, 0, 0, 13975, 1861, 1, 0, 0, 0, 13976, 13977, 5, 103, 0, 0, 13977, 13978, + 3, 1710, 855, 0, 13978, 13979, 5, 94, 0, 0, 13979, 13980, 3, 1710, 855, + 0, 13980, 1863, 1, 0, 0, 0, 13981, 13982, 5, 58, 0, 0, 13982, 13983, 3, + 1710, 855, 0, 13983, 1865, 1, 0, 0, 0, 13984, 13985, 3, 1710, 855, 0, 13985, + 1867, 1, 0, 0, 0, 13986, 13988, 3, 1924, 962, 0, 13987, 13989, 3, 1874, + 937, 0, 13988, 13987, 1, 0, 0, 0, 13988, 13989, 1, 0, 0, 0, 13989, 1869, + 1, 0, 0, 0, 13990, 13993, 5, 11, 0, 0, 13991, 13994, 3, 1894, 947, 0, 13992, + 13994, 5, 9, 0, 0, 13993, 13991, 1, 0, 0, 0, 13993, 13992, 1, 0, 0, 0, + 13994, 14008, 1, 0, 0, 0, 13995, 14004, 5, 4, 0, 0, 13996, 14005, 3, 1710, + 855, 0, 13997, 13999, 3, 1872, 936, 0, 13998, 13997, 1, 0, 0, 0, 13998, + 13999, 1, 0, 0, 0, 13999, 14000, 1, 0, 0, 0, 14000, 14002, 5, 8, 0, 0, + 14001, 14003, 3, 1872, 936, 0, 14002, 14001, 1, 0, 0, 0, 14002, 14003, + 1, 0, 0, 0, 14003, 14005, 1, 0, 0, 0, 14004, 13996, 1, 0, 0, 0, 14004, + 13998, 1, 0, 0, 0, 14005, 14006, 1, 0, 0, 0, 14006, 14008, 5, 5, 0, 0, + 14007, 13990, 1, 0, 0, 0, 14007, 13995, 1, 0, 0, 0, 14008, 1871, 1, 0, + 0, 0, 14009, 14010, 3, 1710, 855, 0, 14010, 1873, 1, 0, 0, 0, 14011, 14013, + 3, 1870, 935, 0, 14012, 14011, 1, 0, 0, 0, 14013, 14014, 1, 0, 0, 0, 14014, + 14012, 1, 0, 0, 0, 14014, 14015, 1, 0, 0, 0, 14015, 1875, 1, 0, 0, 0, 14016, + 14018, 3, 1870, 935, 0, 14017, 14016, 1, 0, 0, 0, 14018, 14021, 1, 0, 0, + 0, 14019, 14017, 1, 0, 0, 0, 14019, 14020, 1, 0, 0, 0, 14020, 1877, 1, + 0, 0, 0, 14021, 14019, 1, 0, 0, 0, 14022, 14023, 3, 1880, 940, 0, 14023, + 1879, 1, 0, 0, 0, 14024, 14029, 3, 1882, 941, 0, 14025, 14026, 5, 6, 0, + 0, 14026, 14028, 3, 1882, 941, 0, 14027, 14025, 1, 0, 0, 0, 14028, 14031, + 1, 0, 0, 0, 14029, 14027, 1, 0, 0, 0, 14029, 14030, 1, 0, 0, 0, 14030, + 1881, 1, 0, 0, 0, 14031, 14029, 1, 0, 0, 0, 14032, 14034, 3, 1710, 855, + 0, 14033, 14035, 3, 1884, 942, 0, 14034, 14033, 1, 0, 0, 0, 14034, 14035, + 1, 0, 0, 0, 14035, 14038, 1, 0, 0, 0, 14036, 14038, 5, 9, 0, 0, 14037, + 14032, 1, 0, 0, 0, 14037, 14036, 1, 0, 0, 0, 14038, 1883, 1, 0, 0, 0, 14039, + 14040, 5, 36, 0, 0, 14040, 14043, 3, 1932, 966, 0, 14041, 14043, 3, 1934, + 967, 0, 14042, 14039, 1, 0, 0, 0, 14042, 14041, 1, 0, 0, 0, 14043, 1885, + 1, 0, 0, 0, 14044, 14049, 3, 1888, 944, 0, 14045, 14046, 5, 6, 0, 0, 14046, + 14048, 3, 1888, 944, 0, 14047, 14045, 1, 0, 0, 0, 14048, 14051, 1, 0, 0, + 0, 14049, 14047, 1, 0, 0, 0, 14049, 14050, 1, 0, 0, 0, 14050, 1887, 1, + 0, 0, 0, 14051, 14049, 1, 0, 0, 0, 14052, 14054, 3, 1924, 962, 0, 14053, + 14055, 3, 1874, 937, 0, 14054, 14053, 1, 0, 0, 0, 14054, 14055, 1, 0, 0, + 0, 14055, 1889, 1, 0, 0, 0, 14056, 14061, 3, 1892, 946, 0, 14057, 14058, + 5, 6, 0, 0, 14058, 14060, 3, 1892, 946, 0, 14059, 14057, 1, 0, 0, 0, 14060, + 14063, 1, 0, 0, 0, 14061, 14059, 1, 0, 0, 0, 14061, 14062, 1, 0, 0, 0, + 14062, 1891, 1, 0, 0, 0, 14063, 14061, 1, 0, 0, 0, 14064, 14065, 3, 1924, + 962, 0, 14065, 1893, 1, 0, 0, 0, 14066, 14067, 3, 1932, 966, 0, 14067, + 1895, 1, 0, 0, 0, 14068, 14069, 3, 1910, 955, 0, 14069, 1897, 1, 0, 0, + 0, 14070, 14078, 3, 1946, 973, 0, 14071, 14078, 3, 1928, 964, 0, 14072, + 14073, 3, 1924, 962, 0, 14073, 14074, 3, 1874, 937, 0, 14074, 14078, 1, + 0, 0, 0, 14075, 14078, 5, 121, 0, 0, 14076, 14078, 5, 128, 0, 0, 14077, + 14070, 1, 0, 0, 0, 14077, 14071, 1, 0, 0, 0, 14077, 14072, 1, 0, 0, 0, + 14077, 14075, 1, 0, 0, 0, 14077, 14076, 1, 0, 0, 0, 14078, 1899, 1, 0, + 0, 0, 14079, 14115, 3, 1908, 954, 0, 14080, 14115, 3, 1906, 953, 0, 14081, + 14115, 3, 1910, 955, 0, 14082, 14115, 3, 1904, 952, 0, 14083, 14115, 3, + 1902, 951, 0, 14084, 14094, 3, 1898, 949, 0, 14085, 14095, 3, 1910, 955, + 0, 14086, 14087, 5, 2, 0, 0, 14087, 14089, 3, 1832, 916, 0, 14088, 14090, + 3, 1540, 770, 0, 14089, 14088, 1, 0, 0, 0, 14089, 14090, 1, 0, 0, 0, 14090, + 14091, 1, 0, 0, 0, 14091, 14092, 5, 3, 0, 0, 14092, 14093, 3, 1910, 955, + 0, 14093, 14095, 1, 0, 0, 0, 14094, 14085, 1, 0, 0, 0, 14094, 14086, 1, + 0, 0, 0, 14095, 14115, 1, 0, 0, 0, 14096, 14097, 3, 1672, 836, 0, 14097, + 14098, 3, 1910, 955, 0, 14098, 14115, 1, 0, 0, 0, 14099, 14109, 3, 1700, + 850, 0, 14100, 14102, 3, 1910, 955, 0, 14101, 14103, 3, 1704, 852, 0, 14102, + 14101, 1, 0, 0, 0, 14102, 14103, 1, 0, 0, 0, 14103, 14110, 1, 0, 0, 0, + 14104, 14105, 5, 2, 0, 0, 14105, 14106, 3, 1908, 954, 0, 14106, 14107, + 5, 3, 0, 0, 14107, 14108, 3, 1910, 955, 0, 14108, 14110, 1, 0, 0, 0, 14109, + 14100, 1, 0, 0, 0, 14109, 14104, 1, 0, 0, 0, 14110, 14115, 1, 0, 0, 0, + 14111, 14115, 5, 97, 0, 0, 14112, 14115, 5, 60, 0, 0, 14113, 14115, 5, + 78, 0, 0, 14114, 14079, 1, 0, 0, 0, 14114, 14080, 1, 0, 0, 0, 14114, 14081, + 1, 0, 0, 0, 14114, 14082, 1, 0, 0, 0, 14114, 14083, 1, 0, 0, 0, 14114, + 14084, 1, 0, 0, 0, 14114, 14096, 1, 0, 0, 0, 14114, 14099, 1, 0, 0, 0, + 14114, 14111, 1, 0, 0, 0, 14114, 14112, 1, 0, 0, 0, 14114, 14113, 1, 0, + 0, 0, 14115, 1901, 1, 0, 0, 0, 14116, 14117, 5, 871, 0, 0, 14117, 1903, + 1, 0, 0, 0, 14118, 14119, 5, 867, 0, 0, 14119, 1905, 1, 0, 0, 0, 14120, + 14121, 5, 877, 0, 0, 14121, 1907, 1, 0, 0, 0, 14122, 14123, 5, 875, 0, + 0, 14123, 1909, 1, 0, 0, 0, 14124, 14126, 3, 1912, 956, 0, 14125, 14127, + 3, 1914, 957, 0, 14126, 14125, 1, 0, 0, 0, 14126, 14127, 1, 0, 0, 0, 14127, + 1911, 1, 0, 0, 0, 14128, 14140, 5, 862, 0, 0, 14129, 14140, 5, 864, 0, + 0, 14130, 14134, 5, 866, 0, 0, 14131, 14133, 5, 894, 0, 0, 14132, 14131, + 1, 0, 0, 0, 14133, 14136, 1, 0, 0, 0, 14134, 14132, 1, 0, 0, 0, 14134, + 14135, 1, 0, 0, 0, 14135, 14137, 1, 0, 0, 0, 14136, 14134, 1, 0, 0, 0, + 14137, 14140, 5, 895, 0, 0, 14138, 14140, 5, 888, 0, 0, 14139, 14128, 1, + 0, 0, 0, 14139, 14129, 1, 0, 0, 0, 14139, 14130, 1, 0, 0, 0, 14139, 14138, + 1, 0, 0, 0, 14140, 1913, 1, 0, 0, 0, 14141, 14142, 5, 686, 0, 0, 14142, + 14143, 3, 1912, 956, 0, 14143, 1915, 1, 0, 0, 0, 14144, 14150, 3, 1908, + 954, 0, 14145, 14146, 5, 12, 0, 0, 14146, 14150, 3, 1908, 954, 0, 14147, + 14148, 5, 13, 0, 0, 14148, 14150, 3, 1908, 954, 0, 14149, 14144, 1, 0, + 0, 0, 14149, 14145, 1, 0, 0, 0, 14149, 14147, 1, 0, 0, 0, 14150, 1917, + 1, 0, 0, 0, 14151, 14152, 3, 1920, 960, 0, 14152, 1919, 1, 0, 0, 0, 14153, + 14158, 3, 1930, 965, 0, 14154, 14158, 5, 853, 0, 0, 14155, 14158, 5, 52, + 0, 0, 14156, 14158, 5, 90, 0, 0, 14157, 14153, 1, 0, 0, 0, 14157, 14154, + 1, 0, 0, 0, 14157, 14155, 1, 0, 0, 0, 14157, 14156, 1, 0, 0, 0, 14158, + 1921, 1, 0, 0, 0, 14159, 14164, 3, 1920, 960, 0, 14160, 14161, 5, 6, 0, + 0, 14161, 14163, 3, 1920, 960, 0, 14162, 14160, 1, 0, 0, 0, 14163, 14166, + 1, 0, 0, 0, 14164, 14162, 1, 0, 0, 0, 14164, 14165, 1, 0, 0, 0, 14165, + 1923, 1, 0, 0, 0, 14166, 14164, 1, 0, 0, 0, 14167, 14174, 3, 1934, 967, + 0, 14168, 14174, 3, 1938, 969, 0, 14169, 14174, 3, 1940, 970, 0, 14170, + 14174, 3, 2160, 1080, 0, 14171, 14174, 5, 121, 0, 0, 14172, 14174, 5, 128, + 0, 0, 14173, 14167, 1, 0, 0, 0, 14173, 14168, 1, 0, 0, 0, 14173, 14169, + 1, 0, 0, 0, 14173, 14170, 1, 0, 0, 0, 14173, 14171, 1, 0, 0, 0, 14173, + 14172, 1, 0, 0, 0, 14174, 1925, 1, 0, 0, 0, 14175, 14180, 3, 1934, 967, + 0, 14176, 14180, 3, 1938, 969, 0, 14177, 14180, 3, 1940, 970, 0, 14178, + 14180, 3, 2160, 1080, 0, 14179, 14175, 1, 0, 0, 0, 14179, 14176, 1, 0, + 0, 0, 14179, 14177, 1, 0, 0, 0, 14179, 14178, 1, 0, 0, 0, 14180, 1927, + 1, 0, 0, 0, 14181, 14186, 3, 1934, 967, 0, 14182, 14186, 3, 1938, 969, + 0, 14183, 14186, 3, 2160, 1080, 0, 14184, 14186, 3, 1942, 971, 0, 14185, + 14181, 1, 0, 0, 0, 14185, 14182, 1, 0, 0, 0, 14185, 14183, 1, 0, 0, 0, + 14185, 14184, 1, 0, 0, 0, 14186, 1929, 1, 0, 0, 0, 14187, 14192, 3, 1934, + 967, 0, 14188, 14192, 3, 1938, 969, 0, 14189, 14192, 3, 1940, 970, 0, 14190, + 14192, 3, 1942, 971, 0, 14191, 14187, 1, 0, 0, 0, 14191, 14188, 1, 0, 0, + 0, 14191, 14189, 1, 0, 0, 0, 14191, 14190, 1, 0, 0, 0, 14192, 1931, 1, + 0, 0, 0, 14193, 14200, 3, 1934, 967, 0, 14194, 14200, 3, 2160, 1080, 0, + 14195, 14200, 3, 1938, 969, 0, 14196, 14200, 3, 1940, 970, 0, 14197, 14200, + 3, 1942, 971, 0, 14198, 14200, 3, 1944, 972, 0, 14199, 14193, 1, 0, 0, + 0, 14199, 14194, 1, 0, 0, 0, 14199, 14195, 1, 0, 0, 0, 14199, 14196, 1, + 0, 0, 0, 14199, 14197, 1, 0, 0, 0, 14199, 14198, 1, 0, 0, 0, 14200, 1933, + 1, 0, 0, 0, 14201, 14203, 5, 851, 0, 0, 14202, 14204, 3, 1914, 957, 0, + 14203, 14202, 1, 0, 0, 0, 14203, 14204, 1, 0, 0, 0, 14204, 14211, 1, 0, + 0, 0, 14205, 14211, 5, 854, 0, 0, 14206, 14211, 5, 858, 0, 0, 14207, 14211, + 3, 1758, 879, 0, 14208, 14211, 3, 1936, 968, 0, 14209, 14211, 3, 2160, + 1080, 0, 14210, 14201, 1, 0, 0, 0, 14210, 14205, 1, 0, 0, 0, 14210, 14206, + 1, 0, 0, 0, 14210, 14207, 1, 0, 0, 0, 14210, 14208, 1, 0, 0, 0, 14210, + 14209, 1, 0, 0, 0, 14211, 1935, 1, 0, 0, 0, 14212, 14213, 5, 879, 0, 0, + 14213, 1937, 1, 0, 0, 0, 14214, 14215, 7, 101, 0, 0, 14215, 1939, 1, 0, + 0, 0, 14216, 14308, 5, 549, 0, 0, 14217, 14308, 5, 550, 0, 0, 14218, 14308, + 3, 1682, 841, 0, 14219, 14308, 5, 552, 0, 0, 14220, 14308, 5, 553, 0, 0, + 14221, 14308, 3, 1690, 845, 0, 14222, 14308, 5, 555, 0, 0, 14223, 14308, + 5, 556, 0, 0, 14224, 14308, 5, 557, 0, 0, 14225, 14308, 5, 558, 0, 0, 14226, + 14308, 5, 559, 0, 0, 14227, 14308, 5, 560, 0, 0, 14228, 14308, 5, 561, + 0, 0, 14229, 14308, 5, 669, 0, 0, 14230, 14308, 5, 562, 0, 0, 14231, 14308, + 5, 563, 0, 0, 14232, 14308, 5, 564, 0, 0, 14233, 14308, 5, 565, 0, 0, 14234, + 14308, 5, 174, 0, 0, 14235, 14308, 5, 533, 0, 0, 14236, 14308, 5, 534, + 0, 0, 14237, 14308, 5, 524, 0, 0, 14238, 14308, 5, 525, 0, 0, 14239, 14308, + 5, 526, 0, 0, 14240, 14308, 5, 527, 0, 0, 14241, 14308, 5, 531, 0, 0, 14242, + 14308, 5, 532, 0, 0, 14243, 14308, 5, 529, 0, 0, 14244, 14308, 5, 530, + 0, 0, 14245, 14308, 5, 535, 0, 0, 14246, 14308, 5, 536, 0, 0, 14247, 14308, + 5, 528, 0, 0, 14248, 14308, 5, 538, 0, 0, 14249, 14308, 5, 445, 0, 0, 14250, + 14308, 5, 199, 0, 0, 14251, 14308, 5, 523, 0, 0, 14252, 14308, 5, 537, + 0, 0, 14253, 14308, 5, 539, 0, 0, 14254, 14308, 5, 540, 0, 0, 14255, 14308, + 5, 520, 0, 0, 14256, 14308, 5, 542, 0, 0, 14257, 14308, 5, 543, 0, 0, 14258, + 14308, 5, 544, 0, 0, 14259, 14308, 5, 452, 0, 0, 14260, 14308, 5, 451, + 0, 0, 14261, 14308, 5, 522, 0, 0, 14262, 14308, 5, 453, 0, 0, 14263, 14308, + 5, 513, 0, 0, 14264, 14308, 5, 521, 0, 0, 14265, 14308, 5, 517, 0, 0, 14266, + 14308, 5, 490, 0, 0, 14267, 14308, 5, 187, 0, 0, 14268, 14308, 5, 198, + 0, 0, 14269, 14308, 5, 461, 0, 0, 14270, 14308, 5, 296, 0, 0, 14271, 14308, + 5, 506, 0, 0, 14272, 14308, 5, 566, 0, 0, 14273, 14308, 5, 567, 0, 0, 14274, + 14308, 5, 568, 0, 0, 14275, 14308, 5, 569, 0, 0, 14276, 14308, 5, 688, + 0, 0, 14277, 14308, 5, 570, 0, 0, 14278, 14308, 3, 1678, 839, 0, 14279, + 14308, 5, 79, 0, 0, 14280, 14308, 5, 652, 0, 0, 14281, 14308, 5, 572, 0, + 0, 14282, 14308, 5, 574, 0, 0, 14283, 14308, 5, 575, 0, 0, 14284, 14308, + 5, 576, 0, 0, 14285, 14308, 5, 577, 0, 0, 14286, 14308, 5, 578, 0, 0, 14287, + 14308, 5, 579, 0, 0, 14288, 14308, 5, 580, 0, 0, 14289, 14308, 5, 581, + 0, 0, 14290, 14308, 5, 582, 0, 0, 14291, 14308, 5, 583, 0, 0, 14292, 14308, + 5, 584, 0, 0, 14293, 14308, 5, 585, 0, 0, 14294, 14308, 5, 586, 0, 0, 14295, + 14308, 5, 587, 0, 0, 14296, 14308, 5, 595, 0, 0, 14297, 14308, 5, 596, + 0, 0, 14298, 14308, 5, 597, 0, 0, 14299, 14308, 5, 598, 0, 0, 14300, 14308, + 5, 675, 0, 0, 14301, 14308, 5, 599, 0, 0, 14302, 14308, 5, 600, 0, 0, 14303, + 14308, 5, 601, 0, 0, 14304, 14308, 5, 602, 0, 0, 14305, 14308, 5, 673, + 0, 0, 14306, 14308, 3, 1946, 973, 0, 14307, 14216, 1, 0, 0, 0, 14307, 14217, + 1, 0, 0, 0, 14307, 14218, 1, 0, 0, 0, 14307, 14219, 1, 0, 0, 0, 14307, + 14220, 1, 0, 0, 0, 14307, 14221, 1, 0, 0, 0, 14307, 14222, 1, 0, 0, 0, + 14307, 14223, 1, 0, 0, 0, 14307, 14224, 1, 0, 0, 0, 14307, 14225, 1, 0, + 0, 0, 14307, 14226, 1, 0, 0, 0, 14307, 14227, 1, 0, 0, 0, 14307, 14228, + 1, 0, 0, 0, 14307, 14229, 1, 0, 0, 0, 14307, 14230, 1, 0, 0, 0, 14307, + 14231, 1, 0, 0, 0, 14307, 14232, 1, 0, 0, 0, 14307, 14233, 1, 0, 0, 0, + 14307, 14234, 1, 0, 0, 0, 14307, 14235, 1, 0, 0, 0, 14307, 14236, 1, 0, + 0, 0, 14307, 14237, 1, 0, 0, 0, 14307, 14238, 1, 0, 0, 0, 14307, 14239, + 1, 0, 0, 0, 14307, 14240, 1, 0, 0, 0, 14307, 14241, 1, 0, 0, 0, 14307, + 14242, 1, 0, 0, 0, 14307, 14243, 1, 0, 0, 0, 14307, 14244, 1, 0, 0, 0, + 14307, 14245, 1, 0, 0, 0, 14307, 14246, 1, 0, 0, 0, 14307, 14247, 1, 0, + 0, 0, 14307, 14248, 1, 0, 0, 0, 14307, 14249, 1, 0, 0, 0, 14307, 14250, + 1, 0, 0, 0, 14307, 14251, 1, 0, 0, 0, 14307, 14252, 1, 0, 0, 0, 14307, + 14253, 1, 0, 0, 0, 14307, 14254, 1, 0, 0, 0, 14307, 14255, 1, 0, 0, 0, + 14307, 14256, 1, 0, 0, 0, 14307, 14257, 1, 0, 0, 0, 14307, 14258, 1, 0, + 0, 0, 14307, 14259, 1, 0, 0, 0, 14307, 14260, 1, 0, 0, 0, 14307, 14261, + 1, 0, 0, 0, 14307, 14262, 1, 0, 0, 0, 14307, 14263, 1, 0, 0, 0, 14307, + 14264, 1, 0, 0, 0, 14307, 14265, 1, 0, 0, 0, 14307, 14266, 1, 0, 0, 0, + 14307, 14267, 1, 0, 0, 0, 14307, 14268, 1, 0, 0, 0, 14307, 14269, 1, 0, + 0, 0, 14307, 14270, 1, 0, 0, 0, 14307, 14271, 1, 0, 0, 0, 14307, 14272, + 1, 0, 0, 0, 14307, 14273, 1, 0, 0, 0, 14307, 14274, 1, 0, 0, 0, 14307, + 14275, 1, 0, 0, 0, 14307, 14276, 1, 0, 0, 0, 14307, 14277, 1, 0, 0, 0, + 14307, 14278, 1, 0, 0, 0, 14307, 14279, 1, 0, 0, 0, 14307, 14280, 1, 0, + 0, 0, 14307, 14281, 1, 0, 0, 0, 14307, 14282, 1, 0, 0, 0, 14307, 14283, + 1, 0, 0, 0, 14307, 14284, 1, 0, 0, 0, 14307, 14285, 1, 0, 0, 0, 14307, + 14286, 1, 0, 0, 0, 14307, 14287, 1, 0, 0, 0, 14307, 14288, 1, 0, 0, 0, + 14307, 14289, 1, 0, 0, 0, 14307, 14290, 1, 0, 0, 0, 14307, 14291, 1, 0, + 0, 0, 14307, 14292, 1, 0, 0, 0, 14307, 14293, 1, 0, 0, 0, 14307, 14294, + 1, 0, 0, 0, 14307, 14295, 1, 0, 0, 0, 14307, 14296, 1, 0, 0, 0, 14307, + 14297, 1, 0, 0, 0, 14307, 14298, 1, 0, 0, 0, 14307, 14299, 1, 0, 0, 0, + 14307, 14300, 1, 0, 0, 0, 14307, 14301, 1, 0, 0, 0, 14307, 14302, 1, 0, + 0, 0, 14307, 14303, 1, 0, 0, 0, 14307, 14304, 1, 0, 0, 0, 14307, 14305, + 1, 0, 0, 0, 14307, 14306, 1, 0, 0, 0, 14308, 1941, 1, 0, 0, 0, 14309, 14310, + 7, 102, 0, 0, 14310, 1943, 1, 0, 0, 0, 14311, 14312, 7, 103, 0, 0, 14312, + 1945, 1, 0, 0, 0, 14313, 14314, 7, 104, 0, 0, 14314, 1947, 1, 0, 0, 0, + 14315, 14316, 3, 1950, 975, 0, 14316, 14318, 3, 1960, 980, 0, 14317, 14319, + 3, 1958, 979, 0, 14318, 14317, 1, 0, 0, 0, 14318, 14319, 1, 0, 0, 0, 14319, + 1949, 1, 0, 0, 0, 14320, 14322, 3, 1952, 976, 0, 14321, 14320, 1, 0, 0, + 0, 14322, 14325, 1, 0, 0, 0, 14323, 14321, 1, 0, 0, 0, 14323, 14324, 1, + 0, 0, 0, 14324, 1951, 1, 0, 0, 0, 14325, 14323, 1, 0, 0, 0, 14326, 14327, + 3, 1954, 977, 0, 14327, 14328, 5, 276, 0, 0, 14328, 14329, 5, 689, 0, 0, + 14329, 14347, 1, 0, 0, 0, 14330, 14331, 3, 1954, 977, 0, 14331, 14332, + 5, 690, 0, 0, 14332, 14333, 3, 1956, 978, 0, 14333, 14347, 1, 0, 0, 0, + 14334, 14335, 3, 1954, 977, 0, 14335, 14336, 5, 691, 0, 0, 14336, 14337, + 5, 692, 0, 0, 14337, 14347, 1, 0, 0, 0, 14338, 14339, 3, 1954, 977, 0, + 14339, 14340, 5, 691, 0, 0, 14340, 14341, 5, 693, 0, 0, 14341, 14347, 1, + 0, 0, 0, 14342, 14343, 3, 1954, 977, 0, 14343, 14344, 5, 691, 0, 0, 14344, + 14345, 5, 694, 0, 0, 14345, 14347, 1, 0, 0, 0, 14346, 14326, 1, 0, 0, 0, + 14346, 14330, 1, 0, 0, 0, 14346, 14334, 1, 0, 0, 0, 14346, 14338, 1, 0, + 0, 0, 14346, 14342, 1, 0, 0, 0, 14347, 1953, 1, 0, 0, 0, 14348, 14349, + 5, 29, 0, 0, 14349, 1955, 1, 0, 0, 0, 14350, 14355, 3, 1910, 955, 0, 14351, + 14355, 3, 1944, 972, 0, 14352, 14355, 3, 2160, 1080, 0, 14353, 14355, 3, + 1938, 969, 0, 14354, 14350, 1, 0, 0, 0, 14354, 14351, 1, 0, 0, 0, 14354, + 14352, 1, 0, 0, 0, 14354, 14353, 1, 0, 0, 0, 14355, 1957, 1, 0, 0, 0, 14356, + 14357, 5, 7, 0, 0, 14357, 1959, 1, 0, 0, 0, 14358, 14359, 3, 1962, 981, + 0, 14359, 14360, 5, 148, 0, 0, 14360, 14362, 3, 2004, 1002, 0, 14361, 14363, + 3, 2140, 1070, 0, 14362, 14361, 1, 0, 0, 0, 14362, 14363, 1, 0, 0, 0, 14363, + 14364, 1, 0, 0, 0, 14364, 14366, 5, 653, 0, 0, 14365, 14367, 3, 2154, 1077, + 0, 14366, 14365, 1, 0, 0, 0, 14366, 14367, 1, 0, 0, 0, 14367, 1961, 1, + 0, 0, 0, 14368, 14370, 3, 2150, 1075, 0, 14369, 14368, 1, 0, 0, 0, 14369, + 14370, 1, 0, 0, 0, 14370, 14375, 1, 0, 0, 0, 14371, 14373, 3, 1964, 982, + 0, 14372, 14374, 3, 1966, 983, 0, 14373, 14372, 1, 0, 0, 0, 14373, 14374, + 1, 0, 0, 0, 14374, 14376, 1, 0, 0, 0, 14375, 14371, 1, 0, 0, 0, 14375, + 14376, 1, 0, 0, 0, 14376, 1963, 1, 0, 0, 0, 14377, 14378, 5, 182, 0, 0, + 14378, 1965, 1, 0, 0, 0, 14379, 14381, 3, 1970, 985, 0, 14380, 14379, 1, + 0, 0, 0, 14381, 14382, 1, 0, 0, 0, 14382, 14380, 1, 0, 0, 0, 14382, 14383, + 1, 0, 0, 0, 14383, 1967, 1, 0, 0, 0, 14384, 14385, 5, 18, 0, 0, 14385, + 14386, 3, 2158, 1079, 0, 14386, 14387, 5, 19, 0, 0, 14387, 1969, 1, 0, + 0, 0, 14388, 14392, 3, 1972, 986, 0, 14389, 14392, 5, 182, 0, 0, 14390, + 14392, 3, 1968, 984, 0, 14391, 14388, 1, 0, 0, 0, 14391, 14389, 1, 0, 0, + 0, 14391, 14390, 1, 0, 0, 0, 14392, 1971, 1, 0, 0, 0, 14393, 14420, 3, + 1988, 994, 0, 14394, 14395, 5, 695, 0, 0, 14395, 14396, 5, 62, 0, 0, 14396, + 14421, 3, 1986, 993, 0, 14397, 14399, 3, 1990, 995, 0, 14398, 14397, 1, + 0, 0, 0, 14398, 14399, 1, 0, 0, 0, 14399, 14400, 1, 0, 0, 0, 14400, 14402, + 3, 1992, 996, 0, 14401, 14403, 3, 1994, 997, 0, 14402, 14401, 1, 0, 0, + 0, 14402, 14403, 1, 0, 0, 0, 14403, 14405, 1, 0, 0, 0, 14404, 14406, 3, + 1996, 998, 0, 14405, 14404, 1, 0, 0, 0, 14405, 14406, 1, 0, 0, 0, 14406, + 14408, 1, 0, 0, 0, 14407, 14409, 3, 1998, 999, 0, 14408, 14407, 1, 0, 0, + 0, 14408, 14409, 1, 0, 0, 0, 14409, 14421, 1, 0, 0, 0, 14410, 14412, 3, + 1974, 987, 0, 14411, 14410, 1, 0, 0, 0, 14411, 14412, 1, 0, 0, 0, 14412, + 14413, 1, 0, 0, 0, 14413, 14415, 5, 175, 0, 0, 14414, 14416, 3, 1978, 989, + 0, 14415, 14414, 1, 0, 0, 0, 14415, 14416, 1, 0, 0, 0, 14416, 14417, 1, + 0, 0, 0, 14417, 14418, 3, 1984, 992, 0, 14418, 14419, 3, 1976, 988, 0, + 14419, 14421, 1, 0, 0, 0, 14420, 14394, 1, 0, 0, 0, 14420, 14398, 1, 0, + 0, 0, 14420, 14411, 1, 0, 0, 0, 14421, 14422, 1, 0, 0, 0, 14422, 14423, + 5, 7, 0, 0, 14423, 1973, 1, 0, 0, 0, 14424, 14425, 5, 266, 0, 0, 14425, + 14428, 5, 322, 0, 0, 14426, 14428, 5, 322, 0, 0, 14427, 14424, 1, 0, 0, + 0, 14427, 14426, 1, 0, 0, 0, 14428, 1975, 1, 0, 0, 0, 14429, 14430, 3, + 1496, 748, 0, 14430, 1977, 1, 0, 0, 0, 14431, 14432, 5, 2, 0, 0, 14432, + 14433, 3, 1980, 990, 0, 14433, 14434, 5, 3, 0, 0, 14434, 1979, 1, 0, 0, + 0, 14435, 14440, 3, 1982, 991, 0, 14436, 14437, 5, 6, 0, 0, 14437, 14439, + 3, 1982, 991, 0, 14438, 14436, 1, 0, 0, 0, 14439, 14442, 1, 0, 0, 0, 14440, + 14438, 1, 0, 0, 0, 14440, 14441, 1, 0, 0, 0, 14441, 1981, 1, 0, 0, 0, 14442, + 14440, 1, 0, 0, 0, 14443, 14444, 3, 1988, 994, 0, 14444, 14445, 3, 1992, + 996, 0, 14445, 1983, 1, 0, 0, 0, 14446, 14447, 7, 105, 0, 0, 14447, 1985, + 1, 0, 0, 0, 14448, 14451, 5, 28, 0, 0, 14449, 14451, 3, 1924, 962, 0, 14450, + 14448, 1, 0, 0, 0, 14450, 14449, 1, 0, 0, 0, 14451, 1987, 1, 0, 0, 0, 14452, + 14453, 3, 2158, 1079, 0, 14453, 1989, 1, 0, 0, 0, 14454, 14455, 5, 696, + 0, 0, 14455, 1991, 1, 0, 0, 0, 14456, 14457, 3, 1662, 831, 0, 14457, 1993, + 1, 0, 0, 0, 14458, 14459, 5, 43, 0, 0, 14459, 14460, 3, 566, 283, 0, 14460, + 1995, 1, 0, 0, 0, 14461, 14462, 5, 77, 0, 0, 14462, 14463, 5, 78, 0, 0, + 14463, 1997, 1, 0, 0, 0, 14464, 14465, 3, 2000, 1000, 0, 14465, 14466, + 3, 2162, 1081, 0, 14466, 1999, 1, 0, 0, 0, 14467, 14470, 3, 2002, 1001, + 0, 14468, 14470, 5, 53, 0, 0, 14469, 14467, 1, 0, 0, 0, 14469, 14468, 1, + 0, 0, 0, 14470, 2001, 1, 0, 0, 0, 14471, 14472, 7, 106, 0, 0, 14472, 2003, + 1, 0, 0, 0, 14473, 14475, 3, 2006, 1003, 0, 14474, 14473, 1, 0, 0, 0, 14475, + 14478, 1, 0, 0, 0, 14476, 14474, 1, 0, 0, 0, 14476, 14477, 1, 0, 0, 0, + 14477, 2005, 1, 0, 0, 0, 14478, 14476, 1, 0, 0, 0, 14479, 14480, 3, 1960, + 980, 0, 14480, 14481, 5, 7, 0, 0, 14481, 14507, 1, 0, 0, 0, 14482, 14507, + 3, 2072, 1036, 0, 14483, 14507, 3, 2076, 1038, 0, 14484, 14507, 3, 2014, + 1007, 0, 14485, 14507, 3, 2030, 1015, 0, 14486, 14507, 3, 2036, 1018, 0, + 14487, 14507, 3, 2046, 1023, 0, 14488, 14507, 3, 2048, 1024, 0, 14489, + 14507, 3, 2050, 1025, 0, 14490, 14507, 3, 2064, 1032, 0, 14491, 14507, + 3, 2068, 1034, 0, 14492, 14507, 3, 2088, 1044, 0, 14493, 14507, 3, 2094, + 1047, 0, 14494, 14507, 3, 2096, 1048, 0, 14495, 14507, 3, 2008, 1004, 0, + 14496, 14507, 3, 2010, 1005, 0, 14497, 14507, 3, 2016, 1008, 0, 14498, + 14507, 3, 2104, 1052, 0, 14499, 14507, 3, 2116, 1058, 0, 14500, 14507, + 3, 2124, 1062, 0, 14501, 14507, 3, 2126, 1063, 0, 14502, 14507, 3, 2128, + 1064, 0, 14503, 14507, 3, 2130, 1065, 0, 14504, 14507, 3, 2132, 1066, 0, + 14505, 14507, 3, 2136, 1068, 0, 14506, 14479, 1, 0, 0, 0, 14506, 14482, + 1, 0, 0, 0, 14506, 14483, 1, 0, 0, 0, 14506, 14484, 1, 0, 0, 0, 14506, + 14485, 1, 0, 0, 0, 14506, 14486, 1, 0, 0, 0, 14506, 14487, 1, 0, 0, 0, + 14506, 14488, 1, 0, 0, 0, 14506, 14489, 1, 0, 0, 0, 14506, 14490, 1, 0, + 0, 0, 14506, 14491, 1, 0, 0, 0, 14506, 14492, 1, 0, 0, 0, 14506, 14493, + 1, 0, 0, 0, 14506, 14494, 1, 0, 0, 0, 14506, 14495, 1, 0, 0, 0, 14506, + 14496, 1, 0, 0, 0, 14506, 14497, 1, 0, 0, 0, 14506, 14498, 1, 0, 0, 0, + 14506, 14499, 1, 0, 0, 0, 14506, 14500, 1, 0, 0, 0, 14506, 14501, 1, 0, + 0, 0, 14506, 14502, 1, 0, 0, 0, 14506, 14503, 1, 0, 0, 0, 14506, 14504, + 1, 0, 0, 0, 14506, 14505, 1, 0, 0, 0, 14507, 2007, 1, 0, 0, 0, 14508, 14509, + 5, 697, 0, 0, 14509, 14510, 3, 2166, 1083, 0, 14510, 14511, 5, 7, 0, 0, + 14511, 2009, 1, 0, 0, 0, 14512, 14513, 5, 603, 0, 0, 14513, 14514, 3, 2158, + 1079, 0, 14514, 14516, 5, 2, 0, 0, 14515, 14517, 3, 2012, 1006, 0, 14516, + 14515, 1, 0, 0, 0, 14516, 14517, 1, 0, 0, 0, 14517, 14518, 1, 0, 0, 0, + 14518, 14519, 5, 3, 0, 0, 14519, 14520, 5, 7, 0, 0, 14520, 14531, 1, 0, + 0, 0, 14521, 14522, 5, 57, 0, 0, 14522, 14523, 3, 2158, 1079, 0, 14523, + 14525, 5, 2, 0, 0, 14524, 14526, 3, 2012, 1006, 0, 14525, 14524, 1, 0, + 0, 0, 14525, 14526, 1, 0, 0, 0, 14526, 14527, 1, 0, 0, 0, 14527, 14528, + 5, 3, 0, 0, 14528, 14529, 5, 7, 0, 0, 14529, 14531, 1, 0, 0, 0, 14530, + 14512, 1, 0, 0, 0, 14530, 14521, 1, 0, 0, 0, 14531, 2011, 1, 0, 0, 0, 14532, + 14533, 3, 1830, 915, 0, 14533, 2013, 1, 0, 0, 0, 14534, 14535, 3, 2028, + 1014, 0, 14535, 14536, 3, 2002, 1001, 0, 14536, 14537, 3, 2162, 1081, 0, + 14537, 14538, 5, 7, 0, 0, 14538, 2015, 1, 0, 0, 0, 14539, 14541, 5, 698, + 0, 0, 14540, 14542, 3, 2018, 1009, 0, 14541, 14540, 1, 0, 0, 0, 14541, + 14542, 1, 0, 0, 0, 14542, 14543, 1, 0, 0, 0, 14543, 14544, 5, 699, 0, 0, + 14544, 14545, 3, 2020, 1010, 0, 14545, 14546, 5, 7, 0, 0, 14546, 2017, + 1, 0, 0, 0, 14547, 14548, 7, 107, 0, 0, 14548, 2019, 1, 0, 0, 0, 14549, + 14554, 3, 2022, 1011, 0, 14550, 14551, 5, 6, 0, 0, 14551, 14553, 3, 2022, + 1011, 0, 14552, 14550, 1, 0, 0, 0, 14553, 14556, 1, 0, 0, 0, 14554, 14552, + 1, 0, 0, 0, 14554, 14555, 1, 0, 0, 0, 14555, 2021, 1, 0, 0, 0, 14556, 14554, + 1, 0, 0, 0, 14557, 14558, 3, 2026, 1013, 0, 14558, 14559, 3, 2002, 1001, + 0, 14559, 14560, 3, 2024, 1012, 0, 14560, 2023, 1, 0, 0, 0, 14561, 14562, + 3, 1924, 962, 0, 14562, 2025, 1, 0, 0, 0, 14563, 14564, 3, 2028, 1014, + 0, 14564, 2027, 1, 0, 0, 0, 14565, 14568, 3, 566, 283, 0, 14566, 14568, + 5, 28, 0, 0, 14567, 14565, 1, 0, 0, 0, 14567, 14566, 1, 0, 0, 0, 14568, + 14575, 1, 0, 0, 0, 14569, 14570, 5, 4, 0, 0, 14570, 14571, 3, 2168, 1084, + 0, 14571, 14572, 5, 5, 0, 0, 14572, 14574, 1, 0, 0, 0, 14573, 14569, 1, + 0, 0, 0, 14574, 14577, 1, 0, 0, 0, 14575, 14573, 1, 0, 0, 0, 14575, 14576, + 1, 0, 0, 0, 14576, 2029, 1, 0, 0, 0, 14577, 14575, 1, 0, 0, 0, 14578, 14579, + 5, 224, 0, 0, 14579, 14580, 3, 2164, 1082, 0, 14580, 14581, 5, 94, 0, 0, + 14581, 14582, 3, 2004, 1002, 0, 14582, 14584, 3, 2032, 1016, 0, 14583, + 14585, 3, 2034, 1017, 0, 14584, 14583, 1, 0, 0, 0, 14584, 14585, 1, 0, + 0, 0, 14585, 14586, 1, 0, 0, 0, 14586, 14587, 5, 653, 0, 0, 14587, 14588, + 5, 224, 0, 0, 14588, 14589, 5, 7, 0, 0, 14589, 2031, 1, 0, 0, 0, 14590, + 14591, 5, 701, 0, 0, 14591, 14592, 3, 1710, 855, 0, 14592, 14593, 5, 94, + 0, 0, 14593, 14594, 3, 2004, 1002, 0, 14594, 14596, 1, 0, 0, 0, 14595, + 14590, 1, 0, 0, 0, 14596, 14599, 1, 0, 0, 0, 14597, 14595, 1, 0, 0, 0, + 14597, 14598, 1, 0, 0, 0, 14598, 2033, 1, 0, 0, 0, 14599, 14597, 1, 0, + 0, 0, 14600, 14601, 5, 58, 0, 0, 14601, 14602, 3, 2004, 1002, 0, 14602, + 2035, 1, 0, 0, 0, 14603, 14605, 5, 40, 0, 0, 14604, 14606, 3, 2038, 1019, + 0, 14605, 14604, 1, 0, 0, 0, 14605, 14606, 1, 0, 0, 0, 14606, 14607, 1, + 0, 0, 0, 14607, 14609, 3, 2040, 1020, 0, 14608, 14610, 3, 2044, 1022, 0, + 14609, 14608, 1, 0, 0, 0, 14609, 14610, 1, 0, 0, 0, 14610, 14611, 1, 0, + 0, 0, 14611, 14612, 5, 653, 0, 0, 14612, 14613, 5, 40, 0, 0, 14613, 14614, + 5, 7, 0, 0, 14614, 2037, 1, 0, 0, 0, 14615, 14616, 3, 2162, 1081, 0, 14616, + 2039, 1, 0, 0, 0, 14617, 14619, 3, 2042, 1021, 0, 14618, 14617, 1, 0, 0, + 0, 14619, 14620, 1, 0, 0, 0, 14620, 14618, 1, 0, 0, 0, 14620, 14621, 1, + 0, 0, 0, 14621, 2041, 1, 0, 0, 0, 14622, 14623, 5, 103, 0, 0, 14623, 14624, + 3, 1830, 915, 0, 14624, 14625, 5, 94, 0, 0, 14625, 14626, 3, 2004, 1002, + 0, 14626, 2043, 1, 0, 0, 0, 14627, 14628, 5, 58, 0, 0, 14628, 14629, 3, + 2004, 1002, 0, 14629, 2045, 1, 0, 0, 0, 14630, 14632, 3, 2152, 1076, 0, + 14631, 14630, 1, 0, 0, 0, 14631, 14632, 1, 0, 0, 0, 14632, 14633, 1, 0, + 0, 0, 14633, 14634, 3, 2092, 1046, 0, 14634, 2047, 1, 0, 0, 0, 14635, 14637, + 3, 2152, 1076, 0, 14636, 14635, 1, 0, 0, 0, 14636, 14637, 1, 0, 0, 0, 14637, + 14638, 1, 0, 0, 0, 14638, 14639, 5, 702, 0, 0, 14639, 14640, 3, 2170, 1085, + 0, 14640, 14641, 3, 2092, 1046, 0, 14641, 2049, 1, 0, 0, 0, 14642, 14644, + 3, 2152, 1076, 0, 14643, 14642, 1, 0, 0, 0, 14643, 14644, 1, 0, 0, 0, 14644, + 14645, 1, 0, 0, 0, 14645, 14646, 5, 62, 0, 0, 14646, 14647, 3, 2052, 1026, + 0, 14647, 14648, 3, 2092, 1046, 0, 14648, 2051, 1, 0, 0, 0, 14649, 14650, + 3, 2062, 1031, 0, 14650, 14671, 5, 68, 0, 0, 14651, 14653, 3, 1490, 745, + 0, 14652, 14654, 3, 2056, 1028, 0, 14653, 14652, 1, 0, 0, 0, 14653, 14654, + 1, 0, 0, 0, 14654, 14672, 1, 0, 0, 0, 14655, 14672, 3, 1496, 748, 0, 14656, + 14672, 3, 1412, 706, 0, 14657, 14658, 5, 206, 0, 0, 14658, 14660, 3, 1710, + 855, 0, 14659, 14661, 3, 2054, 1027, 0, 14660, 14659, 1, 0, 0, 0, 14660, + 14661, 1, 0, 0, 0, 14661, 14672, 1, 0, 0, 0, 14662, 14664, 3, 2058, 1029, + 0, 14663, 14662, 1, 0, 0, 0, 14663, 14664, 1, 0, 0, 0, 14664, 14665, 1, + 0, 0, 0, 14665, 14666, 3, 1710, 855, 0, 14666, 14667, 5, 24, 0, 0, 14667, + 14669, 3, 1710, 855, 0, 14668, 14670, 3, 2060, 1030, 0, 14669, 14668, 1, + 0, 0, 0, 14669, 14670, 1, 0, 0, 0, 14670, 14672, 1, 0, 0, 0, 14671, 14651, + 1, 0, 0, 0, 14671, 14655, 1, 0, 0, 0, 14671, 14656, 1, 0, 0, 0, 14671, + 14657, 1, 0, 0, 0, 14671, 14663, 1, 0, 0, 0, 14672, 2053, 1, 0, 0, 0, 14673, + 14674, 5, 101, 0, 0, 14674, 14675, 3, 1830, 915, 0, 14675, 2055, 1, 0, + 0, 0, 14676, 14677, 5, 2, 0, 0, 14677, 14682, 3, 1710, 855, 0, 14678, 14679, + 5, 6, 0, 0, 14679, 14681, 3, 1710, 855, 0, 14680, 14678, 1, 0, 0, 0, 14681, + 14684, 1, 0, 0, 0, 14682, 14680, 1, 0, 0, 0, 14682, 14683, 1, 0, 0, 0, + 14683, 14685, 1, 0, 0, 0, 14684, 14682, 1, 0, 0, 0, 14685, 14686, 5, 3, + 0, 0, 14686, 2057, 1, 0, 0, 0, 14687, 14688, 5, 703, 0, 0, 14688, 2059, + 1, 0, 0, 0, 14689, 14690, 5, 149, 0, 0, 14690, 14691, 3, 1710, 855, 0, + 14691, 2061, 1, 0, 0, 0, 14692, 14693, 3, 564, 282, 0, 14693, 2063, 1, + 0, 0, 0, 14694, 14696, 3, 2152, 1076, 0, 14695, 14694, 1, 0, 0, 0, 14695, + 14696, 1, 0, 0, 0, 14696, 14697, 1, 0, 0, 0, 14697, 14698, 5, 704, 0, 0, + 14698, 14700, 3, 2062, 1031, 0, 14699, 14701, 3, 2066, 1033, 0, 14700, + 14699, 1, 0, 0, 0, 14700, 14701, 1, 0, 0, 0, 14701, 14702, 1, 0, 0, 0, + 14702, 14703, 5, 68, 0, 0, 14703, 14704, 5, 35, 0, 0, 14704, 14705, 3, + 1710, 855, 0, 14705, 14706, 3, 2092, 1046, 0, 14706, 2065, 1, 0, 0, 0, + 14707, 14708, 5, 705, 0, 0, 14708, 14709, 3, 1908, 954, 0, 14709, 2067, + 1, 0, 0, 0, 14710, 14712, 3, 2070, 1035, 0, 14711, 14713, 3, 2154, 1077, + 0, 14712, 14711, 1, 0, 0, 0, 14712, 14713, 1, 0, 0, 0, 14713, 14715, 1, + 0, 0, 0, 14714, 14716, 3, 2156, 1078, 0, 14715, 14714, 1, 0, 0, 0, 14715, + 14716, 1, 0, 0, 0, 14716, 14717, 1, 0, 0, 0, 14717, 14718, 5, 7, 0, 0, + 14718, 2069, 1, 0, 0, 0, 14719, 14720, 7, 108, 0, 0, 14720, 2071, 1, 0, + 0, 0, 14721, 14736, 5, 707, 0, 0, 14722, 14723, 5, 265, 0, 0, 14723, 14737, + 3, 2162, 1081, 0, 14724, 14731, 5, 708, 0, 0, 14725, 14726, 5, 206, 0, + 0, 14726, 14728, 3, 1710, 855, 0, 14727, 14729, 3, 2054, 1027, 0, 14728, + 14727, 1, 0, 0, 0, 14728, 14729, 1, 0, 0, 0, 14729, 14732, 1, 0, 0, 0, + 14730, 14732, 3, 1496, 748, 0, 14731, 14725, 1, 0, 0, 0, 14731, 14730, + 1, 0, 0, 0, 14732, 14737, 1, 0, 0, 0, 14733, 14735, 3, 2074, 1037, 0, 14734, + 14733, 1, 0, 0, 0, 14734, 14735, 1, 0, 0, 0, 14735, 14737, 1, 0, 0, 0, + 14736, 14722, 1, 0, 0, 0, 14736, 14724, 1, 0, 0, 0, 14736, 14734, 1, 0, + 0, 0, 14737, 14738, 1, 0, 0, 0, 14738, 14739, 5, 7, 0, 0, 14739, 2073, + 1, 0, 0, 0, 14740, 14741, 3, 2162, 1081, 0, 14741, 2075, 1, 0, 0, 0, 14742, + 14744, 5, 709, 0, 0, 14743, 14745, 3, 2078, 1039, 0, 14744, 14743, 1, 0, + 0, 0, 14744, 14745, 1, 0, 0, 0, 14745, 14746, 1, 0, 0, 0, 14746, 14748, + 3, 1910, 955, 0, 14747, 14749, 3, 2080, 1040, 0, 14748, 14747, 1, 0, 0, + 0, 14748, 14749, 1, 0, 0, 0, 14749, 14751, 1, 0, 0, 0, 14750, 14752, 3, + 2082, 1041, 0, 14751, 14750, 1, 0, 0, 0, 14751, 14752, 1, 0, 0, 0, 14752, + 14753, 1, 0, 0, 0, 14753, 14754, 5, 7, 0, 0, 14754, 14786, 1, 0, 0, 0, + 14755, 14757, 5, 709, 0, 0, 14756, 14758, 3, 2078, 1039, 0, 14757, 14756, + 1, 0, 0, 0, 14757, 14758, 1, 0, 0, 0, 14758, 14759, 1, 0, 0, 0, 14759, + 14761, 3, 1934, 967, 0, 14760, 14762, 3, 2082, 1041, 0, 14761, 14760, 1, + 0, 0, 0, 14761, 14762, 1, 0, 0, 0, 14762, 14763, 1, 0, 0, 0, 14763, 14764, + 5, 7, 0, 0, 14764, 14786, 1, 0, 0, 0, 14765, 14767, 5, 709, 0, 0, 14766, + 14768, 3, 2078, 1039, 0, 14767, 14766, 1, 0, 0, 0, 14767, 14768, 1, 0, + 0, 0, 14768, 14769, 1, 0, 0, 0, 14769, 14770, 5, 710, 0, 0, 14770, 14772, + 3, 1910, 955, 0, 14771, 14773, 3, 2082, 1041, 0, 14772, 14771, 1, 0, 0, + 0, 14772, 14773, 1, 0, 0, 0, 14773, 14774, 1, 0, 0, 0, 14774, 14775, 5, + 7, 0, 0, 14775, 14786, 1, 0, 0, 0, 14776, 14778, 5, 709, 0, 0, 14777, 14779, + 3, 2078, 1039, 0, 14778, 14777, 1, 0, 0, 0, 14778, 14779, 1, 0, 0, 0, 14779, + 14781, 1, 0, 0, 0, 14780, 14782, 3, 2082, 1041, 0, 14781, 14780, 1, 0, + 0, 0, 14781, 14782, 1, 0, 0, 0, 14782, 14783, 1, 0, 0, 0, 14783, 14786, + 5, 7, 0, 0, 14784, 14786, 5, 709, 0, 0, 14785, 14742, 1, 0, 0, 0, 14785, + 14755, 1, 0, 0, 0, 14785, 14765, 1, 0, 0, 0, 14785, 14776, 1, 0, 0, 0, + 14785, 14784, 1, 0, 0, 0, 14786, 2077, 1, 0, 0, 0, 14787, 14788, 7, 109, + 0, 0, 14788, 2079, 1, 0, 0, 0, 14789, 14790, 5, 6, 0, 0, 14790, 14792, + 3, 1710, 855, 0, 14791, 14789, 1, 0, 0, 0, 14792, 14793, 1, 0, 0, 0, 14793, + 14791, 1, 0, 0, 0, 14793, 14794, 1, 0, 0, 0, 14794, 2081, 1, 0, 0, 0, 14795, + 14796, 5, 101, 0, 0, 14796, 14797, 3, 2086, 1043, 0, 14797, 2083, 1, 0, + 0, 0, 14798, 14799, 3, 1934, 967, 0, 14799, 14800, 5, 10, 0, 0, 14800, + 14801, 3, 1710, 855, 0, 14801, 2085, 1, 0, 0, 0, 14802, 14807, 3, 2084, + 1042, 0, 14803, 14804, 5, 6, 0, 0, 14804, 14806, 3, 2084, 1042, 0, 14805, + 14803, 1, 0, 0, 0, 14806, 14809, 1, 0, 0, 0, 14807, 14805, 1, 0, 0, 0, + 14807, 14808, 1, 0, 0, 0, 14808, 2087, 1, 0, 0, 0, 14809, 14807, 1, 0, + 0, 0, 14810, 14811, 5, 717, 0, 0, 14811, 14813, 3, 2162, 1081, 0, 14812, + 14814, 3, 2090, 1045, 0, 14813, 14812, 1, 0, 0, 0, 14813, 14814, 1, 0, + 0, 0, 14814, 14815, 1, 0, 0, 0, 14815, 14816, 5, 7, 0, 0, 14816, 2089, + 1, 0, 0, 0, 14817, 14818, 5, 6, 0, 0, 14818, 14819, 3, 2162, 1081, 0, 14819, + 2091, 1, 0, 0, 0, 14820, 14821, 5, 718, 0, 0, 14821, 14822, 3, 2004, 1002, + 0, 14822, 14823, 5, 653, 0, 0, 14823, 14825, 5, 718, 0, 0, 14824, 14826, + 3, 2154, 1077, 0, 14825, 14824, 1, 0, 0, 0, 14825, 14826, 1, 0, 0, 0, 14826, + 14827, 1, 0, 0, 0, 14827, 14828, 5, 7, 0, 0, 14828, 2093, 1, 0, 0, 0, 14829, + 14830, 3, 2172, 1086, 0, 14830, 14831, 5, 7, 0, 0, 14831, 2095, 1, 0, 0, + 0, 14832, 14833, 5, 206, 0, 0, 14833, 14847, 3, 1710, 855, 0, 14834, 14836, + 3, 2102, 1051, 0, 14835, 14834, 1, 0, 0, 0, 14835, 14836, 1, 0, 0, 0, 14836, + 14838, 1, 0, 0, 0, 14837, 14839, 3, 2098, 1049, 0, 14838, 14837, 1, 0, + 0, 0, 14838, 14839, 1, 0, 0, 0, 14839, 14848, 1, 0, 0, 0, 14840, 14842, + 3, 2098, 1049, 0, 14841, 14840, 1, 0, 0, 0, 14841, 14842, 1, 0, 0, 0, 14842, + 14844, 1, 0, 0, 0, 14843, 14845, 3, 2102, 1051, 0, 14844, 14843, 1, 0, + 0, 0, 14844, 14845, 1, 0, 0, 0, 14845, 14848, 1, 0, 0, 0, 14846, 14848, + 1, 0, 0, 0, 14847, 14835, 1, 0, 0, 0, 14847, 14841, 1, 0, 0, 0, 14847, + 14846, 1, 0, 0, 0, 14848, 14849, 1, 0, 0, 0, 14849, 14850, 5, 7, 0, 0, + 14850, 2097, 1, 0, 0, 0, 14851, 14852, 5, 101, 0, 0, 14852, 14853, 3, 2100, + 1050, 0, 14853, 2099, 1, 0, 0, 0, 14854, 14859, 3, 1710, 855, 0, 14855, + 14856, 5, 6, 0, 0, 14856, 14858, 3, 1710, 855, 0, 14857, 14855, 1, 0, 0, + 0, 14858, 14861, 1, 0, 0, 0, 14859, 14857, 1, 0, 0, 0, 14859, 14860, 1, + 0, 0, 0, 14860, 2101, 1, 0, 0, 0, 14861, 14859, 1, 0, 0, 0, 14862, 14864, + 5, 71, 0, 0, 14863, 14865, 5, 344, 0, 0, 14864, 14863, 1, 0, 0, 0, 14864, + 14865, 1, 0, 0, 0, 14865, 14866, 1, 0, 0, 0, 14866, 14867, 3, 2118, 1059, + 0, 14867, 2103, 1, 0, 0, 0, 14868, 14889, 5, 719, 0, 0, 14869, 14871, 3, + 2138, 1069, 0, 14870, 14872, 3, 2112, 1056, 0, 14871, 14870, 1, 0, 0, 0, + 14871, 14872, 1, 0, 0, 0, 14872, 14873, 1, 0, 0, 0, 14873, 14880, 5, 62, + 0, 0, 14874, 14881, 3, 1496, 748, 0, 14875, 14876, 5, 206, 0, 0, 14876, + 14878, 3, 2162, 1081, 0, 14877, 14879, 3, 2110, 1055, 0, 14878, 14877, + 1, 0, 0, 0, 14878, 14879, 1, 0, 0, 0, 14879, 14881, 1, 0, 0, 0, 14880, + 14874, 1, 0, 0, 0, 14880, 14875, 1, 0, 0, 0, 14881, 14890, 1, 0, 0, 0, + 14882, 14887, 3, 1924, 962, 0, 14883, 14884, 5, 2, 0, 0, 14884, 14885, + 3, 2108, 1054, 0, 14885, 14886, 5, 3, 0, 0, 14886, 14888, 1, 0, 0, 0, 14887, + 14883, 1, 0, 0, 0, 14887, 14888, 1, 0, 0, 0, 14888, 14890, 1, 0, 0, 0, + 14889, 14869, 1, 0, 0, 0, 14889, 14882, 1, 0, 0, 0, 14890, 14891, 1, 0, + 0, 0, 14891, 14892, 5, 7, 0, 0, 14892, 2105, 1, 0, 0, 0, 14893, 14894, + 3, 1924, 962, 0, 14894, 14895, 5, 20, 0, 0, 14895, 14896, 3, 1710, 855, + 0, 14896, 14899, 1, 0, 0, 0, 14897, 14899, 3, 1710, 855, 0, 14898, 14893, + 1, 0, 0, 0, 14898, 14897, 1, 0, 0, 0, 14899, 2107, 1, 0, 0, 0, 14900, 14905, + 3, 2106, 1053, 0, 14901, 14902, 5, 6, 0, 0, 14902, 14904, 3, 2106, 1053, + 0, 14903, 14901, 1, 0, 0, 0, 14904, 14907, 1, 0, 0, 0, 14905, 14903, 1, + 0, 0, 0, 14905, 14906, 1, 0, 0, 0, 14906, 2109, 1, 0, 0, 0, 14907, 14905, + 1, 0, 0, 0, 14908, 14909, 5, 101, 0, 0, 14909, 14910, 3, 1830, 915, 0, + 14910, 2111, 1, 0, 0, 0, 14911, 14913, 3, 2114, 1057, 0, 14912, 14911, + 1, 0, 0, 0, 14912, 14913, 1, 0, 0, 0, 14913, 14914, 1, 0, 0, 0, 14914, + 14915, 5, 322, 0, 0, 14915, 2113, 1, 0, 0, 0, 14916, 14917, 5, 266, 0, + 0, 14917, 2115, 1, 0, 0, 0, 14918, 14920, 5, 61, 0, 0, 14919, 14921, 3, + 2122, 1061, 0, 14920, 14919, 1, 0, 0, 0, 14920, 14921, 1, 0, 0, 0, 14921, + 14923, 1, 0, 0, 0, 14922, 14924, 3, 2120, 1060, 0, 14923, 14922, 1, 0, + 0, 0, 14923, 14924, 1, 0, 0, 0, 14924, 14925, 1, 0, 0, 0, 14925, 14926, + 3, 2138, 1069, 0, 14926, 14927, 5, 71, 0, 0, 14927, 14928, 3, 2118, 1059, + 0, 14928, 14929, 5, 7, 0, 0, 14929, 2117, 1, 0, 0, 0, 14930, 14931, 3, + 1830, 915, 0, 14931, 2119, 1, 0, 0, 0, 14932, 14933, 7, 110, 0, 0, 14933, + 2121, 1, 0, 0, 0, 14934, 14950, 5, 265, 0, 0, 14935, 14950, 5, 291, 0, + 0, 14936, 14950, 5, 211, 0, 0, 14937, 14950, 5, 244, 0, 0, 14938, 14939, + 5, 132, 0, 0, 14939, 14950, 3, 1710, 855, 0, 14940, 14941, 5, 305, 0, 0, + 14941, 14950, 3, 1710, 855, 0, 14942, 14950, 3, 1710, 855, 0, 14943, 14950, + 5, 30, 0, 0, 14944, 14947, 7, 111, 0, 0, 14945, 14948, 3, 1710, 855, 0, + 14946, 14948, 5, 30, 0, 0, 14947, 14945, 1, 0, 0, 0, 14947, 14946, 1, 0, + 0, 0, 14947, 14948, 1, 0, 0, 0, 14948, 14950, 1, 0, 0, 0, 14949, 14934, + 1, 0, 0, 0, 14949, 14935, 1, 0, 0, 0, 14949, 14936, 1, 0, 0, 0, 14949, + 14937, 1, 0, 0, 0, 14949, 14938, 1, 0, 0, 0, 14949, 14940, 1, 0, 0, 0, + 14949, 14942, 1, 0, 0, 0, 14949, 14943, 1, 0, 0, 0, 14949, 14944, 1, 0, + 0, 0, 14950, 2123, 1, 0, 0, 0, 14951, 14953, 5, 262, 0, 0, 14952, 14954, + 3, 2122, 1061, 0, 14953, 14952, 1, 0, 0, 0, 14953, 14954, 1, 0, 0, 0, 14954, + 14955, 1, 0, 0, 0, 14955, 14956, 3, 2138, 1069, 0, 14956, 14957, 5, 7, + 0, 0, 14957, 2125, 1, 0, 0, 0, 14958, 14959, 5, 159, 0, 0, 14959, 14960, + 3, 2138, 1069, 0, 14960, 14961, 5, 7, 0, 0, 14961, 2127, 1, 0, 0, 0, 14962, + 14963, 5, 78, 0, 0, 14963, 14964, 5, 7, 0, 0, 14964, 2129, 1, 0, 0, 0, + 14965, 14967, 5, 163, 0, 0, 14966, 14968, 3, 2134, 1067, 0, 14967, 14966, + 1, 0, 0, 0, 14967, 14968, 1, 0, 0, 0, 14968, 14969, 1, 0, 0, 0, 14969, + 14970, 5, 7, 0, 0, 14970, 2131, 1, 0, 0, 0, 14971, 14973, 5, 317, 0, 0, + 14972, 14974, 3, 2134, 1067, 0, 14973, 14972, 1, 0, 0, 0, 14973, 14974, + 1, 0, 0, 0, 14974, 14975, 1, 0, 0, 0, 14975, 14976, 5, 7, 0, 0, 14976, + 2133, 1, 0, 0, 0, 14977, 14979, 5, 33, 0, 0, 14978, 14980, 5, 266, 0, 0, + 14979, 14978, 1, 0, 0, 0, 14979, 14980, 1, 0, 0, 0, 14980, 14981, 1, 0, + 0, 0, 14981, 14982, 5, 155, 0, 0, 14982, 2135, 1, 0, 0, 0, 14983, 14984, + 5, 331, 0, 0, 14984, 14985, 3, 566, 283, 0, 14985, 14986, 5, 95, 0, 0, + 14986, 14987, 5, 53, 0, 0, 14987, 14988, 5, 7, 0, 0, 14988, 14996, 1, 0, + 0, 0, 14989, 14992, 5, 311, 0, 0, 14990, 14993, 3, 566, 283, 0, 14991, + 14993, 5, 30, 0, 0, 14992, 14990, 1, 0, 0, 0, 14992, 14991, 1, 0, 0, 0, + 14993, 14994, 1, 0, 0, 0, 14994, 14996, 5, 7, 0, 0, 14995, 14983, 1, 0, + 0, 0, 14995, 14989, 1, 0, 0, 0, 14996, 2137, 1, 0, 0, 0, 14997, 15000, + 3, 1924, 962, 0, 14998, 15000, 5, 28, 0, 0, 14999, 14997, 1, 0, 0, 0, 14999, + 14998, 1, 0, 0, 0, 15000, 2139, 1, 0, 0, 0, 15001, 15002, 5, 716, 0, 0, + 15002, 15003, 3, 2142, 1071, 0, 15003, 2141, 1, 0, 0, 0, 15004, 15006, + 3, 2144, 1072, 0, 15005, 15004, 1, 0, 0, 0, 15006, 15007, 1, 0, 0, 0, 15007, + 15005, 1, 0, 0, 0, 15007, 15008, 1, 0, 0, 0, 15008, 2143, 1, 0, 0, 0, 15009, + 15010, 5, 103, 0, 0, 15010, 15011, 3, 2146, 1073, 0, 15011, 15012, 5, 94, + 0, 0, 15012, 15013, 3, 2004, 1002, 0, 15013, 2145, 1, 0, 0, 0, 15014, 15019, + 3, 2148, 1074, 0, 15015, 15016, 5, 82, 0, 0, 15016, 15018, 3, 2148, 1074, + 0, 15017, 15015, 1, 0, 0, 0, 15018, 15021, 1, 0, 0, 0, 15019, 15017, 1, + 0, 0, 0, 15019, 15020, 1, 0, 0, 0, 15020, 2147, 1, 0, 0, 0, 15021, 15019, + 1, 0, 0, 0, 15022, 15026, 3, 2158, 1079, 0, 15023, 15024, 5, 710, 0, 0, + 15024, 15026, 3, 1910, 955, 0, 15025, 15022, 1, 0, 0, 0, 15025, 15023, + 1, 0, 0, 0, 15026, 2149, 1, 0, 0, 0, 15027, 15028, 3, 1968, 984, 0, 15028, + 2151, 1, 0, 0, 0, 15029, 15030, 3, 1968, 984, 0, 15030, 2153, 1, 0, 0, + 0, 15031, 15032, 3, 2158, 1079, 0, 15032, 2155, 1, 0, 0, 0, 15033, 15034, + 5, 103, 0, 0, 15034, 15035, 3, 2166, 1083, 0, 15035, 2157, 1, 0, 0, 0, + 15036, 15039, 3, 1924, 962, 0, 15037, 15039, 3, 2160, 1080, 0, 15038, 15036, + 1, 0, 0, 0, 15038, 15037, 1, 0, 0, 0, 15039, 2159, 1, 0, 0, 0, 15040, 15041, + 7, 112, 0, 0, 15041, 2161, 1, 0, 0, 0, 15042, 15044, 3, 1878, 939, 0, 15043, + 15042, 1, 0, 0, 0, 15043, 15044, 1, 0, 0, 0, 15044, 15046, 1, 0, 0, 0, + 15045, 15047, 3, 1524, 762, 0, 15046, 15045, 1, 0, 0, 0, 15046, 15047, + 1, 0, 0, 0, 15047, 15049, 1, 0, 0, 0, 15048, 15050, 3, 1598, 799, 0, 15049, + 15048, 1, 0, 0, 0, 15049, 15050, 1, 0, 0, 0, 15050, 15052, 1, 0, 0, 0, + 15051, 15053, 3, 1638, 819, 0, 15052, 15051, 1, 0, 0, 0, 15052, 15053, + 1, 0, 0, 0, 15053, 15055, 1, 0, 0, 0, 15054, 15056, 3, 1568, 784, 0, 15055, + 15054, 1, 0, 0, 0, 15055, 15056, 1, 0, 0, 0, 15056, 15058, 1, 0, 0, 0, + 15057, 15059, 3, 1582, 791, 0, 15058, 15057, 1, 0, 0, 0, 15058, 15059, + 1, 0, 0, 0, 15059, 15061, 1, 0, 0, 0, 15060, 15062, 3, 1790, 895, 0, 15061, + 15060, 1, 0, 0, 0, 15061, 15062, 1, 0, 0, 0, 15062, 2163, 1, 0, 0, 0, 15063, + 15064, 3, 2162, 1081, 0, 15064, 2165, 1, 0, 0, 0, 15065, 15066, 3, 2162, + 1081, 0, 15066, 2167, 1, 0, 0, 0, 15067, 15068, 3, 1710, 855, 0, 15068, + 2169, 1, 0, 0, 0, 15069, 15070, 3, 1710, 855, 0, 15070, 2171, 1, 0, 0, + 0, 15071, 15073, 3, 8, 4, 0, 15072, 15074, 3, 2174, 1087, 0, 15073, 15072, + 1, 0, 0, 0, 15073, 15074, 1, 0, 0, 0, 15074, 2173, 1, 0, 0, 0, 15075, 15077, + 5, 71, 0, 0, 15076, 15078, 3, 1528, 764, 0, 15077, 15076, 1, 0, 0, 0, 15077, + 15078, 1, 0, 0, 0, 15078, 15079, 1, 0, 0, 0, 15079, 15080, 3, 2118, 1059, + 0, 15080, 2175, 1, 0, 0, 0, 1495, 2185, 2189, 2375, 2379, 2388, 2397, 2405, + 2411, 2414, 2420, 2430, 2440, 2460, 2467, 2479, 2485, 2493, 2506, 2515, + 2519, 2529, 2532, 2538, 2543, 2555, 2571, 2575, 2578, 2581, 2587, 2590, + 2592, 2600, 2603, 2606, 2611, 2619, 2623, 2635, 2655, 2668, 2675, 2683, + 2688, 2695, 2701, 2708, 2719, 2723, 2727, 2740, 2744, 2749, 2754, 2769, + 2778, 2795, 2804, 2849, 2867, 2873, 2877, 2880, 2883, 2887, 2891, 2895, + 2904, 2908, 2918, 2947, 2957, 2972, 2993, 2998, 3002, 3026, 3036, 3060, + 3067, 3076, 3085, 3093, 3103, 3112, 3121, 3129, 3137, 3146, 3155, 3159, + 3166, 3174, 3184, 3190, 3194, 3198, 3202, 3206, 3211, 3214, 3218, 3239, + 3245, 3344, 3351, 3367, 3381, 3391, 3393, 3398, 3402, 3405, 3411, 3413, + 3441, 3451, 3464, 3471, 3477, 3481, 3487, 3492, 3495, 3497, 3502, 3506, + 3510, 3514, 3518, 3521, 3525, 3533, 3537, 3544, 3550, 3555, 3558, 3563, + 3573, 3575, 3578, 3581, 3585, 3589, 3592, 3596, 3609, 3618, 3625, 3630, + 3637, 3642, 3649, 3654, 3672, 3677, 3689, 3694, 3703, 3710, 3717, 3723, + 3728, 3732, 3737, 3748, 3757, 3760, 3775, 3783, 3789, 3793, 3798, 3801, + 3806, 3827, 3844, 3846, 3851, 3858, 3869, 3876, 3879, 3882, 3887, 3890, + 3897, 3906, 3913, 3918, 3921, 3924, 3926, 3930, 3937, 3944, 3954, 3964, + 3974, 3980, 3983, 3986, 3993, 4001, 4004, 4007, 4014, 4018, 4024, 4027, + 4030, 4033, 4045, 4048, 4051, 4055, 4069, 4087, 4098, 4113, 4130, 4132, + 4153, 4158, 4161, 4165, 4168, 4174, 4177, 4179, 4188, 4197, 4205, 4219, + 4222, 4245, 4249, 4260, 4269, 4278, 4281, 4287, 4293, 4296, 4301, 4304, + 4314, 4321, 4330, 4337, 4342, 4346, 4359, 4363, 4366, 4370, 4376, 4380, + 4386, 4400, 4409, 4427, 4432, 4435, 4438, 4448, 4455, 4460, 4463, 4466, + 4473, 4476, 4478, 4484, 4493, 4503, 4508, 4517, 4526, 4530, 4537, 4547, + 4558, 4668, 4676, 4679, 4689, 4694, 4704, 4715, 4727, 4740, 4750, 4763, + 4766, 4773, 4782, 4785, 4792, 4794, 4802, 4812, 4814, 4822, 4826, 4831, + 4842, 4846, 4851, 4861, 4867, 4880, 4886, 4888, 4895, 4903, 4908, 4923, + 4936, 4938, 4942, 4962, 4979, 4982, 4985, 4988, 4991, 4999, 5002, 5005, + 5051, 5054, 5057, 5075, 5082, 5091, 5097, 5104, 5114, 5122, 5127, 5139, + 5156, 5162, 5169, 5177, 5191, 5219, 5226, 5240, 5255, 5268, 5277, 5302, + 5313, 5380, 5391, 5397, 5405, 5416, 5430, 5439, 5449, 5461, 5476, 5487, + 5495, 5505, 5512, 5515, 5521, 5524, 5539, 5552, 5581, 5588, 5603, 5612, + 5623, 5625, 5634, 5645, 5647, 5654, 5669, 5675, 5683, 5689, 5697, 5707, + 5713, 5721, 5727, 5735, 5742, 5751, 5753, 5778, 5786, 5797, 5802, 5811, + 5816, 5822, 5829, 5834, 5838, 5841, 5847, 5996, 6000, 6005, 6016, 6027, + 6038, 6049, 6060, 6071, 6082, 6094, 6105, 6113, 6120, 6134, 6140, 6152, + 6158, 6186, 6196, 6208, 6215, 6220, 6224, 6231, 6235, 6248, 6258, 6266, + 6273, 6293, 6305, 6326, 6330, 6344, 6348, 6362, 6366, 6391, 6395, 6405, + 6410, 6414, 6437, 6439, 6448, 6453, 6458, 6469, 6476, 6480, 6493, 6501, + 6508, 6514, 6526, 6530, 6539, 6555, 6565, 6572, 6577, 6587, 6596, 6604, + 6607, 6611, 6615, 6622, 6675, 6682, 6686, 6697, 6713, 6721, 6725, 6729, + 6733, 6737, 6745, 6753, 6761, 6767, 6774, 6782, 6786, 6795, 6799, 6809, + 6813, 6817, 6820, 6824, 6828, 6838, 6845, 6850, 6857, 6870, 6874, 6886, + 6892, 6900, 6909, 6917, 6927, 6929, 6939, 6945, 6953, 6966, 6972, 6974, + 6982, 6994, 7005, 7009, 7014, 7025, 7029, 7034, 7045, 7049, 7054, 7066, + 7078, 7082, 7087, 7093, 7102, 7108, 7121, 7123, 7126, 7132, 7140, 7145, + 7147, 7152, 7163, 7174, 7179, 7191, 7201, 7210, 7222, 7224, 7230, 7238, + 7244, 7252, 7258, 7266, 7272, 7280, 7286, 7294, 7300, 7308, 7314, 7322, + 7324, 7341, 7348, 7353, 7357, 7361, 7367, 7369, 7431, 7438, 7444, 7455, + 7458, 7465, 7468, 7478, 7481, 7483, 7502, 7514, 7523, 7532, 7544, 7546, + 7552, 7556, 7561, 7564, 7569, 7575, 7578, 7581, 7584, 7587, 7603, 7607, + 7610, 7613, 7616, 7619, 7624, 7627, 7629, 7642, 7654, 7668, 7672, 7684, + 7686, 7693, 7705, 7707, 7710, 7721, 7733, 7741, 7744, 7748, 7757, 7765, + 7774, 7776, 7780, 7789, 7794, 7800, 7805, 7813, 7819, 7825, 7831, 7836, + 7851, 7860, 7871, 7877, 7916, 7931, 7938, 7949, 7963, 7976, 7988, 7993, + 8001, 8009, 8015, 8023, 8029, 8037, 8039, 8045, 8053, 8055, 8061, 8069, + 8071, 8095, 8102, 8112, 8124, 8129, 8142, 8154, 8166, 8168, 8174, 8179, + 8187, 8194, 8239, 8244, 8251, 8256, 8263, 8273, 8283, 8287, 8298, 8315, + 8386, 8581, 8594, 8605, 8618, 8630, 8644, 8676, 8690, 8802, 8804, 8815, + 8826, 8837, 8850, 8862, 8873, 8880, 9101, 9116, 9127, 9134, 9188, 9329, + 9335, 9344, 9352, 9354, 9361, 9367, 9370, 9377, 9381, 9384, 9389, 9392, + 9396, 9399, 9402, 9433, 9443, 9450, 9473, 9482, 9500, 9506, 9514, 9516, + 9520, 9530, 9534, 9544, 9547, 9551, 9555, 9563, 9574, 9586, 9590, 9593, + 9597, 9600, 9605, 9609, 9612, 9616, 9619, 9623, 9626, 9637, 9644, 9657, + 9671, 9675, 9680, 9687, 9694, 9697, 9702, 9705, 9714, 9716, 9721, 9724, + 9733, 9752, 9758, 9765, 9785, 9792, 9798, 9802, 9811, 9820, 9826, 9833, + 9838, 9841, 9845, 9848, 9859, 9863, 9868, 9879, 9891, 9901, 9908, 9914, + 9920, 9932, 9938, 9948, 9954, 9958, 9963, 9970, 9976, 9979, 9990, 9996, + 10000, 10011, 10022, 10028, 10043, 10061, 10065, 10069, 10077, 10081, 10085, + 10093, 10098, 10102, 10107, 10111, 10118, 10125, 10137, 10141, 10146, 10148, + 10155, 10163, 10167, 10180, 10189, 10206, 10212, 10224, 10235, 10242, 10250, + 10267, 10279, 10281, 10288, 10295, 10301, 10307, 10319, 10321, 10328, 10342, + 10352, 10356, 10363, 10369, 10378, 10382, 10391, 10405, 10408, 10412, 10438, + 10442, 10451, 10466, 10470, 10472, 10490, 10497, 10526, 10532, 10539, 10549, + 10555, 10563, 10574, 10584, 10589, 10611, 10616, 10618, 10628, 10633, 10644, + 10651, 10658, 10660, 10666, 10683, 10698, 10706, 10710, 10714, 10720, 10724, + 10728, 10732, 10736, 10740, 10747, 10755, 10759, 10764, 10785, 10792, 10803, + 10840, 10847, 10857, 10869, 10871, 10901, 10912, 10919, 10927, 10931, 10936, + 10944, 10951, 10959, 10963, 10974, 10983, 10988, 11000, 11012, 11029, 11038, + 11040, 11044, 11049, 11052, 11064, 11068, 11074, 11087, 11100, 11105, 11109, + 11116, 11121, 11137, 11144, 11146, 11152, 11159, 11165, 11169, 11173, 11182, + 11184, 11191, 11198, 11201, 11203, 11208, 11214, 11220, 11227, 11231, 11235, + 11250, 11254, 11270, 11276, 11297, 11308, 11312, 11318, 11327, 11351, 11355, + 11359, 11363, 11369, 11383, 11386, 11393, 11397, 11403, 11410, 11420, 11429, + 11432, 11446, 11448, 11464, 11484, 11505, 11509, 11514, 11597, 11603, 11616, + 11620, 11624, 11628, 11634, 11641, 11644, 11647, 11650, 11653, 11660, 11664, + 11667, 11673, 11676, 11678, 11687, 11691, 11698, 11700, 11706, 11713, 11720, + 11724, 11728, 11744, 11751, 11761, 11774, 11785, 11792, 11797, 11801, 11805, + 11810, 11824, 11829, 11833, 11841, 11844, 11848, 11859, 11862, 11864, 11880, + 11883, 11890, 11893, 11898, 11913, 11919, 11928, 11937, 11944, 11947, 11953, + 11958, 11964, 11969, 11973, 11978, 11981, 11988, 11992, 11997, 12004, 12007, + 12014, 12022, 12025, 12035, 12038, 12043, 12047, 12051, 12054, 12057, 12064, + 12068, 12071, 12086, 12089, 12096, 12099, 12106, 12109, 12112, 12119, 12132, + 12142, 12150, 12162, 12164, 12171, 12175, 12185, 12189, 12193, 12197, 12199, + 12204, 12208, 12212, 12214, 12216, 12221, 12226, 12232, 12237, 12242, 12245, + 12248, 12251, 12254, 12260, 12263, 12266, 12269, 12272, 12275, 12278, 12281, + 12284, 12287, 12293, 12306, 12314, 12323, 12328, 12332, 12341, 12347, 12351, + 12359, 12363, 12368, 12374, 12386, 12401, 12408, 12410, 12413, 12417, 12421, + 12423, 12431, 12440, 12446, 12448, 12450, 12457, 12461, 12470, 12474, 12489, + 12493, 12500, 12528, 12535, 12539, 12542, 12547, 12551, 12554, 12570, 12581, + 12586, 12589, 12593, 12597, 12601, 12606, 12610, 12614, 12616, 12625, 12630, + 12636, 12640, 12642, 12647, 12651, 12662, 12666, 12669, 12676, 12681, 12688, + 12693, 12696, 12702, 12706, 12715, 12719, 12727, 12729, 12736, 12741, 12744, + 12752, 12761, 12769, 12771, 12775, 12782, 12801, 12810, 12816, 12835, 12844, + 12850, 12854, 12859, 12869, 12876, 12885, 12888, 12892, 12899, 12901, 12908, + 12912, 12917, 12927, 12933, 12936, 12942, 12954, 12960, 12963, 12966, 12979, + 12985, 12989, 12993, 12996, 13004, 13008, 13012, 13020, 13026, 13030, 13036, + 13040, 13044, 13050, 13052, 13061, 13064, 13074, 13090, 13096, 13101, 13108, + 13117, 13124, 13132, 13140, 13145, 13149, 13155, 13159, 13163, 13166, 13172, + 13177, 13193, 13196, 13198, 13210, 13212, 13215, 13221, 13227, 13231, 13233, + 13241, 13245, 13254, 13262, 13268, 13271, 13280, 13285, 13292, 13302, 13328, + 13339, 13341, 13343, 13351, 13374, 13382, 13392, 13395, 13400, 13405, 13409, + 13415, 13418, 13421, 13424, 13428, 13442, 13449, 13456, 13463, 13481, 13489, + 13501, 13519, 13558, 13560, 13580, 13590, 13601, 13613, 13620, 13632, 13644, + 13650, 13658, 13675, 13700, 13710, 13714, 13717, 13720, 13723, 13736, 13741, + 13746, 13748, 13756, 13765, 13774, 13779, 13788, 13793, 13807, 13817, 13825, + 13839, 13846, 13854, 13862, 13869, 13875, 13884, 13899, 13910, 13943, 13952, + 13959, 13963, 13967, 13974, 13988, 13993, 13998, 14002, 14004, 14007, 14014, + 14019, 14029, 14034, 14037, 14042, 14049, 14054, 14061, 14077, 14089, 14094, + 14102, 14109, 14114, 14126, 14134, 14139, 14149, 14157, 14164, 14173, 14179, + 14185, 14191, 14199, 14203, 14210, 14307, 14318, 14323, 14346, 14354, 14362, + 14366, 14369, 14373, 14375, 14382, 14391, 14398, 14402, 14405, 14408, 14411, + 14415, 14420, 14427, 14440, 14450, 14469, 14476, 14506, 14516, 14525, 14530, + 14541, 14554, 14567, 14575, 14584, 14597, 14605, 14609, 14620, 14631, 14636, + 14643, 14653, 14660, 14663, 14669, 14671, 14682, 14695, 14700, 14712, 14715, + 14728, 14731, 14734, 14736, 14744, 14748, 14751, 14757, 14761, 14767, 14772, + 14778, 14781, 14785, 14793, 14807, 14813, 14825, 14835, 14838, 14841, 14844, + 14847, 14859, 14864, 14871, 14878, 14880, 14887, 14889, 14898, 14905, 14912, + 14920, 14923, 14947, 14949, 14953, 14967, 14973, 14979, 14992, 14995, 14999, + 15007, 15019, 15025, 15038, 15043, 15046, 15049, 15052, 15055, 15058, 15061, + 15073, 15077, + } + 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) + } +} + +// RedshiftParserInit initializes any static state used to implement RedshiftParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewRedshiftParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func RedshiftParserInit() { + staticData := &RedshiftParserParserStaticData + staticData.once.Do(redshiftparserParserInit) +} + +// NewRedshiftParser produces a new parser instance for the optional input antlr.TokenStream. +func NewRedshiftParser(input antlr.TokenStream) *RedshiftParser { + RedshiftParserInit() + this := new(RedshiftParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &RedshiftParserParserStaticData + 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 = "RedshiftParser.g4" + + return this +} + +// Note that '@members' cannot be changed now, but this should have been 'globals' +// If you are looking to have variables for each instance, use '@structmembers' + +// RedshiftParser tokens. +const ( + RedshiftParserEOF = antlr.TokenEOF + RedshiftParserDollar = 1 + RedshiftParserOPEN_PAREN = 2 + RedshiftParserCLOSE_PAREN = 3 + RedshiftParserOPEN_BRACKET = 4 + RedshiftParserCLOSE_BRACKET = 5 + RedshiftParserCOMMA = 6 + RedshiftParserSEMI = 7 + RedshiftParserCOLON = 8 + RedshiftParserSTAR = 9 + RedshiftParserEQUAL = 10 + RedshiftParserDOT = 11 + RedshiftParserPLUS = 12 + RedshiftParserMINUS = 13 + RedshiftParserSLASH = 14 + RedshiftParserCARET = 15 + RedshiftParserLT = 16 + RedshiftParserGT = 17 + RedshiftParserLESS_LESS = 18 + RedshiftParserGREATER_GREATER = 19 + RedshiftParserCOLON_EQUALS = 20 + RedshiftParserLESS_EQUALS = 21 + RedshiftParserEQUALS_GREATER = 22 + RedshiftParserGREATER_EQUALS = 23 + RedshiftParserDOT_DOT = 24 + RedshiftParserNOT_EQUALS = 25 + RedshiftParserTYPECAST = 26 + RedshiftParserPERCENT = 27 + RedshiftParserPARAM = 28 + RedshiftParserOperator = 29 + RedshiftParserALL = 30 + RedshiftParserANALYSE = 31 + RedshiftParserANALYZE = 32 + RedshiftParserAND = 33 + RedshiftParserANY = 34 + RedshiftParserARRAY = 35 + RedshiftParserAS = 36 + RedshiftParserASC = 37 + RedshiftParserASYMMETRIC = 38 + RedshiftParserBOTH = 39 + RedshiftParserCASE = 40 + RedshiftParserCAST = 41 + RedshiftParserCHECK = 42 + RedshiftParserCOLLATE = 43 + RedshiftParserCOLUMN = 44 + RedshiftParserCONSTRAINT = 45 + RedshiftParserCREATE = 46 + RedshiftParserCURRENT_CATALOG = 47 + RedshiftParserCURRENT_DATE = 48 + RedshiftParserCURRENT_ROLE = 49 + RedshiftParserCURRENT_TIME = 50 + RedshiftParserCURRENT_TIMESTAMP = 51 + RedshiftParserCURRENT_USER = 52 + RedshiftParserDEFAULT = 53 + RedshiftParserDEFERRABLE = 54 + RedshiftParserDESC = 55 + RedshiftParserDISTINCT = 56 + RedshiftParserDO = 57 + RedshiftParserELSE = 58 + RedshiftParserEXCEPT = 59 + RedshiftParserFALSE_P = 60 + RedshiftParserFETCH = 61 + RedshiftParserFOR = 62 + RedshiftParserFOREIGN = 63 + RedshiftParserFROM = 64 + RedshiftParserGRANT = 65 + RedshiftParserGROUP_P = 66 + RedshiftParserHAVING = 67 + RedshiftParserIN_P = 68 + RedshiftParserINITIALLY = 69 + RedshiftParserINTERSECT = 70 + RedshiftParserINTO = 71 + RedshiftParserLATERAL_P = 72 + RedshiftParserLEADING = 73 + RedshiftParserLIMIT = 74 + RedshiftParserLOCALTIME = 75 + RedshiftParserLOCALTIMESTAMP = 76 + RedshiftParserNOT = 77 + RedshiftParserNULL_P = 78 + RedshiftParserOFFSET = 79 + RedshiftParserON = 80 + RedshiftParserONLY = 81 + RedshiftParserOR = 82 + RedshiftParserORDER = 83 + RedshiftParserPLACING = 84 + RedshiftParserPRIMARY = 85 + RedshiftParserPUBLIC = 86 + RedshiftParserREFERENCES = 87 + RedshiftParserRETURNING = 88 + RedshiftParserSELECT = 89 + RedshiftParserSESSION_USER = 90 + RedshiftParserSOME = 91 + RedshiftParserSYMMETRIC = 92 + RedshiftParserTABLE = 93 + RedshiftParserTHEN = 94 + RedshiftParserTO = 95 + RedshiftParserTRAILING = 96 + RedshiftParserTRUE_P = 97 + RedshiftParserUNION = 98 + RedshiftParserUNIQUE = 99 + RedshiftParserUSER = 100 + RedshiftParserUSING = 101 + RedshiftParserVARIADIC = 102 + RedshiftParserWHEN = 103 + RedshiftParserWHERE = 104 + RedshiftParserWINDOW = 105 + RedshiftParserWITH = 106 + RedshiftParserAUTHORIZATION = 107 + RedshiftParserBINARY = 108 + RedshiftParserBINDING = 109 + RedshiftParserCOLLATION = 110 + RedshiftParserCONCURRENTLY = 111 + RedshiftParserCROSS = 112 + RedshiftParserCURRENT_SCHEMA = 113 + RedshiftParserFREEZE = 114 + RedshiftParserFULL = 115 + RedshiftParserILIKE = 116 + RedshiftParserINNER_P = 117 + RedshiftParserIS = 118 + RedshiftParserISNULL = 119 + RedshiftParserJOIN = 120 + RedshiftParserLEFT = 121 + RedshiftParserLIKE = 122 + RedshiftParserNATURAL = 123 + RedshiftParserNOTNULL = 124 + RedshiftParserOUTER_P = 125 + RedshiftParserOVER = 126 + RedshiftParserOVERLAPS = 127 + RedshiftParserRIGHT = 128 + RedshiftParserSIMILAR = 129 + RedshiftParserVERBOSE = 130 + RedshiftParserABORT_P = 131 + RedshiftParserABSOLUTE_P = 132 + RedshiftParserACCESS = 133 + RedshiftParserACTION = 134 + RedshiftParserADD_P = 135 + RedshiftParserADMIN = 136 + RedshiftParserAFTER = 137 + RedshiftParserAGGREGATE = 138 + RedshiftParserALSO = 139 + RedshiftParserALTER = 140 + RedshiftParserALWAYS = 141 + RedshiftParserASSERTION = 142 + RedshiftParserASSIGNMENT = 143 + RedshiftParserAT = 144 + RedshiftParserATTRIBUTE = 145 + RedshiftParserBACKWARD = 146 + RedshiftParserBEFORE = 147 + RedshiftParserBEGIN_P = 148 + RedshiftParserBY = 149 + RedshiftParserCACHE = 150 + RedshiftParserCALLED = 151 + RedshiftParserCASCADE = 152 + RedshiftParserCASCADED = 153 + RedshiftParserCATALOG = 154 + RedshiftParserCHAIN = 155 + RedshiftParserCHARACTERISTICS = 156 + RedshiftParserCHECKPOINT = 157 + RedshiftParserCLASS = 158 + RedshiftParserCLOSE = 159 + RedshiftParserCLUSTER = 160 + RedshiftParserCOMMENT = 161 + RedshiftParserCOMMENTS = 162 + RedshiftParserCOMMIT = 163 + RedshiftParserCOMMITTED = 164 + RedshiftParserCONFIGURATION = 165 + RedshiftParserCONNECTION = 166 + RedshiftParserCONSTRAINTS = 167 + RedshiftParserCONTENT_P = 168 + RedshiftParserCONTINUE_P = 169 + RedshiftParserCONVERSION_P = 170 + RedshiftParserCOPY = 171 + RedshiftParserCOST = 172 + RedshiftParserCSV = 173 + RedshiftParserJSON = 174 + RedshiftParserCURSOR = 175 + RedshiftParserCYCLE = 176 + RedshiftParserDATA_P = 177 + RedshiftParserDATA_CATALOG = 178 + RedshiftParserDATABASE = 179 + RedshiftParserDAY_P = 180 + RedshiftParserDEALLOCATE = 181 + RedshiftParserDECLARE = 182 + RedshiftParserDEFAULTS = 183 + RedshiftParserDEFERRED = 184 + RedshiftParserDEFINER = 185 + RedshiftParserDELETE_P = 186 + RedshiftParserDELIMITER = 187 + RedshiftParserDELIMITERS = 188 + RedshiftParserDICTIONARY = 189 + RedshiftParserDISABLE_P = 190 + RedshiftParserDISCARD = 191 + RedshiftParserDOCUMENT_P = 192 + RedshiftParserDOMAIN_P = 193 + RedshiftParserDOUBLE_P = 194 + RedshiftParserDROP = 195 + RedshiftParserEACH = 196 + RedshiftParserENABLE_P = 197 + RedshiftParserENCODING = 198 + RedshiftParserENCRYPTED = 199 + RedshiftParserENUM_P = 200 + RedshiftParserESCAPE = 201 + RedshiftParserEVENT = 202 + RedshiftParserEXCLUDE = 203 + RedshiftParserEXCLUDING = 204 + RedshiftParserEXCLUSIVE = 205 + RedshiftParserEXECUTE = 206 + RedshiftParserEXPLAIN = 207 + RedshiftParserEXTENSION = 208 + RedshiftParserEXTERNAL = 209 + RedshiftParserFAMILY = 210 + RedshiftParserFIRST_P = 211 + RedshiftParserFOLLOWING = 212 + RedshiftParserFORCE = 213 + RedshiftParserFORWARD = 214 + RedshiftParserFUNCTION = 215 + RedshiftParserFUNCTIONS = 216 + RedshiftParserGLOBAL = 217 + RedshiftParserGRANTED = 218 + RedshiftParserHANDLER = 219 + RedshiftParserHEADER_P = 220 + RedshiftParserHOLD = 221 + RedshiftParserHOUR_P = 222 + RedshiftParserIDENTITY_P = 223 + RedshiftParserIF_P = 224 + RedshiftParserIMMEDIATE = 225 + RedshiftParserIMMUTABLE = 226 + RedshiftParserIMPLICIT_P = 227 + RedshiftParserINCLUDING = 228 + RedshiftParserINCREMENT = 229 + RedshiftParserINDEX = 230 + RedshiftParserINDEXES = 231 + RedshiftParserINHERIT = 232 + RedshiftParserINHERITS = 233 + RedshiftParserINLINE_P = 234 + RedshiftParserINSENSITIVE = 235 + RedshiftParserINSERT = 236 + RedshiftParserINSTEAD = 237 + RedshiftParserINVOKER = 238 + RedshiftParserISOLATION = 239 + RedshiftParserKEY = 240 + RedshiftParserLABEL = 241 + RedshiftParserLANGUAGE = 242 + RedshiftParserLARGE_P = 243 + RedshiftParserLAST_P = 244 + RedshiftParserLEAKPROOF = 245 + RedshiftParserLEVEL = 246 + RedshiftParserLISTEN = 247 + RedshiftParserLOAD = 248 + RedshiftParserLOCAL = 249 + RedshiftParserLOCATION = 250 + RedshiftParserLOCK_P = 251 + RedshiftParserMAPPING = 252 + RedshiftParserMATCH = 253 + RedshiftParserMATCHED = 254 + RedshiftParserMATERIALIZED = 255 + RedshiftParserMAXVALUE = 256 + RedshiftParserMERGE = 257 + RedshiftParserMINUTE_P = 258 + RedshiftParserMINVALUE = 259 + RedshiftParserMODE = 260 + RedshiftParserMONTH_P = 261 + RedshiftParserMOVE = 262 + RedshiftParserNAME_P = 263 + RedshiftParserNAMES = 264 + RedshiftParserNEXT = 265 + RedshiftParserNO = 266 + RedshiftParserNOTHING = 267 + RedshiftParserNOTIFY = 268 + RedshiftParserNOWAIT = 269 + RedshiftParserNULLS_P = 270 + RedshiftParserOBJECT_P = 271 + RedshiftParserOF = 272 + RedshiftParserOFF = 273 + RedshiftParserOIDS = 274 + RedshiftParserOPERATOR = 275 + RedshiftParserOPTION = 276 + RedshiftParserOPTIONS = 277 + RedshiftParserOWNED = 278 + RedshiftParserOWNER = 279 + RedshiftParserPARSER = 280 + RedshiftParserPARTIAL = 281 + RedshiftParserPARTITION = 282 + RedshiftParserPASSING = 283 + RedshiftParserPASSWORD = 284 + RedshiftParserPLANS = 285 + RedshiftParserPRECEDING = 286 + RedshiftParserPREDICATE = 287 + RedshiftParserPREPARE = 288 + RedshiftParserPREPARED = 289 + RedshiftParserPRESERVE = 290 + RedshiftParserPRIOR = 291 + RedshiftParserPRIVILEGES = 292 + RedshiftParserPROCEDURAL = 293 + RedshiftParserPROCEDURE = 294 + RedshiftParserPROGRAM = 295 + RedshiftParserQUOTE = 296 + RedshiftParserRANGE = 297 + RedshiftParserREAD = 298 + RedshiftParserREASSIGN = 299 + RedshiftParserRECHECK = 300 + RedshiftParserRECURSIVE = 301 + RedshiftParserREF = 302 + RedshiftParserREFRESH = 303 + RedshiftParserREINDEX = 304 + RedshiftParserRELATIVE_P = 305 + RedshiftParserRELEASE = 306 + RedshiftParserRENAME = 307 + RedshiftParserREPEATABLE = 308 + RedshiftParserREPLACE = 309 + RedshiftParserREPLICA = 310 + RedshiftParserRESET = 311 + RedshiftParserRESTART = 312 + RedshiftParserRESTRICT = 313 + RedshiftParserRETURNS = 314 + RedshiftParserREVOKE = 315 + RedshiftParserROLE = 316 + RedshiftParserROLLBACK = 317 + RedshiftParserROWS = 318 + RedshiftParserRULE = 319 + RedshiftParserSAVEPOINT = 320 + RedshiftParserSCHEMA = 321 + RedshiftParserSCROLL = 322 + RedshiftParserSEARCH = 323 + RedshiftParserSECOND_P = 324 + RedshiftParserSECURITY = 325 + RedshiftParserSEQUENCE = 326 + RedshiftParserSEQUENCES = 327 + RedshiftParserSERIALIZABLE = 328 + RedshiftParserSERVER = 329 + RedshiftParserSESSION = 330 + RedshiftParserSET = 331 + RedshiftParserSHARE = 332 + RedshiftParserSHOW = 333 + RedshiftParserSIMPLE = 334 + RedshiftParserSNAPSHOT = 335 + RedshiftParserSTABLE = 336 + RedshiftParserSTANDALONE_P = 337 + RedshiftParserSTART = 338 + RedshiftParserSTATEMENT = 339 + RedshiftParserSTATISTICS = 340 + RedshiftParserSTDIN = 341 + RedshiftParserSTDOUT = 342 + RedshiftParserSTORAGE = 343 + RedshiftParserSTRICT_P = 344 + RedshiftParserSTRIP_P = 345 + RedshiftParserSYSID = 346 + RedshiftParserSYSTEM_P = 347 + RedshiftParserTABLES = 348 + RedshiftParserTABLESPACE = 349 + RedshiftParserTEMP = 350 + RedshiftParserTEMPLATE = 351 + RedshiftParserTEMPORARY = 352 + RedshiftParserTEXT_P = 353 + RedshiftParserTRANSACTION = 354 + RedshiftParserTRIGGER = 355 + RedshiftParserTRUNCATE = 356 + RedshiftParserTRUSTED = 357 + RedshiftParserTYPE_P = 358 + RedshiftParserTYPES_P = 359 + RedshiftParserUNBOUNDED = 360 + RedshiftParserUNCOMMITTED = 361 + RedshiftParserUNENCRYPTED = 362 + RedshiftParserUNKNOWN = 363 + RedshiftParserUNLISTEN = 364 + RedshiftParserUNLOGGED = 365 + RedshiftParserUNTIL = 366 + RedshiftParserUPDATE = 367 + RedshiftParserVACUUM = 368 + RedshiftParserVALID = 369 + RedshiftParserVALIDATE = 370 + RedshiftParserVALIDATOR = 371 + RedshiftParserVARYING = 372 + RedshiftParserVERSION_P = 373 + RedshiftParserVIEW = 374 + RedshiftParserVOLATILE = 375 + RedshiftParserWHITESPACE_P = 376 + RedshiftParserWITHOUT = 377 + RedshiftParserWORK = 378 + RedshiftParserWRAPPER = 379 + RedshiftParserWRITE = 380 + RedshiftParserXML_P = 381 + RedshiftParserYEAR_P = 382 + RedshiftParserYES_P = 383 + RedshiftParserZONE = 384 + RedshiftParserQUALIFY = 385 + RedshiftParserCONNECT = 386 + RedshiftParserTOP = 387 + RedshiftParserVARBYTE = 388 + RedshiftParserVARBINARY = 389 + RedshiftParserCONJUNCTION = 390 + RedshiftParserDEFINITION = 391 + RedshiftParserDATASHARE = 392 + RedshiftParserFILE = 393 + RedshiftParserPUBLICACCESSIBLE = 394 + RedshiftParserINCLUDENEW = 395 + RedshiftParserIAM_ROLE = 396 + RedshiftParserCATALOG_ROLE = 397 + RedshiftParserCATALOG_ID = 398 + RedshiftParserHIVE = 399 + RedshiftParserMETASTORE = 400 + RedshiftParserURI = 401 + RedshiftParserPOSTGRES = 402 + RedshiftParserMYSQL = 403 + RedshiftParserSECRET_ARN = 404 + RedshiftParserKINESIS = 405 + RedshiftParserKAFKA = 406 + RedshiftParserMSK = 407 + RedshiftParserAUTHENTICATION = 408 + RedshiftParserAUTHENTICATION_ARN = 409 + RedshiftParserSESSION_TOKEN = 410 + RedshiftParserMTLS = 411 + RedshiftParserMASKING = 412 + RedshiftParserRLS = 413 + RedshiftParserIDENTITY = 414 + RedshiftParserPROVIDER = 415 + RedshiftParserPROTECTED = 416 + RedshiftParserMODEL = 417 + RedshiftParserTARGET = 418 + RedshiftParserSAGEMAKER = 419 + RedshiftParserAUTO = 420 + RedshiftParserMODEL_TYPE = 421 + RedshiftParserPROBLEM_TYPE = 422 + RedshiftParserOBJECTIVE = 423 + RedshiftParserPREPROCESSORS = 424 + RedshiftParserHYPERPARAMETERS = 425 + RedshiftParserXGBOOST = 426 + RedshiftParserMLP = 427 + RedshiftParserLINEAR_LEARNER = 428 + RedshiftParserKMEANS = 429 + RedshiftParserFORECAST = 430 + RedshiftParserREGRESSION = 431 + RedshiftParserBINARY_CLASSIFICATION = 432 + RedshiftParserMULTICLASS_CLASSIFICATION = 433 + RedshiftParserS3_BUCKET = 434 + RedshiftParserTAGS = 435 + RedshiftParserKMS_KEY_ID = 436 + RedshiftParserS3_GARBAGE_COLLECT = 437 + RedshiftParserMAX_CELLS = 438 + RedshiftParserMAX_RUNTIME = 439 + RedshiftParserHORIZON = 440 + RedshiftParserFREQUENCY = 441 + RedshiftParserPERCENTILES = 442 + RedshiftParserMAX_BATCH_ROWS = 443 + RedshiftParserUNLOAD = 444 + RedshiftParserMANIFEST = 445 + RedshiftParserADDQUOTES = 446 + RedshiftParserALLOWOVERWRITE = 447 + RedshiftParserCLEANPATH = 448 + RedshiftParserMAXFILESIZE = 449 + RedshiftParserROWGROUPSIZE = 450 + RedshiftParserBZIP2 = 451 + RedshiftParserGZIP = 452 + RedshiftParserZSTD = 453 + RedshiftParserDATABASES = 454 + RedshiftParserDATASHARES = 455 + RedshiftParserGRANTS = 456 + RedshiftParserUSE = 457 + RedshiftParserCANCEL = 458 + RedshiftParserSESSION_AUTHORIZATION = 459 + RedshiftParserSESSION_CHARACTERISTICS = 460 + RedshiftParserCOMPRESSION = 461 + RedshiftParserLIBRARY = 462 + RedshiftParserAPPEND = 463 + RedshiftParserMB = 464 + RedshiftParserGB = 465 + RedshiftParserACCOUNT = 466 + RedshiftParserNAMESPACE = 467 + RedshiftParserDESCRIBE = 468 + RedshiftParserNONATOMIC = 469 + RedshiftParserMANAGEDBY = 470 + RedshiftParserADX = 471 + RedshiftParserREMOVE = 472 + RedshiftParserDUPLICATES = 473 + RedshiftParserBEDROCK = 474 + RedshiftParserMODEL_ID = 475 + RedshiftParserPROMPT = 476 + RedshiftParserSUFFIX = 477 + RedshiftParserREQUEST_TYPE = 478 + RedshiftParserRESPONSE_TYPE = 479 + RedshiftParserRAW = 480 + RedshiftParserUNIFIED = 481 + RedshiftParserSUPER = 482 + RedshiftParserCI = 483 + RedshiftParserCS = 484 + RedshiftParserPLPYTHONU = 485 + RedshiftParserFILLTARGET = 486 + RedshiftParserIGNOREEXTRA = 487 + RedshiftParserCREATEUSER = 488 + RedshiftParserNOCREATEUSER = 489 + RedshiftParserREGION = 490 + RedshiftParserPORT = 491 + RedshiftParserREDSHIFT = 492 + RedshiftParserIAM = 493 + RedshiftParserCREATEDB = 494 + RedshiftParserNOCREATEDB = 495 + RedshiftParserRESTRICTED = 496 + RedshiftParserUNLIMITED = 497 + RedshiftParserEXTERNALID = 498 + RedshiftParserTIMEOUT = 499 + RedshiftParserSYSLOG = 500 + RedshiftParserCREDENTIALS = 501 + RedshiftParserUNRESTRICTED = 502 + RedshiftParserPARAMETERS = 503 + RedshiftParserAPPLICATION_ARN = 504 + RedshiftParserAUTO_CREATE_ROLES = 505 + RedshiftParserCOMPROWS = 506 + RedshiftParserPROVIDER_URL = 507 + RedshiftParserPROVIDER_URL_PORT = 508 + RedshiftParserATTRIBUTE_MAP = 509 + RedshiftParserPROVIDER_ARN = 510 + RedshiftParserASSUME_ROLE_ARN = 511 + RedshiftParserPROPERTIES = 512 + RedshiftParserAVRO = 513 + RedshiftParserRCFILE = 514 + RedshiftParserSEQUENCEFILE = 515 + RedshiftParserTEXTFILE = 516 + RedshiftParserORC = 517 + RedshiftParserION = 518 + RedshiftParserLAMBDA = 519 + RedshiftParserFIXEDWIDTH = 520 + RedshiftParserPARQUET = 521 + RedshiftParserLZOP = 522 + RedshiftParserREMOVEQUOTES = 523 + RedshiftParserTRUNCATECOLUMNS = 524 + RedshiftParserFILLRECORD = 525 + RedshiftParserBLANKSASNULL = 526 + RedshiftParserEMPTYASNULL = 527 + RedshiftParserMAXERROR = 528 + RedshiftParserDATEFORMAT = 529 + RedshiftParserTIMEFORMAT = 530 + RedshiftParserACCEPTINVCHARS = 531 + RedshiftParserACCEPTANYDATE = 532 + RedshiftParserIGNOREHEADER = 533 + RedshiftParserIGNOREBLANKLINES = 534 + RedshiftParserCOMPUPDATE = 535 + RedshiftParserSTATUPDATE = 536 + RedshiftParserEXPLICIT_IDS = 537 + RedshiftParserREADRATIO = 538 + RedshiftParserROUNDEC = 539 + RedshiftParserTRIMBLANKS = 540 + RedshiftParserPRESET = 541 + RedshiftParserACCESS_KEY_ID = 542 + RedshiftParserSECRET_ACCESS_KEY = 543 + RedshiftParserSESSION_TOKEN_KW = 544 + RedshiftParserHEADER = 545 + RedshiftParserSETTINGS = 546 + RedshiftParserFUNCTION_NAME = 547 + RedshiftParserATOMIC_P = 548 + RedshiftParserBETWEEN = 549 + RedshiftParserBIGINT = 550 + RedshiftParserBIT = 551 + RedshiftParserBOOLEAN_P = 552 + RedshiftParserCHAR_P = 553 + RedshiftParserCHARACTER = 554 + RedshiftParserCOALESCE = 555 + RedshiftParserDEC = 556 + RedshiftParserDECIMAL_P = 557 + RedshiftParserEXISTS = 558 + RedshiftParserEXTRACT = 559 + RedshiftParserFLOAT_P = 560 + RedshiftParserGREATEST = 561 + RedshiftParserINOUT = 562 + RedshiftParserINT_P = 563 + RedshiftParserINTEGER = 564 + RedshiftParserINTERVAL = 565 + RedshiftParserLEAST = 566 + RedshiftParserNATIONAL = 567 + RedshiftParserNCHAR = 568 + RedshiftParserNONE = 569 + RedshiftParserNULLIF = 570 + RedshiftParserNUMERIC = 571 + RedshiftParserOVERLAY = 572 + RedshiftParserPARAMETER = 573 + RedshiftParserPOSITION = 574 + RedshiftParserPRECISION = 575 + RedshiftParserREAL = 576 + RedshiftParserROW = 577 + RedshiftParserSETOF = 578 + RedshiftParserSMALLINT = 579 + RedshiftParserSUBSTRING = 580 + RedshiftParserTIME = 581 + RedshiftParserTIMESTAMP = 582 + RedshiftParserTREAT = 583 + RedshiftParserTRIM = 584 + RedshiftParserVALUES = 585 + RedshiftParserVARCHAR = 586 + RedshiftParserXMLATTRIBUTES = 587 + RedshiftParserXMLCOMMENT = 588 + RedshiftParserXMLAGG = 589 + RedshiftParserXML_IS_WELL_FORMED = 590 + RedshiftParserXML_IS_WELL_FORMED_DOCUMENT = 591 + RedshiftParserXML_IS_WELL_FORMED_CONTENT = 592 + RedshiftParserXPATH = 593 + RedshiftParserXPATH_EXISTS = 594 + RedshiftParserXMLCONCAT = 595 + RedshiftParserXMLELEMENT = 596 + RedshiftParserXMLEXISTS = 597 + RedshiftParserXMLFOREST = 598 + RedshiftParserXMLPARSE = 599 + RedshiftParserXMLPI = 600 + RedshiftParserXMLROOT = 601 + RedshiftParserXMLSERIALIZE = 602 + RedshiftParserCALL = 603 + RedshiftParserCURRENT_P = 604 + RedshiftParserATTACH = 605 + RedshiftParserDETACH = 606 + RedshiftParserEXPRESSION = 607 + RedshiftParserGENERATED = 608 + RedshiftParserLOGGED = 609 + RedshiftParserSTORED = 610 + RedshiftParserSERDE = 611 + RedshiftParserSERDEPROPERTIES = 612 + RedshiftParserINPUTFORMAT = 613 + RedshiftParserOUTPUTFORMAT = 614 + RedshiftParserFIELDS = 615 + RedshiftParserCOLLECTION = 616 + RedshiftParserITEMS = 617 + RedshiftParserTERMINATED = 618 + RedshiftParserESCAPED = 619 + RedshiftParserDEFINED = 620 + RedshiftParserLINES = 621 + RedshiftParserKEYS = 622 + RedshiftParserPARTITIONED = 623 + RedshiftParserSTRUCT = 624 + RedshiftParserMAP = 625 + RedshiftParserSTRING = 626 + RedshiftParserDELIMITED = 627 + RedshiftParserUSAGE = 628 + RedshiftParserIGNORE = 629 + RedshiftParserLANGUAGES = 630 + RedshiftParserJOB = 631 + RedshiftParserJOBS = 632 + RedshiftParserVIA = 633 + RedshiftParserASSUMEROLE = 634 + RedshiftParserRETRY_TIMEOUT = 635 + RedshiftParserMAX_BATCH_SIZE = 636 + RedshiftParserMAX_PAYLOAD_IN_MB = 637 + RedshiftParserKB = 638 + RedshiftParserINCLUDE = 639 + RedshiftParserROUTINE = 640 + RedshiftParserTRANSFORM = 641 + RedshiftParserIMPORT_P = 642 + RedshiftParserPOLICY = 643 + RedshiftParserPRIORITY = 644 + RedshiftParserMETHOD = 645 + RedshiftParserREFERENCING = 646 + RedshiftParserNEW = 647 + RedshiftParserOLD = 648 + RedshiftParserVALUE_P = 649 + RedshiftParserSUBSCRIPTION = 650 + RedshiftParserPUBLICATION = 651 + RedshiftParserOUT_P = 652 + RedshiftParserEND_P = 653 + RedshiftParserROUTINES = 654 + RedshiftParserSCHEMAS = 655 + RedshiftParserPROCEDURES = 656 + RedshiftParserINPUT_P = 657 + RedshiftParserSUPPORT = 658 + RedshiftParserPARALLEL = 659 + RedshiftParserSQL_P = 660 + RedshiftParserDEPENDS = 661 + RedshiftParserOVERRIDING = 662 + RedshiftParserCONFLICT = 663 + RedshiftParserSKIP_P = 664 + RedshiftParserLOCKED = 665 + RedshiftParserTIES = 666 + RedshiftParserROLLUP = 667 + RedshiftParserCUBE = 668 + RedshiftParserGROUPING = 669 + RedshiftParserSETS = 670 + RedshiftParserTABLESAMPLE = 671 + RedshiftParserORDINALITY = 672 + RedshiftParserXMLTABLE = 673 + RedshiftParserCOLUMNS = 674 + RedshiftParserXMLNAMESPACES = 675 + RedshiftParserROWTYPE = 676 + RedshiftParserNORMALIZED = 677 + RedshiftParserWITHIN = 678 + RedshiftParserFILTER = 679 + RedshiftParserGROUPS = 680 + RedshiftParserOTHERS = 681 + RedshiftParserNFC = 682 + RedshiftParserNFD = 683 + RedshiftParserNFKC = 684 + RedshiftParserNFKD = 685 + RedshiftParserUESCAPE = 686 + RedshiftParserVIEWS = 687 + RedshiftParserNORMALIZE = 688 + RedshiftParserDUMP = 689 + RedshiftParserPRINT_STRICT_PARAMS = 690 + RedshiftParserVARIABLE_CONFLICT = 691 + RedshiftParserERROR = 692 + RedshiftParserUSE_VARIABLE = 693 + RedshiftParserUSE_COLUMN = 694 + RedshiftParserALIAS = 695 + RedshiftParserCONSTANT = 696 + RedshiftParserPERFORM = 697 + RedshiftParserGET = 698 + RedshiftParserDIAGNOSTICS = 699 + RedshiftParserSTACKED = 700 + RedshiftParserELSIF = 701 + RedshiftParserWHILE = 702 + RedshiftParserREVERSE = 703 + RedshiftParserFOREACH = 704 + RedshiftParserSLICE = 705 + RedshiftParserEXIT = 706 + RedshiftParserRETURN = 707 + RedshiftParserQUERY = 708 + RedshiftParserRAISE = 709 + RedshiftParserSQLSTATE = 710 + RedshiftParserDEBUG = 711 + RedshiftParserLOG = 712 + RedshiftParserINFO = 713 + RedshiftParserNOTICE = 714 + RedshiftParserWARNING = 715 + RedshiftParserEXCEPTION = 716 + RedshiftParserASSERT = 717 + RedshiftParserLOOP = 718 + RedshiftParserOPEN = 719 + RedshiftParserABS = 720 + RedshiftParserCBRT = 721 + RedshiftParserCEIL = 722 + RedshiftParserCEILING = 723 + RedshiftParserDEGREES = 724 + RedshiftParserDIV = 725 + RedshiftParserEXP = 726 + RedshiftParserFACTORIAL = 727 + RedshiftParserFLOOR = 728 + RedshiftParserGCD = 729 + RedshiftParserLCM = 730 + RedshiftParserLN = 731 + RedshiftParserLOG10 = 732 + RedshiftParserMIN_SCALE = 733 + RedshiftParserMOD = 734 + RedshiftParserPI = 735 + RedshiftParserPOWER = 736 + RedshiftParserRADIANS = 737 + RedshiftParserROUND = 738 + RedshiftParserSCALE = 739 + RedshiftParserSIGN = 740 + RedshiftParserSQRT = 741 + RedshiftParserTRIM_SCALE = 742 + RedshiftParserTRUNC = 743 + RedshiftParserWIDTH_BUCKET = 744 + RedshiftParserRANDOM = 745 + RedshiftParserSETSEED = 746 + RedshiftParserACOS = 747 + RedshiftParserACOSD = 748 + RedshiftParserASIN = 749 + RedshiftParserASIND = 750 + RedshiftParserATAN = 751 + RedshiftParserATAND = 752 + RedshiftParserATAN2 = 753 + RedshiftParserATAN2D = 754 + RedshiftParserCOS = 755 + RedshiftParserCOSD = 756 + RedshiftParserCOT = 757 + RedshiftParserCOTD = 758 + RedshiftParserSIN = 759 + RedshiftParserSIND = 760 + RedshiftParserTAN = 761 + RedshiftParserTAND = 762 + RedshiftParserSINH = 763 + RedshiftParserCOSH = 764 + RedshiftParserTANH = 765 + RedshiftParserASINH = 766 + RedshiftParserACOSH = 767 + RedshiftParserATANH = 768 + RedshiftParserBIT_LENGTH = 769 + RedshiftParserCHAR_LENGTH = 770 + RedshiftParserCHARACTER_LENGTH = 771 + RedshiftParserLOWER = 772 + RedshiftParserOCTET_LENGTH = 773 + RedshiftParserUPPER = 774 + RedshiftParserASCII = 775 + RedshiftParserBTRIM = 776 + RedshiftParserCHR = 777 + RedshiftParserCONCAT = 778 + RedshiftParserCONCAT_WS = 779 + RedshiftParserFORMAT = 780 + RedshiftParserINITCAP = 781 + RedshiftParserLENGTH = 782 + RedshiftParserLPAD = 783 + RedshiftParserLTRIM = 784 + RedshiftParserMD5 = 785 + RedshiftParserPARSE_IDENT = 786 + RedshiftParserPG_CLIENT_ENCODING = 787 + RedshiftParserQUOTE_IDENT = 788 + RedshiftParserQUOTE_LITERAL = 789 + RedshiftParserQUOTE_NULLABLE = 790 + RedshiftParserREGEXP_COUNT = 791 + RedshiftParserREGEXP_INSTR = 792 + RedshiftParserREGEXP_LIKE = 793 + RedshiftParserREGEXP_MATCH = 794 + RedshiftParserREGEXP_MATCHES = 795 + RedshiftParserREGEXP_REPLACE = 796 + RedshiftParserREGEXP_SPLIT_TO_ARRAY = 797 + RedshiftParserREGEXP_SPLIT_TO_TABLE = 798 + RedshiftParserREGEXP_SUBSTR = 799 + RedshiftParserREPEAT = 800 + RedshiftParserRPAD = 801 + RedshiftParserRTRIM = 802 + RedshiftParserSPLIT_PART = 803 + RedshiftParserSTARTS_WITH = 804 + RedshiftParserSTRING_TO_ARRAY = 805 + RedshiftParserSTRING_TO_TABLE = 806 + RedshiftParserSTRPOS = 807 + RedshiftParserSUBSTR = 808 + RedshiftParserTO_ASCII = 809 + RedshiftParserTO_HEX = 810 + RedshiftParserTRANSLATE = 811 + RedshiftParserUNISTR = 812 + RedshiftParserAGE = 813 + RedshiftParserCLOCK_TIMESTAMP = 814 + RedshiftParserDATE_BIN = 815 + RedshiftParserDATE_PART = 816 + RedshiftParserDATE_TRUNC = 817 + RedshiftParserISFINITE = 818 + RedshiftParserJUSTIFY_DAYS = 819 + RedshiftParserJUSTIFY_HOURS = 820 + RedshiftParserJUSTIFY_INTERVAL = 821 + RedshiftParserMAKE_DATE = 822 + RedshiftParserMAKE_INTERVAL = 823 + RedshiftParserMAKE_TIME = 824 + RedshiftParserMAKE_TIMESTAMP = 825 + RedshiftParserMAKE_TIMESTAMPTZ = 826 + RedshiftParserNOW = 827 + RedshiftParserSTATEMENT_TIMESTAMP = 828 + RedshiftParserTIMEOFDAY = 829 + RedshiftParserTRANSACTION_TIMESTAMP = 830 + RedshiftParserTO_TIMESTAMP = 831 + RedshiftParserTO_CHAR = 832 + RedshiftParserTO_DATE = 833 + RedshiftParserTO_NUMBER = 834 + RedshiftParserENCODE = 835 + RedshiftParserDISTKEY = 836 + RedshiftParserSORTKEY = 837 + RedshiftParserDISTSTYLE = 838 + RedshiftParserBACKUP = 839 + RedshiftParserCOMPOUND = 840 + RedshiftParserINTERLEAVED = 841 + RedshiftParserEVEN = 842 + RedshiftParserCASE_SENSITIVE = 843 + RedshiftParserQUOTA = 844 + RedshiftParserTB = 845 + RedshiftParserBOOST = 846 + RedshiftParserRECLUSTER = 847 + RedshiftParserSORT = 848 + RedshiftParserPERCENT_WORD = 849 + RedshiftParserCASE_INSENSITIVE = 850 + RedshiftParserIdentifier = 851 + RedshiftParserTemporaryIdentifier = 852 + RedshiftParserNamespaceUser = 853 + RedshiftParserQuotedIdentifier = 854 + RedshiftParserUnterminatedQuotedIdentifier = 855 + RedshiftParserInvalidQuotedIdentifier = 856 + RedshiftParserInvalidUnterminatedQuotedIdentifier = 857 + RedshiftParserUnicodeQuotedIdentifier = 858 + RedshiftParserUnterminatedUnicodeQuotedIdentifier = 859 + RedshiftParserInvalidUnicodeQuotedIdentifier = 860 + RedshiftParserInvalidUnterminatedUnicodeQuotedIdentifier = 861 + RedshiftParserStringConstant = 862 + RedshiftParserUnterminatedStringConstant = 863 + RedshiftParserUnicodeEscapeStringConstant = 864 + RedshiftParserUnterminatedUnicodeEscapeStringConstant = 865 + RedshiftParserBeginDollarStringConstant = 866 + RedshiftParserBinaryStringConstant = 867 + RedshiftParserUnterminatedBinaryStringConstant = 868 + RedshiftParserInvalidBinaryStringConstant = 869 + RedshiftParserInvalidUnterminatedBinaryStringConstant = 870 + RedshiftParserHexadecimalStringConstant = 871 + RedshiftParserUnterminatedHexadecimalStringConstant = 872 + RedshiftParserInvalidHexadecimalStringConstant = 873 + RedshiftParserInvalidUnterminatedHexadecimalStringConstant = 874 + RedshiftParserIntegral = 875 + RedshiftParserNumericFail = 876 + RedshiftParserNumeric = 877 + RedshiftParserPLSQLVARIABLENAME = 878 + RedshiftParserPLSQLIDENTIFIER = 879 + RedshiftParserWhitespace = 880 + RedshiftParserNewline = 881 + RedshiftParserLineComment = 882 + RedshiftParserBlockComment = 883 + RedshiftParserUnterminatedBlockComment = 884 + RedshiftParserMetaCommand = 885 + RedshiftParserEndMetaCommand = 886 + RedshiftParserErrorCharacter = 887 + RedshiftParserEscapeStringConstant = 888 + RedshiftParserUnterminatedEscapeStringConstant = 889 + RedshiftParserInvalidEscapeStringConstant = 890 + RedshiftParserInvalidUnterminatedEscapeStringConstant = 891 + RedshiftParserAfterEscapeStringConstantMode_NotContinued = 892 + RedshiftParserAfterEscapeStringConstantWithNewlineMode_NotContinued = 893 + RedshiftParserDollarText = 894 + RedshiftParserEndDollarStringConstant = 895 + RedshiftParserAfterEscapeStringConstantWithNewlineMode_Continued = 896 +) + +// RedshiftParser rules. +const ( + RedshiftParserRULE_root = 0 + RedshiftParserRULE_plsqlroot = 1 + RedshiftParserRULE_stmtblock = 2 + RedshiftParserRULE_stmtmulti = 3 + RedshiftParserRULE_stmt = 4 + RedshiftParserRULE_plsqlconsolecommand = 5 + RedshiftParserRULE_callstmt = 6 + RedshiftParserRULE_createrolestmt = 7 + RedshiftParserRULE_opt_with = 8 + RedshiftParserRULE_optrolelist = 9 + RedshiftParserRULE_alteroptrolelist = 10 + RedshiftParserRULE_alteroptroleelem = 11 + RedshiftParserRULE_createoptroleelem = 12 + RedshiftParserRULE_createuserstmt = 13 + RedshiftParserRULE_alterrolestmt = 14 + RedshiftParserRULE_alterroleaction = 15 + RedshiftParserRULE_opt_in_database = 16 + RedshiftParserRULE_alterrolesetstmt = 17 + RedshiftParserRULE_alterschemastmt = 18 + RedshiftParserRULE_droprolestmt = 19 + RedshiftParserRULE_dropuserstmt = 20 + RedshiftParserRULE_dropgroupstmt = 21 + RedshiftParserRULE_creategroupstmt = 22 + RedshiftParserRULE_altergroupstmt = 23 + RedshiftParserRULE_add_drop = 24 + RedshiftParserRULE_createschemastmt = 25 + RedshiftParserRULE_opt_auth_clause = 26 + RedshiftParserRULE_opt_quota = 27 + RedshiftParserRULE_optschemaeltlist = 28 + RedshiftParserRULE_schema_stmt = 29 + RedshiftParserRULE_variablesetstmt = 30 + RedshiftParserRULE_set_rest = 31 + RedshiftParserRULE_generic_set = 32 + RedshiftParserRULE_set_rest_more = 33 + RedshiftParserRULE_var_name = 34 + RedshiftParserRULE_var_list = 35 + RedshiftParserRULE_var_value = 36 + RedshiftParserRULE_iso_level = 37 + RedshiftParserRULE_opt_boolean_or_string = 38 + RedshiftParserRULE_zone_value = 39 + RedshiftParserRULE_opt_encoding = 40 + RedshiftParserRULE_nonreservedword_or_sconst = 41 + RedshiftParserRULE_variableresetstmt = 42 + RedshiftParserRULE_reset_rest = 43 + RedshiftParserRULE_generic_reset = 44 + RedshiftParserRULE_setresetclause = 45 + RedshiftParserRULE_functionsetresetclause = 46 + RedshiftParserRULE_variableshowstmt = 47 + RedshiftParserRULE_constraintssetstmt = 48 + RedshiftParserRULE_constraints_set_list = 49 + RedshiftParserRULE_constraints_set_mode = 50 + RedshiftParserRULE_checkpointstmt = 51 + RedshiftParserRULE_discardstmt = 52 + RedshiftParserRULE_altertablestmt = 53 + RedshiftParserRULE_alter_table_cmds = 54 + RedshiftParserRULE_table_constraint = 55 + RedshiftParserRULE_partition_cmd = 56 + RedshiftParserRULE_index_partition_cmd = 57 + RedshiftParserRULE_alter_table_cmd = 58 + RedshiftParserRULE_alter_column_default = 59 + RedshiftParserRULE_opt_drop_behavior = 60 + RedshiftParserRULE_opt_collate_clause = 61 + RedshiftParserRULE_alter_using = 62 + RedshiftParserRULE_replica_identity = 63 + RedshiftParserRULE_reloptions = 64 + RedshiftParserRULE_opt_reloptions = 65 + RedshiftParserRULE_reloption_list = 66 + RedshiftParserRULE_reloption_elem = 67 + RedshiftParserRULE_alter_identity_column_option_list = 68 + RedshiftParserRULE_alter_identity_column_option = 69 + RedshiftParserRULE_partitionboundspec = 70 + RedshiftParserRULE_hash_partbound_elem = 71 + RedshiftParserRULE_hash_partbound = 72 + RedshiftParserRULE_altercompositetypestmt = 73 + RedshiftParserRULE_alter_type_cmds = 74 + RedshiftParserRULE_alter_type_cmd = 75 + RedshiftParserRULE_closeportalstmt = 76 + RedshiftParserRULE_copystmt = 77 + RedshiftParserRULE_redshift_copy_authorization = 78 + RedshiftParserRULE_redshift_copy_format = 79 + RedshiftParserRULE_redshift_copy_parameter = 80 + RedshiftParserRULE_copy_param_name = 81 + RedshiftParserRULE_copy_param_value = 82 + RedshiftParserRULE_copy_from = 83 + RedshiftParserRULE_opt_program = 84 + RedshiftParserRULE_copy_file_name = 85 + RedshiftParserRULE_copy_options = 86 + RedshiftParserRULE_copy_opt_list = 87 + RedshiftParserRULE_copy_opt_item = 88 + RedshiftParserRULE_opt_binary = 89 + RedshiftParserRULE_copy_delimiter = 90 + RedshiftParserRULE_opt_using = 91 + RedshiftParserRULE_copy_generic_opt_list = 92 + RedshiftParserRULE_copy_generic_opt_elem = 93 + RedshiftParserRULE_copy_generic_opt_arg = 94 + RedshiftParserRULE_copy_generic_opt_arg_list = 95 + RedshiftParserRULE_copy_generic_opt_arg_list_item = 96 + RedshiftParserRULE_createstmt = 97 + RedshiftParserRULE_opt_table_attributes = 98 + RedshiftParserRULE_opttemp = 99 + RedshiftParserRULE_opttableelementlist = 100 + RedshiftParserRULE_opttypedtableelementlist = 101 + RedshiftParserRULE_tableelementlist = 102 + RedshiftParserRULE_typedtableelementlist = 103 + RedshiftParserRULE_tableelement = 104 + RedshiftParserRULE_typedtableelement = 105 + RedshiftParserRULE_columnDef = 106 + RedshiftParserRULE_rs_colattributes = 107 + RedshiftParserRULE_rs_colattribute = 108 + RedshiftParserRULE_columnOptions = 109 + RedshiftParserRULE_colquallist = 110 + RedshiftParserRULE_colconstraint = 111 + RedshiftParserRULE_colconstraintelem = 112 + RedshiftParserRULE_opt_unique_null_treatment = 113 + RedshiftParserRULE_generated_when = 114 + RedshiftParserRULE_constraintattr = 115 + RedshiftParserRULE_tablelikeclause = 116 + RedshiftParserRULE_tablelikeoptionlist = 117 + RedshiftParserRULE_tablelikeoption = 118 + RedshiftParserRULE_tableconstraint = 119 + RedshiftParserRULE_constraintelem = 120 + RedshiftParserRULE_opt_no_inherit = 121 + RedshiftParserRULE_opt_column_list = 122 + RedshiftParserRULE_columnlist = 123 + RedshiftParserRULE_columnElem = 124 + RedshiftParserRULE_opt_c_include = 125 + RedshiftParserRULE_key_match = 126 + RedshiftParserRULE_exclusionconstraintlist = 127 + RedshiftParserRULE_exclusionconstraintelem = 128 + RedshiftParserRULE_exclusionwhereclause = 129 + RedshiftParserRULE_key_actions = 130 + RedshiftParserRULE_key_update = 131 + RedshiftParserRULE_key_delete = 132 + RedshiftParserRULE_key_action = 133 + RedshiftParserRULE_optinherit = 134 + RedshiftParserRULE_optpartitionspec = 135 + RedshiftParserRULE_partitionspec = 136 + RedshiftParserRULE_part_params = 137 + RedshiftParserRULE_part_elem = 138 + RedshiftParserRULE_table_access_method_clause = 139 + RedshiftParserRULE_optwith = 140 + RedshiftParserRULE_oncommitoption = 141 + RedshiftParserRULE_opttablespace = 142 + RedshiftParserRULE_optredshifttableoptions = 143 + RedshiftParserRULE_redshifttableoption = 144 + RedshiftParserRULE_sortkeyclause = 145 + RedshiftParserRULE_sortkeyclausetype = 146 + RedshiftParserRULE_optconstablespace = 147 + RedshiftParserRULE_existingindex = 148 + RedshiftParserRULE_createstatsstmt = 149 + RedshiftParserRULE_alterstatsstmt = 150 + RedshiftParserRULE_createasstmt = 151 + RedshiftParserRULE_create_as_target = 152 + RedshiftParserRULE_opt_backup_clause_table_attributes = 153 + RedshiftParserRULE_table_attributes = 154 + RedshiftParserRULE_opt_backup_clause = 155 + RedshiftParserRULE_opt_with_data = 156 + RedshiftParserRULE_creatematviewstmt = 157 + RedshiftParserRULE_opt_auto_refresh = 158 + RedshiftParserRULE_refreshmatviewstmt = 159 + RedshiftParserRULE_createseqstmt = 160 + RedshiftParserRULE_alterseqstmt = 161 + RedshiftParserRULE_optseqoptlist = 162 + RedshiftParserRULE_optparenthesizedseqoptlist = 163 + RedshiftParserRULE_seqoptlist = 164 + RedshiftParserRULE_seqoptelem = 165 + RedshiftParserRULE_opt_by = 166 + RedshiftParserRULE_numericonly = 167 + RedshiftParserRULE_numericonly_list = 168 + RedshiftParserRULE_createplangstmt = 169 + RedshiftParserRULE_opt_trusted = 170 + RedshiftParserRULE_handler_name = 171 + RedshiftParserRULE_opt_inline_handler = 172 + RedshiftParserRULE_validator_clause = 173 + RedshiftParserRULE_opt_validator = 174 + RedshiftParserRULE_opt_procedural = 175 + RedshiftParserRULE_createtablespacestmt = 176 + RedshiftParserRULE_opttablespaceowner = 177 + RedshiftParserRULE_droptablespacestmt = 178 + RedshiftParserRULE_createextensionstmt = 179 + RedshiftParserRULE_create_extension_opt_list = 180 + RedshiftParserRULE_create_extension_opt_item = 181 + RedshiftParserRULE_alterextensionstmt = 182 + RedshiftParserRULE_alter_extension_opt_list = 183 + RedshiftParserRULE_alter_extension_opt_item = 184 + RedshiftParserRULE_alterextensioncontentsstmt = 185 + RedshiftParserRULE_createfdwstmt = 186 + RedshiftParserRULE_fdw_option = 187 + RedshiftParserRULE_fdw_options = 188 + RedshiftParserRULE_opt_fdw_options = 189 + RedshiftParserRULE_alterfdwstmt = 190 + RedshiftParserRULE_create_generic_options = 191 + RedshiftParserRULE_generic_option_list = 192 + RedshiftParserRULE_alter_generic_options = 193 + RedshiftParserRULE_alter_generic_option_list = 194 + RedshiftParserRULE_alter_generic_option_elem = 195 + RedshiftParserRULE_generic_option_elem = 196 + RedshiftParserRULE_generic_option_name = 197 + RedshiftParserRULE_generic_option_arg = 198 + RedshiftParserRULE_createforeignserverstmt = 199 + RedshiftParserRULE_opt_type = 200 + RedshiftParserRULE_foreign_server_version = 201 + RedshiftParserRULE_opt_foreign_server_version = 202 + RedshiftParserRULE_alterforeignserverstmt = 203 + RedshiftParserRULE_createforeigntablestmt = 204 + RedshiftParserRULE_importforeignschemastmt = 205 + RedshiftParserRULE_import_qualification_type = 206 + RedshiftParserRULE_import_qualification = 207 + RedshiftParserRULE_createusermappingstmt = 208 + RedshiftParserRULE_auth_ident = 209 + RedshiftParserRULE_dropusermappingstmt = 210 + RedshiftParserRULE_alterusermappingstmt = 211 + RedshiftParserRULE_createpolicystmt = 212 + RedshiftParserRULE_alterpolicystmt = 213 + RedshiftParserRULE_rowsecurityoptionalexpr = 214 + RedshiftParserRULE_rowsecurityoptionalwithcheck = 215 + RedshiftParserRULE_rowsecuritydefaulttorole = 216 + RedshiftParserRULE_rowsecurityoptionaltorole = 217 + RedshiftParserRULE_rowsecuritydefaultpermissive = 218 + RedshiftParserRULE_rowsecuritydefaultforcmd = 219 + RedshiftParserRULE_row_security_cmd = 220 + RedshiftParserRULE_createamstmt = 221 + RedshiftParserRULE_am_type = 222 + RedshiftParserRULE_createtrigstmt = 223 + RedshiftParserRULE_triggeractiontime = 224 + RedshiftParserRULE_triggerevents = 225 + RedshiftParserRULE_triggeroneevent = 226 + RedshiftParserRULE_triggerreferencing = 227 + RedshiftParserRULE_triggertransitions = 228 + RedshiftParserRULE_triggertransition = 229 + RedshiftParserRULE_transitionoldornew = 230 + RedshiftParserRULE_transitionrowortable = 231 + RedshiftParserRULE_transitionrelname = 232 + RedshiftParserRULE_triggerforspec = 233 + RedshiftParserRULE_triggerforopteach = 234 + RedshiftParserRULE_triggerfortype = 235 + RedshiftParserRULE_triggerwhen = 236 + RedshiftParserRULE_function_or_procedure = 237 + RedshiftParserRULE_triggerfuncargs = 238 + RedshiftParserRULE_triggerfuncarg = 239 + RedshiftParserRULE_optconstrfromtable = 240 + RedshiftParserRULE_constraintattributespec = 241 + RedshiftParserRULE_constraintattributeElem = 242 + RedshiftParserRULE_createeventtrigstmt = 243 + RedshiftParserRULE_event_trigger_when_list = 244 + RedshiftParserRULE_event_trigger_when_item = 245 + RedshiftParserRULE_event_trigger_value_list = 246 + RedshiftParserRULE_altereventtrigstmt = 247 + RedshiftParserRULE_enable_trigger = 248 + RedshiftParserRULE_createassertionstmt = 249 + RedshiftParserRULE_definestmt = 250 + RedshiftParserRULE_definition = 251 + RedshiftParserRULE_def_list = 252 + RedshiftParserRULE_def_elem = 253 + RedshiftParserRULE_def_arg = 254 + RedshiftParserRULE_old_aggr_definition = 255 + RedshiftParserRULE_old_aggr_list = 256 + RedshiftParserRULE_old_aggr_elem = 257 + RedshiftParserRULE_opt_enum_val_list = 258 + RedshiftParserRULE_enum_val_list = 259 + RedshiftParserRULE_alterenumstmt = 260 + RedshiftParserRULE_opt_if_not_exists = 261 + RedshiftParserRULE_createopclassstmt = 262 + RedshiftParserRULE_opclass_item_list = 263 + RedshiftParserRULE_opclass_item = 264 + RedshiftParserRULE_opt_default = 265 + RedshiftParserRULE_opt_opfamily = 266 + RedshiftParserRULE_opclass_purpose = 267 + RedshiftParserRULE_opt_recheck = 268 + RedshiftParserRULE_createopfamilystmt = 269 + RedshiftParserRULE_alteropfamilystmt = 270 + RedshiftParserRULE_opclass_drop_list = 271 + RedshiftParserRULE_opclass_drop = 272 + RedshiftParserRULE_dropopclassstmt = 273 + RedshiftParserRULE_dropopfamilystmt = 274 + RedshiftParserRULE_dropownedstmt = 275 + RedshiftParserRULE_reassignownedstmt = 276 + RedshiftParserRULE_dropstmt = 277 + RedshiftParserRULE_object_type_any_name = 278 + RedshiftParserRULE_object_type_name = 279 + RedshiftParserRULE_drop_type_name = 280 + RedshiftParserRULE_object_type_name_on_any_name = 281 + RedshiftParserRULE_any_name_list = 282 + RedshiftParserRULE_any_name = 283 + RedshiftParserRULE_attrs = 284 + RedshiftParserRULE_type_name_list = 285 + RedshiftParserRULE_truncatestmt = 286 + RedshiftParserRULE_opt_restart_seqs = 287 + RedshiftParserRULE_commentstmt = 288 + RedshiftParserRULE_comment_text = 289 + RedshiftParserRULE_seclabelstmt = 290 + RedshiftParserRULE_opt_provider = 291 + RedshiftParserRULE_security_label = 292 + RedshiftParserRULE_fetchstmt = 293 + RedshiftParserRULE_fetch_args = 294 + RedshiftParserRULE_grantstmt = 295 + RedshiftParserRULE_grant_permissions_for_rls_lookup_tables = 296 + RedshiftParserRULE_grant_explain_permissions_for_row_level_security_policy_filters = 297 + RedshiftParserRULE_grant_machine_learning_permissions = 298 + RedshiftParserRULE_grant_role_permissions = 299 + RedshiftParserRULE_grant_role_permission_target_list = 300 + RedshiftParserRULE_grant_role_permission_target_list_item = 301 + RedshiftParserRULE_system_permissions = 302 + RedshiftParserRULE_system_permissions_item = 303 + RedshiftParserRULE_opt_with_admin_option = 304 + RedshiftParserRULE_grant_scoped_permissions = 305 + RedshiftParserRULE_grant_scoped_schemas_permissions = 306 + RedshiftParserRULE_grant_scoped_tables_permissions = 307 + RedshiftParserRULE_grant_scoped_functions_permissions = 308 + RedshiftParserRULE_grant_scoped_procedures_permissions = 309 + RedshiftParserRULE_grant_scoped_languages_permissions = 310 + RedshiftParserRULE_grant_scoped_copy_jobs_permissions = 311 + RedshiftParserRULE_grantee_list_without_public = 312 + RedshiftParserRULE_grantee_without_public = 313 + RedshiftParserRULE_grant_datashare_permissions = 314 + RedshiftParserRULE_grant_spectrum_integration_permissions = 315 + RedshiftParserRULE_grant_spectrum_integration_external_schema_permissions = 316 + RedshiftParserRULE_spectrum_integration_external_schema_permission_list = 317 + RedshiftParserRULE_spectrum_integration_external_schema_permission = 318 + RedshiftParserRULE_grant_spectrum_integration_external_table_permissions = 319 + RedshiftParserRULE_spectrum_integration_external_table_permission = 320 + RedshiftParserRULE_spectrum_integration_external_table_permission_list = 321 + RedshiftParserRULE_grant_spectrum_integration_extenral_column_permissions = 322 + RedshiftParserRULE_iamrolelist_or_public = 323 + RedshiftParserRULE_iamrolelist = 324 + RedshiftParserRULE_grant_assume_role_permissions = 325 + RedshiftParserRULE_grant_assume_role_for_list = 326 + RedshiftParserRULE_grant_assume_role_for_item = 327 + RedshiftParserRULE_grant_assume_role_target = 328 + RedshiftParserRULE_grant_column_level_permissions = 329 + RedshiftParserRULE_column_privilege_target = 330 + RedshiftParserRULE_column_privilege_list = 331 + RedshiftParserRULE_column_all_privilege = 332 + RedshiftParserRULE_column_select_update_privilege = 333 + RedshiftParserRULE_common_grant = 334 + RedshiftParserRULE_copy_job_privilege_list = 335 + RedshiftParserRULE_copy_job_privilege = 336 + RedshiftParserRULE_copy_job_target = 337 + RedshiftParserRULE_copy_job_name = 338 + RedshiftParserRULE_language_privilege_list = 339 + RedshiftParserRULE_grant_language_target = 340 + RedshiftParserRULE_grant_procedure_target = 341 + RedshiftParserRULE_procedure_privilege_list = 342 + RedshiftParserRULE_procedure_privilege = 343 + RedshiftParserRULE_function_privilege_list = 344 + RedshiftParserRULE_function_privilege = 345 + RedshiftParserRULE_grant_function_target = 346 + RedshiftParserRULE_grant_schema_target = 347 + RedshiftParserRULE_revoke_schema_target = 348 + RedshiftParserRULE_schema_privilege_list = 349 + RedshiftParserRULE_schema_privilege = 350 + RedshiftParserRULE_database_privilege_list = 351 + RedshiftParserRULE_database_privilege = 352 + RedshiftParserRULE_grant_database_target = 353 + RedshiftParserRULE_grant_table_target = 354 + RedshiftParserRULE_revoke_table_target = 355 + RedshiftParserRULE_all_tables_in_schema_list = 356 + RedshiftParserRULE_all_privileges = 357 + RedshiftParserRULE_grantee_list = 358 + RedshiftParserRULE_grantee = 359 + RedshiftParserRULE_opt_with_grant_option = 360 + RedshiftParserRULE_table_privilege = 361 + RedshiftParserRULE_table_privilege_list = 362 + RedshiftParserRULE_revokestmt = 363 + RedshiftParserRULE_revoke_permissions_for_rls_lookup_tables = 364 + RedshiftParserRULE_revoke_explain_permissions_for_row_level_security_policy_filters = 365 + RedshiftParserRULE_revoke_machine_learning_permissions = 366 + RedshiftParserRULE_revoke_role_permissions = 367 + RedshiftParserRULE_revoke_scoped_permissions = 368 + RedshiftParserRULE_revoke_scoped_schemas_permissions = 369 + RedshiftParserRULE_revoke_scoped_tables_permissions = 370 + RedshiftParserRULE_revoke_scoped_functions_permissions = 371 + RedshiftParserRULE_revoke_scoped_procedures_permissions = 372 + RedshiftParserRULE_revoke_scoped_languages_permissions = 373 + RedshiftParserRULE_revoke_scoped_copy_jobs_permissions = 374 + RedshiftParserRULE_revoke_datashare_permissions = 375 + RedshiftParserRULE_revoke_spectrum_integration_permissions = 376 + RedshiftParserRULE_revoke_spectrum_integration_external_schema_permissions = 377 + RedshiftParserRULE_revoke_spectrum_integration_external_table_permissions = 378 + RedshiftParserRULE_revoke_spectrum_integration_extenral_column_permissions = 379 + RedshiftParserRULE_revoke_assume_role_permissions = 380 + RedshiftParserRULE_revoke_column_level_permissions = 381 + RedshiftParserRULE_common_revoke = 382 + RedshiftParserRULE_privileges = 383 + RedshiftParserRULE_privilege_list = 384 + RedshiftParserRULE_privilege = 385 + RedshiftParserRULE_privilege_target = 386 + RedshiftParserRULE_parameter_name_list = 387 + RedshiftParserRULE_parameter_name = 388 + RedshiftParserRULE_opt_grant_grant_option = 389 + RedshiftParserRULE_grantrolestmt = 390 + RedshiftParserRULE_revokerolestmt = 391 + RedshiftParserRULE_opt_grant_admin_option = 392 + RedshiftParserRULE_opt_granted_by = 393 + RedshiftParserRULE_alterdefaultprivilegesstmt = 394 + RedshiftParserRULE_defacloptionlist = 395 + RedshiftParserRULE_defacloption = 396 + RedshiftParserRULE_defaclaction = 397 + RedshiftParserRULE_defacl_privilege_target = 398 + RedshiftParserRULE_indexstmt = 399 + RedshiftParserRULE_opt_unique = 400 + RedshiftParserRULE_opt_concurrently = 401 + RedshiftParserRULE_opt_index_name = 402 + RedshiftParserRULE_access_method_clause = 403 + RedshiftParserRULE_index_params = 404 + RedshiftParserRULE_index_elem_options = 405 + RedshiftParserRULE_index_elem = 406 + RedshiftParserRULE_opt_include = 407 + RedshiftParserRULE_index_including_params = 408 + RedshiftParserRULE_opt_collate = 409 + RedshiftParserRULE_opt_class = 410 + RedshiftParserRULE_opt_asc_desc = 411 + RedshiftParserRULE_opt_nulls_order = 412 + RedshiftParserRULE_createfunctionstmt = 413 + RedshiftParserRULE_createprocedurestmt = 414 + RedshiftParserRULE_opt_nonatomic = 415 + RedshiftParserRULE_opt_or_replace = 416 + RedshiftParserRULE_func_py_args_or_sql_args = 417 + RedshiftParserRULE_func_py_args_or_sql_args_list = 418 + RedshiftParserRULE_func_args = 419 + RedshiftParserRULE_func_args_list = 420 + RedshiftParserRULE_function_with_argtypes_list = 421 + RedshiftParserRULE_function_with_argtypes = 422 + RedshiftParserRULE_func_args_with_defaults = 423 + RedshiftParserRULE_func_args_with_defaults_list = 424 + RedshiftParserRULE_func_arg = 425 + RedshiftParserRULE_arg_class = 426 + RedshiftParserRULE_param_name = 427 + RedshiftParserRULE_func_return = 428 + RedshiftParserRULE_func_type = 429 + RedshiftParserRULE_func_arg_with_default = 430 + RedshiftParserRULE_aggr_arg = 431 + RedshiftParserRULE_aggr_args = 432 + RedshiftParserRULE_aggr_args_list = 433 + RedshiftParserRULE_aggregate_with_argtypes = 434 + RedshiftParserRULE_aggregate_with_argtypes_list = 435 + RedshiftParserRULE_createfunc_opt_list = 436 + RedshiftParserRULE_common_func_opt_item = 437 + RedshiftParserRULE_createfunc_opt_item = 438 + RedshiftParserRULE_func_as = 439 + RedshiftParserRULE_transform_type_list = 440 + RedshiftParserRULE_opt_definition = 441 + RedshiftParserRULE_table_func_column = 442 + RedshiftParserRULE_table_func_column_list = 443 + RedshiftParserRULE_alterfunctionstmt = 444 + RedshiftParserRULE_alterprocedurestmt = 445 + RedshiftParserRULE_alterfunc_opt_list = 446 + RedshiftParserRULE_opt_restrict = 447 + RedshiftParserRULE_removefuncstmt = 448 + RedshiftParserRULE_removeaggrstmt = 449 + RedshiftParserRULE_removeoperstmt = 450 + RedshiftParserRULE_oper_argtypes = 451 + RedshiftParserRULE_any_operator = 452 + RedshiftParserRULE_operator_with_argtypes_list = 453 + RedshiftParserRULE_operator_with_argtypes = 454 + RedshiftParserRULE_dostmt = 455 + RedshiftParserRULE_dostmt_opt_list = 456 + RedshiftParserRULE_dostmt_opt_item = 457 + RedshiftParserRULE_createcaststmt = 458 + RedshiftParserRULE_cast_context = 459 + RedshiftParserRULE_dropcaststmt = 460 + RedshiftParserRULE_opt_if_exists = 461 + RedshiftParserRULE_createtransformstmt = 462 + RedshiftParserRULE_transform_element_list = 463 + RedshiftParserRULE_droptransformstmt = 464 + RedshiftParserRULE_reindexstmt = 465 + RedshiftParserRULE_reindex_target_type = 466 + RedshiftParserRULE_reindex_target_multitable = 467 + RedshiftParserRULE_reindex_option_list = 468 + RedshiftParserRULE_reindex_option_elem = 469 + RedshiftParserRULE_altertblspcstmt = 470 + RedshiftParserRULE_renamestmt = 471 + RedshiftParserRULE_opt_column = 472 + RedshiftParserRULE_opt_set_data = 473 + RedshiftParserRULE_alterobjectdependsstmt = 474 + RedshiftParserRULE_opt_no = 475 + RedshiftParserRULE_alterobjectschemastmt = 476 + RedshiftParserRULE_alteroperatorstmt = 477 + RedshiftParserRULE_operator_def_list = 478 + RedshiftParserRULE_operator_def_elem = 479 + RedshiftParserRULE_operator_def_arg = 480 + RedshiftParserRULE_altertypestmt = 481 + RedshiftParserRULE_alterownerstmt = 482 + RedshiftParserRULE_createpublicationstmt = 483 + RedshiftParserRULE_pub_obj_list = 484 + RedshiftParserRULE_publication_obj_spec = 485 + RedshiftParserRULE_opt_where_clause = 486 + RedshiftParserRULE_alterpublicationstmt = 487 + RedshiftParserRULE_createsubscriptionstmt = 488 + RedshiftParserRULE_publication_name_list = 489 + RedshiftParserRULE_publication_name_item = 490 + RedshiftParserRULE_altersubscriptionstmt = 491 + RedshiftParserRULE_dropsubscriptionstmt = 492 + RedshiftParserRULE_rulestmt = 493 + RedshiftParserRULE_ruleactionlist = 494 + RedshiftParserRULE_ruleactionmulti = 495 + RedshiftParserRULE_ruleactionstmt = 496 + RedshiftParserRULE_ruleactionstmtOrEmpty = 497 + RedshiftParserRULE_event = 498 + RedshiftParserRULE_opt_instead = 499 + RedshiftParserRULE_notifystmt = 500 + RedshiftParserRULE_notify_payload = 501 + RedshiftParserRULE_listenstmt = 502 + RedshiftParserRULE_unlistenstmt = 503 + RedshiftParserRULE_transactionstmt = 504 + RedshiftParserRULE_opt_transaction = 505 + RedshiftParserRULE_transaction_mode_item = 506 + RedshiftParserRULE_transaction_mode_list = 507 + RedshiftParserRULE_transaction_mode_list_or_empty = 508 + RedshiftParserRULE_opt_transaction_chain = 509 + RedshiftParserRULE_viewstmt = 510 + RedshiftParserRULE_with_no_schema_binding = 511 + RedshiftParserRULE_opt_check_option = 512 + RedshiftParserRULE_loadstmt = 513 + RedshiftParserRULE_alterdatasharestmt = 514 + RedshiftParserRULE_alterdatashare_action = 515 + RedshiftParserRULE_alterdatashare_add_drop = 516 + RedshiftParserRULE_alterdatashare_objects = 517 + RedshiftParserRULE_datashare_table_list = 518 + RedshiftParserRULE_datashare_table_name = 519 + RedshiftParserRULE_table_name = 520 + RedshiftParserRULE_temporary_table_name = 521 + RedshiftParserRULE_datashare_function_list = 522 + RedshiftParserRULE_datashare_function = 523 + RedshiftParserRULE_datashare_function_name = 524 + RedshiftParserRULE_createdatasharestmt = 525 + RedshiftParserRULE_createdatashareoptions = 526 + RedshiftParserRULE_createdatashareoption = 527 + RedshiftParserRULE_setpublicaccessibleoption = 528 + RedshiftParserRULE_managedbyoption = 529 + RedshiftParserRULE_descdatasharestmt = 530 + RedshiftParserRULE_dropdatasharestmt = 531 + RedshiftParserRULE_alterexternalschemastmt = 532 + RedshiftParserRULE_altexternalschemaopts = 533 + RedshiftParserRULE_alterexternalviewstmt = 534 + RedshiftParserRULE_createexternalschemastmt = 535 + RedshiftParserRULE_fromdatacatalogclause = 536 + RedshiftParserRULE_dropschemastmt = 537 + RedshiftParserRULE_implicitdatacatalogclause = 538 + RedshiftParserRULE_fromhivemetastoreclause = 539 + RedshiftParserRULE_frompostgresclause = 540 + RedshiftParserRULE_frommysqlclause = 541 + RedshiftParserRULE_fromkinesisclause = 542 + RedshiftParserRULE_fromkafkaclause = 543 + RedshiftParserRULE_frommskclause = 544 + RedshiftParserRULE_fromredshiftclause = 545 + RedshiftParserRULE_iamrolevalue = 546 + RedshiftParserRULE_catalogrolevalue = 547 + RedshiftParserRULE_authenticationvalue = 548 + RedshiftParserRULE_createexternalfunctionstmt = 549 + RedshiftParserRULE_external_func_params = 550 + RedshiftParserRULE_paramlist = 551 + RedshiftParserRULE_param_spec = 552 + RedshiftParserRULE_createexternalmodelstmt = 553 + RedshiftParserRULE_createexternaltablestmt = 554 + RedshiftParserRULE_extern_column_list = 555 + RedshiftParserRULE_extern_column_def = 556 + RedshiftParserRULE_extern_typename = 557 + RedshiftParserRULE_extern_table_format = 558 + RedshiftParserRULE_row_format_spec = 559 + RedshiftParserRULE_serde_properties_list = 560 + RedshiftParserRULE_serde_property = 561 + RedshiftParserRULE_external_format_spec = 562 + RedshiftParserRULE_table_properties_list = 563 + RedshiftParserRULE_table_property = 564 + RedshiftParserRULE_createexternalviewstmt = 565 + RedshiftParserRULE_dropexternalviewstmt = 566 + RedshiftParserRULE_alteridentityproviderstmt = 567 + RedshiftParserRULE_alteridprovideropts = 568 + RedshiftParserRULE_altermaskingpolicystmt = 569 + RedshiftParserRULE_altermaterializedviewstmt = 570 + RedshiftParserRULE_altmaskingpolicyopts = 571 + RedshiftParserRULE_altmaskingpolicyargs = 572 + RedshiftParserRULE_altmaskingpolicyarg = 573 + RedshiftParserRULE_alterrlspolicystmt = 574 + RedshiftParserRULE_attachmaskingpolicystmt = 575 + RedshiftParserRULE_attachpolicycollist = 576 + RedshiftParserRULE_attachpolicycolumn = 577 + RedshiftParserRULE_attachpolicytargets = 578 + RedshiftParserRULE_attachpolicytarget = 579 + RedshiftParserRULE_attachrlspolicystmt = 580 + RedshiftParserRULE_table_name_list = 581 + RedshiftParserRULE_createidentityproviderstmt = 582 + RedshiftParserRULE_createidprovideropts = 583 + RedshiftParserRULE_groupfilter = 584 + RedshiftParserRULE_createlibrarystmt = 585 + RedshiftParserRULE_createlibraryopts = 586 + RedshiftParserRULE_createmaskingpolicystmt = 587 + RedshiftParserRULE_inputcolumnlist = 588 + RedshiftParserRULE_inputcolumn = 589 + RedshiftParserRULE_maskingexpression = 590 + RedshiftParserRULE_createmodelstmt = 591 + RedshiftParserRULE_createmodelfromclause = 592 + RedshiftParserRULE_iamrolespec = 593 + RedshiftParserRULE_sagemakerspec = 594 + RedshiftParserRULE_modeltypespec = 595 + RedshiftParserRULE_problemtypespec = 596 + RedshiftParserRULE_problemtype = 597 + RedshiftParserRULE_objectivespec = 598 + RedshiftParserRULE_hyperparametersspec = 599 + RedshiftParserRULE_hyperparameterslist = 600 + RedshiftParserRULE_hyperparameteritem = 601 + RedshiftParserRULE_settingsclause = 602 + RedshiftParserRULE_settingsitem = 603 + RedshiftParserRULE_datatypelist = 604 + RedshiftParserRULE_datatype = 605 + RedshiftParserRULE_createrlspolicystmt = 606 + RedshiftParserRULE_descidentityproviderstmt = 607 + RedshiftParserRULE_detachmaskingpolicystmt = 608 + RedshiftParserRULE_detachrlspolicystmt = 609 + RedshiftParserRULE_role_or_user_or_public_list = 610 + RedshiftParserRULE_role_or_user_or_public = 611 + RedshiftParserRULE_rlspolicyname = 612 + RedshiftParserRULE_dropidentityproviderstmt = 613 + RedshiftParserRULE_droplibrarystmt = 614 + RedshiftParserRULE_dropmaskingpolicystmt = 615 + RedshiftParserRULE_dropmodelstmt = 616 + RedshiftParserRULE_droprlspolicystmt = 617 + RedshiftParserRULE_altertableappendstmt = 618 + RedshiftParserRULE_appendoptions = 619 + RedshiftParserRULE_alteruserstmt = 620 + RedshiftParserRULE_alteruseropts = 621 + RedshiftParserRULE_analyzecompressionstmt = 622 + RedshiftParserRULE_cancelstmt = 623 + RedshiftParserRULE_closestmt = 624 + RedshiftParserRULE_insertexternaltablestmt = 625 + RedshiftParserRULE_select_or_values = 626 + RedshiftParserRULE_selectintostmt = 627 + RedshiftParserRULE_setsessionauthorizationstmt = 628 + RedshiftParserRULE_setsessioncharacteristicsstmt = 629 + RedshiftParserRULE_showcolumnsstmt = 630 + RedshiftParserRULE_showdatabasesstmt = 631 + RedshiftParserRULE_showdbsopts = 632 + RedshiftParserRULE_showdatasharesstmt = 633 + RedshiftParserRULE_showexternaltablestmt = 634 + RedshiftParserRULE_showgrantsstmt = 635 + RedshiftParserRULE_grantobject = 636 + RedshiftParserRULE_grantprincipal = 637 + RedshiftParserRULE_showmodelstmt = 638 + RedshiftParserRULE_showprocedurestmt = 639 + RedshiftParserRULE_showschemasstmt = 640 + RedshiftParserRULE_showtablestmt = 641 + RedshiftParserRULE_showtablesstmt = 642 + RedshiftParserRULE_showviewstmt = 643 + RedshiftParserRULE_unloadstmt = 644 + RedshiftParserRULE_iamroleclause = 645 + RedshiftParserRULE_unloadoptions = 646 + RedshiftParserRULE_formatoption = 647 + RedshiftParserRULE_partitionbyoption = 648 + RedshiftParserRULE_manifestoption = 649 + RedshiftParserRULE_headeroption = 650 + RedshiftParserRULE_delimiteroption = 651 + RedshiftParserRULE_fixedwidthoption = 652 + RedshiftParserRULE_encryptedoption = 653 + RedshiftParserRULE_kmskeyoption = 654 + RedshiftParserRULE_compressionoption = 655 + RedshiftParserRULE_addquotesoption = 656 + RedshiftParserRULE_nullasoption = 657 + RedshiftParserRULE_escapeoption = 658 + RedshiftParserRULE_allowoverwriteoption = 659 + RedshiftParserRULE_cleanpathoption = 660 + RedshiftParserRULE_paralleloption = 661 + RedshiftParserRULE_maxfilesizeoption = 662 + RedshiftParserRULE_rowgroupsizeoption = 663 + RedshiftParserRULE_sizeunit = 664 + RedshiftParserRULE_regionoption = 665 + RedshiftParserRULE_extensionoption = 666 + RedshiftParserRULE_usestmt = 667 + RedshiftParserRULE_createdbstmt = 668 + RedshiftParserRULE_createdb_opt_list = 669 + RedshiftParserRULE_createdb_opt_items = 670 + RedshiftParserRULE_createdb_opt_item = 671 + RedshiftParserRULE_createdb_opt_name = 672 + RedshiftParserRULE_opt_equal = 673 + RedshiftParserRULE_alterdatabasestmt = 674 + RedshiftParserRULE_alterdatabasesetstmt = 675 + RedshiftParserRULE_dropdbstmt = 676 + RedshiftParserRULE_drop_option_list = 677 + RedshiftParserRULE_drop_option = 678 + RedshiftParserRULE_altercollationstmt = 679 + RedshiftParserRULE_altersystemstmt = 680 + RedshiftParserRULE_createdomainstmt = 681 + RedshiftParserRULE_alterdomainstmt = 682 + RedshiftParserRULE_opt_as = 683 + RedshiftParserRULE_altertsdictionarystmt = 684 + RedshiftParserRULE_altertsconfigurationstmt = 685 + RedshiftParserRULE_any_with = 686 + RedshiftParserRULE_createconversionstmt = 687 + RedshiftParserRULE_clusterstmt = 688 + RedshiftParserRULE_cluster_index_specification = 689 + RedshiftParserRULE_vacuumstmt = 690 + RedshiftParserRULE_vacuum_option = 691 + RedshiftParserRULE_analyzestmt = 692 + RedshiftParserRULE_vac_analyze_option_list = 693 + RedshiftParserRULE_analyze_keyword = 694 + RedshiftParserRULE_vac_analyze_option_elem = 695 + RedshiftParserRULE_vac_analyze_option_name = 696 + RedshiftParserRULE_vac_analyze_option_arg = 697 + RedshiftParserRULE_opt_analyze = 698 + RedshiftParserRULE_opt_verbose = 699 + RedshiftParserRULE_opt_full = 700 + RedshiftParserRULE_opt_freeze = 701 + RedshiftParserRULE_opt_name_list = 702 + RedshiftParserRULE_vacuum_relation = 703 + RedshiftParserRULE_vacuum_relation_list = 704 + RedshiftParserRULE_opt_vacuum_relation_list = 705 + RedshiftParserRULE_explainstmt = 706 + RedshiftParserRULE_explainablestmt = 707 + RedshiftParserRULE_explain_option_list = 708 + RedshiftParserRULE_explain_option_elem = 709 + RedshiftParserRULE_explain_option_name = 710 + RedshiftParserRULE_explain_option_arg = 711 + RedshiftParserRULE_preparestmt = 712 + RedshiftParserRULE_prep_type_clause = 713 + RedshiftParserRULE_preparablestmt = 714 + RedshiftParserRULE_executestmt = 715 + RedshiftParserRULE_execute_param_clause = 716 + RedshiftParserRULE_deallocatestmt = 717 + RedshiftParserRULE_insertstmt = 718 + RedshiftParserRULE_insert_target = 719 + RedshiftParserRULE_insert_rest = 720 + RedshiftParserRULE_override_kind = 721 + RedshiftParserRULE_insert_column_list = 722 + RedshiftParserRULE_insert_column_item = 723 + RedshiftParserRULE_opt_on_conflict = 724 + RedshiftParserRULE_opt_conf_expr = 725 + RedshiftParserRULE_returning_clause = 726 + RedshiftParserRULE_mergestmt = 727 + RedshiftParserRULE_merge_when_clause = 728 + RedshiftParserRULE_merge_insert_clause = 729 + RedshiftParserRULE_merge_update_clause = 730 + RedshiftParserRULE_merge_delete_clause = 731 + RedshiftParserRULE_deletestmt = 732 + RedshiftParserRULE_using_clause = 733 + RedshiftParserRULE_lockstmt = 734 + RedshiftParserRULE_opt_lock = 735 + RedshiftParserRULE_lock_type = 736 + RedshiftParserRULE_opt_nowait = 737 + RedshiftParserRULE_opt_nowait_or_skip = 738 + RedshiftParserRULE_updatestmt = 739 + RedshiftParserRULE_set_clause_list = 740 + RedshiftParserRULE_set_clause = 741 + RedshiftParserRULE_set_target = 742 + RedshiftParserRULE_set_target_list = 743 + RedshiftParserRULE_declarecursorstmt = 744 + RedshiftParserRULE_cursor_name = 745 + RedshiftParserRULE_cursor_options = 746 + RedshiftParserRULE_opt_hold = 747 + RedshiftParserRULE_selectstmt = 748 + RedshiftParserRULE_select_with_parens = 749 + RedshiftParserRULE_select_no_parens = 750 + RedshiftParserRULE_select_clause = 751 + RedshiftParserRULE_simple_select_intersect = 752 + RedshiftParserRULE_simple_select_pramary = 753 + RedshiftParserRULE_exclude_clause = 754 + RedshiftParserRULE_qualify_clause = 755 + RedshiftParserRULE_start_with_clause = 756 + RedshiftParserRULE_with_clause = 757 + RedshiftParserRULE_cte_list = 758 + RedshiftParserRULE_common_table_expr = 759 + RedshiftParserRULE_opt_materialized = 760 + RedshiftParserRULE_opt_with_clause = 761 + RedshiftParserRULE_into_clause = 762 + RedshiftParserRULE_opt_top_clause = 763 + RedshiftParserRULE_opt_strict = 764 + RedshiftParserRULE_opttempTableName = 765 + RedshiftParserRULE_opt_table = 766 + RedshiftParserRULE_all_or_distinct = 767 + RedshiftParserRULE_distinct_clause = 768 + RedshiftParserRULE_opt_all_clause = 769 + RedshiftParserRULE_opt_sort_clause = 770 + RedshiftParserRULE_sort_clause = 771 + RedshiftParserRULE_sortby_list = 772 + RedshiftParserRULE_sortby = 773 + RedshiftParserRULE_select_limit = 774 + RedshiftParserRULE_opt_select_limit = 775 + RedshiftParserRULE_limit_clause = 776 + RedshiftParserRULE_offset_clause = 777 + RedshiftParserRULE_select_limit_value = 778 + RedshiftParserRULE_select_offset_value = 779 + RedshiftParserRULE_select_fetch_first_value = 780 + RedshiftParserRULE_i_or_f_const = 781 + RedshiftParserRULE_row_or_rows = 782 + RedshiftParserRULE_first_or_next = 783 + RedshiftParserRULE_group_clause = 784 + RedshiftParserRULE_group_by_list = 785 + RedshiftParserRULE_group_by_item = 786 + RedshiftParserRULE_empty_grouping_set = 787 + RedshiftParserRULE_rollup_clause = 788 + RedshiftParserRULE_cube_clause = 789 + RedshiftParserRULE_grouping_sets_clause = 790 + RedshiftParserRULE_having_clause = 791 + RedshiftParserRULE_for_locking_clause = 792 + RedshiftParserRULE_opt_for_locking_clause = 793 + RedshiftParserRULE_for_locking_items = 794 + RedshiftParserRULE_for_locking_item = 795 + RedshiftParserRULE_for_locking_strength = 796 + RedshiftParserRULE_locked_rels_list = 797 + RedshiftParserRULE_values_clause = 798 + RedshiftParserRULE_from_clause = 799 + RedshiftParserRULE_from_list = 800 + RedshiftParserRULE_table_ref = 801 + RedshiftParserRULE_joined_table = 802 + RedshiftParserRULE_alias_clause = 803 + RedshiftParserRULE_opt_alias_clause = 804 + RedshiftParserRULE_table_alias_clause = 805 + RedshiftParserRULE_func_alias_clause = 806 + RedshiftParserRULE_join_type = 807 + RedshiftParserRULE_join_qual = 808 + RedshiftParserRULE_relation_expr = 809 + RedshiftParserRULE_relation_expr_list = 810 + RedshiftParserRULE_relation_expr_opt_alias = 811 + RedshiftParserRULE_tablesample_clause = 812 + RedshiftParserRULE_opt_repeatable_clause = 813 + RedshiftParserRULE_func_table = 814 + RedshiftParserRULE_rowsfrom_item = 815 + RedshiftParserRULE_rowsfrom_list = 816 + RedshiftParserRULE_opt_col_def_list = 817 + RedshiftParserRULE_opt_ordinality = 818 + RedshiftParserRULE_where_clause = 819 + RedshiftParserRULE_where_or_current_clause = 820 + RedshiftParserRULE_opttablefuncelementlist = 821 + RedshiftParserRULE_tablefuncelementlist = 822 + RedshiftParserRULE_tablefuncelement = 823 + RedshiftParserRULE_xmltable = 824 + RedshiftParserRULE_xmltable_column_list = 825 + RedshiftParserRULE_xmltable_column_el = 826 + RedshiftParserRULE_xmltable_column_option_list = 827 + RedshiftParserRULE_xmltable_column_option_el = 828 + RedshiftParserRULE_xml_namespace_list = 829 + RedshiftParserRULE_xml_namespace_el = 830 + RedshiftParserRULE_typename = 831 + RedshiftParserRULE_opt_array_bounds = 832 + RedshiftParserRULE_simpletypename = 833 + RedshiftParserRULE_varbyte = 834 + RedshiftParserRULE_json_type = 835 + RedshiftParserRULE_consttypename = 836 + RedshiftParserRULE_generictype = 837 + RedshiftParserRULE_opt_type_modifiers = 838 + RedshiftParserRULE_numeric = 839 + RedshiftParserRULE_opt_float = 840 + RedshiftParserRULE_bit = 841 + RedshiftParserRULE_constbit = 842 + RedshiftParserRULE_bitwithlength = 843 + RedshiftParserRULE_bitwithoutlength = 844 + RedshiftParserRULE_character = 845 + RedshiftParserRULE_constcharacter = 846 + RedshiftParserRULE_character_c = 847 + RedshiftParserRULE_opt_varying = 848 + RedshiftParserRULE_constdatetime = 849 + RedshiftParserRULE_constinterval = 850 + RedshiftParserRULE_opt_timezone = 851 + RedshiftParserRULE_opt_interval = 852 + RedshiftParserRULE_interval_second = 853 + RedshiftParserRULE_opt_escape = 854 + RedshiftParserRULE_a_expr = 855 + RedshiftParserRULE_a_expr_qual = 856 + RedshiftParserRULE_a_expr_lessless = 857 + RedshiftParserRULE_a_expr_or = 858 + RedshiftParserRULE_a_expr_and = 859 + RedshiftParserRULE_a_expr_between = 860 + RedshiftParserRULE_a_expr_in = 861 + RedshiftParserRULE_a_expr_unary_not = 862 + RedshiftParserRULE_a_expr_isnull = 863 + RedshiftParserRULE_a_expr_is_not = 864 + RedshiftParserRULE_a_expr_compare = 865 + RedshiftParserRULE_a_expr_prior_or_level = 866 + RedshiftParserRULE_a_expr_like = 867 + RedshiftParserRULE_a_expr_qual_op = 868 + RedshiftParserRULE_a_expr_unary_qualop = 869 + RedshiftParserRULE_a_expr_add = 870 + RedshiftParserRULE_a_expr_mul = 871 + RedshiftParserRULE_a_expr_caret = 872 + RedshiftParserRULE_a_expr_unary_sign = 873 + RedshiftParserRULE_a_expr_at_time_zone = 874 + RedshiftParserRULE_a_expr_collate = 875 + RedshiftParserRULE_a_expr_typecast = 876 + RedshiftParserRULE_b_expr = 877 + RedshiftParserRULE_c_expr = 878 + RedshiftParserRULE_plsqlvariablename = 879 + RedshiftParserRULE_func_application = 880 + RedshiftParserRULE_func_expr = 881 + RedshiftParserRULE_func_expr_windowless = 882 + RedshiftParserRULE_func_expr_common_subexpr = 883 + RedshiftParserRULE_xml_root_version = 884 + RedshiftParserRULE_opt_xml_root_standalone = 885 + RedshiftParserRULE_xml_attributes = 886 + RedshiftParserRULE_xml_attribute_list = 887 + RedshiftParserRULE_xml_attribute_el = 888 + RedshiftParserRULE_document_or_content = 889 + RedshiftParserRULE_xml_whitespace_option = 890 + RedshiftParserRULE_xmlexists_argument = 891 + RedshiftParserRULE_xml_passing_mech = 892 + RedshiftParserRULE_within_group_clause = 893 + RedshiftParserRULE_filter_clause = 894 + RedshiftParserRULE_window_clause = 895 + RedshiftParserRULE_window_definition_list = 896 + RedshiftParserRULE_window_definition = 897 + RedshiftParserRULE_over_clause = 898 + RedshiftParserRULE_window_specification = 899 + RedshiftParserRULE_opt_existing_window_name = 900 + RedshiftParserRULE_opt_partition_clause = 901 + RedshiftParserRULE_opt_frame_clause = 902 + RedshiftParserRULE_frame_extent = 903 + RedshiftParserRULE_frame_bound = 904 + RedshiftParserRULE_opt_window_exclusion_clause = 905 + RedshiftParserRULE_row = 906 + RedshiftParserRULE_explicit_row = 907 + RedshiftParserRULE_implicit_row = 908 + RedshiftParserRULE_sub_type = 909 + RedshiftParserRULE_all_op = 910 + RedshiftParserRULE_mathop = 911 + RedshiftParserRULE_qual_op = 912 + RedshiftParserRULE_qual_all_op = 913 + RedshiftParserRULE_subquery_Op = 914 + RedshiftParserRULE_expr_list = 915 + RedshiftParserRULE_func_arg_list = 916 + RedshiftParserRULE_func_arg_expr = 917 + RedshiftParserRULE_type_list = 918 + RedshiftParserRULE_array_expr = 919 + RedshiftParserRULE_array_expr_list = 920 + RedshiftParserRULE_extract_list = 921 + RedshiftParserRULE_extract_arg = 922 + RedshiftParserRULE_unicode_normal_form = 923 + RedshiftParserRULE_overlay_list = 924 + RedshiftParserRULE_position_list = 925 + RedshiftParserRULE_substr_list = 926 + RedshiftParserRULE_trim_list = 927 + RedshiftParserRULE_in_expr = 928 + RedshiftParserRULE_case_expr = 929 + RedshiftParserRULE_when_clause_list = 930 + RedshiftParserRULE_when_clause = 931 + RedshiftParserRULE_case_default = 932 + RedshiftParserRULE_case_arg = 933 + RedshiftParserRULE_columnref = 934 + RedshiftParserRULE_indirection_el = 935 + RedshiftParserRULE_opt_slice_bound = 936 + RedshiftParserRULE_indirection = 937 + RedshiftParserRULE_opt_indirection = 938 + RedshiftParserRULE_opt_target_list = 939 + RedshiftParserRULE_target_list = 940 + RedshiftParserRULE_target_el = 941 + RedshiftParserRULE_target_alias = 942 + RedshiftParserRULE_qualified_name_list = 943 + RedshiftParserRULE_qualified_name = 944 + RedshiftParserRULE_name_list = 945 + RedshiftParserRULE_name = 946 + RedshiftParserRULE_attr_name = 947 + RedshiftParserRULE_file_name = 948 + RedshiftParserRULE_func_name = 949 + RedshiftParserRULE_aexprconst = 950 + RedshiftParserRULE_xconst = 951 + RedshiftParserRULE_bconst = 952 + RedshiftParserRULE_fconst = 953 + RedshiftParserRULE_iconst = 954 + RedshiftParserRULE_sconst = 955 + RedshiftParserRULE_anysconst = 956 + RedshiftParserRULE_opt_uescape = 957 + RedshiftParserRULE_signediconst = 958 + RedshiftParserRULE_roleid = 959 + RedshiftParserRULE_rolespec = 960 + RedshiftParserRULE_role_list = 961 + RedshiftParserRULE_colid = 962 + RedshiftParserRULE_table_alias = 963 + RedshiftParserRULE_type_function_name = 964 + RedshiftParserRULE_nonreservedword = 965 + RedshiftParserRULE_collabel = 966 + RedshiftParserRULE_identifier = 967 + RedshiftParserRULE_plsqlidentifier = 968 + RedshiftParserRULE_unreserved_keyword = 969 + RedshiftParserRULE_col_name_keyword = 970 + RedshiftParserRULE_type_func_name_keyword = 971 + RedshiftParserRULE_reserved_keyword = 972 + RedshiftParserRULE_builtin_function_name = 973 + RedshiftParserRULE_pl_function = 974 + RedshiftParserRULE_comp_options = 975 + RedshiftParserRULE_comp_option = 976 + RedshiftParserRULE_sharp = 977 + RedshiftParserRULE_option_value = 978 + RedshiftParserRULE_opt_semi = 979 + RedshiftParserRULE_pl_block = 980 + RedshiftParserRULE_decl_sect = 981 + RedshiftParserRULE_decl_start = 982 + RedshiftParserRULE_decl_stmts = 983 + RedshiftParserRULE_label_decl = 984 + RedshiftParserRULE_decl_stmt = 985 + RedshiftParserRULE_decl_statement = 986 + RedshiftParserRULE_opt_scrollable = 987 + RedshiftParserRULE_decl_cursor_query = 988 + RedshiftParserRULE_decl_cursor_args = 989 + RedshiftParserRULE_decl_cursor_arglist = 990 + RedshiftParserRULE_decl_cursor_arg = 991 + RedshiftParserRULE_decl_is_for = 992 + RedshiftParserRULE_decl_aliasitem = 993 + RedshiftParserRULE_decl_varname = 994 + RedshiftParserRULE_decl_const = 995 + RedshiftParserRULE_decl_datatype = 996 + RedshiftParserRULE_decl_collate = 997 + RedshiftParserRULE_decl_notnull = 998 + RedshiftParserRULE_decl_defval = 999 + RedshiftParserRULE_decl_defkey = 1000 + RedshiftParserRULE_assign_operator = 1001 + RedshiftParserRULE_proc_sect = 1002 + RedshiftParserRULE_proc_stmt = 1003 + RedshiftParserRULE_stmt_perform = 1004 + RedshiftParserRULE_stmt_call = 1005 + RedshiftParserRULE_opt_expr_list = 1006 + RedshiftParserRULE_stmt_assign = 1007 + RedshiftParserRULE_stmt_getdiag = 1008 + RedshiftParserRULE_getdiag_area_opt = 1009 + RedshiftParserRULE_getdiag_list = 1010 + RedshiftParserRULE_getdiag_list_item = 1011 + RedshiftParserRULE_getdiag_item = 1012 + RedshiftParserRULE_getdiag_target = 1013 + RedshiftParserRULE_assign_var = 1014 + RedshiftParserRULE_stmt_if = 1015 + RedshiftParserRULE_stmt_elsifs = 1016 + RedshiftParserRULE_stmt_else = 1017 + RedshiftParserRULE_stmt_case = 1018 + RedshiftParserRULE_opt_expr_until_when = 1019 + RedshiftParserRULE_case_when_list = 1020 + RedshiftParserRULE_case_when = 1021 + RedshiftParserRULE_opt_case_else = 1022 + RedshiftParserRULE_stmt_loop = 1023 + RedshiftParserRULE_stmt_while = 1024 + RedshiftParserRULE_stmt_for = 1025 + RedshiftParserRULE_for_control = 1026 + RedshiftParserRULE_opt_for_using_expression = 1027 + RedshiftParserRULE_opt_cursor_parameters = 1028 + RedshiftParserRULE_opt_reverse = 1029 + RedshiftParserRULE_opt_by_expression = 1030 + RedshiftParserRULE_for_variable = 1031 + RedshiftParserRULE_stmt_foreach_a = 1032 + RedshiftParserRULE_foreach_slice = 1033 + RedshiftParserRULE_stmt_exit = 1034 + RedshiftParserRULE_exit_type = 1035 + RedshiftParserRULE_stmt_return = 1036 + RedshiftParserRULE_opt_return_result = 1037 + RedshiftParserRULE_stmt_raise = 1038 + RedshiftParserRULE_opt_stmt_raise_level = 1039 + RedshiftParserRULE_opt_raise_list = 1040 + RedshiftParserRULE_opt_raise_using = 1041 + RedshiftParserRULE_opt_raise_using_elem = 1042 + RedshiftParserRULE_opt_raise_using_elem_list = 1043 + RedshiftParserRULE_stmt_assert = 1044 + RedshiftParserRULE_opt_stmt_assert_message = 1045 + RedshiftParserRULE_loop_body = 1046 + RedshiftParserRULE_stmt_execsql = 1047 + RedshiftParserRULE_stmt_dynexecute = 1048 + RedshiftParserRULE_opt_execute_using = 1049 + RedshiftParserRULE_opt_execute_using_list = 1050 + RedshiftParserRULE_opt_execute_into = 1051 + RedshiftParserRULE_stmt_open = 1052 + RedshiftParserRULE_opt_open_bound_list_item = 1053 + RedshiftParserRULE_opt_open_bound_list = 1054 + RedshiftParserRULE_opt_open_using = 1055 + RedshiftParserRULE_opt_scroll_option = 1056 + RedshiftParserRULE_opt_scroll_option_no = 1057 + RedshiftParserRULE_stmt_fetch = 1058 + RedshiftParserRULE_into_target = 1059 + RedshiftParserRULE_opt_cursor_from = 1060 + RedshiftParserRULE_opt_fetch_direction = 1061 + RedshiftParserRULE_stmt_move = 1062 + RedshiftParserRULE_stmt_close = 1063 + RedshiftParserRULE_stmt_null = 1064 + RedshiftParserRULE_stmt_commit = 1065 + RedshiftParserRULE_stmt_rollback = 1066 + RedshiftParserRULE_plsql_opt_transaction_chain = 1067 + RedshiftParserRULE_stmt_set = 1068 + RedshiftParserRULE_cursor_variable = 1069 + RedshiftParserRULE_exception_sect = 1070 + RedshiftParserRULE_proc_exceptions = 1071 + RedshiftParserRULE_proc_exception = 1072 + RedshiftParserRULE_proc_conditions = 1073 + RedshiftParserRULE_proc_condition = 1074 + RedshiftParserRULE_opt_block_label = 1075 + RedshiftParserRULE_opt_loop_label = 1076 + RedshiftParserRULE_opt_label = 1077 + RedshiftParserRULE_opt_exitcond = 1078 + RedshiftParserRULE_any_identifier = 1079 + RedshiftParserRULE_plsql_unreserved_keyword = 1080 + RedshiftParserRULE_sql_expression = 1081 + RedshiftParserRULE_expr_until_then = 1082 + RedshiftParserRULE_expr_until_semi = 1083 + RedshiftParserRULE_expr_until_rightbracket = 1084 + RedshiftParserRULE_expr_until_loop = 1085 + RedshiftParserRULE_make_execsql_stmt = 1086 + RedshiftParserRULE_opt_returning_clause_into = 1087 +) + +// IRootContext is an interface to support dynamic dispatch. +type IRootContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Stmtblock() IStmtblockContext + EOF() antlr.TerminalNode + + // IsRootContext differentiates from other interfaces. + IsRootContext() +} + +type RootContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRootContext() *RootContext { + var p = new(RootContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_root + return p +} + +func InitEmptyRootContext(p *RootContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_root +} + +func (*RootContext) IsRootContext() {} + +func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext { + var p = new(RootContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_root + + return p +} + +func (s *RootContext) GetParser() antlr.Parser { return s.parser } + +func (s *RootContext) Stmtblock() IStmtblockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtblockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmtblockContext) +} + +func (s *RootContext) EOF() antlr.TerminalNode { + return s.GetToken(RedshiftParserEOF, 0) +} + +func (s *RootContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RootContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRoot(s) + } +} + +func (s *RootContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRoot(s) + } +} + +func (s *RootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRoot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Root() (localctx IRootContext) { + localctx = NewRootContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, RedshiftParserRULE_root) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2176) + p.Stmtblock() + } + { + p.SetState(2177) + p.Match(RedshiftParserEOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsqlrootContext is an interface to support dynamic dispatch. +type IPlsqlrootContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pl_function() IPl_functionContext + + // IsPlsqlrootContext differentiates from other interfaces. + IsPlsqlrootContext() +} + +type PlsqlrootContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsqlrootContext() *PlsqlrootContext { + var p = new(PlsqlrootContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlroot + return p +} + +func InitEmptyPlsqlrootContext(p *PlsqlrootContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlroot +} + +func (*PlsqlrootContext) IsPlsqlrootContext() {} + +func NewPlsqlrootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlrootContext { + var p = new(PlsqlrootContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_plsqlroot + + return p +} + +func (s *PlsqlrootContext) GetParser() antlr.Parser { return s.parser } + +func (s *PlsqlrootContext) Pl_function() IPl_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPl_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPl_functionContext) +} + +func (s *PlsqlrootContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PlsqlrootContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PlsqlrootContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPlsqlroot(s) + } +} + +func (s *PlsqlrootContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPlsqlroot(s) + } +} + +func (s *PlsqlrootContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPlsqlroot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Plsqlroot() (localctx IPlsqlrootContext) { + localctx = NewPlsqlrootContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, RedshiftParserRULE_plsqlroot) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2179) + p.Pl_function() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmtblockContext is an interface to support dynamic dispatch. +type IStmtblockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Stmtmulti() IStmtmultiContext + + // IsStmtblockContext differentiates from other interfaces. + IsStmtblockContext() +} + +type StmtblockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmtblockContext() *StmtblockContext { + var p = new(StmtblockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmtblock + return p +} + +func InitEmptyStmtblockContext(p *StmtblockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmtblock +} + +func (*StmtblockContext) IsStmtblockContext() {} + +func NewStmtblockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtblockContext { + var p = new(StmtblockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmtblock + + return p +} + +func (s *StmtblockContext) GetParser() antlr.Parser { return s.parser } + +func (s *StmtblockContext) Stmtmulti() IStmtmultiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtmultiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmtmultiContext) +} + +func (s *StmtblockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StmtblockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StmtblockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmtblock(s) + } +} + +func (s *StmtblockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmtblock(s) + } +} + +func (s *StmtblockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmtblock(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmtblock() (localctx IStmtblockContext) { + localctx = NewStmtblockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, RedshiftParserRULE_stmtblock) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2181) + p.Stmtmulti() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmtmultiContext is an interface to support dynamic dispatch. +type IStmtmultiContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStmt() []IStmtContext + Stmt(i int) IStmtContext + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + + // IsStmtmultiContext differentiates from other interfaces. + IsStmtmultiContext() +} + +type StmtmultiContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmtmultiContext() *StmtmultiContext { + var p = new(StmtmultiContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmtmulti + return p +} + +func InitEmptyStmtmultiContext(p *StmtmultiContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmtmulti +} + +func (*StmtmultiContext) IsStmtmultiContext() {} + +func NewStmtmultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtmultiContext { + var p = new(StmtmultiContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmtmulti + + return p +} + +func (s *StmtmultiContext) GetParser() antlr.Parser { return s.parser } + +func (s *StmtmultiContext) AllStmt() []IStmtContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStmtContext); ok { + len++ + } + } + + tst := make([]IStmtContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStmtContext); ok { + tst[i] = t.(IStmtContext) + i++ + } + } + + return tst +} + +func (s *StmtmultiContext) Stmt(i int) IStmtContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStmtContext) +} + +func (s *StmtmultiContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserSEMI) +} + +func (s *StmtmultiContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, i) +} + +func (s *StmtmultiContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StmtmultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StmtmultiContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmtmulti(s) + } +} + +func (s *StmtmultiContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmtmulti(s) + } +} + +func (s *StmtmultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmtmulti(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmtmulti() (localctx IStmtmultiContext) { + localctx = NewStmtmultiContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, RedshiftParserRULE_stmtmulti) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2189) + 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(2183) + p.Stmt() + } + p.SetState(2185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSEMI { + { + p.SetState(2184) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(2191) + 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 + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmtContext is an interface to support dynamic dispatch. +type IStmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Altereventtrigstmt() IAltereventtrigstmtContext + Altercollationstmt() IAltercollationstmtContext + Alterdatabasestmt() IAlterdatabasestmtContext + Alterdatabasesetstmt() IAlterdatabasesetstmtContext + Alterdefaultprivilegesstmt() IAlterdefaultprivilegesstmtContext + Alterdomainstmt() IAlterdomainstmtContext + Alterenumstmt() IAlterenumstmtContext + Alterextensionstmt() IAlterextensionstmtContext + Alterextensioncontentsstmt() IAlterextensioncontentsstmtContext + Alterfdwstmt() IAlterfdwstmtContext + Alterforeignserverstmt() IAlterforeignserverstmtContext + Alterfunctionstmt() IAlterfunctionstmtContext + Alterprocedurestmt() IAlterprocedurestmtContext + Altergroupstmt() IAltergroupstmtContext + Alterobjectdependsstmt() IAlterobjectdependsstmtContext + Alterobjectschemastmt() IAlterobjectschemastmtContext + Alterownerstmt() IAlterownerstmtContext + Alteroperatorstmt() IAlteroperatorstmtContext + Altertypestmt() IAltertypestmtContext + Alterpolicystmt() IAlterpolicystmtContext + Alterseqstmt() IAlterseqstmtContext + Altersystemstmt() IAltersystemstmtContext + Altertablestmt() IAltertablestmtContext + Altertblspcstmt() IAltertblspcstmtContext + Altercompositetypestmt() IAltercompositetypestmtContext + Alterpublicationstmt() IAlterpublicationstmtContext + Alterrolesetstmt() IAlterrolesetstmtContext + Alterrolestmt() IAlterrolestmtContext + Alteruserstmt() IAlteruserstmtContext + Alterschemastmt() IAlterschemastmtContext + Altersubscriptionstmt() IAltersubscriptionstmtContext + Alterstatsstmt() IAlterstatsstmtContext + Altertsconfigurationstmt() IAltertsconfigurationstmtContext + Altertsdictionarystmt() IAltertsdictionarystmtContext + Alterusermappingstmt() IAlterusermappingstmtContext + Analyzestmt() IAnalyzestmtContext + Callstmt() ICallstmtContext + Checkpointstmt() ICheckpointstmtContext + Closeportalstmt() ICloseportalstmtContext + Clusterstmt() IClusterstmtContext + Commentstmt() ICommentstmtContext + Constraintssetstmt() IConstraintssetstmtContext + Copystmt() ICopystmtContext + Createamstmt() ICreateamstmtContext + Createasstmt() ICreateasstmtContext + Createassertionstmt() ICreateassertionstmtContext + Createcaststmt() ICreatecaststmtContext + Createconversionstmt() ICreateconversionstmtContext + Createdomainstmt() ICreatedomainstmtContext + Createextensionstmt() ICreateextensionstmtContext + Createfdwstmt() ICreatefdwstmtContext + Createforeignserverstmt() ICreateforeignserverstmtContext + Createforeigntablestmt() ICreateforeigntablestmtContext + Createfunctionstmt() ICreatefunctionstmtContext + Createprocedurestmt() ICreateprocedurestmtContext + Creategroupstmt() ICreategroupstmtContext + Creatematviewstmt() ICreatematviewstmtContext + Createopclassstmt() ICreateopclassstmtContext + Createopfamilystmt() ICreateopfamilystmtContext + Createpublicationstmt() ICreatepublicationstmtContext + Alteropfamilystmt() IAlteropfamilystmtContext + Createpolicystmt() ICreatepolicystmtContext + Createplangstmt() ICreateplangstmtContext + Createschemastmt() ICreateschemastmtContext + Createseqstmt() ICreateseqstmtContext + Createstmt() ICreatestmtContext + Createsubscriptionstmt() ICreatesubscriptionstmtContext + Createstatsstmt() ICreatestatsstmtContext + Createtablespacestmt() ICreatetablespacestmtContext + Createtransformstmt() ICreatetransformstmtContext + Createtrigstmt() ICreatetrigstmtContext + Createeventtrigstmt() ICreateeventtrigstmtContext + Createrolestmt() ICreaterolestmtContext + Createuserstmt() ICreateuserstmtContext + Createusermappingstmt() ICreateusermappingstmtContext + Createdbstmt() ICreatedbstmtContext + Deallocatestmt() IDeallocatestmtContext + Declarecursorstmt() IDeclarecursorstmtContext + Definestmt() IDefinestmtContext + Deletestmt() IDeletestmtContext + Discardstmt() IDiscardstmtContext + Dostmt() IDostmtContext + Dropcaststmt() IDropcaststmtContext + Dropopclassstmt() IDropopclassstmtContext + Dropopfamilystmt() IDropopfamilystmtContext + Dropownedstmt() IDropownedstmtContext + Dropschemastmt() IDropschemastmtContext + Dropstmt() IDropstmtContext + Dropsubscriptionstmt() IDropsubscriptionstmtContext + Droptablespacestmt() IDroptablespacestmtContext + Droptransformstmt() IDroptransformstmtContext + Droprolestmt() IDroprolestmtContext + Dropuserstmt() IDropuserstmtContext + Dropgroupstmt() IDropgroupstmtContext + Dropusermappingstmt() IDropusermappingstmtContext + Dropdbstmt() IDropdbstmtContext + Executestmt() IExecutestmtContext + Explainstmt() IExplainstmtContext + Fetchstmt() IFetchstmtContext + Grantstmt() IGrantstmtContext + Importforeignschemastmt() IImportforeignschemastmtContext + Indexstmt() IIndexstmtContext + Insertstmt() IInsertstmtContext + Mergestmt() IMergestmtContext + Listenstmt() IListenstmtContext + Refreshmatviewstmt() IRefreshmatviewstmtContext + Loadstmt() ILoadstmtContext + Lockstmt() ILockstmtContext + Notifystmt() INotifystmtContext + Preparestmt() IPreparestmtContext + Reassignownedstmt() IReassignownedstmtContext + Reindexstmt() IReindexstmtContext + Removeaggrstmt() IRemoveaggrstmtContext + Removefuncstmt() IRemovefuncstmtContext + Removeoperstmt() IRemoveoperstmtContext + Renamestmt() IRenamestmtContext + Revokestmt() IRevokestmtContext + Revokerolestmt() IRevokerolestmtContext + Rulestmt() IRulestmtContext + Seclabelstmt() ISeclabelstmtContext + Selectstmt() ISelectstmtContext + Transactionstmt() ITransactionstmtContext + Truncatestmt() ITruncatestmtContext + Unlistenstmt() IUnlistenstmtContext + Updatestmt() IUpdatestmtContext + Vacuumstmt() IVacuumstmtContext + Variableresetstmt() IVariableresetstmtContext + Variablesetstmt() IVariablesetstmtContext + Variableshowstmt() IVariableshowstmtContext + Viewstmt() IViewstmtContext + Alterdatasharestmt() IAlterdatasharestmtContext + Alterexternalschemastmt() IAlterexternalschemastmtContext + Alterexternalviewstmt() IAlterexternalviewstmtContext + Alteridentityproviderstmt() IAlteridentityproviderstmtContext + Altermaskingpolicystmt() IAltermaskingpolicystmtContext + Altermaterializedviewstmt() IAltermaterializedviewstmtContext + Alterrlspolicystmt() IAlterrlspolicystmtContext + Altertableappendstmt() IAltertableappendstmtContext + Analyzecompressionstmt() IAnalyzecompressionstmtContext + Attachmaskingpolicystmt() IAttachmaskingpolicystmtContext + Attachrlspolicystmt() IAttachrlspolicystmtContext + Cancelstmt() ICancelstmtContext + Closestmt() IClosestmtContext + Createdatasharestmt() ICreatedatasharestmtContext + Createexternalfunctionstmt() ICreateexternalfunctionstmtContext + Createexternalmodelstmt() ICreateexternalmodelstmtContext + Createexternalschemastmt() ICreateexternalschemastmtContext + Createexternaltablestmt() ICreateexternaltablestmtContext + Createexternalviewstmt() ICreateexternalviewstmtContext + Createidentityproviderstmt() ICreateidentityproviderstmtContext + Createlibrarystmt() ICreatelibrarystmtContext + Createmaskingpolicystmt() ICreatemaskingpolicystmtContext + Createmodelstmt() ICreatemodelstmtContext + Createrlspolicystmt() ICreaterlspolicystmtContext + Descdatasharestmt() IDescdatasharestmtContext + Descidentityproviderstmt() IDescidentityproviderstmtContext + Detachmaskingpolicystmt() IDetachmaskingpolicystmtContext + Detachrlspolicystmt() IDetachrlspolicystmtContext + Dropdatasharestmt() IDropdatasharestmtContext + Dropexternalviewstmt() IDropexternalviewstmtContext + Dropidentityproviderstmt() IDropidentityproviderstmtContext + Droplibrarystmt() IDroplibrarystmtContext + Dropmaskingpolicystmt() IDropmaskingpolicystmtContext + Dropmodelstmt() IDropmodelstmtContext + Droprlspolicystmt() IDroprlspolicystmtContext + Insertexternaltablestmt() IInsertexternaltablestmtContext + Selectintostmt() ISelectintostmtContext + Setsessionauthorizationstmt() ISetsessionauthorizationstmtContext + Setsessioncharacteristicsstmt() ISetsessioncharacteristicsstmtContext + Showcolumnsstmt() IShowcolumnsstmtContext + Showdatabasesstmt() IShowdatabasesstmtContext + Showdatasharesstmt() IShowdatasharesstmtContext + Showexternaltablestmt() IShowexternaltablestmtContext + Showgrantsstmt() IShowgrantsstmtContext + Showmodelstmt() IShowmodelstmtContext + Showprocedurestmt() IShowprocedurestmtContext + Showschemasstmt() IShowschemasstmtContext + Showtablestmt() IShowtablestmtContext + Showtablesstmt() IShowtablesstmtContext + Showviewstmt() IShowviewstmtContext + Unloadstmt() IUnloadstmtContext + Usestmt() IUsestmtContext + Plsqlconsolecommand() IPlsqlconsolecommandContext + + // IsStmtContext differentiates from other interfaces. + IsStmtContext() +} + +type StmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmtContext() *StmtContext { + var p = new(StmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt + return p +} + +func InitEmptyStmtContext(p *StmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt +} + +func (*StmtContext) IsStmtContext() {} + +func NewStmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StmtContext { + var p = new(StmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt + + return p +} + +func (s *StmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *StmtContext) Altereventtrigstmt() IAltereventtrigstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltereventtrigstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltereventtrigstmtContext) +} + +func (s *StmtContext) Altercollationstmt() IAltercollationstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltercollationstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltercollationstmtContext) +} + +func (s *StmtContext) Alterdatabasestmt() IAlterdatabasestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdatabasestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdatabasestmtContext) +} + +func (s *StmtContext) Alterdatabasesetstmt() IAlterdatabasesetstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdatabasesetstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdatabasesetstmtContext) +} + +func (s *StmtContext) Alterdefaultprivilegesstmt() IAlterdefaultprivilegesstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdefaultprivilegesstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdefaultprivilegesstmtContext) +} + +func (s *StmtContext) Alterdomainstmt() IAlterdomainstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdomainstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdomainstmtContext) +} + +func (s *StmtContext) Alterenumstmt() IAlterenumstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterenumstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterenumstmtContext) +} + +func (s *StmtContext) Alterextensionstmt() IAlterextensionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterextensionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterextensionstmtContext) +} + +func (s *StmtContext) Alterextensioncontentsstmt() IAlterextensioncontentsstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterextensioncontentsstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterextensioncontentsstmtContext) +} + +func (s *StmtContext) Alterfdwstmt() IAlterfdwstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterfdwstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterfdwstmtContext) +} + +func (s *StmtContext) Alterforeignserverstmt() IAlterforeignserverstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterforeignserverstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterforeignserverstmtContext) +} + +func (s *StmtContext) Alterfunctionstmt() IAlterfunctionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterfunctionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterfunctionstmtContext) +} + +func (s *StmtContext) Alterprocedurestmt() IAlterprocedurestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterprocedurestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterprocedurestmtContext) +} + +func (s *StmtContext) Altergroupstmt() IAltergroupstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltergroupstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltergroupstmtContext) +} + +func (s *StmtContext) Alterobjectdependsstmt() IAlterobjectdependsstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterobjectdependsstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterobjectdependsstmtContext) +} + +func (s *StmtContext) Alterobjectschemastmt() IAlterobjectschemastmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterobjectschemastmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterobjectschemastmtContext) +} + +func (s *StmtContext) Alterownerstmt() IAlterownerstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterownerstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterownerstmtContext) +} + +func (s *StmtContext) Alteroperatorstmt() IAlteroperatorstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteroperatorstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlteroperatorstmtContext) +} + +func (s *StmtContext) Altertypestmt() IAltertypestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltertypestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltertypestmtContext) +} + +func (s *StmtContext) Alterpolicystmt() IAlterpolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterpolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterpolicystmtContext) +} + +func (s *StmtContext) Alterseqstmt() IAlterseqstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterseqstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterseqstmtContext) +} + +func (s *StmtContext) Altersystemstmt() IAltersystemstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltersystemstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltersystemstmtContext) +} + +func (s *StmtContext) Altertablestmt() IAltertablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltertablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltertablestmtContext) +} + +func (s *StmtContext) Altertblspcstmt() IAltertblspcstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltertblspcstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltertblspcstmtContext) +} + +func (s *StmtContext) Altercompositetypestmt() IAltercompositetypestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltercompositetypestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltercompositetypestmtContext) +} + +func (s *StmtContext) Alterpublicationstmt() IAlterpublicationstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterpublicationstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterpublicationstmtContext) +} + +func (s *StmtContext) Alterrolesetstmt() IAlterrolesetstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterrolesetstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterrolesetstmtContext) +} + +func (s *StmtContext) Alterrolestmt() IAlterrolestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterrolestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterrolestmtContext) +} + +func (s *StmtContext) Alteruserstmt() IAlteruserstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteruserstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlteruserstmtContext) +} + +func (s *StmtContext) Alterschemastmt() IAlterschemastmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterschemastmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterschemastmtContext) +} + +func (s *StmtContext) Altersubscriptionstmt() IAltersubscriptionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltersubscriptionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltersubscriptionstmtContext) +} + +func (s *StmtContext) Alterstatsstmt() IAlterstatsstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterstatsstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterstatsstmtContext) +} + +func (s *StmtContext) Altertsconfigurationstmt() IAltertsconfigurationstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltertsconfigurationstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltertsconfigurationstmtContext) +} + +func (s *StmtContext) Altertsdictionarystmt() IAltertsdictionarystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltertsdictionarystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltertsdictionarystmtContext) +} + +func (s *StmtContext) Alterusermappingstmt() IAlterusermappingstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterusermappingstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterusermappingstmtContext) +} + +func (s *StmtContext) Analyzestmt() IAnalyzestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyzestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyzestmtContext) +} + +func (s *StmtContext) Callstmt() ICallstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICallstmtContext) +} + +func (s *StmtContext) Checkpointstmt() ICheckpointstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheckpointstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheckpointstmtContext) +} + +func (s *StmtContext) Closeportalstmt() ICloseportalstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloseportalstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloseportalstmtContext) +} + +func (s *StmtContext) Clusterstmt() IClusterstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClusterstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClusterstmtContext) +} + +func (s *StmtContext) Commentstmt() ICommentstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentstmtContext) +} + +func (s *StmtContext) Constraintssetstmt() IConstraintssetstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintssetstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintssetstmtContext) +} + +func (s *StmtContext) Copystmt() ICopystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopystmtContext) +} + +func (s *StmtContext) Createamstmt() ICreateamstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateamstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateamstmtContext) +} + +func (s *StmtContext) Createasstmt() ICreateasstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateasstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateasstmtContext) +} + +func (s *StmtContext) Createassertionstmt() ICreateassertionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateassertionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateassertionstmtContext) +} + +func (s *StmtContext) Createcaststmt() ICreatecaststmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatecaststmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatecaststmtContext) +} + +func (s *StmtContext) Createconversionstmt() ICreateconversionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateconversionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateconversionstmtContext) +} + +func (s *StmtContext) Createdomainstmt() ICreatedomainstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedomainstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedomainstmtContext) +} + +func (s *StmtContext) Createextensionstmt() ICreateextensionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateextensionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateextensionstmtContext) +} + +func (s *StmtContext) Createfdwstmt() ICreatefdwstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatefdwstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatefdwstmtContext) +} + +func (s *StmtContext) Createforeignserverstmt() ICreateforeignserverstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateforeignserverstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateforeignserverstmtContext) +} + +func (s *StmtContext) Createforeigntablestmt() ICreateforeigntablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateforeigntablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateforeigntablestmtContext) +} + +func (s *StmtContext) Createfunctionstmt() ICreatefunctionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatefunctionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatefunctionstmtContext) +} + +func (s *StmtContext) Createprocedurestmt() ICreateprocedurestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateprocedurestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateprocedurestmtContext) +} + +func (s *StmtContext) Creategroupstmt() ICreategroupstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreategroupstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreategroupstmtContext) +} + +func (s *StmtContext) Creatematviewstmt() ICreatematviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatematviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatematviewstmtContext) +} + +func (s *StmtContext) Createopclassstmt() ICreateopclassstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateopclassstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateopclassstmtContext) +} + +func (s *StmtContext) Createopfamilystmt() ICreateopfamilystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateopfamilystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateopfamilystmtContext) +} + +func (s *StmtContext) Createpublicationstmt() ICreatepublicationstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatepublicationstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatepublicationstmtContext) +} + +func (s *StmtContext) Alteropfamilystmt() IAlteropfamilystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteropfamilystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlteropfamilystmtContext) +} + +func (s *StmtContext) Createpolicystmt() ICreatepolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatepolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatepolicystmtContext) +} + +func (s *StmtContext) Createplangstmt() ICreateplangstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateplangstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateplangstmtContext) +} + +func (s *StmtContext) Createschemastmt() ICreateschemastmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateschemastmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateschemastmtContext) +} + +func (s *StmtContext) Createseqstmt() ICreateseqstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateseqstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateseqstmtContext) +} + +func (s *StmtContext) Createstmt() ICreatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatestmtContext) +} + +func (s *StmtContext) Createsubscriptionstmt() ICreatesubscriptionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatesubscriptionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatesubscriptionstmtContext) +} + +func (s *StmtContext) Createstatsstmt() ICreatestatsstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatestatsstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatestatsstmtContext) +} + +func (s *StmtContext) Createtablespacestmt() ICreatetablespacestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatetablespacestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatetablespacestmtContext) +} + +func (s *StmtContext) Createtransformstmt() ICreatetransformstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatetransformstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatetransformstmtContext) +} + +func (s *StmtContext) Createtrigstmt() ICreatetrigstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatetrigstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatetrigstmtContext) +} + +func (s *StmtContext) Createeventtrigstmt() ICreateeventtrigstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateeventtrigstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateeventtrigstmtContext) +} + +func (s *StmtContext) Createrolestmt() ICreaterolestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreaterolestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreaterolestmtContext) +} + +func (s *StmtContext) Createuserstmt() ICreateuserstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateuserstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateuserstmtContext) +} + +func (s *StmtContext) Createusermappingstmt() ICreateusermappingstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateusermappingstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateusermappingstmtContext) +} + +func (s *StmtContext) Createdbstmt() ICreatedbstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedbstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedbstmtContext) +} + +func (s *StmtContext) Deallocatestmt() IDeallocatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocatestmtContext) +} + +func (s *StmtContext) Declarecursorstmt() IDeclarecursorstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclarecursorstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclarecursorstmtContext) +} + +func (s *StmtContext) Definestmt() IDefinestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefinestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefinestmtContext) +} + +func (s *StmtContext) Deletestmt() IDeletestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeletestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeletestmtContext) +} + +func (s *StmtContext) Discardstmt() IDiscardstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiscardstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiscardstmtContext) +} + +func (s *StmtContext) Dostmt() IDostmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDostmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDostmtContext) +} + +func (s *StmtContext) Dropcaststmt() IDropcaststmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropcaststmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropcaststmtContext) +} + +func (s *StmtContext) Dropopclassstmt() IDropopclassstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropopclassstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropopclassstmtContext) +} + +func (s *StmtContext) Dropopfamilystmt() IDropopfamilystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropopfamilystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropopfamilystmtContext) +} + +func (s *StmtContext) Dropownedstmt() IDropownedstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropownedstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropownedstmtContext) +} + +func (s *StmtContext) Dropschemastmt() IDropschemastmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropschemastmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropschemastmtContext) +} + +func (s *StmtContext) Dropstmt() IDropstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropstmtContext) +} + +func (s *StmtContext) Dropsubscriptionstmt() IDropsubscriptionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropsubscriptionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropsubscriptionstmtContext) +} + +func (s *StmtContext) Droptablespacestmt() IDroptablespacestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDroptablespacestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDroptablespacestmtContext) +} + +func (s *StmtContext) Droptransformstmt() IDroptransformstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDroptransformstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDroptransformstmtContext) +} + +func (s *StmtContext) Droprolestmt() IDroprolestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDroprolestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDroprolestmtContext) +} + +func (s *StmtContext) Dropuserstmt() IDropuserstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropuserstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropuserstmtContext) +} + +func (s *StmtContext) Dropgroupstmt() IDropgroupstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropgroupstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropgroupstmtContext) +} + +func (s *StmtContext) Dropusermappingstmt() IDropusermappingstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropusermappingstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropusermappingstmtContext) +} + +func (s *StmtContext) Dropdbstmt() IDropdbstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropdbstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropdbstmtContext) +} + +func (s *StmtContext) Executestmt() IExecutestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecutestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecutestmtContext) +} + +func (s *StmtContext) Explainstmt() IExplainstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainstmtContext) +} + +func (s *StmtContext) Fetchstmt() IFetchstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetchstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFetchstmtContext) +} + +func (s *StmtContext) Grantstmt() IGrantstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantstmtContext) +} + +func (s *StmtContext) Importforeignschemastmt() IImportforeignschemastmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImportforeignschemastmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImportforeignschemastmtContext) +} + +func (s *StmtContext) Indexstmt() IIndexstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexstmtContext) +} + +func (s *StmtContext) Insertstmt() IInsertstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertstmtContext) +} + +func (s *StmtContext) Mergestmt() IMergestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMergestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMergestmtContext) +} + +func (s *StmtContext) Listenstmt() IListenstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IListenstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IListenstmtContext) +} + +func (s *StmtContext) Refreshmatviewstmt() IRefreshmatviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefreshmatviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefreshmatviewstmtContext) +} + +func (s *StmtContext) Loadstmt() ILoadstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoadstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoadstmtContext) +} + +func (s *StmtContext) Lockstmt() ILockstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockstmtContext) +} + +func (s *StmtContext) Notifystmt() INotifystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INotifystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INotifystmtContext) +} + +func (s *StmtContext) Preparestmt() IPreparestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPreparestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPreparestmtContext) +} + +func (s *StmtContext) Reassignownedstmt() IReassignownedstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReassignownedstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReassignownedstmtContext) +} + +func (s *StmtContext) Reindexstmt() IReindexstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReindexstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReindexstmtContext) +} + +func (s *StmtContext) Removeaggrstmt() IRemoveaggrstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRemoveaggrstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRemoveaggrstmtContext) +} + +func (s *StmtContext) Removefuncstmt() IRemovefuncstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRemovefuncstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRemovefuncstmtContext) +} + +func (s *StmtContext) Removeoperstmt() IRemoveoperstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRemoveoperstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRemoveoperstmtContext) +} + +func (s *StmtContext) Renamestmt() IRenamestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRenamestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRenamestmtContext) +} + +func (s *StmtContext) Revokestmt() IRevokestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokestmtContext) +} + +func (s *StmtContext) Revokerolestmt() IRevokerolestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokerolestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokerolestmtContext) +} + +func (s *StmtContext) Rulestmt() IRulestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRulestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRulestmtContext) +} + +func (s *StmtContext) Seclabelstmt() ISeclabelstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeclabelstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeclabelstmtContext) +} + +func (s *StmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *StmtContext) Transactionstmt() ITransactionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransactionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransactionstmtContext) +} + +func (s *StmtContext) Truncatestmt() ITruncatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncatestmtContext) +} + +func (s *StmtContext) Unlistenstmt() IUnlistenstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnlistenstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnlistenstmtContext) +} + +func (s *StmtContext) Updatestmt() IUpdatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdatestmtContext) +} + +func (s *StmtContext) Vacuumstmt() IVacuumstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVacuumstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVacuumstmtContext) +} + +func (s *StmtContext) Variableresetstmt() IVariableresetstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableresetstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableresetstmtContext) +} + +func (s *StmtContext) Variablesetstmt() IVariablesetstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariablesetstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariablesetstmtContext) +} + +func (s *StmtContext) Variableshowstmt() IVariableshowstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableshowstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableshowstmtContext) +} + +func (s *StmtContext) Viewstmt() IViewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IViewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IViewstmtContext) +} + +func (s *StmtContext) Alterdatasharestmt() IAlterdatasharestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdatasharestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdatasharestmtContext) +} + +func (s *StmtContext) Alterexternalschemastmt() IAlterexternalschemastmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterexternalschemastmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterexternalschemastmtContext) +} + +func (s *StmtContext) Alterexternalviewstmt() IAlterexternalviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterexternalviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterexternalviewstmtContext) +} + +func (s *StmtContext) Alteridentityproviderstmt() IAlteridentityproviderstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteridentityproviderstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlteridentityproviderstmtContext) +} + +func (s *StmtContext) Altermaskingpolicystmt() IAltermaskingpolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltermaskingpolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltermaskingpolicystmtContext) +} + +func (s *StmtContext) Altermaterializedviewstmt() IAltermaterializedviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltermaterializedviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltermaterializedviewstmtContext) +} + +func (s *StmtContext) Alterrlspolicystmt() IAlterrlspolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterrlspolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterrlspolicystmtContext) +} + +func (s *StmtContext) Altertableappendstmt() IAltertableappendstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltertableappendstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltertableappendstmtContext) +} + +func (s *StmtContext) Analyzecompressionstmt() IAnalyzecompressionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyzecompressionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyzecompressionstmtContext) +} + +func (s *StmtContext) Attachmaskingpolicystmt() IAttachmaskingpolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachmaskingpolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttachmaskingpolicystmtContext) +} + +func (s *StmtContext) Attachrlspolicystmt() IAttachrlspolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachrlspolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttachrlspolicystmtContext) +} + +func (s *StmtContext) Cancelstmt() ICancelstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICancelstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICancelstmtContext) +} + +func (s *StmtContext) Closestmt() IClosestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClosestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClosestmtContext) +} + +func (s *StmtContext) Createdatasharestmt() ICreatedatasharestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedatasharestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedatasharestmtContext) +} + +func (s *StmtContext) Createexternalfunctionstmt() ICreateexternalfunctionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateexternalfunctionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateexternalfunctionstmtContext) +} + +func (s *StmtContext) Createexternalmodelstmt() ICreateexternalmodelstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateexternalmodelstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateexternalmodelstmtContext) +} + +func (s *StmtContext) Createexternalschemastmt() ICreateexternalschemastmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateexternalschemastmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateexternalschemastmtContext) +} + +func (s *StmtContext) Createexternaltablestmt() ICreateexternaltablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateexternaltablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateexternaltablestmtContext) +} + +func (s *StmtContext) Createexternalviewstmt() ICreateexternalviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateexternalviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateexternalviewstmtContext) +} + +func (s *StmtContext) Createidentityproviderstmt() ICreateidentityproviderstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateidentityproviderstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateidentityproviderstmtContext) +} + +func (s *StmtContext) Createlibrarystmt() ICreatelibrarystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatelibrarystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatelibrarystmtContext) +} + +func (s *StmtContext) Createmaskingpolicystmt() ICreatemaskingpolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatemaskingpolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatemaskingpolicystmtContext) +} + +func (s *StmtContext) Createmodelstmt() ICreatemodelstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatemodelstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatemodelstmtContext) +} + +func (s *StmtContext) Createrlspolicystmt() ICreaterlspolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreaterlspolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreaterlspolicystmtContext) +} + +func (s *StmtContext) Descdatasharestmt() IDescdatasharestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescdatasharestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescdatasharestmtContext) +} + +func (s *StmtContext) Descidentityproviderstmt() IDescidentityproviderstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescidentityproviderstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescidentityproviderstmtContext) +} + +func (s *StmtContext) Detachmaskingpolicystmt() IDetachmaskingpolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDetachmaskingpolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDetachmaskingpolicystmtContext) +} + +func (s *StmtContext) Detachrlspolicystmt() IDetachrlspolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDetachrlspolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDetachrlspolicystmtContext) +} + +func (s *StmtContext) Dropdatasharestmt() IDropdatasharestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropdatasharestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropdatasharestmtContext) +} + +func (s *StmtContext) Dropexternalviewstmt() IDropexternalviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropexternalviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropexternalviewstmtContext) +} + +func (s *StmtContext) Dropidentityproviderstmt() IDropidentityproviderstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropidentityproviderstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropidentityproviderstmtContext) +} + +func (s *StmtContext) Droplibrarystmt() IDroplibrarystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDroplibrarystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDroplibrarystmtContext) +} + +func (s *StmtContext) Dropmaskingpolicystmt() IDropmaskingpolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropmaskingpolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropmaskingpolicystmtContext) +} + +func (s *StmtContext) Dropmodelstmt() IDropmodelstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDropmodelstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDropmodelstmtContext) +} + +func (s *StmtContext) Droprlspolicystmt() IDroprlspolicystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDroprlspolicystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDroprlspolicystmtContext) +} + +func (s *StmtContext) Insertexternaltablestmt() IInsertexternaltablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertexternaltablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertexternaltablestmtContext) +} + +func (s *StmtContext) Selectintostmt() ISelectintostmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectintostmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectintostmtContext) +} + +func (s *StmtContext) Setsessionauthorizationstmt() ISetsessionauthorizationstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetsessionauthorizationstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetsessionauthorizationstmtContext) +} + +func (s *StmtContext) Setsessioncharacteristicsstmt() ISetsessioncharacteristicsstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetsessioncharacteristicsstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetsessioncharacteristicsstmtContext) +} + +func (s *StmtContext) Showcolumnsstmt() IShowcolumnsstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowcolumnsstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowcolumnsstmtContext) +} + +func (s *StmtContext) Showdatabasesstmt() IShowdatabasesstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowdatabasesstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowdatabasesstmtContext) +} + +func (s *StmtContext) Showdatasharesstmt() IShowdatasharesstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowdatasharesstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowdatasharesstmtContext) +} + +func (s *StmtContext) Showexternaltablestmt() IShowexternaltablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowexternaltablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowexternaltablestmtContext) +} + +func (s *StmtContext) Showgrantsstmt() IShowgrantsstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowgrantsstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowgrantsstmtContext) +} + +func (s *StmtContext) Showmodelstmt() IShowmodelstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowmodelstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowmodelstmtContext) +} + +func (s *StmtContext) Showprocedurestmt() IShowprocedurestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowprocedurestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowprocedurestmtContext) +} + +func (s *StmtContext) Showschemasstmt() IShowschemasstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowschemasstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowschemasstmtContext) +} + +func (s *StmtContext) Showtablestmt() IShowtablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowtablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowtablestmtContext) +} + +func (s *StmtContext) Showtablesstmt() IShowtablesstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowtablesstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowtablesstmtContext) +} + +func (s *StmtContext) Showviewstmt() IShowviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShowviewstmtContext) +} + +func (s *StmtContext) Unloadstmt() IUnloadstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnloadstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnloadstmtContext) +} + +func (s *StmtContext) Usestmt() IUsestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsestmtContext) +} + +func (s *StmtContext) Plsqlconsolecommand() IPlsqlconsolecommandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsqlconsolecommandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsqlconsolecommandContext) +} + +func (s *StmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt(s) + } +} + +func (s *StmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt(s) + } +} + +func (s *StmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt() (localctx IStmtContext) { + localctx = NewStmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, RedshiftParserRULE_stmt) + p.SetState(2375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2192) + p.Altereventtrigstmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2193) + p.Altercollationstmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2194) + p.Alterdatabasestmt() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2195) + p.Alterdatabasesetstmt() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2196) + p.Alterdefaultprivilegesstmt() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2197) + p.Alterdomainstmt() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2198) + p.Alterenumstmt() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2199) + p.Alterextensionstmt() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2200) + p.Alterextensioncontentsstmt() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2201) + p.Alterfdwstmt() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2202) + p.Alterforeignserverstmt() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2203) + p.Alterfunctionstmt() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2204) + p.Alterprocedurestmt() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2205) + p.Altergroupstmt() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2206) + p.Alterobjectdependsstmt() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2207) + p.Alterobjectschemastmt() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2208) + p.Alterownerstmt() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2209) + p.Alteroperatorstmt() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2210) + p.Altertypestmt() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2211) + p.Alterpolicystmt() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2212) + p.Alterseqstmt() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2213) + p.Altersystemstmt() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2214) + p.Altertablestmt() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2215) + p.Altertblspcstmt() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2216) + p.Altercompositetypestmt() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2217) + p.Alterpublicationstmt() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2218) + p.Alterrolesetstmt() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2219) + p.Alterrolestmt() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2220) + p.Alteruserstmt() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2221) + p.Alterschemastmt() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(2222) + p.Altersubscriptionstmt() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(2223) + p.Alterstatsstmt() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(2224) + p.Altertsconfigurationstmt() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(2225) + p.Altertsdictionarystmt() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2226) + p.Alterusermappingstmt() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(2227) + p.Analyzestmt() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(2228) + p.Callstmt() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(2229) + p.Checkpointstmt() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(2230) + p.Closeportalstmt() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(2231) + p.Clusterstmt() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(2232) + p.Commentstmt() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(2233) + p.Constraintssetstmt() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(2234) + p.Copystmt() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(2235) + p.Createamstmt() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(2236) + p.Createasstmt() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(2237) + p.Createassertionstmt() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(2238) + p.Createcaststmt() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(2239) + p.Createconversionstmt() + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(2240) + p.Createdomainstmt() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(2241) + p.Createextensionstmt() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(2242) + p.Createfdwstmt() + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(2243) + p.Createforeignserverstmt() + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(2244) + p.Createforeigntablestmt() + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(2245) + p.Createfunctionstmt() + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(2246) + p.Createprocedurestmt() + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(2247) + p.Creategroupstmt() + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(2248) + p.Creatematviewstmt() + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(2249) + p.Createopclassstmt() + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(2250) + p.Createopfamilystmt() + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(2251) + p.Createpublicationstmt() + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(2252) + p.Alteropfamilystmt() + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(2253) + p.Createpolicystmt() + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(2254) + p.Createplangstmt() + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(2255) + p.Createschemastmt() + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(2256) + p.Createseqstmt() + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(2257) + p.Createstmt() + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(2258) + p.Createsubscriptionstmt() + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(2259) + p.Createstatsstmt() + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(2260) + p.Createtablespacestmt() + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(2261) + p.Createtransformstmt() + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(2262) + p.Createtrigstmt() + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(2263) + p.Createeventtrigstmt() + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(2264) + p.Createrolestmt() + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(2265) + p.Createuserstmt() + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(2266) + p.Createusermappingstmt() + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(2267) + p.Createdbstmt() + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(2268) + p.Deallocatestmt() + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(2269) + p.Declarecursorstmt() + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(2270) + p.Definestmt() + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(2271) + p.Deletestmt() + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(2272) + p.Discardstmt() + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(2273) + p.Dostmt() + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(2274) + p.Dropcaststmt() + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(2275) + p.Dropopclassstmt() + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(2276) + p.Dropopfamilystmt() + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(2277) + p.Dropownedstmt() + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(2278) + p.Dropschemastmt() + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(2279) + p.Dropstmt() + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(2280) + p.Dropsubscriptionstmt() + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(2281) + p.Droptablespacestmt() + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(2282) + p.Droptransformstmt() + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(2283) + p.Droprolestmt() + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(2284) + p.Dropuserstmt() + } + + case 94: + p.EnterOuterAlt(localctx, 94) + { + p.SetState(2285) + p.Dropgroupstmt() + } + + case 95: + p.EnterOuterAlt(localctx, 95) + { + p.SetState(2286) + p.Dropusermappingstmt() + } + + case 96: + p.EnterOuterAlt(localctx, 96) + { + p.SetState(2287) + p.Dropdbstmt() + } + + case 97: + p.EnterOuterAlt(localctx, 97) + { + p.SetState(2288) + p.Executestmt() + } + + case 98: + p.EnterOuterAlt(localctx, 98) + { + p.SetState(2289) + p.Explainstmt() + } + + case 99: + p.EnterOuterAlt(localctx, 99) + { + p.SetState(2290) + p.Fetchstmt() + } + + case 100: + p.EnterOuterAlt(localctx, 100) + { + p.SetState(2291) + p.Grantstmt() + } + + case 101: + p.EnterOuterAlt(localctx, 101) + { + p.SetState(2292) + p.Importforeignschemastmt() + } + + case 102: + p.EnterOuterAlt(localctx, 102) + { + p.SetState(2293) + p.Indexstmt() + } + + case 103: + p.EnterOuterAlt(localctx, 103) + { + p.SetState(2294) + p.Insertstmt() + } + + case 104: + p.EnterOuterAlt(localctx, 104) + { + p.SetState(2295) + p.Mergestmt() + } + + case 105: + p.EnterOuterAlt(localctx, 105) + { + p.SetState(2296) + p.Listenstmt() + } + + case 106: + p.EnterOuterAlt(localctx, 106) + { + p.SetState(2297) + p.Refreshmatviewstmt() + } + + case 107: + p.EnterOuterAlt(localctx, 107) + { + p.SetState(2298) + p.Loadstmt() + } + + case 108: + p.EnterOuterAlt(localctx, 108) + { + p.SetState(2299) + p.Lockstmt() + } + + case 109: + p.EnterOuterAlt(localctx, 109) + { + p.SetState(2300) + p.Notifystmt() + } + + case 110: + p.EnterOuterAlt(localctx, 110) + { + p.SetState(2301) + p.Preparestmt() + } + + case 111: + p.EnterOuterAlt(localctx, 111) + { + p.SetState(2302) + p.Reassignownedstmt() + } + + case 112: + p.EnterOuterAlt(localctx, 112) + { + p.SetState(2303) + p.Reindexstmt() + } + + case 113: + p.EnterOuterAlt(localctx, 113) + { + p.SetState(2304) + p.Removeaggrstmt() + } + + case 114: + p.EnterOuterAlt(localctx, 114) + { + p.SetState(2305) + p.Removefuncstmt() + } + + case 115: + p.EnterOuterAlt(localctx, 115) + { + p.SetState(2306) + p.Removeoperstmt() + } + + case 116: + p.EnterOuterAlt(localctx, 116) + { + p.SetState(2307) + p.Renamestmt() + } + + case 117: + p.EnterOuterAlt(localctx, 117) + { + p.SetState(2308) + p.Revokestmt() + } + + case 118: + p.EnterOuterAlt(localctx, 118) + { + p.SetState(2309) + p.Revokerolestmt() + } + + case 119: + p.EnterOuterAlt(localctx, 119) + { + p.SetState(2310) + p.Rulestmt() + } + + case 120: + p.EnterOuterAlt(localctx, 120) + { + p.SetState(2311) + p.Seclabelstmt() + } + + case 121: + p.EnterOuterAlt(localctx, 121) + { + p.SetState(2312) + p.Selectstmt() + } + + case 122: + p.EnterOuterAlt(localctx, 122) + { + p.SetState(2313) + p.Transactionstmt() + } + + case 123: + p.EnterOuterAlt(localctx, 123) + { + p.SetState(2314) + p.Truncatestmt() + } + + case 124: + p.EnterOuterAlt(localctx, 124) + { + p.SetState(2315) + p.Unlistenstmt() + } + + case 125: + p.EnterOuterAlt(localctx, 125) + { + p.SetState(2316) + p.Updatestmt() + } + + case 126: + p.EnterOuterAlt(localctx, 126) + { + p.SetState(2317) + p.Vacuumstmt() + } + + case 127: + p.EnterOuterAlt(localctx, 127) + { + p.SetState(2318) + p.Variableresetstmt() + } + + case 128: + p.EnterOuterAlt(localctx, 128) + { + p.SetState(2319) + p.Variablesetstmt() + } + + case 129: + p.EnterOuterAlt(localctx, 129) + { + p.SetState(2320) + p.Variableshowstmt() + } + + case 130: + p.EnterOuterAlt(localctx, 130) + { + p.SetState(2321) + p.Viewstmt() + } + + case 131: + p.EnterOuterAlt(localctx, 131) + { + p.SetState(2322) + p.Alterdatasharestmt() + } + + case 132: + p.EnterOuterAlt(localctx, 132) + { + p.SetState(2323) + p.Alterexternalschemastmt() + } + + case 133: + p.EnterOuterAlt(localctx, 133) + { + p.SetState(2324) + p.Alterexternalviewstmt() + } + + case 134: + p.EnterOuterAlt(localctx, 134) + { + p.SetState(2325) + p.Alteridentityproviderstmt() + } + + case 135: + p.EnterOuterAlt(localctx, 135) + { + p.SetState(2326) + p.Altermaskingpolicystmt() + } + + case 136: + p.EnterOuterAlt(localctx, 136) + { + p.SetState(2327) + p.Altermaterializedviewstmt() + } + + case 137: + p.EnterOuterAlt(localctx, 137) + { + p.SetState(2328) + p.Alterrlspolicystmt() + } + + case 138: + p.EnterOuterAlt(localctx, 138) + { + p.SetState(2329) + p.Altertableappendstmt() + } + + case 139: + p.EnterOuterAlt(localctx, 139) + { + p.SetState(2330) + p.Analyzecompressionstmt() + } + + case 140: + p.EnterOuterAlt(localctx, 140) + { + p.SetState(2331) + p.Attachmaskingpolicystmt() + } + + case 141: + p.EnterOuterAlt(localctx, 141) + { + p.SetState(2332) + p.Attachrlspolicystmt() + } + + case 142: + p.EnterOuterAlt(localctx, 142) + { + p.SetState(2333) + p.Cancelstmt() + } + + case 143: + p.EnterOuterAlt(localctx, 143) + { + p.SetState(2334) + p.Closestmt() + } + + case 144: + p.EnterOuterAlt(localctx, 144) + { + p.SetState(2335) + p.Createdatasharestmt() + } + + case 145: + p.EnterOuterAlt(localctx, 145) + { + p.SetState(2336) + p.Createexternalfunctionstmt() + } + + case 146: + p.EnterOuterAlt(localctx, 146) + { + p.SetState(2337) + p.Createexternalmodelstmt() + } + + case 147: + p.EnterOuterAlt(localctx, 147) + { + p.SetState(2338) + p.Createexternalschemastmt() + } + + case 148: + p.EnterOuterAlt(localctx, 148) + { + p.SetState(2339) + p.Createexternaltablestmt() + } + + case 149: + p.EnterOuterAlt(localctx, 149) + { + p.SetState(2340) + p.Createexternalviewstmt() + } + + case 150: + p.EnterOuterAlt(localctx, 150) + { + p.SetState(2341) + p.Createidentityproviderstmt() + } + + case 151: + p.EnterOuterAlt(localctx, 151) + { + p.SetState(2342) + p.Createlibrarystmt() + } + + case 152: + p.EnterOuterAlt(localctx, 152) + { + p.SetState(2343) + p.Createmaskingpolicystmt() + } + + case 153: + p.EnterOuterAlt(localctx, 153) + { + p.SetState(2344) + p.Createmodelstmt() + } + + case 154: + p.EnterOuterAlt(localctx, 154) + { + p.SetState(2345) + p.Createrlspolicystmt() + } + + case 155: + p.EnterOuterAlt(localctx, 155) + { + p.SetState(2346) + p.Descdatasharestmt() + } + + case 156: + p.EnterOuterAlt(localctx, 156) + { + p.SetState(2347) + p.Descidentityproviderstmt() + } + + case 157: + p.EnterOuterAlt(localctx, 157) + { + p.SetState(2348) + p.Detachmaskingpolicystmt() + } + + case 158: + p.EnterOuterAlt(localctx, 158) + { + p.SetState(2349) + p.Detachrlspolicystmt() + } + + case 159: + p.EnterOuterAlt(localctx, 159) + { + p.SetState(2350) + p.Dropdatasharestmt() + } + + case 160: + p.EnterOuterAlt(localctx, 160) + { + p.SetState(2351) + p.Dropexternalviewstmt() + } + + case 161: + p.EnterOuterAlt(localctx, 161) + { + p.SetState(2352) + p.Dropidentityproviderstmt() + } + + case 162: + p.EnterOuterAlt(localctx, 162) + { + p.SetState(2353) + p.Droplibrarystmt() + } + + case 163: + p.EnterOuterAlt(localctx, 163) + { + p.SetState(2354) + p.Dropmaskingpolicystmt() + } + + case 164: + p.EnterOuterAlt(localctx, 164) + { + p.SetState(2355) + p.Dropmodelstmt() + } + + case 165: + p.EnterOuterAlt(localctx, 165) + { + p.SetState(2356) + p.Droprlspolicystmt() + } + + case 166: + p.EnterOuterAlt(localctx, 166) + { + p.SetState(2357) + p.Insertexternaltablestmt() + } + + case 167: + p.EnterOuterAlt(localctx, 167) + { + p.SetState(2358) + p.Selectintostmt() + } + + case 168: + p.EnterOuterAlt(localctx, 168) + { + p.SetState(2359) + p.Setsessionauthorizationstmt() + } + + case 169: + p.EnterOuterAlt(localctx, 169) + { + p.SetState(2360) + p.Setsessioncharacteristicsstmt() + } + + case 170: + p.EnterOuterAlt(localctx, 170) + { + p.SetState(2361) + p.Showcolumnsstmt() + } + + case 171: + p.EnterOuterAlt(localctx, 171) + { + p.SetState(2362) + p.Showdatabasesstmt() + } + + case 172: + p.EnterOuterAlt(localctx, 172) + { + p.SetState(2363) + p.Showdatasharesstmt() + } + + case 173: + p.EnterOuterAlt(localctx, 173) + { + p.SetState(2364) + p.Showexternaltablestmt() + } + + case 174: + p.EnterOuterAlt(localctx, 174) + { + p.SetState(2365) + p.Showgrantsstmt() + } + + case 175: + p.EnterOuterAlt(localctx, 175) + { + p.SetState(2366) + p.Showmodelstmt() + } + + case 176: + p.EnterOuterAlt(localctx, 176) + { + p.SetState(2367) + p.Showprocedurestmt() + } + + case 177: + p.EnterOuterAlt(localctx, 177) + { + p.SetState(2368) + p.Showschemasstmt() + } + + case 178: + p.EnterOuterAlt(localctx, 178) + { + p.SetState(2369) + p.Showtablestmt() + } + + case 179: + p.EnterOuterAlt(localctx, 179) + { + p.SetState(2370) + p.Showtablesstmt() + } + + case 180: + p.EnterOuterAlt(localctx, 180) + { + p.SetState(2371) + p.Showviewstmt() + } + + case 181: + p.EnterOuterAlt(localctx, 181) + { + p.SetState(2372) + p.Unloadstmt() + } + + case 182: + p.EnterOuterAlt(localctx, 182) + { + p.SetState(2373) + p.Usestmt() + } + + case 183: + p.EnterOuterAlt(localctx, 183) + { + p.SetState(2374) + p.Plsqlconsolecommand() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsqlconsolecommandContext is an interface to support dynamic dispatch. +type IPlsqlconsolecommandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MetaCommand() antlr.TerminalNode + EndMetaCommand() antlr.TerminalNode + + // IsPlsqlconsolecommandContext differentiates from other interfaces. + IsPlsqlconsolecommandContext() +} + +type PlsqlconsolecommandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsqlconsolecommandContext() *PlsqlconsolecommandContext { + var p = new(PlsqlconsolecommandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlconsolecommand + return p +} + +func InitEmptyPlsqlconsolecommandContext(p *PlsqlconsolecommandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlconsolecommand +} + +func (*PlsqlconsolecommandContext) IsPlsqlconsolecommandContext() {} + +func NewPlsqlconsolecommandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlconsolecommandContext { + var p = new(PlsqlconsolecommandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_plsqlconsolecommand + + return p +} + +func (s *PlsqlconsolecommandContext) GetParser() antlr.Parser { return s.parser } + +func (s *PlsqlconsolecommandContext) MetaCommand() antlr.TerminalNode { + return s.GetToken(RedshiftParserMetaCommand, 0) +} + +func (s *PlsqlconsolecommandContext) EndMetaCommand() antlr.TerminalNode { + return s.GetToken(RedshiftParserEndMetaCommand, 0) +} + +func (s *PlsqlconsolecommandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PlsqlconsolecommandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PlsqlconsolecommandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPlsqlconsolecommand(s) + } +} + +func (s *PlsqlconsolecommandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPlsqlconsolecommand(s) + } +} + +func (s *PlsqlconsolecommandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPlsqlconsolecommand(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Plsqlconsolecommand() (localctx IPlsqlconsolecommandContext) { + localctx = NewPlsqlconsolecommandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, RedshiftParserRULE_plsqlconsolecommand) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2377) + p.Match(RedshiftParserMetaCommand) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEndMetaCommand { + { + p.SetState(2378) + p.Match(RedshiftParserEndMetaCommand) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICallstmtContext is an interface to support dynamic dispatch. +type ICallstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALL() antlr.TerminalNode + Func_application() IFunc_applicationContext + + // IsCallstmtContext differentiates from other interfaces. + IsCallstmtContext() +} + +type CallstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCallstmtContext() *CallstmtContext { + var p = new(CallstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_callstmt + return p +} + +func InitEmptyCallstmtContext(p *CallstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_callstmt +} + +func (*CallstmtContext) IsCallstmtContext() {} + +func NewCallstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallstmtContext { + var p = new(CallstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_callstmt + + return p +} + +func (s *CallstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CallstmtContext) CALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCALL, 0) +} + +func (s *CallstmtContext) Func_application() IFunc_applicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_applicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_applicationContext) +} + +func (s *CallstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CallstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CallstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCallstmt(s) + } +} + +func (s *CallstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCallstmt(s) + } +} + +func (s *CallstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCallstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Callstmt() (localctx ICallstmtContext) { + localctx = NewCallstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, RedshiftParserRULE_callstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2381) + p.Match(RedshiftParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2382) + p.Func_application() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreaterolestmtContext is an interface to support dynamic dispatch. +type ICreaterolestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ROLE() antlr.TerminalNode + Roleid() IRoleidContext + Optrolelist() IOptrolelistContext + Opt_with() IOpt_withContext + + // IsCreaterolestmtContext differentiates from other interfaces. + IsCreaterolestmtContext() +} + +type CreaterolestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreaterolestmtContext() *CreaterolestmtContext { + var p = new(CreaterolestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createrolestmt + return p +} + +func InitEmptyCreaterolestmtContext(p *CreaterolestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createrolestmt +} + +func (*CreaterolestmtContext) IsCreaterolestmtContext() {} + +func NewCreaterolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreaterolestmtContext { + var p = new(CreaterolestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createrolestmt + + return p +} + +func (s *CreaterolestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreaterolestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreaterolestmtContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *CreaterolestmtContext) Roleid() IRoleidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleidContext) +} + +func (s *CreaterolestmtContext) Optrolelist() IOptrolelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptrolelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptrolelistContext) +} + +func (s *CreaterolestmtContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *CreaterolestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreaterolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreaterolestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreaterolestmt(s) + } +} + +func (s *CreaterolestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreaterolestmt(s) + } +} + +func (s *CreaterolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreaterolestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createrolestmt() (localctx ICreaterolestmtContext) { + localctx = NewCreaterolestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, RedshiftParserRULE_createrolestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2384) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2385) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2386) + p.Roleid() + } + p.SetState(2388) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) == 1 { + { + p.SetState(2387) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2390) + p.Optrolelist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_withContext is an interface to support dynamic dispatch. +type IOpt_withContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + + // IsOpt_withContext differentiates from other interfaces. + IsOpt_withContext() +} + +type Opt_withContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_withContext() *Opt_withContext { + var p = new(Opt_withContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with + return p +} + +func InitEmptyOpt_withContext(p *Opt_withContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with +} + +func (*Opt_withContext) IsOpt_withContext() {} + +func NewOpt_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_withContext { + var p = new(Opt_withContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_with + + return p +} + +func (s *Opt_withContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_withContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_withContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_withContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_with(s) + } +} + +func (s *Opt_withContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_with(s) + } +} + +func (s *Opt_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_with(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_with() (localctx IOpt_withContext) { + localctx = NewOpt_withContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, RedshiftParserRULE_opt_with) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2392) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptrolelistContext is an interface to support dynamic dispatch. +type IOptrolelistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCreateoptroleelem() []ICreateoptroleelemContext + Createoptroleelem(i int) ICreateoptroleelemContext + + // IsOptrolelistContext differentiates from other interfaces. + IsOptrolelistContext() +} + +type OptrolelistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptrolelistContext() *OptrolelistContext { + var p = new(OptrolelistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optrolelist + return p +} + +func InitEmptyOptrolelistContext(p *OptrolelistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optrolelist +} + +func (*OptrolelistContext) IsOptrolelistContext() {} + +func NewOptrolelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptrolelistContext { + var p = new(OptrolelistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optrolelist + + return p +} + +func (s *OptrolelistContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptrolelistContext) AllCreateoptroleelem() []ICreateoptroleelemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreateoptroleelemContext); ok { + len++ + } + } + + tst := make([]ICreateoptroleelemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreateoptroleelemContext); ok { + tst[i] = t.(ICreateoptroleelemContext) + i++ + } + } + + return tst +} + +func (s *OptrolelistContext) Createoptroleelem(i int) ICreateoptroleelemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateoptroleelemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreateoptroleelemContext) +} + +func (s *OptrolelistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptrolelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptrolelistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptrolelist(s) + } +} + +func (s *OptrolelistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptrolelist(s) + } +} + +func (s *OptrolelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptrolelist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optrolelist() (localctx IOptrolelistContext) { + localctx = NewOptrolelistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, RedshiftParserRULE_optrolelist) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2397) + 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(2394) + p.Createoptroleelem() + } + + } + p.SetState(2399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlteroptrolelistContext is an interface to support dynamic dispatch. +type IAlteroptrolelistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlteroptroleelem() []IAlteroptroleelemContext + Alteroptroleelem(i int) IAlteroptroleelemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlteroptrolelistContext differentiates from other interfaces. + IsAlteroptrolelistContext() +} + +type AlteroptrolelistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlteroptrolelistContext() *AlteroptrolelistContext { + var p = new(AlteroptrolelistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteroptrolelist + return p +} + +func InitEmptyAlteroptrolelistContext(p *AlteroptrolelistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteroptrolelist +} + +func (*AlteroptrolelistContext) IsAlteroptrolelistContext() {} + +func NewAlteroptrolelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroptrolelistContext { + var p = new(AlteroptrolelistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteroptrolelist + + return p +} + +func (s *AlteroptrolelistContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteroptrolelistContext) AllAlteroptroleelem() []IAlteroptroleelemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlteroptroleelemContext); ok { + len++ + } + } + + tst := make([]IAlteroptroleelemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlteroptroleelemContext); ok { + tst[i] = t.(IAlteroptroleelemContext) + i++ + } + } + + return tst +} + +func (s *AlteroptrolelistContext) Alteroptroleelem(i int) IAlteroptroleelemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteroptroleelemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlteroptroleelemContext) +} + +func (s *AlteroptrolelistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *AlteroptrolelistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *AlteroptrolelistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteroptrolelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteroptrolelistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteroptrolelist(s) + } +} + +func (s *AlteroptrolelistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteroptrolelist(s) + } +} + +func (s *AlteroptrolelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteroptrolelist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteroptrolelist() (localctx IAlteroptrolelistContext) { + localctx = NewAlteroptrolelistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, RedshiftParserRULE_alteroptrolelist) + var _la int + + p.SetState(2414) + 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(2400) + p.Alteroptroleelem() + } + p.SetState(2405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(2401) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2402) + p.Alteroptroleelem() + } + + p.SetState(2407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(2411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-93)) & ^0x3f) == 0 && ((int64(1)<<(_la-93))&4620693771766464641) != 0) || ((int64((_la-159)) & ^0x3f) == 0 && ((int64(1)<<(_la-159))&40533496158028945) != 0) || ((int64((_la-232)) & ^0x3f) == 0 && ((int64(1)<<(_la-232))&580981970960388113) != 0) || ((int64((_la-305)) & ^0x3f) == 0 && ((int64(1)<<(_la-305))&153122387431460929) != 0) || _la == RedshiftParserVALID || ((int64((_la-488)) & ^0x3f) == 0 && ((int64(1)<<(_la-488))&5315) != 0) || _la == RedshiftParserCALL || _la == RedshiftParserCURRENT_P || ((int64((_la-676)) & ^0x3f) == 0 && ((int64(1)<<(_la-676))&13124950286337) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&402653321) != 0) { + { + p.SetState(2408) + p.Alteroptroleelem() + } + + p.SetState(2413) + 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 +} + +// IAlteroptroleelemContext is an interface to support dynamic dispatch. +type IAlteroptroleelemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PASSWORD() antlr.TerminalNode + Sconst() ISconstContext + NULL_P() antlr.TerminalNode + DISABLE_P() antlr.TerminalNode + ENCRYPTED() antlr.TerminalNode + UNENCRYPTED() antlr.TerminalNode + INHERIT() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Signediconst() ISignediconstContext + UNLIMITED() antlr.TerminalNode + VALID() antlr.TerminalNode + UNTIL() antlr.TerminalNode + USER() antlr.TerminalNode + Role_list() IRole_listContext + EXTERNALID() antlr.TerminalNode + Identifier() IIdentifierContext + CREATEDB() antlr.TerminalNode + NOCREATEDB() antlr.TerminalNode + CREATEUSER() antlr.TerminalNode + NOCREATEUSER() antlr.TerminalNode + SYSLOG() antlr.TerminalNode + ACCESS() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + UNRESTRICTED() antlr.TerminalNode + SESSION() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + Iconst() IIconstContext + RESET() antlr.TerminalNode + ALL() antlr.TerminalNode + SET() antlr.TerminalNode + Var_name() IVar_nameContext + Var_list() IVar_listContext + TO() antlr.TerminalNode + EQUAL() antlr.TerminalNode + + // IsAlteroptroleelemContext differentiates from other interfaces. + IsAlteroptroleelemContext() +} + +type AlteroptroleelemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlteroptroleelemContext() *AlteroptroleelemContext { + var p = new(AlteroptroleelemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteroptroleelem + return p +} + +func InitEmptyAlteroptroleelemContext(p *AlteroptroleelemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteroptroleelem +} + +func (*AlteroptroleelemContext) IsAlteroptroleelemContext() {} + +func NewAlteroptroleelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroptroleelemContext { + var p = new(AlteroptroleelemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteroptroleelem + + return p +} + +func (s *AlteroptroleelemContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteroptroleelemContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(RedshiftParserPASSWORD, 0) +} + +func (s *AlteroptroleelemContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *AlteroptroleelemContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *AlteroptroleelemContext) DISABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISABLE_P, 0) +} + +func (s *AlteroptroleelemContext) ENCRYPTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCRYPTED, 0) +} + +func (s *AlteroptroleelemContext) UNENCRYPTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNENCRYPTED, 0) +} + +func (s *AlteroptroleelemContext) INHERIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINHERIT, 0) +} + +func (s *AlteroptroleelemContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECTION, 0) +} + +func (s *AlteroptroleelemContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *AlteroptroleelemContext) Signediconst() ISignediconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignediconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignediconstContext) +} + +func (s *AlteroptroleelemContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLIMITED, 0) +} + +func (s *AlteroptroleelemContext) VALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALID, 0) +} + +func (s *AlteroptroleelemContext) UNTIL() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNTIL, 0) +} + +func (s *AlteroptroleelemContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *AlteroptroleelemContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *AlteroptroleelemContext) EXTERNALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNALID, 0) +} + +func (s *AlteroptroleelemContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *AlteroptroleelemContext) CREATEDB() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATEDB, 0) +} + +func (s *AlteroptroleelemContext) NOCREATEDB() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOCREATEDB, 0) +} + +func (s *AlteroptroleelemContext) CREATEUSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATEUSER, 0) +} + +func (s *AlteroptroleelemContext) NOCREATEUSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOCREATEUSER, 0) +} + +func (s *AlteroptroleelemContext) SYSLOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSLOG, 0) +} + +func (s *AlteroptroleelemContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *AlteroptroleelemContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICTED, 0) +} + +func (s *AlteroptroleelemContext) UNRESTRICTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNRESTRICTED, 0) +} + +func (s *AlteroptroleelemContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *AlteroptroleelemContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMEOUT, 0) +} + +func (s *AlteroptroleelemContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *AlteroptroleelemContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *AlteroptroleelemContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *AlteroptroleelemContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlteroptroleelemContext) Var_name() IVar_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVar_nameContext) +} + +func (s *AlteroptroleelemContext) Var_list() IVar_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVar_listContext) +} + +func (s *AlteroptroleelemContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AlteroptroleelemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *AlteroptroleelemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteroptroleelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteroptroleelemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteroptroleelem(s) + } +} + +func (s *AlteroptroleelemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteroptroleelem(s) + } +} + +func (s *AlteroptroleelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteroptroleelem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteroptroleelem() (localctx IAlteroptroleelemContext) { + localctx = NewAlteroptroleelemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, RedshiftParserRULE_alteroptroleelem) + var _la int + + p.SetState(2467) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 13, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2416) + p.Match(RedshiftParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(2417) + p.Sconst() + } + + case RedshiftParserNULL_P: + { + p.SetState(2418) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDISABLE_P: + { + p.SetState(2419) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2422) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserENCRYPTED || _la == RedshiftParserUNENCRYPTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2423) + p.Match(RedshiftParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2424) + p.Sconst() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2425) + p.Match(RedshiftParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2426) + p.Match(RedshiftParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2427) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserIntegral: + { + p.SetState(2428) + p.Signediconst() + } + + case RedshiftParserUNLIMITED: + { + p.SetState(2429) + p.Match(RedshiftParserUNLIMITED) + 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.EnterOuterAlt(localctx, 5) + { + p.SetState(2432) + p.Match(RedshiftParserVALID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2433) + p.Match(RedshiftParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2434) + p.Sconst() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2435) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2436) + p.Role_list() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2437) + p.Match(RedshiftParserEXTERNALID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(2438) + p.Sconst() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserOUTER_P, RedshiftParserABSOLUTE_P, RedshiftParserBACKWARD, RedshiftParserCHAIN, RedshiftParserCLOSE, RedshiftParserCOMMIT, RedshiftParserCONTINUE_P, RedshiftParserCURSOR, RedshiftParserFIRST_P, RedshiftParserFORWARD, RedshiftParserINSERT, RedshiftParserLAST_P, RedshiftParserMOVE, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserOPTION, RedshiftParserPRIOR, RedshiftParserRELATIVE_P, RedshiftParserRESET, RedshiftParserROLLBACK, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSET, RedshiftParserTYPE_P, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserROWTYPE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(2439) + p.Identifier() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2442) + p.Match(RedshiftParserCREATEDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2443) + p.Match(RedshiftParserNOCREATEDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2444) + p.Match(RedshiftParserCREATEUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2445) + p.Match(RedshiftParserNOCREATEUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2446) + p.Match(RedshiftParserSYSLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2447) + p.Match(RedshiftParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2448) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserRESTRICTED || _la == RedshiftParserUNRESTRICTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2449) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2450) + p.Match(RedshiftParserTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2451) + p.Iconst() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2452) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2453) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2454) + p.Match(RedshiftParserTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2455) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2456) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2457) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2458) + p.Var_name() + } + p.SetState(2460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL || _la == RedshiftParserTO { + { + p.SetState(2459) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEQUAL || _la == RedshiftParserTO) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(2462) + p.Var_list() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2464) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2465) + p.Var_name() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2466) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateoptroleelemContext is an interface to support dynamic dispatch. +type ICreateoptroleelemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alteroptroleelem() IAlteroptroleelemContext + SYSID() antlr.TerminalNode + Iconst() IIconstContext + ADMIN() antlr.TerminalNode + Role_list() IRole_listContext + ROLE() antlr.TerminalNode + IN_P() antlr.TerminalNode + GROUP_P() antlr.TerminalNode + + // IsCreateoptroleelemContext differentiates from other interfaces. + IsCreateoptroleelemContext() +} + +type CreateoptroleelemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateoptroleelemContext() *CreateoptroleelemContext { + var p = new(CreateoptroleelemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createoptroleelem + return p +} + +func InitEmptyCreateoptroleelemContext(p *CreateoptroleelemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createoptroleelem +} + +func (*CreateoptroleelemContext) IsCreateoptroleelemContext() {} + +func NewCreateoptroleelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateoptroleelemContext { + var p = new(CreateoptroleelemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createoptroleelem + + return p +} + +func (s *CreateoptroleelemContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateoptroleelemContext) Alteroptroleelem() IAlteroptroleelemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteroptroleelemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlteroptroleelemContext) +} + +func (s *CreateoptroleelemContext) SYSID() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSID, 0) +} + +func (s *CreateoptroleelemContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *CreateoptroleelemContext) ADMIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserADMIN, 0) +} + +func (s *CreateoptroleelemContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *CreateoptroleelemContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *CreateoptroleelemContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *CreateoptroleelemContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *CreateoptroleelemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateoptroleelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateoptroleelemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateoptroleelem(s) + } +} + +func (s *CreateoptroleelemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateoptroleelem(s) + } +} + +func (s *CreateoptroleelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateoptroleelem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createoptroleelem() (localctx ICreateoptroleelemContext) { + localctx = NewCreateoptroleelemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, RedshiftParserRULE_createoptroleelem) + var _la int + + p.SetState(2479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserTABLE, RedshiftParserUSER, RedshiftParserIS, RedshiftParserOUTER_P, RedshiftParserABSOLUTE_P, RedshiftParserBACKWARD, RedshiftParserCHAIN, RedshiftParserCLOSE, RedshiftParserCOMMIT, RedshiftParserCONNECTION, RedshiftParserCONTINUE_P, RedshiftParserCURSOR, RedshiftParserENCRYPTED, RedshiftParserFIRST_P, RedshiftParserFORWARD, RedshiftParserINHERIT, RedshiftParserINSERT, RedshiftParserLAST_P, RedshiftParserMOVE, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserOPTION, RedshiftParserPASSWORD, RedshiftParserPRIOR, RedshiftParserRELATIVE_P, RedshiftParserRESET, RedshiftParserROLLBACK, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserTYPE_P, RedshiftParserUNENCRYPTED, RedshiftParserVALID, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserEXTERNALID, RedshiftParserSYSLOG, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserROWTYPE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2469) + p.Alteroptroleelem() + } + + case RedshiftParserSYSID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2470) + p.Match(RedshiftParserSYSID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2471) + p.Iconst() + } + + case RedshiftParserADMIN: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2472) + p.Match(RedshiftParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2473) + p.Role_list() + } + + case RedshiftParserROLE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2474) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2475) + p.Role_list() + } + + case RedshiftParserIN_P: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2476) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2477) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserGROUP_P || _la == RedshiftParserROLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2478) + p.Role_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateuserstmtContext is an interface to support dynamic dispatch. +type ICreateuserstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + USER() antlr.TerminalNode + Roleid() IRoleidContext + Optrolelist() IOptrolelistContext + Opt_with() IOpt_withContext + + // IsCreateuserstmtContext differentiates from other interfaces. + IsCreateuserstmtContext() +} + +type CreateuserstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateuserstmtContext() *CreateuserstmtContext { + var p = new(CreateuserstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createuserstmt + return p +} + +func InitEmptyCreateuserstmtContext(p *CreateuserstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createuserstmt +} + +func (*CreateuserstmtContext) IsCreateuserstmtContext() {} + +func NewCreateuserstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateuserstmtContext { + var p = new(CreateuserstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createuserstmt + + return p +} + +func (s *CreateuserstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateuserstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateuserstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *CreateuserstmtContext) Roleid() IRoleidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleidContext) +} + +func (s *CreateuserstmtContext) Optrolelist() IOptrolelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptrolelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptrolelistContext) +} + +func (s *CreateuserstmtContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *CreateuserstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateuserstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateuserstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateuserstmt(s) + } +} + +func (s *CreateuserstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateuserstmt(s) + } +} + +func (s *CreateuserstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateuserstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createuserstmt() (localctx ICreateuserstmtContext) { + localctx = NewCreateuserstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, RedshiftParserRULE_createuserstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2481) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2482) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2483) + p.Roleid() + } + p.SetState(2485) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 15, p.GetParserRuleContext()) == 1 { + { + p.SetState(2484) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2487) + p.Optrolelist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterrolestmtContext is an interface to support dynamic dispatch. +type IAlterrolestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ROLE() antlr.TerminalNode + Rolespec() IRolespecContext + Alterroleaction() IAlterroleactionContext + Opt_with() IOpt_withContext + + // IsAlterrolestmtContext differentiates from other interfaces. + IsAlterrolestmtContext() +} + +type AlterrolestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterrolestmtContext() *AlterrolestmtContext { + var p = new(AlterrolestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterrolestmt + return p +} + +func InitEmptyAlterrolestmtContext(p *AlterrolestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterrolestmt +} + +func (*AlterrolestmtContext) IsAlterrolestmtContext() {} + +func NewAlterrolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterrolestmtContext { + var p = new(AlterrolestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterrolestmt + + return p +} + +func (s *AlterrolestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterrolestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterrolestmtContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *AlterrolestmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *AlterrolestmtContext) Alterroleaction() IAlterroleactionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterroleactionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterroleactionContext) +} + +func (s *AlterrolestmtContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *AlterrolestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterrolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterrolestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterrolestmt(s) + } +} + +func (s *AlterrolestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterrolestmt(s) + } +} + +func (s *AlterrolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterrolestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterrolestmt() (localctx IAlterrolestmtContext) { + localctx = NewAlterrolestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, RedshiftParserRULE_alterrolestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2489) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2490) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2491) + p.Rolespec() + } + p.SetState(2493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(2492) + p.Opt_with() + } + + } + { + p.SetState(2495) + p.Alterroleaction() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterroleactionContext is an interface to support dynamic dispatch. +type IAlterroleactionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Colid() IColidContext + OWNER() antlr.TerminalNode + EXTERNALID() antlr.TerminalNode + + // IsAlterroleactionContext differentiates from other interfaces. + IsAlterroleactionContext() +} + +type AlterroleactionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterroleactionContext() *AlterroleactionContext { + var p = new(AlterroleactionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterroleaction + return p +} + +func InitEmptyAlterroleactionContext(p *AlterroleactionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterroleaction +} + +func (*AlterroleactionContext) IsAlterroleactionContext() {} + +func NewAlterroleactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterroleactionContext { + var p = new(AlterroleactionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterroleaction + + return p +} + +func (s *AlterroleactionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterroleactionContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *AlterroleactionContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AlterroleactionContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AlterroleactionContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *AlterroleactionContext) EXTERNALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNALID, 0) +} + +func (s *AlterroleactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterroleactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterroleactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterroleaction(s) + } +} + +func (s *AlterroleactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterroleaction(s) + } +} + +func (s *AlterroleactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterroleaction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterroleaction() (localctx IAlterroleactionContext) { + localctx = NewAlterroleactionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, RedshiftParserRULE_alterroleaction) + p.SetState(2506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserRENAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2497) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2498) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2499) + p.Colid() + } + + case RedshiftParserOWNER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2500) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2501) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2502) + p.Colid() + } + + case RedshiftParserEXTERNALID: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2503) + p.Match(RedshiftParserEXTERNALID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2504) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2505) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_in_databaseContext is an interface to support dynamic dispatch. +type IOpt_in_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Name() INameContext + + // IsOpt_in_databaseContext differentiates from other interfaces. + IsOpt_in_databaseContext() +} + +type Opt_in_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_in_databaseContext() *Opt_in_databaseContext { + var p = new(Opt_in_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_in_database + return p +} + +func InitEmptyOpt_in_databaseContext(p *Opt_in_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_in_database +} + +func (*Opt_in_databaseContext) IsOpt_in_databaseContext() {} + +func NewOpt_in_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_in_databaseContext { + var p = new(Opt_in_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_in_database + + return p +} + +func (s *Opt_in_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_in_databaseContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Opt_in_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Opt_in_databaseContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Opt_in_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_in_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_in_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_in_database(s) + } +} + +func (s *Opt_in_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_in_database(s) + } +} + +func (s *Opt_in_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_in_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_in_database() (localctx IOpt_in_databaseContext) { + localctx = NewOpt_in_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, RedshiftParserRULE_opt_in_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2508) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2509) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2510) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterrolesetstmtContext is an interface to support dynamic dispatch. +type IAlterrolesetstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + Rolespec() IRolespecContext + Setresetclause() ISetresetclauseContext + ROLE() antlr.TerminalNode + USER() antlr.TerminalNode + ALL() antlr.TerminalNode + Opt_in_database() IOpt_in_databaseContext + + // IsAlterrolesetstmtContext differentiates from other interfaces. + IsAlterrolesetstmtContext() +} + +type AlterrolesetstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterrolesetstmtContext() *AlterrolesetstmtContext { + var p = new(AlterrolesetstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterrolesetstmt + return p +} + +func InitEmptyAlterrolesetstmtContext(p *AlterrolesetstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterrolesetstmt +} + +func (*AlterrolesetstmtContext) IsAlterrolesetstmtContext() {} + +func NewAlterrolesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterrolesetstmtContext { + var p = new(AlterrolesetstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterrolesetstmt + + return p +} + +func (s *AlterrolesetstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterrolesetstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterrolesetstmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *AlterrolesetstmtContext) Setresetclause() ISetresetclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetresetclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetresetclauseContext) +} + +func (s *AlterrolesetstmtContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *AlterrolesetstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *AlterrolesetstmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *AlterrolesetstmtContext) Opt_in_database() IOpt_in_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_in_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_in_databaseContext) +} + +func (s *AlterrolesetstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterrolesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterrolesetstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterrolesetstmt(s) + } +} + +func (s *AlterrolesetstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterrolesetstmt(s) + } +} + +func (s *AlterrolesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterrolesetstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterrolesetstmt() (localctx IAlterrolesetstmtContext) { + localctx = NewAlterrolesetstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, RedshiftParserRULE_alterrolesetstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2512) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2513) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserUSER || _la == RedshiftParserROLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserALL { + { + p.SetState(2514) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2517) + p.Rolespec() + } + p.SetState(2519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIN_P { + { + p.SetState(2518) + p.Opt_in_database() + } + + } + { + p.SetState(2521) + p.Setresetclause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterschemastmtContext is an interface to support dynamic dispatch. +type IAlterschemastmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Name() INameContext + QUOTA() antlr.TerminalNode + Iconst() IIconstContext + UNLIMITED() antlr.TerminalNode + MB() antlr.TerminalNode + GB() antlr.TerminalNode + TB() antlr.TerminalNode + + // IsAlterschemastmtContext differentiates from other interfaces. + IsAlterschemastmtContext() +} + +type AlterschemastmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterschemastmtContext() *AlterschemastmtContext { + var p = new(AlterschemastmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterschemastmt + return p +} + +func InitEmptyAlterschemastmtContext(p *AlterschemastmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterschemastmt +} + +func (*AlterschemastmtContext) IsAlterschemastmtContext() {} + +func NewAlterschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterschemastmtContext { + var p = new(AlterschemastmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterschemastmt + + return p +} + +func (s *AlterschemastmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterschemastmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterschemastmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *AlterschemastmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterschemastmtContext) QUOTA() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTA, 0) +} + +func (s *AlterschemastmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *AlterschemastmtContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLIMITED, 0) +} + +func (s *AlterschemastmtContext) MB() antlr.TerminalNode { + return s.GetToken(RedshiftParserMB, 0) +} + +func (s *AlterschemastmtContext) GB() antlr.TerminalNode { + return s.GetToken(RedshiftParserGB, 0) +} + +func (s *AlterschemastmtContext) TB() antlr.TerminalNode { + return s.GetToken(RedshiftParserTB, 0) +} + +func (s *AlterschemastmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterschemastmt(s) + } +} + +func (s *AlterschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterschemastmt(s) + } +} + +func (s *AlterschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterschemastmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterschemastmt() (localctx IAlterschemastmtContext) { + localctx = NewAlterschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, RedshiftParserRULE_alterschemastmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2523) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2524) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2525) + p.Name() + } + { + p.SetState(2526) + p.Match(RedshiftParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + { + p.SetState(2527) + p.Iconst() + } + p.SetState(2529) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMB || _la == RedshiftParserGB || _la == RedshiftParserTB { + { + p.SetState(2528) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserMB || _la == RedshiftParserGB || _la == RedshiftParserTB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case RedshiftParserUNLIMITED: + { + p.SetState(2531) + p.Match(RedshiftParserUNLIMITED) + 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 +} + +// IDroprolestmtContext is an interface to support dynamic dispatch. +type IDroprolestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ROLE() antlr.TerminalNode + Rolespec() IRolespecContext + FORCE() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + + // IsDroprolestmtContext differentiates from other interfaces. + IsDroprolestmtContext() +} + +type DroprolestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDroprolestmtContext() *DroprolestmtContext { + var p = new(DroprolestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droprolestmt + return p +} + +func InitEmptyDroprolestmtContext(p *DroprolestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droprolestmt +} + +func (*DroprolestmtContext) IsDroprolestmtContext() {} + +func NewDroprolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroprolestmtContext { + var p = new(DroprolestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_droprolestmt + + return p +} + +func (s *DroprolestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DroprolestmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DroprolestmtContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *DroprolestmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *DroprolestmtContext) FORCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORCE, 0) +} + +func (s *DroprolestmtContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *DroprolestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DroprolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DroprolestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDroprolestmt(s) + } +} + +func (s *DroprolestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDroprolestmt(s) + } +} + +func (s *DroprolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDroprolestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Droprolestmt() (localctx IDroprolestmtContext) { + localctx = NewDroprolestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, RedshiftParserRULE_droprolestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2534) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2535) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2536) + p.Rolespec() + } + p.SetState(2538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFORCE || _la == RedshiftParserRESTRICT { + { + p.SetState(2537) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFORCE || _la == RedshiftParserRESTRICT) { + 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 +} + +// IDropuserstmtContext is an interface to support dynamic dispatch. +type IDropuserstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + USER() antlr.TerminalNode + Role_list() IRole_listContext + Opt_if_exists() IOpt_if_existsContext + + // IsDropuserstmtContext differentiates from other interfaces. + IsDropuserstmtContext() +} + +type DropuserstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropuserstmtContext() *DropuserstmtContext { + var p = new(DropuserstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropuserstmt + return p +} + +func InitEmptyDropuserstmtContext(p *DropuserstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropuserstmt +} + +func (*DropuserstmtContext) IsDropuserstmtContext() {} + +func NewDropuserstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropuserstmtContext { + var p = new(DropuserstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropuserstmt + + return p +} + +func (s *DropuserstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropuserstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropuserstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *DropuserstmtContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *DropuserstmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropuserstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropuserstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropuserstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropuserstmt(s) + } +} + +func (s *DropuserstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropuserstmt(s) + } +} + +func (s *DropuserstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropuserstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropuserstmt() (localctx IDropuserstmtContext) { + localctx = NewDropuserstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, RedshiftParserRULE_dropuserstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2540) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2541) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2543) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 23, p.GetParserRuleContext()) == 1 { + { + p.SetState(2542) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2545) + p.Role_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropgroupstmtContext is an interface to support dynamic dispatch. +type IDropgroupstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + GROUP_P() antlr.TerminalNode + Rolespec() IRolespecContext + + // IsDropgroupstmtContext differentiates from other interfaces. + IsDropgroupstmtContext() +} + +type DropgroupstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropgroupstmtContext() *DropgroupstmtContext { + var p = new(DropgroupstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropgroupstmt + return p +} + +func InitEmptyDropgroupstmtContext(p *DropgroupstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropgroupstmt +} + +func (*DropgroupstmtContext) IsDropgroupstmtContext() {} + +func NewDropgroupstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropgroupstmtContext { + var p = new(DropgroupstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropgroupstmt + + return p +} + +func (s *DropgroupstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropgroupstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropgroupstmtContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *DropgroupstmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *DropgroupstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropgroupstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropgroupstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropgroupstmt(s) + } +} + +func (s *DropgroupstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropgroupstmt(s) + } +} + +func (s *DropgroupstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropgroupstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropgroupstmt() (localctx IDropgroupstmtContext) { + localctx = NewDropgroupstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, RedshiftParserRULE_dropgroupstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2547) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2548) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2549) + p.Rolespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreategroupstmtContext is an interface to support dynamic dispatch. +type ICreategroupstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + GROUP_P() antlr.TerminalNode + Roleid() IRoleidContext + Optrolelist() IOptrolelistContext + Opt_with() IOpt_withContext + + // IsCreategroupstmtContext differentiates from other interfaces. + IsCreategroupstmtContext() +} + +type CreategroupstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreategroupstmtContext() *CreategroupstmtContext { + var p = new(CreategroupstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_creategroupstmt + return p +} + +func InitEmptyCreategroupstmtContext(p *CreategroupstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_creategroupstmt +} + +func (*CreategroupstmtContext) IsCreategroupstmtContext() {} + +func NewCreategroupstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreategroupstmtContext { + var p = new(CreategroupstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_creategroupstmt + + return p +} + +func (s *CreategroupstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreategroupstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreategroupstmtContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *CreategroupstmtContext) Roleid() IRoleidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoleidContext) +} + +func (s *CreategroupstmtContext) Optrolelist() IOptrolelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptrolelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptrolelistContext) +} + +func (s *CreategroupstmtContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *CreategroupstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreategroupstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreategroupstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreategroupstmt(s) + } +} + +func (s *CreategroupstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreategroupstmt(s) + } +} + +func (s *CreategroupstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreategroupstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Creategroupstmt() (localctx ICreategroupstmtContext) { + localctx = NewCreategroupstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, RedshiftParserRULE_creategroupstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2551) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2552) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2553) + p.Roleid() + } + p.SetState(2555) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 24, p.GetParserRuleContext()) == 1 { + { + p.SetState(2554) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2557) + p.Optrolelist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltergroupstmtContext is an interface to support dynamic dispatch. +type IAltergroupstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + GROUP_P() antlr.TerminalNode + Rolespec() IRolespecContext + Add_drop() IAdd_dropContext + USER() antlr.TerminalNode + Role_list() IRole_listContext + + // IsAltergroupstmtContext differentiates from other interfaces. + IsAltergroupstmtContext() +} + +type AltergroupstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltergroupstmtContext() *AltergroupstmtContext { + var p = new(AltergroupstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altergroupstmt + return p +} + +func InitEmptyAltergroupstmtContext(p *AltergroupstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altergroupstmt +} + +func (*AltergroupstmtContext) IsAltergroupstmtContext() {} + +func NewAltergroupstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltergroupstmtContext { + var p = new(AltergroupstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altergroupstmt + + return p +} + +func (s *AltergroupstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltergroupstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltergroupstmtContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *AltergroupstmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *AltergroupstmtContext) Add_drop() IAdd_dropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_dropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_dropContext) +} + +func (s *AltergroupstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *AltergroupstmtContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *AltergroupstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltergroupstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltergroupstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltergroupstmt(s) + } +} + +func (s *AltergroupstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltergroupstmt(s) + } +} + +func (s *AltergroupstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltergroupstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altergroupstmt() (localctx IAltergroupstmtContext) { + localctx = NewAltergroupstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, RedshiftParserRULE_altergroupstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2559) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2560) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2561) + p.Rolespec() + } + { + p.SetState(2562) + p.Add_drop() + } + { + p.SetState(2563) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2564) + p.Role_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_dropContext is an interface to support dynamic dispatch. +type IAdd_dropContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD_P() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAdd_dropContext differentiates from other interfaces. + IsAdd_dropContext() +} + +type Add_dropContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_dropContext() *Add_dropContext { + var p = new(Add_dropContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_add_drop + return p +} + +func InitEmptyAdd_dropContext(p *Add_dropContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_add_drop +} + +func (*Add_dropContext) IsAdd_dropContext() {} + +func NewAdd_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_dropContext { + var p = new(Add_dropContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_add_drop + + return p +} + +func (s *Add_dropContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_dropContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *Add_dropContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Add_dropContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_dropContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAdd_drop(s) + } +} + +func (s *Add_dropContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAdd_drop(s) + } +} + +func (s *Add_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAdd_drop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Add_drop() (localctx IAdd_dropContext) { + localctx = NewAdd_dropContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, RedshiftParserRULE_add_drop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2566) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserADD_P || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateschemastmtContext is an interface to support dynamic dispatch. +type ICreateschemastmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchemaname returns the schemaname rule contexts. + GetSchemaname() IColidContext + + // SetSchemaname sets the schemaname rule contexts. + SetSchemaname(IColidContext) + + // Getter signatures + CREATE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Colid() IColidContext + Opt_if_not_exists() IOpt_if_not_existsContext + Opt_auth_clause() IOpt_auth_clauseContext + Opt_quota() IOpt_quotaContext + Optschemaeltlist() IOptschemaeltlistContext + + // IsCreateschemastmtContext differentiates from other interfaces. + IsCreateschemastmtContext() +} + +type CreateschemastmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schemaname IColidContext +} + +func NewEmptyCreateschemastmtContext() *CreateschemastmtContext { + var p = new(CreateschemastmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createschemastmt + return p +} + +func InitEmptyCreateschemastmtContext(p *CreateschemastmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createschemastmt +} + +func (*CreateschemastmtContext) IsCreateschemastmtContext() {} + +func NewCreateschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateschemastmtContext { + var p = new(CreateschemastmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createschemastmt + + return p +} + +func (s *CreateschemastmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateschemastmtContext) GetSchemaname() IColidContext { return s.schemaname } + +func (s *CreateschemastmtContext) SetSchemaname(v IColidContext) { s.schemaname = v } + +func (s *CreateschemastmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateschemastmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *CreateschemastmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CreateschemastmtContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *CreateschemastmtContext) Opt_auth_clause() IOpt_auth_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_auth_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_auth_clauseContext) +} + +func (s *CreateschemastmtContext) Opt_quota() IOpt_quotaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_quotaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_quotaContext) +} + +func (s *CreateschemastmtContext) Optschemaeltlist() IOptschemaeltlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptschemaeltlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptschemaeltlistContext) +} + +func (s *CreateschemastmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateschemastmt(s) + } +} + +func (s *CreateschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateschemastmt(s) + } +} + +func (s *CreateschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateschemastmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createschemastmt() (localctx ICreateschemastmtContext) { + localctx = NewCreateschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, RedshiftParserRULE_createschemastmt) + var _la int + + p.SetState(2592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 31, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2568) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2569) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2571) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 25, p.GetParserRuleContext()) == 1 { + { + p.SetState(2570) + p.Opt_if_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2573) + + var _x = p.Colid() + + localctx.(*CreateschemastmtContext).schemaname = _x + } + p.SetState(2575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAUTHORIZATION { + { + p.SetState(2574) + p.Opt_auth_clause() + } + + } + p.SetState(2578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserQUOTA { + { + p.SetState(2577) + p.Opt_quota() + } + + } + p.SetState(2581) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 28, p.GetParserRuleContext()) == 1 { + { + p.SetState(2580) + p.Optschemaeltlist() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2583) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2584) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2585) + p.Opt_auth_clause() + } + p.SetState(2587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserQUOTA { + { + p.SetState(2586) + p.Opt_quota() + } + + } + p.SetState(2590) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 { + { + p.SetState(2589) + p.Optschemaeltlist() + } + + } 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 +} + +// IOpt_auth_clauseContext is an interface to support dynamic dispatch. +type IOpt_auth_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTHORIZATION() antlr.TerminalNode + Rolespec() IRolespecContext + + // IsOpt_auth_clauseContext differentiates from other interfaces. + IsOpt_auth_clauseContext() +} + +type Opt_auth_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_auth_clauseContext() *Opt_auth_clauseContext { + var p = new(Opt_auth_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_auth_clause + return p +} + +func InitEmptyOpt_auth_clauseContext(p *Opt_auth_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_auth_clause +} + +func (*Opt_auth_clauseContext) IsOpt_auth_clauseContext() {} + +func NewOpt_auth_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_auth_clauseContext { + var p = new(Opt_auth_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_auth_clause + + return p +} + +func (s *Opt_auth_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_auth_clauseContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHORIZATION, 0) +} + +func (s *Opt_auth_clauseContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Opt_auth_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_auth_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_auth_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_auth_clause(s) + } +} + +func (s *Opt_auth_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_auth_clause(s) + } +} + +func (s *Opt_auth_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_auth_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_auth_clause() (localctx IOpt_auth_clauseContext) { + localctx = NewOpt_auth_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, RedshiftParserRULE_opt_auth_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2594) + p.Match(RedshiftParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2595) + p.Rolespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_quotaContext is an interface to support dynamic dispatch. +type IOpt_quotaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUOTA() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + Fconst() IFconstContext + Iconst() IIconstContext + MB() antlr.TerminalNode + GB() antlr.TerminalNode + TB() antlr.TerminalNode + + // IsOpt_quotaContext differentiates from other interfaces. + IsOpt_quotaContext() +} + +type Opt_quotaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_quotaContext() *Opt_quotaContext { + var p = new(Opt_quotaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_quota + return p +} + +func InitEmptyOpt_quotaContext(p *Opt_quotaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_quota +} + +func (*Opt_quotaContext) IsOpt_quotaContext() {} + +func NewOpt_quotaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_quotaContext { + var p = new(Opt_quotaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_quota + + return p +} + +func (s *Opt_quotaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_quotaContext) QUOTA() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTA, 0) +} + +func (s *Opt_quotaContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLIMITED, 0) +} + +func (s *Opt_quotaContext) Fconst() IFconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFconstContext) +} + +func (s *Opt_quotaContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Opt_quotaContext) MB() antlr.TerminalNode { + return s.GetToken(RedshiftParserMB, 0) +} + +func (s *Opt_quotaContext) GB() antlr.TerminalNode { + return s.GetToken(RedshiftParserGB, 0) +} + +func (s *Opt_quotaContext) TB() antlr.TerminalNode { + return s.GetToken(RedshiftParserTB, 0) +} + +func (s *Opt_quotaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_quotaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_quotaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_quota(s) + } +} + +func (s *Opt_quotaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_quota(s) + } +} + +func (s *Opt_quotaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_quota(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_quota() (localctx IOpt_quotaContext) { + localctx = NewOpt_quotaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, RedshiftParserRULE_opt_quota) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2597) + p.Match(RedshiftParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral, RedshiftParserNumeric: + p.SetState(2600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNumeric: + { + p.SetState(2598) + p.Fconst() + } + + case RedshiftParserIntegral: + { + p.SetState(2599) + p.Iconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMB || _la == RedshiftParserGB || _la == RedshiftParserTB { + { + p.SetState(2602) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserMB || _la == RedshiftParserGB || _la == RedshiftParserTB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case RedshiftParserUNLIMITED: + { + p.SetState(2605) + p.Match(RedshiftParserUNLIMITED) + 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 +} + +// IOptschemaeltlistContext is an interface to support dynamic dispatch. +type IOptschemaeltlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSchema_stmt() []ISchema_stmtContext + Schema_stmt(i int) ISchema_stmtContext + + // IsOptschemaeltlistContext differentiates from other interfaces. + IsOptschemaeltlistContext() +} + +type OptschemaeltlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptschemaeltlistContext() *OptschemaeltlistContext { + var p = new(OptschemaeltlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optschemaeltlist + return p +} + +func InitEmptyOptschemaeltlistContext(p *OptschemaeltlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optschemaeltlist +} + +func (*OptschemaeltlistContext) IsOptschemaeltlistContext() {} + +func NewOptschemaeltlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptschemaeltlistContext { + var p = new(OptschemaeltlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optschemaeltlist + + return p +} + +func (s *OptschemaeltlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptschemaeltlistContext) AllSchema_stmt() []ISchema_stmtContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_stmtContext); ok { + len++ + } + } + + tst := make([]ISchema_stmtContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_stmtContext); ok { + tst[i] = t.(ISchema_stmtContext) + i++ + } + } + + return tst +} + +func (s *OptschemaeltlistContext) Schema_stmt(i int) ISchema_stmtContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_stmtContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_stmtContext) +} + +func (s *OptschemaeltlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptschemaeltlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptschemaeltlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptschemaeltlist(s) + } +} + +func (s *OptschemaeltlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptschemaeltlist(s) + } +} + +func (s *OptschemaeltlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptschemaeltlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optschemaeltlist() (localctx IOptschemaeltlistContext) { + localctx = NewOptschemaeltlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, RedshiftParserRULE_optschemaeltlist) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(2608) + p.Schema_stmt() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2611) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_stmtContext is an interface to support dynamic dispatch. +type ISchema_stmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Createstmt() ICreatestmtContext + Indexstmt() IIndexstmtContext + Createseqstmt() ICreateseqstmtContext + Createtrigstmt() ICreatetrigstmtContext + Grantstmt() IGrantstmtContext + Viewstmt() IViewstmtContext + + // IsSchema_stmtContext differentiates from other interfaces. + IsSchema_stmtContext() +} + +type Schema_stmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_stmtContext() *Schema_stmtContext { + var p = new(Schema_stmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_schema_stmt + return p +} + +func InitEmptySchema_stmtContext(p *Schema_stmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_schema_stmt +} + +func (*Schema_stmtContext) IsSchema_stmtContext() {} + +func NewSchema_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_stmtContext { + var p = new(Schema_stmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_schema_stmt + + return p +} + +func (s *Schema_stmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_stmtContext) Createstmt() ICreatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatestmtContext) +} + +func (s *Schema_stmtContext) Indexstmt() IIndexstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexstmtContext) +} + +func (s *Schema_stmtContext) Createseqstmt() ICreateseqstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateseqstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateseqstmtContext) +} + +func (s *Schema_stmtContext) Createtrigstmt() ICreatetrigstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatetrigstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatetrigstmtContext) +} + +func (s *Schema_stmtContext) Grantstmt() IGrantstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantstmtContext) +} + +func (s *Schema_stmtContext) Viewstmt() IViewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IViewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IViewstmtContext) +} + +func (s *Schema_stmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_stmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSchema_stmt(s) + } +} + +func (s *Schema_stmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSchema_stmt(s) + } +} + +func (s *Schema_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSchema_stmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Schema_stmt() (localctx ISchema_stmtContext) { + localctx = NewSchema_stmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, RedshiftParserRULE_schema_stmt) + p.SetState(2619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 36, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2613) + p.Createstmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2614) + p.Indexstmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2615) + p.Createseqstmt() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2616) + p.Createtrigstmt() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2617) + p.Grantstmt() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2618) + p.Viewstmt() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariablesetstmtContext is an interface to support dynamic dispatch. +type IVariablesetstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + Set_rest() ISet_restContext + LOCAL() antlr.TerminalNode + SESSION() antlr.TerminalNode + + // IsVariablesetstmtContext differentiates from other interfaces. + IsVariablesetstmtContext() +} + +type VariablesetstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariablesetstmtContext() *VariablesetstmtContext { + var p = new(VariablesetstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_variablesetstmt + return p +} + +func InitEmptyVariablesetstmtContext(p *VariablesetstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_variablesetstmt +} + +func (*VariablesetstmtContext) IsVariablesetstmtContext() {} + +func NewVariablesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariablesetstmtContext { + var p = new(VariablesetstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_variablesetstmt + + return p +} + +func (s *VariablesetstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariablesetstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *VariablesetstmtContext) Set_rest() ISet_restContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_restContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_restContext) +} + +func (s *VariablesetstmtContext) LOCAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCAL, 0) +} + +func (s *VariablesetstmtContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *VariablesetstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariablesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariablesetstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVariablesetstmt(s) + } +} + +func (s *VariablesetstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVariablesetstmt(s) + } +} + +func (s *VariablesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVariablesetstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Variablesetstmt() (localctx IVariablesetstmtContext) { + localctx = NewVariablesetstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, RedshiftParserRULE_variablesetstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2621) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2623) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 37, p.GetParserRuleContext()) == 1 { + { + p.SetState(2622) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserLOCAL || _la == RedshiftParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2625) + p.Set_rest() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_restContext is an interface to support dynamic dispatch. +type ISet_restContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRANSACTION() antlr.TerminalNode + Transaction_mode_list() ITransaction_mode_listContext + SESSION() antlr.TerminalNode + CHARACTERISTICS() antlr.TerminalNode + AS() antlr.TerminalNode + Set_rest_more() ISet_rest_moreContext + + // IsSet_restContext differentiates from other interfaces. + IsSet_restContext() +} + +type Set_restContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_restContext() *Set_restContext { + var p = new(Set_restContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_rest + return p +} + +func InitEmptySet_restContext(p *Set_restContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_rest +} + +func (*Set_restContext) IsSet_restContext() {} + +func NewSet_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_restContext { + var p = new(Set_restContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_set_rest + + return p +} + +func (s *Set_restContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_restContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *Set_restContext) Transaction_mode_list() ITransaction_mode_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_mode_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_mode_listContext) +} + +func (s *Set_restContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *Set_restContext) CHARACTERISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHARACTERISTICS, 0) +} + +func (s *Set_restContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Set_restContext) Set_rest_more() ISet_rest_moreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_rest_moreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_rest_moreContext) +} + +func (s *Set_restContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_restContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSet_rest(s) + } +} + +func (s *Set_restContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSet_rest(s) + } +} + +func (s *Set_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSet_rest(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Set_rest() (localctx ISet_restContext) { + localctx = NewSet_restContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, RedshiftParserRULE_set_rest) + p.SetState(2635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2627) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2628) + p.Transaction_mode_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2629) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2630) + p.Match(RedshiftParserCHARACTERISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2631) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2632) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2633) + p.Transaction_mode_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2634) + p.Set_rest_more() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_setContext is an interface to support dynamic dispatch. +type IGeneric_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Var_name() IVar_nameContext + Var_list() IVar_listContext + TO() antlr.TerminalNode + EQUAL() antlr.TerminalNode + + // IsGeneric_setContext differentiates from other interfaces. + IsGeneric_setContext() +} + +type Generic_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_setContext() *Generic_setContext { + var p = new(Generic_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_set + return p +} + +func InitEmptyGeneric_setContext(p *Generic_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_set +} + +func (*Generic_setContext) IsGeneric_setContext() {} + +func NewGeneric_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_setContext { + var p = new(Generic_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generic_set + + return p +} + +func (s *Generic_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_setContext) Var_name() IVar_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVar_nameContext) +} + +func (s *Generic_setContext) Var_list() IVar_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVar_listContext) +} + +func (s *Generic_setContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Generic_setContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Generic_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGeneric_set(s) + } +} + +func (s *Generic_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGeneric_set(s) + } +} + +func (s *Generic_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGeneric_set(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generic_set() (localctx IGeneric_setContext) { + localctx = NewGeneric_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, RedshiftParserRULE_generic_set) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2637) + p.Var_name() + } + { + p.SetState(2638) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEQUAL || _la == RedshiftParserTO) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2639) + p.Var_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_rest_moreContext is an interface to support dynamic dispatch. +type ISet_rest_moreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generic_set() IGeneric_setContext + Var_name() IVar_nameContext + FROM() antlr.TerminalNode + CURRENT_P() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + Zone_value() IZone_valueContext + CATALOG() antlr.TerminalNode + Sconst() ISconstContext + SCHEMA() antlr.TerminalNode + NAMES() antlr.TerminalNode + Opt_encoding() IOpt_encodingContext + ROLE() antlr.TerminalNode + Nonreservedword_or_sconst() INonreservedword_or_sconstContext + SESSION() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + XML_P() antlr.TerminalNode + OPTION() antlr.TerminalNode + Document_or_content() IDocument_or_contentContext + TRANSACTION() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + + // IsSet_rest_moreContext differentiates from other interfaces. + IsSet_rest_moreContext() +} + +type Set_rest_moreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_rest_moreContext() *Set_rest_moreContext { + var p = new(Set_rest_moreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_rest_more + return p +} + +func InitEmptySet_rest_moreContext(p *Set_rest_moreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_rest_more +} + +func (*Set_rest_moreContext) IsSet_rest_moreContext() {} + +func NewSet_rest_moreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_rest_moreContext { + var p = new(Set_rest_moreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_set_rest_more + + return p +} + +func (s *Set_rest_moreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_rest_moreContext) Generic_set() IGeneric_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_setContext) +} + +func (s *Set_rest_moreContext) Var_name() IVar_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVar_nameContext) +} + +func (s *Set_rest_moreContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Set_rest_moreContext) CURRENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_P, 0) +} + +func (s *Set_rest_moreContext) TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIME, 0) +} + +func (s *Set_rest_moreContext) ZONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserZONE, 0) +} + +func (s *Set_rest_moreContext) Zone_value() IZone_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZone_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZone_valueContext) +} + +func (s *Set_rest_moreContext) CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG, 0) +} + +func (s *Set_rest_moreContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Set_rest_moreContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Set_rest_moreContext) NAMES() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMES, 0) +} + +func (s *Set_rest_moreContext) Opt_encoding() IOpt_encodingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_encodingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_encodingContext) +} + +func (s *Set_rest_moreContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Set_rest_moreContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedword_or_sconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedword_or_sconstContext) +} + +func (s *Set_rest_moreContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *Set_rest_moreContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHORIZATION, 0) +} + +func (s *Set_rest_moreContext) XML_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserXML_P, 0) +} + +func (s *Set_rest_moreContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Set_rest_moreContext) Document_or_content() IDocument_or_contentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDocument_or_contentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDocument_or_contentContext) +} + +func (s *Set_rest_moreContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *Set_rest_moreContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSNAPSHOT, 0) +} + +func (s *Set_rest_moreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_rest_moreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_rest_moreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSet_rest_more(s) + } +} + +func (s *Set_rest_moreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSet_rest_more(s) + } +} + +func (s *Set_rest_moreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSet_rest_more(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Set_rest_more() (localctx ISet_rest_moreContext) { + localctx = NewSet_rest_moreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, RedshiftParserRULE_set_rest_more) + var _la int + + p.SetState(2668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 40, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2641) + p.Generic_set() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2642) + p.Var_name() + } + { + p.SetState(2643) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2644) + p.Match(RedshiftParserCURRENT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2646) + p.Match(RedshiftParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2647) + p.Match(RedshiftParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2648) + p.Zone_value() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2649) + p.Match(RedshiftParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2650) + p.Sconst() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2651) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2652) + p.Sconst() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2653) + p.Match(RedshiftParserNAMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDEFAULT || ((int64((_la-862)) & ^0x3f) == 0 && ((int64(1)<<(_la-862))&67108885) != 0) { + { + p.SetState(2654) + p.Opt_encoding() + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2657) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2658) + p.Nonreservedword_or_sconst() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2659) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2660) + p.Match(RedshiftParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2661) + p.Nonreservedword_or_sconst() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2662) + p.Match(RedshiftParserXML_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2663) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2664) + p.Document_or_content() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2665) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2666) + p.Match(RedshiftParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2667) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVar_nameContext is an interface to support dynamic dispatch. +type IVar_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColid() []IColidContext + Colid(i int) IColidContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsVar_nameContext differentiates from other interfaces. + IsVar_nameContext() +} + +type Var_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVar_nameContext() *Var_nameContext { + var p = new(Var_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_var_name + return p +} + +func InitEmptyVar_nameContext(p *Var_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_var_name +} + +func (*Var_nameContext) IsVar_nameContext() {} + +func NewVar_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_nameContext { + var p = new(Var_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_var_name + + return p +} + +func (s *Var_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Var_nameContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Var_nameContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Var_nameContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserDOT) +} + +func (s *Var_nameContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, i) +} + +func (s *Var_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Var_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Var_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVar_name(s) + } +} + +func (s *Var_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVar_name(s) + } +} + +func (s *Var_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVar_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Var_name() (localctx IVar_nameContext) { + localctx = NewVar_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, RedshiftParserRULE_var_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2670) + p.Colid() + } + p.SetState(2675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserDOT { + { + p.SetState(2671) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2672) + p.Colid() + } + + p.SetState(2677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVar_listContext is an interface to support dynamic dispatch. +type IVar_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllVar_value() []IVar_valueContext + Var_value(i int) IVar_valueContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsVar_listContext differentiates from other interfaces. + IsVar_listContext() +} + +type Var_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVar_listContext() *Var_listContext { + var p = new(Var_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_var_list + return p +} + +func InitEmptyVar_listContext(p *Var_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_var_list +} + +func (*Var_listContext) IsVar_listContext() {} + +func NewVar_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_listContext { + var p = new(Var_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_var_list + + return p +} + +func (s *Var_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Var_listContext) AllVar_value() []IVar_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVar_valueContext); ok { + len++ + } + } + + tst := make([]IVar_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVar_valueContext); ok { + tst[i] = t.(IVar_valueContext) + i++ + } + } + + return tst +} + +func (s *Var_listContext) Var_value(i int) IVar_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVar_valueContext) +} + +func (s *Var_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Var_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Var_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Var_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Var_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVar_list(s) + } +} + +func (s *Var_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVar_list(s) + } +} + +func (s *Var_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVar_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Var_list() (localctx IVar_listContext) { + localctx = NewVar_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, RedshiftParserRULE_var_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2678) + p.Var_value() + } + p.SetState(2683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 42, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2679) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2680) + p.Var_value() + } + + } + p.SetState(2685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 42, 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 +} + +// IVar_valueContext is an interface to support dynamic dispatch. +type IVar_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_boolean_or_string() IOpt_boolean_or_stringContext + Numericonly() INumericonlyContext + + // IsVar_valueContext differentiates from other interfaces. + IsVar_valueContext() +} + +type Var_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVar_valueContext() *Var_valueContext { + var p = new(Var_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_var_value + return p +} + +func InitEmptyVar_valueContext(p *Var_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_var_value +} + +func (*Var_valueContext) IsVar_valueContext() {} + +func NewVar_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Var_valueContext { + var p = new(Var_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_var_value + + return p +} + +func (s *Var_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Var_valueContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_boolean_or_stringContext) +} + +func (s *Var_valueContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Var_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Var_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Var_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVar_value(s) + } +} + +func (s *Var_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVar_value(s) + } +} + +func (s *Var_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVar_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Var_value() (localctx IVar_valueContext) { + localctx = NewVar_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, RedshiftParserRULE_var_value) + p.SetState(2688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2686) + p.Opt_boolean_or_string() + } + + case RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserIntegral, RedshiftParserNumeric: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2687) + p.Numericonly() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIso_levelContext is an interface to support dynamic dispatch. +type IIso_levelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READ() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + + // IsIso_levelContext differentiates from other interfaces. + IsIso_levelContext() +} + +type Iso_levelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIso_levelContext() *Iso_levelContext { + var p = new(Iso_levelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iso_level + return p +} + +func InitEmptyIso_levelContext(p *Iso_levelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iso_level +} + +func (*Iso_levelContext) IsIso_levelContext() {} + +func NewIso_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Iso_levelContext { + var p = new(Iso_levelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_iso_level + + return p +} + +func (s *Iso_levelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Iso_levelContext) READ() antlr.TerminalNode { + return s.GetToken(RedshiftParserREAD, 0) +} + +func (s *Iso_levelContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNCOMMITTED, 0) +} + +func (s *Iso_levelContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMITTED, 0) +} + +func (s *Iso_levelContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPEATABLE, 0) +} + +func (s *Iso_levelContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERIALIZABLE, 0) +} + +func (s *Iso_levelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Iso_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Iso_levelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIso_level(s) + } +} + +func (s *Iso_levelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIso_level(s) + } +} + +func (s *Iso_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIso_level(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Iso_level() (localctx IIso_levelContext) { + localctx = NewIso_levelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, RedshiftParserRULE_iso_level) + var _la int + + p.SetState(2695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserREAD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2690) + p.Match(RedshiftParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2691) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCOMMITTED || _la == RedshiftParserUNCOMMITTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserREPEATABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2692) + p.Match(RedshiftParserREPEATABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2693) + p.Match(RedshiftParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSERIALIZABLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2694) + p.Match(RedshiftParserSERIALIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_boolean_or_stringContext is an interface to support dynamic dispatch. +type IOpt_boolean_or_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUE_P() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + ON() antlr.TerminalNode + Nonreservedword_or_sconst() INonreservedword_or_sconstContext + + // IsOpt_boolean_or_stringContext differentiates from other interfaces. + IsOpt_boolean_or_stringContext() +} + +type Opt_boolean_or_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_boolean_or_stringContext() *Opt_boolean_or_stringContext { + var p = new(Opt_boolean_or_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_boolean_or_string + return p +} + +func InitEmptyOpt_boolean_or_stringContext(p *Opt_boolean_or_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_boolean_or_string +} + +func (*Opt_boolean_or_stringContext) IsOpt_boolean_or_stringContext() {} + +func NewOpt_boolean_or_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_boolean_or_stringContext { + var p = new(Opt_boolean_or_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_boolean_or_string + + return p +} + +func (s *Opt_boolean_or_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_boolean_or_stringContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *Opt_boolean_or_stringContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *Opt_boolean_or_stringContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Opt_boolean_or_stringContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedword_or_sconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedword_or_sconstContext) +} + +func (s *Opt_boolean_or_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_boolean_or_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_boolean_or_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_boolean_or_string(s) + } +} + +func (s *Opt_boolean_or_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_boolean_or_string(s) + } +} + +func (s *Opt_boolean_or_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_boolean_or_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_boolean_or_string() (localctx IOpt_boolean_or_stringContext) { + localctx = NewOpt_boolean_or_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, RedshiftParserRULE_opt_boolean_or_string) + p.SetState(2701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserTRUE_P: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2697) + p.Match(RedshiftParserTRUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFALSE_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2698) + p.Match(RedshiftParserFALSE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserON: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2699) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2700) + p.Nonreservedword_or_sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZone_valueContext is an interface to support dynamic dispatch. +type IZone_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + Identifier() IIdentifierContext + Constinterval() IConstintervalContext + Opt_interval() IOpt_intervalContext + OPEN_PAREN() antlr.TerminalNode + Iconst() IIconstContext + CLOSE_PAREN() antlr.TerminalNode + Numericonly() INumericonlyContext + DEFAULT() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsZone_valueContext differentiates from other interfaces. + IsZone_valueContext() +} + +type Zone_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZone_valueContext() *Zone_valueContext { + var p = new(Zone_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_zone_value + return p +} + +func InitEmptyZone_valueContext(p *Zone_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_zone_value +} + +func (*Zone_valueContext) IsZone_valueContext() {} + +func NewZone_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zone_valueContext { + var p = new(Zone_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_zone_value + + return p +} + +func (s *Zone_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zone_valueContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Zone_valueContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Zone_valueContext) Constinterval() IConstintervalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstintervalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstintervalContext) +} + +func (s *Zone_valueContext) Opt_interval() IOpt_intervalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_intervalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_intervalContext) +} + +func (s *Zone_valueContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Zone_valueContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Zone_valueContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Zone_valueContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Zone_valueContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Zone_valueContext) LOCAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCAL, 0) +} + +func (s *Zone_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zone_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zone_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterZone_value(s) + } +} + +func (s *Zone_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitZone_value(s) + } +} + +func (s *Zone_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitZone_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Zone_value() (localctx IZone_valueContext) { + localctx = NewZone_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, RedshiftParserRULE_zone_value) + var _la int + + p.SetState(2719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 47, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2703) + p.Sconst() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2704) + p.Identifier() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2705) + p.Constinterval() + } + { + p.SetState(2706) + p.Sconst() + } + p.SetState(2708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDAY_P || _la == RedshiftParserHOUR_P || _la == RedshiftParserMINUTE_P || _la == RedshiftParserMONTH_P || _la == RedshiftParserSECOND_P || _la == RedshiftParserYEAR_P { + { + p.SetState(2707) + p.Opt_interval() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2710) + p.Constinterval() + } + { + p.SetState(2711) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2712) + p.Iconst() + } + { + p.SetState(2713) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2714) + p.Sconst() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2716) + p.Numericonly() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2717) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2718) + p.Match(RedshiftParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_encodingContext is an interface to support dynamic dispatch. +type IOpt_encodingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + DEFAULT() antlr.TerminalNode + + // IsOpt_encodingContext differentiates from other interfaces. + IsOpt_encodingContext() +} + +type Opt_encodingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_encodingContext() *Opt_encodingContext { + var p = new(Opt_encodingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_encoding + return p +} + +func InitEmptyOpt_encodingContext(p *Opt_encodingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_encoding +} + +func (*Opt_encodingContext) IsOpt_encodingContext() {} + +func NewOpt_encodingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_encodingContext { + var p = new(Opt_encodingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_encoding + + return p +} + +func (s *Opt_encodingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_encodingContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Opt_encodingContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Opt_encodingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_encodingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_encodingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_encoding(s) + } +} + +func (s *Opt_encodingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_encoding(s) + } +} + +func (s *Opt_encodingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_encoding(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_encoding() (localctx IOpt_encodingContext) { + localctx = NewOpt_encodingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, RedshiftParserRULE_opt_encoding) + p.SetState(2723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2721) + p.Sconst() + } + + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2722) + p.Match(RedshiftParserDEFAULT) + 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 +} + +// INonreservedword_or_sconstContext is an interface to support dynamic dispatch. +type INonreservedword_or_sconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Nonreservedword() INonreservedwordContext + Sconst() ISconstContext + + // IsNonreservedword_or_sconstContext differentiates from other interfaces. + IsNonreservedword_or_sconstContext() +} + +type Nonreservedword_or_sconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNonreservedword_or_sconstContext() *Nonreservedword_or_sconstContext { + var p = new(Nonreservedword_or_sconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_nonreservedword_or_sconst + return p +} + +func InitEmptyNonreservedword_or_sconstContext(p *Nonreservedword_or_sconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_nonreservedword_or_sconst +} + +func (*Nonreservedword_or_sconstContext) IsNonreservedword_or_sconstContext() {} + +func NewNonreservedword_or_sconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nonreservedword_or_sconstContext { + var p = new(Nonreservedword_or_sconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_nonreservedword_or_sconst + + return p +} + +func (s *Nonreservedword_or_sconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nonreservedword_or_sconstContext) Nonreservedword() INonreservedwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedwordContext) +} + +func (s *Nonreservedword_or_sconstContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Nonreservedword_or_sconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nonreservedword_or_sconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nonreservedword_or_sconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNonreservedword_or_sconst(s) + } +} + +func (s *Nonreservedword_or_sconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNonreservedword_or_sconst(s) + } +} + +func (s *Nonreservedword_or_sconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNonreservedword_or_sconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Nonreservedword_or_sconst() (localctx INonreservedword_or_sconstContext) { + localctx = NewNonreservedword_or_sconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, RedshiftParserRULE_nonreservedword_or_sconst) + p.SetState(2727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2725) + p.Nonreservedword() + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2726) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariableresetstmtContext is an interface to support dynamic dispatch. +type IVariableresetstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESET() antlr.TerminalNode + Reset_rest() IReset_restContext + + // IsVariableresetstmtContext differentiates from other interfaces. + IsVariableresetstmtContext() +} + +type VariableresetstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariableresetstmtContext() *VariableresetstmtContext { + var p = new(VariableresetstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_variableresetstmt + return p +} + +func InitEmptyVariableresetstmtContext(p *VariableresetstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_variableresetstmt +} + +func (*VariableresetstmtContext) IsVariableresetstmtContext() {} + +func NewVariableresetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableresetstmtContext { + var p = new(VariableresetstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_variableresetstmt + + return p +} + +func (s *VariableresetstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariableresetstmtContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *VariableresetstmtContext) Reset_rest() IReset_restContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReset_restContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReset_restContext) +} + +func (s *VariableresetstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariableresetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariableresetstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVariableresetstmt(s) + } +} + +func (s *VariableresetstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVariableresetstmt(s) + } +} + +func (s *VariableresetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVariableresetstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Variableresetstmt() (localctx IVariableresetstmtContext) { + localctx = NewVariableresetstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, RedshiftParserRULE_variableresetstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2729) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2730) + p.Reset_rest() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReset_restContext is an interface to support dynamic dispatch. +type IReset_restContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generic_reset() IGeneric_resetContext + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + SESSION() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + + // IsReset_restContext differentiates from other interfaces. + IsReset_restContext() +} + +type Reset_restContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReset_restContext() *Reset_restContext { + var p = new(Reset_restContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reset_rest + return p +} + +func InitEmptyReset_restContext(p *Reset_restContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reset_rest +} + +func (*Reset_restContext) IsReset_restContext() {} + +func NewReset_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reset_restContext { + var p = new(Reset_restContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reset_rest + + return p +} + +func (s *Reset_restContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reset_restContext) Generic_reset() IGeneric_resetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_resetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_resetContext) +} + +func (s *Reset_restContext) TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIME, 0) +} + +func (s *Reset_restContext) ZONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserZONE, 0) +} + +func (s *Reset_restContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *Reset_restContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserISOLATION, 0) +} + +func (s *Reset_restContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *Reset_restContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *Reset_restContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHORIZATION, 0) +} + +func (s *Reset_restContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reset_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reset_restContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReset_rest(s) + } +} + +func (s *Reset_restContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReset_rest(s) + } +} + +func (s *Reset_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReset_rest(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reset_rest() (localctx IReset_restContext) { + localctx = NewReset_restContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, RedshiftParserRULE_reset_rest) + p.SetState(2740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 50, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2732) + p.Generic_reset() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2733) + p.Match(RedshiftParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2734) + p.Match(RedshiftParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2735) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2736) + p.Match(RedshiftParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2737) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2738) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2739) + p.Match(RedshiftParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_resetContext is an interface to support dynamic dispatch. +type IGeneric_resetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Var_name() IVar_nameContext + ALL() antlr.TerminalNode + + // IsGeneric_resetContext differentiates from other interfaces. + IsGeneric_resetContext() +} + +type Generic_resetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_resetContext() *Generic_resetContext { + var p = new(Generic_resetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_reset + return p +} + +func InitEmptyGeneric_resetContext(p *Generic_resetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_reset +} + +func (*Generic_resetContext) IsGeneric_resetContext() {} + +func NewGeneric_resetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_resetContext { + var p = new(Generic_resetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generic_reset + + return p +} + +func (s *Generic_resetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_resetContext) Var_name() IVar_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVar_nameContext) +} + +func (s *Generic_resetContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Generic_resetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_resetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_resetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGeneric_reset(s) + } +} + +func (s *Generic_resetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGeneric_reset(s) + } +} + +func (s *Generic_resetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGeneric_reset(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generic_reset() (localctx IGeneric_resetContext) { + localctx = NewGeneric_resetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, RedshiftParserRULE_generic_reset) + p.SetState(2744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2742) + p.Var_name() + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2743) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetresetclauseContext is an interface to support dynamic dispatch. +type ISetresetclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + Set_rest() ISet_restContext + Variableresetstmt() IVariableresetstmtContext + + // IsSetresetclauseContext differentiates from other interfaces. + IsSetresetclauseContext() +} + +type SetresetclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetresetclauseContext() *SetresetclauseContext { + var p = new(SetresetclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setresetclause + return p +} + +func InitEmptySetresetclauseContext(p *SetresetclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setresetclause +} + +func (*SetresetclauseContext) IsSetresetclauseContext() {} + +func NewSetresetclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetresetclauseContext { + var p = new(SetresetclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_setresetclause + + return p +} + +func (s *SetresetclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetresetclauseContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *SetresetclauseContext) Set_rest() ISet_restContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_restContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_restContext) +} + +func (s *SetresetclauseContext) Variableresetstmt() IVariableresetstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableresetstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableresetstmtContext) +} + +func (s *SetresetclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetresetclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetresetclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSetresetclause(s) + } +} + +func (s *SetresetclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSetresetclause(s) + } +} + +func (s *SetresetclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSetresetclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Setresetclause() (localctx ISetresetclauseContext) { + localctx = NewSetresetclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, RedshiftParserRULE_setresetclause) + p.SetState(2749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2746) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2747) + p.Set_rest() + } + + case RedshiftParserRESET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2748) + p.Variableresetstmt() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunctionsetresetclauseContext is an interface to support dynamic dispatch. +type IFunctionsetresetclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + Set_rest_more() ISet_rest_moreContext + Variableresetstmt() IVariableresetstmtContext + + // IsFunctionsetresetclauseContext differentiates from other interfaces. + IsFunctionsetresetclauseContext() +} + +type FunctionsetresetclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunctionsetresetclauseContext() *FunctionsetresetclauseContext { + var p = new(FunctionsetresetclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_functionsetresetclause + return p +} + +func InitEmptyFunctionsetresetclauseContext(p *FunctionsetresetclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_functionsetresetclause +} + +func (*FunctionsetresetclauseContext) IsFunctionsetresetclauseContext() {} + +func NewFunctionsetresetclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionsetresetclauseContext { + var p = new(FunctionsetresetclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_functionsetresetclause + + return p +} + +func (s *FunctionsetresetclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FunctionsetresetclauseContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *FunctionsetresetclauseContext) Set_rest_more() ISet_rest_moreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_rest_moreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_rest_moreContext) +} + +func (s *FunctionsetresetclauseContext) Variableresetstmt() IVariableresetstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariableresetstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariableresetstmtContext) +} + +func (s *FunctionsetresetclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FunctionsetresetclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FunctionsetresetclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunctionsetresetclause(s) + } +} + +func (s *FunctionsetresetclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunctionsetresetclause(s) + } +} + +func (s *FunctionsetresetclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunctionsetresetclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Functionsetresetclause() (localctx IFunctionsetresetclauseContext) { + localctx = NewFunctionsetresetclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, RedshiftParserRULE_functionsetresetclause) + p.SetState(2754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2751) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2752) + p.Set_rest_more() + } + + case RedshiftParserRESET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2753) + p.Variableresetstmt() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariableshowstmtContext is an interface to support dynamic dispatch. +type IVariableshowstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + Var_name() IVar_nameContext + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + SESSION() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + CURRENT_SCHEMA() antlr.TerminalNode + SESSION_USER() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsVariableshowstmtContext differentiates from other interfaces. + IsVariableshowstmtContext() +} + +type VariableshowstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariableshowstmtContext() *VariableshowstmtContext { + var p = new(VariableshowstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_variableshowstmt + return p +} + +func InitEmptyVariableshowstmtContext(p *VariableshowstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_variableshowstmt +} + +func (*VariableshowstmtContext) IsVariableshowstmtContext() {} + +func NewVariableshowstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableshowstmtContext { + var p = new(VariableshowstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_variableshowstmt + + return p +} + +func (s *VariableshowstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *VariableshowstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *VariableshowstmtContext) Var_name() IVar_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVar_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVar_nameContext) +} + +func (s *VariableshowstmtContext) TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIME, 0) +} + +func (s *VariableshowstmtContext) ZONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserZONE, 0) +} + +func (s *VariableshowstmtContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *VariableshowstmtContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserISOLATION, 0) +} + +func (s *VariableshowstmtContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *VariableshowstmtContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *VariableshowstmtContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHORIZATION, 0) +} + +func (s *VariableshowstmtContext) CURRENT_SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_SCHEMA, 0) +} + +func (s *VariableshowstmtContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_USER, 0) +} + +func (s *VariableshowstmtContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_USER, 0) +} + +func (s *VariableshowstmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *VariableshowstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VariableshowstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VariableshowstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVariableshowstmt(s) + } +} + +func (s *VariableshowstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVariableshowstmt(s) + } +} + +func (s *VariableshowstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVariableshowstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Variableshowstmt() (localctx IVariableshowstmtContext) { + localctx = NewVariableshowstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, RedshiftParserRULE_variableshowstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2756) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 54, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2757) + p.Var_name() + } + + case 2: + { + p.SetState(2758) + p.Match(RedshiftParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2759) + p.Match(RedshiftParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(2760) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2761) + p.Match(RedshiftParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2762) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(2763) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2764) + p.Match(RedshiftParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(2765) + p.Match(RedshiftParserCURRENT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(2766) + p.Match(RedshiftParserSESSION_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + { + p.SetState(2767) + p.Match(RedshiftParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(2768) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraintssetstmtContext is an interface to support dynamic dispatch. +type IConstraintssetstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + Constraints_set_list() IConstraints_set_listContext + Constraints_set_mode() IConstraints_set_modeContext + + // IsConstraintssetstmtContext differentiates from other interfaces. + IsConstraintssetstmtContext() +} + +type ConstraintssetstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraintssetstmtContext() *ConstraintssetstmtContext { + var p = new(ConstraintssetstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintssetstmt + return p +} + +func InitEmptyConstraintssetstmtContext(p *ConstraintssetstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintssetstmt +} + +func (*ConstraintssetstmtContext) IsConstraintssetstmtContext() {} + +func NewConstraintssetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintssetstmtContext { + var p = new(ConstraintssetstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constraintssetstmt + + return p +} + +func (s *ConstraintssetstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstraintssetstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *ConstraintssetstmtContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINTS, 0) +} + +func (s *ConstraintssetstmtContext) Constraints_set_list() IConstraints_set_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraints_set_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraints_set_listContext) +} + +func (s *ConstraintssetstmtContext) Constraints_set_mode() IConstraints_set_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraints_set_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraints_set_modeContext) +} + +func (s *ConstraintssetstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintssetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstraintssetstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstraintssetstmt(s) + } +} + +func (s *ConstraintssetstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstraintssetstmt(s) + } +} + +func (s *ConstraintssetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstraintssetstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constraintssetstmt() (localctx IConstraintssetstmtContext) { + localctx = NewConstraintssetstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, RedshiftParserRULE_constraintssetstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2771) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2772) + p.Match(RedshiftParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2773) + p.Constraints_set_list() + } + { + p.SetState(2774) + p.Constraints_set_mode() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraints_set_listContext is an interface to support dynamic dispatch. +type IConstraints_set_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + + // IsConstraints_set_listContext differentiates from other interfaces. + IsConstraints_set_listContext() +} + +type Constraints_set_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraints_set_listContext() *Constraints_set_listContext { + var p = new(Constraints_set_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraints_set_list + return p +} + +func InitEmptyConstraints_set_listContext(p *Constraints_set_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraints_set_list +} + +func (*Constraints_set_listContext) IsConstraints_set_listContext() {} + +func NewConstraints_set_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraints_set_listContext { + var p = new(Constraints_set_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constraints_set_list + + return p +} + +func (s *Constraints_set_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraints_set_listContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Constraints_set_listContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Constraints_set_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraints_set_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraints_set_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstraints_set_list(s) + } +} + +func (s *Constraints_set_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstraints_set_list(s) + } +} + +func (s *Constraints_set_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstraints_set_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constraints_set_list() (localctx IConstraints_set_listContext) { + localctx = NewConstraints_set_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, RedshiftParserRULE_constraints_set_list) + p.SetState(2778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2776) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2777) + p.Qualified_name_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraints_set_modeContext is an interface to support dynamic dispatch. +type IConstraints_set_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFERRED() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + + // IsConstraints_set_modeContext differentiates from other interfaces. + IsConstraints_set_modeContext() +} + +type Constraints_set_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraints_set_modeContext() *Constraints_set_modeContext { + var p = new(Constraints_set_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraints_set_mode + return p +} + +func InitEmptyConstraints_set_modeContext(p *Constraints_set_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraints_set_mode +} + +func (*Constraints_set_modeContext) IsConstraints_set_modeContext() {} + +func NewConstraints_set_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraints_set_modeContext { + var p = new(Constraints_set_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constraints_set_mode + + return p +} + +func (s *Constraints_set_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraints_set_modeContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRED, 0) +} + +func (s *Constraints_set_modeContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMEDIATE, 0) +} + +func (s *Constraints_set_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraints_set_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraints_set_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstraints_set_mode(s) + } +} + +func (s *Constraints_set_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstraints_set_mode(s) + } +} + +func (s *Constraints_set_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstraints_set_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constraints_set_mode() (localctx IConstraints_set_modeContext) { + localctx = NewConstraints_set_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, RedshiftParserRULE_constraints_set_mode) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2780) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserDEFERRED || _la == RedshiftParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheckpointstmtContext is an interface to support dynamic dispatch. +type ICheckpointstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECKPOINT() antlr.TerminalNode + + // IsCheckpointstmtContext differentiates from other interfaces. + IsCheckpointstmtContext() +} + +type CheckpointstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheckpointstmtContext() *CheckpointstmtContext { + var p = new(CheckpointstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_checkpointstmt + return p +} + +func InitEmptyCheckpointstmtContext(p *CheckpointstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_checkpointstmt +} + +func (*CheckpointstmtContext) IsCheckpointstmtContext() {} + +func NewCheckpointstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CheckpointstmtContext { + var p = new(CheckpointstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_checkpointstmt + + return p +} + +func (s *CheckpointstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CheckpointstmtContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECKPOINT, 0) +} + +func (s *CheckpointstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CheckpointstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CheckpointstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCheckpointstmt(s) + } +} + +func (s *CheckpointstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCheckpointstmt(s) + } +} + +func (s *CheckpointstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCheckpointstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Checkpointstmt() (localctx ICheckpointstmtContext) { + localctx = NewCheckpointstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, RedshiftParserRULE_checkpointstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2782) + p.Match(RedshiftParserCHECKPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiscardstmtContext is an interface to support dynamic dispatch. +type IDiscardstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISCARD() antlr.TerminalNode + ALL() antlr.TerminalNode + TEMP() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + PLANS() antlr.TerminalNode + SEQUENCES() antlr.TerminalNode + + // IsDiscardstmtContext differentiates from other interfaces. + IsDiscardstmtContext() +} + +type DiscardstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiscardstmtContext() *DiscardstmtContext { + var p = new(DiscardstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_discardstmt + return p +} + +func InitEmptyDiscardstmtContext(p *DiscardstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_discardstmt +} + +func (*DiscardstmtContext) IsDiscardstmtContext() {} + +func NewDiscardstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DiscardstmtContext { + var p = new(DiscardstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_discardstmt + + return p +} + +func (s *DiscardstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DiscardstmtContext) DISCARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISCARD, 0) +} + +func (s *DiscardstmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *DiscardstmtContext) TEMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMP, 0) +} + +func (s *DiscardstmtContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPORARY, 0) +} + +func (s *DiscardstmtContext) PLANS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLANS, 0) +} + +func (s *DiscardstmtContext) SEQUENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCES, 0) +} + +func (s *DiscardstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DiscardstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DiscardstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDiscardstmt(s) + } +} + +func (s *DiscardstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDiscardstmt(s) + } +} + +func (s *DiscardstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDiscardstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Discardstmt() (localctx IDiscardstmtContext) { + localctx = NewDiscardstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, RedshiftParserRULE_discardstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2784) + p.Match(RedshiftParserDISCARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2785) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || _la == RedshiftParserPLANS || _la == RedshiftParserSEQUENCES || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltertablestmtContext is an interface to support dynamic dispatch. +type IAltertablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TABLE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + AllAlter_table_cmds() []IAlter_table_cmdsContext + Alter_table_cmds(i int) IAlter_table_cmdsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAltertablestmtContext differentiates from other interfaces. + IsAltertablestmtContext() +} + +type AltertablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltertablestmtContext() *AltertablestmtContext { + var p = new(AltertablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertablestmt + return p +} + +func InitEmptyAltertablestmtContext(p *AltertablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertablestmt +} + +func (*AltertablestmtContext) IsAltertablestmtContext() {} + +func NewAltertablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertablestmtContext { + var p = new(AltertablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altertablestmt + + return p +} + +func (s *AltertablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltertablestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltertablestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *AltertablestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AltertablestmtContext) AllAlter_table_cmds() []IAlter_table_cmdsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_table_cmdsContext); ok { + len++ + } + } + + tst := make([]IAlter_table_cmdsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_table_cmdsContext); ok { + tst[i] = t.(IAlter_table_cmdsContext) + i++ + } + } + + return tst +} + +func (s *AltertablestmtContext) Alter_table_cmds(i int) IAlter_table_cmdsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_cmdsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_cmdsContext) +} + +func (s *AltertablestmtContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *AltertablestmtContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *AltertablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltertablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltertablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltertablestmt(s) + } +} + +func (s *AltertablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltertablestmt(s) + } +} + +func (s *AltertablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltertablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altertablestmt() (localctx IAltertablestmtContext) { + localctx = NewAltertablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, RedshiftParserRULE_altertablestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2787) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2788) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2789) + p.Qualified_name() + } + { + p.SetState(2790) + p.Alter_table_cmds() + } + p.SetState(2795) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(2791) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2792) + p.Alter_table_cmds() + } + + p.SetState(2797) + 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_table_cmdsContext is an interface to support dynamic dispatch. +type IAlter_table_cmdsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD_P() antlr.TerminalNode + Table_constraint() ITable_constraintContext + DROP() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + RESTRICT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + OWNER() antlr.TerminalNode + TO() antlr.TerminalNode + Rolespec() IRolespecContext + RENAME() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ALTER() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + Typename() ITypenameContext + ENCODE() antlr.TerminalNode + DISTKEY() antlr.TerminalNode + DISTSTYLE() antlr.TerminalNode + ALL() antlr.TerminalNode + EVEN() antlr.TerminalNode + KEY() antlr.TerminalNode + AUTO() antlr.TerminalNode + SORTKEY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + COMPOUND() antlr.TerminalNode + NONE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + NULL_P() antlr.TerminalNode + COLLATE() antlr.TerminalNode + CASE_SENSITIVE() antlr.TerminalNode + CS() antlr.TerminalNode + CASE_INSENSITIVE() antlr.TerminalNode + CI() antlr.TerminalNode + NOT() antlr.TerminalNode + ROW() antlr.TerminalNode + LEVEL() antlr.TerminalNode + SECURITY() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + CONJUNCTION() antlr.TerminalNode + FOR() antlr.TerminalNode + DATASHARES() antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + MASKING() antlr.TerminalNode + APPEND() antlr.TerminalNode + FROM() antlr.TerminalNode + Qualified_name() IQualified_nameContext + IGNOREEXTRA() antlr.TerminalNode + FILLTARGET() antlr.TerminalNode + SET() antlr.TerminalNode + LOCATION() antlr.TerminalNode + StringConstant() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + TABLE() antlr.TerminalNode + PROPERTIES() antlr.TerminalNode + Table_properties_list() ITable_properties_listContext + PARTITION() antlr.TerminalNode + AllEQUAL() []antlr.TerminalNode + EQUAL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Opt_if_not_exists() IOpt_if_not_existsContext + + // IsAlter_table_cmdsContext differentiates from other interfaces. + IsAlter_table_cmdsContext() +} + +type Alter_table_cmdsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_cmdsContext() *Alter_table_cmdsContext { + var p = new(Alter_table_cmdsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_table_cmds + return p +} + +func InitEmptyAlter_table_cmdsContext(p *Alter_table_cmdsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_table_cmds +} + +func (*Alter_table_cmdsContext) IsAlter_table_cmdsContext() {} + +func NewAlter_table_cmdsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_cmdsContext { + var p = new(Alter_table_cmdsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_table_cmds + + return p +} + +func (s *Alter_table_cmdsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_cmdsContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *Alter_table_cmdsContext) Table_constraint() ITable_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_constraintContext) +} + +func (s *Alter_table_cmdsContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Alter_table_cmdsContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *Alter_table_cmdsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_cmdsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Alter_table_cmdsContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *Alter_table_cmdsContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *Alter_table_cmdsContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *Alter_table_cmdsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Alter_table_cmdsContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Alter_table_cmdsContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *Alter_table_cmdsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMN, 0) +} + +func (s *Alter_table_cmdsContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Alter_table_cmdsContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Alter_table_cmdsContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Alter_table_cmdsContext) ENCODE() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODE, 0) +} + +func (s *Alter_table_cmdsContext) DISTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTKEY, 0) +} + +func (s *Alter_table_cmdsContext) DISTSTYLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTSTYLE, 0) +} + +func (s *Alter_table_cmdsContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Alter_table_cmdsContext) EVEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVEN, 0) +} + +func (s *Alter_table_cmdsContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *Alter_table_cmdsContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *Alter_table_cmdsContext) SORTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSORTKEY, 0) +} + +func (s *Alter_table_cmdsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Alter_table_cmdsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Alter_table_cmdsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Alter_table_cmdsContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPOUND, 0) +} + +func (s *Alter_table_cmdsContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *Alter_table_cmdsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Alter_table_cmdsContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_cmdsContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Alter_table_cmdsContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Alter_table_cmdsContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Alter_table_cmdsContext) CASE_SENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_SENSITIVE, 0) +} + +func (s *Alter_table_cmdsContext) CS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCS, 0) +} + +func (s *Alter_table_cmdsContext) CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_INSENSITIVE, 0) +} + +func (s *Alter_table_cmdsContext) CI() antlr.TerminalNode { + return s.GetToken(RedshiftParserCI, 0) +} + +func (s *Alter_table_cmdsContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Alter_table_cmdsContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Alter_table_cmdsContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *Alter_table_cmdsContext) SECURITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECURITY, 0) +} + +func (s *Alter_table_cmdsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Alter_table_cmdsContext) OFF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFF, 0) +} + +func (s *Alter_table_cmdsContext) CONJUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONJUNCTION, 0) +} + +func (s *Alter_table_cmdsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Alter_table_cmdsContext) DATASHARES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARES, 0) +} + +func (s *Alter_table_cmdsContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Alter_table_cmdsContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *Alter_table_cmdsContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *Alter_table_cmdsContext) APPEND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAPPEND, 0) +} + +func (s *Alter_table_cmdsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Alter_table_cmdsContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Alter_table_cmdsContext) IGNOREEXTRA() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNOREEXTRA, 0) +} + +func (s *Alter_table_cmdsContext) FILLTARGET() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILLTARGET, 0) +} + +func (s *Alter_table_cmdsContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Alter_table_cmdsContext) LOCATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCATION, 0) +} + +func (s *Alter_table_cmdsContext) StringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserStringConstant, 0) +} + +func (s *Alter_table_cmdsContext) FILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILE, 0) +} + +func (s *Alter_table_cmdsContext) FORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORMAT, 0) +} + +func (s *Alter_table_cmdsContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Alter_table_cmdsContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROPERTIES, 0) +} + +func (s *Alter_table_cmdsContext) Table_properties_list() ITable_properties_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_properties_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_properties_listContext) +} + +func (s *Alter_table_cmdsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *Alter_table_cmdsContext) AllEQUAL() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserEQUAL) +} + +func (s *Alter_table_cmdsContext) EQUAL(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, i) +} + +func (s *Alter_table_cmdsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Alter_table_cmdsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Alter_table_cmdsContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *Alter_table_cmdsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_cmdsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_cmdsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_table_cmds(s) + } +} + +func (s *Alter_table_cmdsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_table_cmds(s) + } +} + +func (s *Alter_table_cmdsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_table_cmds(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_table_cmds() (localctx IAlter_table_cmdsContext) { + localctx = NewAlter_table_cmdsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, RedshiftParserRULE_alter_table_cmds) + var _la int + + p.SetState(2998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 74, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2798) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2799) + p.Table_constraint() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2800) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2801) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2802) + p.Colid() + } + p.SetState(2804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(2803) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2806) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2807) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2808) + p.Rolespec() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2809) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2810) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2811) + p.Colid() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2812) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2813) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2814) + p.Colid() + } + { + p.SetState(2815) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2816) + p.Colid() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2818) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2819) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2820) + p.Colid() + } + { + p.SetState(2821) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2822) + p.Typename() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2824) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2825) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2826) + p.Colid() + } + { + p.SetState(2827) + p.Match(RedshiftParserENCODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2828) + p.Colid() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2830) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2831) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2832) + p.Colid() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2833) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2834) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2835) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2836) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2837) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2838) + p.Match(RedshiftParserEVEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2839) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2840) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2841) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2842) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2843) + p.Colid() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2844) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2845) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2846) + p.Match(RedshiftParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2847) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMPOUND { + { + p.SetState(2848) + p.Match(RedshiftParserCOMPOUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2851) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2852) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2853) + p.Columnlist() + } + { + p.SetState(2854) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2856) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2857) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2858) + p.Match(RedshiftParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2859) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2860) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2861) + p.Match(RedshiftParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2862) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2863) + p.Match(RedshiftParserENCODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2864) + p.Match(RedshiftParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2865) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2867) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext()) == 1 { + { + p.SetState(2866) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2869) + p.Colid() + } + { + p.SetState(2870) + p.Typename() + } + p.SetState(2873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDEFAULT { + { + p.SetState(2871) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2872) + p.A_expr() + } + + } + p.SetState(2877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserENCODE { + { + p.SetState(2875) + p.Match(RedshiftParserENCODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2876) + p.Colid() + } + + } + p.SetState(2883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT || _la == RedshiftParserNULL_P { + p.SetState(2880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(2879) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2882) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLLATE { + { + p.SetState(2885) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2886) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCI || _la == RedshiftParserCS || _la == RedshiftParserCASE_SENSITIVE || _la == RedshiftParserCASE_INSENSITIVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2889) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2891) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 65, p.GetParserRuleContext()) == 1 { + { + p.SetState(2890) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2893) + p.Colid() + } + p.SetState(2895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(2894) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2897) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2898) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2899) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2900) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserON || _la == RedshiftParserOFF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONJUNCTION { + { + p.SetState(2901) + p.Match(RedshiftParserCONJUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2902) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2903) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserAND || _la == RedshiftParserOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(2908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(2906) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2907) + p.Match(RedshiftParserDATASHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2910) + p.Match(RedshiftParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2911) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserON || _la == RedshiftParserOFF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2912) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2913) + p.Match(RedshiftParserDATASHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2914) + p.Match(RedshiftParserAPPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2915) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2916) + p.Qualified_name() + } + p.SetState(2918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFILLTARGET || _la == RedshiftParserIGNOREEXTRA { + { + p.SetState(2917) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFILLTARGET || _la == RedshiftParserIGNOREEXTRA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2920) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2921) + p.Match(RedshiftParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2922) + p.Match(RedshiftParserStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2923) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2924) + p.Match(RedshiftParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2925) + p.Match(RedshiftParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2926) + p.Colid() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2927) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2928) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2929) + p.Match(RedshiftParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2930) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2931) + p.Table_properties_list() + } + { + p.SetState(2932) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2934) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2935) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2936) + p.Colid() + } + { + p.SetState(2937) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2938) + p.A_expr() + } + + p.SetState(2947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(2940) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2941) + p.Colid() + } + { + p.SetState(2942) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2943) + p.A_expr() + } + + p.SetState(2949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(2950) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2951) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2952) + p.Match(RedshiftParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2953) + p.Match(RedshiftParserStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2955) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIF_P { + { + p.SetState(2956) + p.Opt_if_not_exists() + } + + } + { + p.SetState(2959) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2960) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2961) + p.Colid() + } + { + p.SetState(2962) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2963) + p.A_expr() + } + + p.SetState(2972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(2965) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2966) + p.Colid() + } + { + p.SetState(2967) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2968) + p.A_expr() + } + + p.SetState(2974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(2975) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2976) + p.Match(RedshiftParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2977) + p.Match(RedshiftParserStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2979) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2980) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2981) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2982) + p.Colid() + } + { + p.SetState(2983) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2984) + p.A_expr() + } + + p.SetState(2993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(2986) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2987) + p.Colid() + } + { + p.SetState(2988) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2989) + p.A_expr() + } + + p.SetState(2995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(2996) + p.Match(RedshiftParserCLOSE_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_constraintContext is an interface to support dynamic dispatch. +type ITable_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRAINT() antlr.TerminalNode + Colid() IColidContext + UNIQUE() antlr.TerminalNode + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + AllColumnlist() []IColumnlistContext + Columnlist(i int) IColumnlistContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + Qualified_name() IQualified_nameContext + + // IsTable_constraintContext differentiates from other interfaces. + IsTable_constraintContext() +} + +type Table_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_constraintContext() *Table_constraintContext { + var p = new(Table_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_constraint + return p +} + +func InitEmptyTable_constraintContext(p *Table_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_constraint +} + +func (*Table_constraintContext) IsTable_constraintContext() {} + +func NewTable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_constraintContext { + var p = new(Table_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_constraint + + return p +} + +func (s *Table_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *Table_constraintContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Table_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIQUE, 0) +} + +func (s *Table_constraintContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *Table_constraintContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *Table_constraintContext) AllColumnlist() []IColumnlistContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnlistContext); ok { + len++ + } + } + + tst := make([]IColumnlistContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnlistContext); ok { + tst[i] = t.(IColumnlistContext) + i++ + } + } + + return tst +} + +func (s *Table_constraintContext) Columnlist(i int) IColumnlistContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Table_constraintContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *Table_constraintContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *Table_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIMARY, 0) +} + +func (s *Table_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *Table_constraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *Table_constraintContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCES, 0) +} + +func (s *Table_constraintContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Table_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_constraint(s) + } +} + +func (s *Table_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_constraint(s) + } +} + +func (s *Table_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_constraint() (localctx ITable_constraintContext) { + localctx = NewTable_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, RedshiftParserRULE_table_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONSTRAINT { + { + p.SetState(3000) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3001) + p.Colid() + } + + } + p.SetState(3026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserUNIQUE: + { + p.SetState(3004) + p.Match(RedshiftParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3005) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3006) + p.Columnlist() + } + { + p.SetState(3007) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserPRIMARY: + { + p.SetState(3009) + p.Match(RedshiftParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3010) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3011) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3012) + p.Columnlist() + } + { + p.SetState(3013) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFOREIGN: + { + p.SetState(3015) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3016) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3017) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3018) + p.Columnlist() + } + { + p.SetState(3019) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3020) + p.Match(RedshiftParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3021) + p.Qualified_name() + } + { + p.SetState(3022) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3023) + p.Columnlist() + } + { + p.SetState(3024) + p.Match(RedshiftParserCLOSE_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 +} + +// IPartition_cmdContext is an interface to support dynamic dispatch. +type IPartition_cmdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTACH() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Partitionboundspec() IPartitionboundspecContext + DETACH() antlr.TerminalNode + + // IsPartition_cmdContext differentiates from other interfaces. + IsPartition_cmdContext() +} + +type Partition_cmdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_cmdContext() *Partition_cmdContext { + var p = new(Partition_cmdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partition_cmd + return p +} + +func InitEmptyPartition_cmdContext(p *Partition_cmdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partition_cmd +} + +func (*Partition_cmdContext) IsPartition_cmdContext() {} + +func NewPartition_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_cmdContext { + var p = new(Partition_cmdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_partition_cmd + + return p +} + +func (s *Partition_cmdContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_cmdContext) ATTACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTACH, 0) +} + +func (s *Partition_cmdContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *Partition_cmdContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Partition_cmdContext) Partitionboundspec() IPartitionboundspecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionboundspecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionboundspecContext) +} + +func (s *Partition_cmdContext) DETACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserDETACH, 0) +} + +func (s *Partition_cmdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_cmdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPartition_cmd(s) + } +} + +func (s *Partition_cmdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPartition_cmd(s) + } +} + +func (s *Partition_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPartition_cmd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Partition_cmd() (localctx IPartition_cmdContext) { + localctx = NewPartition_cmdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, RedshiftParserRULE_partition_cmd) + p.SetState(3036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserATTACH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3028) + p.Match(RedshiftParserATTACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3029) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3030) + p.Qualified_name() + } + { + p.SetState(3031) + p.Partitionboundspec() + } + + case RedshiftParserDETACH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3033) + p.Match(RedshiftParserDETACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3034) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3035) + p.Qualified_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_partition_cmdContext is an interface to support dynamic dispatch. +type IIndex_partition_cmdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTACH() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Qualified_name() IQualified_nameContext + + // IsIndex_partition_cmdContext differentiates from other interfaces. + IsIndex_partition_cmdContext() +} + +type Index_partition_cmdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_partition_cmdContext() *Index_partition_cmdContext { + var p = new(Index_partition_cmdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_partition_cmd + return p +} + +func InitEmptyIndex_partition_cmdContext(p *Index_partition_cmdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_partition_cmd +} + +func (*Index_partition_cmdContext) IsIndex_partition_cmdContext() {} + +func NewIndex_partition_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partition_cmdContext { + var p = new(Index_partition_cmdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_index_partition_cmd + + return p +} + +func (s *Index_partition_cmdContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_partition_cmdContext) ATTACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTACH, 0) +} + +func (s *Index_partition_cmdContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *Index_partition_cmdContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Index_partition_cmdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_partition_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_partition_cmdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndex_partition_cmd(s) + } +} + +func (s *Index_partition_cmdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndex_partition_cmd(s) + } +} + +func (s *Index_partition_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndex_partition_cmd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Index_partition_cmd() (localctx IIndex_partition_cmdContext) { + localctx = NewIndex_partition_cmdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, RedshiftParserRULE_index_partition_cmd) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3038) + p.Match(RedshiftParserATTACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3039) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3040) + p.Qualified_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_table_cmdContext is an interface to support dynamic dispatch. +type IAlter_table_cmdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD_P() antlr.TerminalNode + ColumnDef() IColumnDefContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ALTER() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + Alter_column_default() IAlter_column_defaultContext + Opt_column() IOpt_columnContext + DROP() antlr.TerminalNode + NULL_P() antlr.TerminalNode + SET() antlr.TerminalNode + EXPRESSION() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + Signediconst() ISignediconstContext + Iconst() IIconstContext + Reloptions() IReloptionsContext + RESET() antlr.TerminalNode + STORAGE() antlr.TerminalNode + GENERATED() antlr.TerminalNode + Generated_when() IGenerated_whenContext + AS() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext + Alter_identity_column_option_list() IAlter_identity_column_option_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + TYPE_P() antlr.TerminalNode + Typename() ITypenameContext + Opt_set_data() IOpt_set_dataContext + Opt_collate_clause() IOpt_collate_clauseContext + Alter_using() IAlter_usingContext + Alter_generic_options() IAlter_generic_optionsContext + Tableconstraint() ITableconstraintContext + CONSTRAINT() antlr.TerminalNode + Name() INameContext + Constraintattributespec() IConstraintattributespecContext + VALIDATE() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + OIDS() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + ON() antlr.TerminalNode + LOGGED() antlr.TerminalNode + UNLOGGED() antlr.TerminalNode + ENABLE_P() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + REPLICA() antlr.TerminalNode + ALL() antlr.TerminalNode + USER() antlr.TerminalNode + DISABLE_P() antlr.TerminalNode + RULE() antlr.TerminalNode + INHERIT() antlr.TerminalNode + Qualified_name() IQualified_nameContext + NO() antlr.TerminalNode + OF() antlr.TerminalNode + Any_name() IAny_nameContext + OWNER() antlr.TerminalNode + TO() antlr.TerminalNode + Rolespec() IRolespecContext + ACCESS() antlr.TerminalNode + METHOD() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Replica_identity() IReplica_identityContext + ROW() antlr.TerminalNode + LEVEL() antlr.TerminalNode + SECURITY() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsAlter_table_cmdContext differentiates from other interfaces. + IsAlter_table_cmdContext() +} + +type Alter_table_cmdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_cmdContext() *Alter_table_cmdContext { + var p = new(Alter_table_cmdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_table_cmd + return p +} + +func InitEmptyAlter_table_cmdContext(p *Alter_table_cmdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_table_cmd +} + +func (*Alter_table_cmdContext) IsAlter_table_cmdContext() {} + +func NewAlter_table_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_cmdContext { + var p = new(Alter_table_cmdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_table_cmd + + return p +} + +func (s *Alter_table_cmdContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_cmdContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *Alter_table_cmdContext) ColumnDef() IColumnDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefContext) +} + +func (s *Alter_table_cmdContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *Alter_table_cmdContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Alter_table_cmdContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *Alter_table_cmdContext) COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMN, 0) +} + +func (s *Alter_table_cmdContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Alter_table_cmdContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_cmdContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Alter_table_cmdContext) Alter_column_default() IAlter_column_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_column_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_column_defaultContext) +} + +func (s *Alter_table_cmdContext) Opt_column() IOpt_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_columnContext) +} + +func (s *Alter_table_cmdContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Alter_table_cmdContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Alter_table_cmdContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Alter_table_cmdContext) EXPRESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPRESSION, 0) +} + +func (s *Alter_table_cmdContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *Alter_table_cmdContext) Signediconst() ISignediconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignediconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignediconstContext) +} + +func (s *Alter_table_cmdContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Alter_table_cmdContext) Reloptions() IReloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReloptionsContext) +} + +func (s *Alter_table_cmdContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *Alter_table_cmdContext) STORAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTORAGE, 0) +} + +func (s *Alter_table_cmdContext) GENERATED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGENERATED, 0) +} + +func (s *Alter_table_cmdContext) Generated_when() IGenerated_whenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_whenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_whenContext) +} + +func (s *Alter_table_cmdContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Alter_table_cmdContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *Alter_table_cmdContext) Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptparenthesizedseqoptlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptparenthesizedseqoptlistContext) +} + +func (s *Alter_table_cmdContext) Alter_identity_column_option_list() IAlter_identity_column_option_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_identity_column_option_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_identity_column_option_listContext) +} + +func (s *Alter_table_cmdContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Alter_table_cmdContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Alter_table_cmdContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Alter_table_cmdContext) Opt_set_data() IOpt_set_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_set_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_set_dataContext) +} + +func (s *Alter_table_cmdContext) Opt_collate_clause() IOpt_collate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_collate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_collate_clauseContext) +} + +func (s *Alter_table_cmdContext) Alter_using() IAlter_usingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_usingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_usingContext) +} + +func (s *Alter_table_cmdContext) Alter_generic_options() IAlter_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_generic_optionsContext) +} + +func (s *Alter_table_cmdContext) Tableconstraint() ITableconstraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableconstraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableconstraintContext) +} + +func (s *Alter_table_cmdContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *Alter_table_cmdContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Alter_table_cmdContext) Constraintattributespec() IConstraintattributespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintattributespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintattributespecContext) +} + +func (s *Alter_table_cmdContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALIDATE, 0) +} + +func (s *Alter_table_cmdContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHOUT, 0) +} + +func (s *Alter_table_cmdContext) OIDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOIDS, 0) +} + +func (s *Alter_table_cmdContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLUSTER, 0) +} + +func (s *Alter_table_cmdContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Alter_table_cmdContext) LOGGED() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOGGED, 0) +} + +func (s *Alter_table_cmdContext) UNLOGGED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLOGGED, 0) +} + +func (s *Alter_table_cmdContext) ENABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserENABLE_P, 0) +} + +func (s *Alter_table_cmdContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *Alter_table_cmdContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(RedshiftParserALWAYS, 0) +} + +func (s *Alter_table_cmdContext) REPLICA() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLICA, 0) +} + +func (s *Alter_table_cmdContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Alter_table_cmdContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *Alter_table_cmdContext) DISABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISABLE_P, 0) +} + +func (s *Alter_table_cmdContext) RULE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRULE, 0) +} + +func (s *Alter_table_cmdContext) INHERIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINHERIT, 0) +} + +func (s *Alter_table_cmdContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Alter_table_cmdContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Alter_table_cmdContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *Alter_table_cmdContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Alter_table_cmdContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *Alter_table_cmdContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Alter_table_cmdContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Alter_table_cmdContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *Alter_table_cmdContext) METHOD() antlr.TerminalNode { + return s.GetToken(RedshiftParserMETHOD, 0) +} + +func (s *Alter_table_cmdContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *Alter_table_cmdContext) Replica_identity() IReplica_identityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplica_identityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplica_identityContext) +} + +func (s *Alter_table_cmdContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Alter_table_cmdContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *Alter_table_cmdContext) SECURITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECURITY, 0) +} + +func (s *Alter_table_cmdContext) FORCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORCE, 0) +} + +func (s *Alter_table_cmdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_cmdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_table_cmd(s) + } +} + +func (s *Alter_table_cmdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_table_cmd(s) + } +} + +func (s *Alter_table_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_table_cmd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_table_cmd() (localctx IAlter_table_cmdContext) { + localctx = NewAlter_table_cmdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, RedshiftParserRULE_alter_table_cmd) + var _la int + + p.SetState(3344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 104, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3042) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3043) + p.ColumnDef() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3044) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3045) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3046) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3047) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3048) + p.ColumnDef() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3049) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3050) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3051) + p.ColumnDef() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3052) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3053) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3054) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3055) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3056) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3057) + p.ColumnDef() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3058) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3060) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 78, p.GetParserRuleContext()) == 1 { + { + p.SetState(3059) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3062) + p.Colid() + } + { + p.SetState(3063) + p.Alter_column_default() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3065) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3067) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 79, p.GetParserRuleContext()) == 1 { + { + p.SetState(3066) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3069) + p.Colid() + } + { + p.SetState(3070) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3071) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3072) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3074) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3076) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 80, p.GetParserRuleContext()) == 1 { + { + p.SetState(3075) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3078) + p.Colid() + } + { + p.SetState(3079) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3080) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3081) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3083) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3085) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 81, p.GetParserRuleContext()) == 1 { + { + p.SetState(3084) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3087) + p.Colid() + } + { + p.SetState(3088) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3089) + p.Match(RedshiftParserEXPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3091) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3093) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 82, p.GetParserRuleContext()) == 1 { + { + p.SetState(3092) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3095) + p.Colid() + } + { + p.SetState(3096) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3097) + p.Match(RedshiftParserEXPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3098) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3099) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3101) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3103) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 83, p.GetParserRuleContext()) == 1 { + { + p.SetState(3102) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3105) + p.Colid() + } + { + p.SetState(3106) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3107) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3108) + p.Signediconst() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3110) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLUMN { + { + p.SetState(3111) + p.Opt_column() + } + + } + { + p.SetState(3114) + p.Iconst() + } + { + p.SetState(3115) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3116) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3117) + p.Signediconst() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3119) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3121) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 85, p.GetParserRuleContext()) == 1 { + { + p.SetState(3120) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3123) + p.Colid() + } + { + p.SetState(3124) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3125) + p.Reloptions() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(3127) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3129) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 86, p.GetParserRuleContext()) == 1 { + { + p.SetState(3128) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3131) + p.Colid() + } + { + p.SetState(3132) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3133) + p.Reloptions() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(3135) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3137) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 87, p.GetParserRuleContext()) == 1 { + { + p.SetState(3136) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3139) + p.Colid() + } + { + p.SetState(3140) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3141) + p.Match(RedshiftParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3142) + p.Colid() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(3144) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3146) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 88, p.GetParserRuleContext()) == 1 { + { + p.SetState(3145) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3148) + p.Colid() + } + { + p.SetState(3149) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3150) + p.Match(RedshiftParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3151) + p.Generated_when() + } + { + p.SetState(3152) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3153) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(3154) + p.Optparenthesizedseqoptlist() + } + + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(3157) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3159) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 90, p.GetParserRuleContext()) == 1 { + { + p.SetState(3158) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3161) + p.Colid() + } + { + p.SetState(3162) + p.Alter_identity_column_option_list() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(3164) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3166) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 91, p.GetParserRuleContext()) == 1 { + { + p.SetState(3165) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3168) + p.Colid() + } + { + p.SetState(3169) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3170) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(3172) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3174) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 92, p.GetParserRuleContext()) == 1 { + { + p.SetState(3173) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3176) + p.Colid() + } + { + p.SetState(3177) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3178) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3179) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3180) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(3182) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLUMN { + { + p.SetState(3183) + p.Opt_column() + } + + } + { + p.SetState(3186) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3187) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3188) + p.Colid() + } + p.SetState(3190) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(3189) + p.Opt_drop_behavior() + } + + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(3192) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3194) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 95, p.GetParserRuleContext()) == 1 { + { + p.SetState(3193) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3196) + p.Colid() + } + p.SetState(3198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(3197) + p.Opt_drop_behavior() + } + + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(3200) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3202) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 97, p.GetParserRuleContext()) == 1 { + { + p.SetState(3201) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3204) + p.Colid() + } + p.SetState(3206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSET { + { + p.SetState(3205) + p.Opt_set_data() + } + + } + { + p.SetState(3208) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3209) + p.Typename() + } + p.SetState(3211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLLATE { + { + p.SetState(3210) + p.Opt_collate_clause() + } + + } + p.SetState(3214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(3213) + p.Alter_using() + } + + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(3216) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3218) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 101, p.GetParserRuleContext()) == 1 { + { + p.SetState(3217) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3220) + p.Colid() + } + { + p.SetState(3221) + p.Alter_generic_options() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(3223) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3224) + p.Tableconstraint() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(3225) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3226) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3227) + p.Name() + } + { + p.SetState(3228) + p.Constraintattributespec() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(3230) + p.Match(RedshiftParserVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3231) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3232) + p.Name() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(3233) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3234) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3235) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3236) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3237) + p.Name() + } + p.SetState(3239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(3238) + p.Opt_drop_behavior() + } + + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(3241) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3242) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3243) + p.Name() + } + p.SetState(3245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(3244) + p.Opt_drop_behavior() + } + + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(3247) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3248) + p.Match(RedshiftParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3249) + p.Match(RedshiftParserOIDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(3250) + p.Match(RedshiftParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3251) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3252) + p.Name() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(3253) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3254) + p.Match(RedshiftParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3255) + p.Match(RedshiftParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(3256) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3257) + p.Match(RedshiftParserLOGGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(3258) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3259) + p.Match(RedshiftParserUNLOGGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(3260) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3261) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3262) + p.Name() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(3263) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3264) + p.Match(RedshiftParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3265) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3266) + p.Name() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(3267) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3268) + p.Match(RedshiftParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3269) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3270) + p.Name() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(3271) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3272) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3273) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(3274) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3275) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3276) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(3277) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3278) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3279) + p.Name() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(3280) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3281) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3282) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(3283) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3284) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3285) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(3286) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3287) + p.Match(RedshiftParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3288) + p.Name() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(3289) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3290) + p.Match(RedshiftParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3291) + p.Match(RedshiftParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3292) + p.Name() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(3293) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3294) + p.Match(RedshiftParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3295) + p.Match(RedshiftParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3296) + p.Name() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(3297) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3298) + p.Match(RedshiftParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3299) + p.Name() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(3300) + p.Match(RedshiftParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3301) + p.Qualified_name() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(3302) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3303) + p.Match(RedshiftParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3304) + p.Qualified_name() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(3305) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3306) + p.Any_name() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(3307) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3308) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(3309) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3310) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3311) + p.Rolespec() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(3312) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3313) + p.Match(RedshiftParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3314) + p.Match(RedshiftParserMETHOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3315) + p.Name() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(3316) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3317) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3318) + p.Name() + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(3319) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3320) + p.Reloptions() + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(3321) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3322) + p.Reloptions() + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(3323) + p.Match(RedshiftParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3324) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3325) + p.Replica_identity() + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(3326) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3327) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3328) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3329) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(3330) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3331) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3332) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3333) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(3334) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3335) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3336) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3337) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(3338) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3339) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3340) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3341) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3342) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(3343) + p.Alter_generic_options() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_column_defaultContext is an interface to support dynamic dispatch. +type IAlter_column_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + A_expr() IA_exprContext + DROP() antlr.TerminalNode + + // IsAlter_column_defaultContext differentiates from other interfaces. + IsAlter_column_defaultContext() +} + +type Alter_column_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_column_defaultContext() *Alter_column_defaultContext { + var p = new(Alter_column_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_column_default + return p +} + +func InitEmptyAlter_column_defaultContext(p *Alter_column_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_column_default +} + +func (*Alter_column_defaultContext) IsAlter_column_defaultContext() {} + +func NewAlter_column_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_defaultContext { + var p = new(Alter_column_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_column_default + + return p +} + +func (s *Alter_column_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_column_defaultContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Alter_column_defaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Alter_column_defaultContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Alter_column_defaultContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Alter_column_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_column_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_column_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_column_default(s) + } +} + +func (s *Alter_column_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_column_default(s) + } +} + +func (s *Alter_column_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_column_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_column_default() (localctx IAlter_column_defaultContext) { + localctx = NewAlter_column_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, RedshiftParserRULE_alter_column_default) + p.SetState(3351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3346) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3347) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3348) + p.A_expr() + } + + case RedshiftParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3349) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3350) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_drop_behaviorContext is an interface to support dynamic dispatch. +type IOpt_drop_behaviorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CASCADE() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + + // IsOpt_drop_behaviorContext differentiates from other interfaces. + IsOpt_drop_behaviorContext() +} + +type Opt_drop_behaviorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_drop_behaviorContext() *Opt_drop_behaviorContext { + var p = new(Opt_drop_behaviorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_drop_behavior + return p +} + +func InitEmptyOpt_drop_behaviorContext(p *Opt_drop_behaviorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_drop_behavior +} + +func (*Opt_drop_behaviorContext) IsOpt_drop_behaviorContext() {} + +func NewOpt_drop_behaviorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_drop_behaviorContext { + var p = new(Opt_drop_behaviorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_drop_behavior + + return p +} + +func (s *Opt_drop_behaviorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_drop_behaviorContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *Opt_drop_behaviorContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *Opt_drop_behaviorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_drop_behaviorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_drop_behaviorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_drop_behavior(s) + } +} + +func (s *Opt_drop_behaviorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_drop_behavior(s) + } +} + +func (s *Opt_drop_behaviorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_drop_behavior(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_drop_behavior() (localctx IOpt_drop_behaviorContext) { + localctx = NewOpt_drop_behaviorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, RedshiftParserRULE_opt_drop_behavior) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3353) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_collate_clauseContext is an interface to support dynamic dispatch. +type IOpt_collate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLLATE() antlr.TerminalNode + Any_name() IAny_nameContext + + // IsOpt_collate_clauseContext differentiates from other interfaces. + IsOpt_collate_clauseContext() +} + +type Opt_collate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_collate_clauseContext() *Opt_collate_clauseContext { + var p = new(Opt_collate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_collate_clause + return p +} + +func InitEmptyOpt_collate_clauseContext(p *Opt_collate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_collate_clause +} + +func (*Opt_collate_clauseContext) IsOpt_collate_clauseContext() {} + +func NewOpt_collate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_collate_clauseContext { + var p = new(Opt_collate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_collate_clause + + return p +} + +func (s *Opt_collate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_collate_clauseContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Opt_collate_clauseContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Opt_collate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_collate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_collate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_collate_clause(s) + } +} + +func (s *Opt_collate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_collate_clause(s) + } +} + +func (s *Opt_collate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_collate_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_collate_clause() (localctx IOpt_collate_clauseContext) { + localctx = NewOpt_collate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, RedshiftParserRULE_opt_collate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3355) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3356) + p.Any_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_usingContext is an interface to support dynamic dispatch. +type IAlter_usingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + A_expr() IA_exprContext + + // IsAlter_usingContext differentiates from other interfaces. + IsAlter_usingContext() +} + +type Alter_usingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_usingContext() *Alter_usingContext { + var p = new(Alter_usingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_using + return p +} + +func InitEmptyAlter_usingContext(p *Alter_usingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_using +} + +func (*Alter_usingContext) IsAlter_usingContext() {} + +func NewAlter_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_usingContext { + var p = new(Alter_usingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_using + + return p +} + +func (s *Alter_usingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_usingContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Alter_usingContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Alter_usingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_usingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_using(s) + } +} + +func (s *Alter_usingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_using(s) + } +} + +func (s *Alter_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_using(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_using() (localctx IAlter_usingContext) { + localctx = NewAlter_usingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, RedshiftParserRULE_alter_using) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3358) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3359) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplica_identityContext is an interface to support dynamic dispatch. +type IReplica_identityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOTHING() antlr.TerminalNode + FULL() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + Name() INameContext + + // IsReplica_identityContext differentiates from other interfaces. + IsReplica_identityContext() +} + +type Replica_identityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplica_identityContext() *Replica_identityContext { + var p = new(Replica_identityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_replica_identity + return p +} + +func InitEmptyReplica_identityContext(p *Replica_identityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_replica_identity +} + +func (*Replica_identityContext) IsReplica_identityContext() {} + +func NewReplica_identityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replica_identityContext { + var p = new(Replica_identityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_replica_identity + + return p +} + +func (s *Replica_identityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replica_identityContext) NOTHING() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTHING, 0) +} + +func (s *Replica_identityContext) FULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserFULL, 0) +} + +func (s *Replica_identityContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Replica_identityContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Replica_identityContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *Replica_identityContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Replica_identityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replica_identityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replica_identityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReplica_identity(s) + } +} + +func (s *Replica_identityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReplica_identity(s) + } +} + +func (s *Replica_identityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReplica_identity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Replica_identity() (localctx IReplica_identityContext) { + localctx = NewReplica_identityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, RedshiftParserRULE_replica_identity) + p.SetState(3367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNOTHING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3361) + p.Match(RedshiftParserNOTHING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFULL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3362) + p.Match(RedshiftParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3363) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUSING: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3364) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3365) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3366) + p.Name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReloptionsContext is an interface to support dynamic dispatch. +type IReloptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Reloption_list() IReloption_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsReloptionsContext differentiates from other interfaces. + IsReloptionsContext() +} + +type ReloptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReloptionsContext() *ReloptionsContext { + var p = new(ReloptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reloptions + return p +} + +func InitEmptyReloptionsContext(p *ReloptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reloptions +} + +func (*ReloptionsContext) IsReloptionsContext() {} + +func NewReloptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReloptionsContext { + var p = new(ReloptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reloptions + + return p +} + +func (s *ReloptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReloptionsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ReloptionsContext) Reloption_list() IReloption_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReloption_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReloption_listContext) +} + +func (s *ReloptionsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ReloptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReloptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReloptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReloptions(s) + } +} + +func (s *ReloptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReloptions(s) + } +} + +func (s *ReloptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReloptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reloptions() (localctx IReloptionsContext) { + localctx = NewReloptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, RedshiftParserRULE_reloptions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3369) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3370) + p.Reloption_list() + } + { + p.SetState(3371) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_reloptionsContext is an interface to support dynamic dispatch. +type IOpt_reloptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + Reloptions() IReloptionsContext + + // IsOpt_reloptionsContext differentiates from other interfaces. + IsOpt_reloptionsContext() +} + +type Opt_reloptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_reloptionsContext() *Opt_reloptionsContext { + var p = new(Opt_reloptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_reloptions + return p +} + +func InitEmptyOpt_reloptionsContext(p *Opt_reloptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_reloptions +} + +func (*Opt_reloptionsContext) IsOpt_reloptionsContext() {} + +func NewOpt_reloptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_reloptionsContext { + var p = new(Opt_reloptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_reloptions + + return p +} + +func (s *Opt_reloptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_reloptionsContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_reloptionsContext) Reloptions() IReloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReloptionsContext) +} + +func (s *Opt_reloptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_reloptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_reloptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_reloptions(s) + } +} + +func (s *Opt_reloptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_reloptions(s) + } +} + +func (s *Opt_reloptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_reloptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_reloptions() (localctx IOpt_reloptionsContext) { + localctx = NewOpt_reloptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, RedshiftParserRULE_opt_reloptions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3373) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3374) + p.Reloptions() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReloption_listContext is an interface to support dynamic dispatch. +type IReloption_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllReloption_elem() []IReloption_elemContext + Reloption_elem(i int) IReloption_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReloption_listContext differentiates from other interfaces. + IsReloption_listContext() +} + +type Reloption_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReloption_listContext() *Reloption_listContext { + var p = new(Reloption_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reloption_list + return p +} + +func InitEmptyReloption_listContext(p *Reloption_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reloption_list +} + +func (*Reloption_listContext) IsReloption_listContext() {} + +func NewReloption_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reloption_listContext { + var p = new(Reloption_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reloption_list + + return p +} + +func (s *Reloption_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reloption_listContext) AllReloption_elem() []IReloption_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReloption_elemContext); ok { + len++ + } + } + + tst := make([]IReloption_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReloption_elemContext); ok { + tst[i] = t.(IReloption_elemContext) + i++ + } + } + + return tst +} + +func (s *Reloption_listContext) Reloption_elem(i int) IReloption_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReloption_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReloption_elemContext) +} + +func (s *Reloption_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Reloption_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Reloption_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reloption_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reloption_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReloption_list(s) + } +} + +func (s *Reloption_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReloption_list(s) + } +} + +func (s *Reloption_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReloption_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reloption_list() (localctx IReloption_listContext) { + localctx = NewReloption_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, RedshiftParserRULE_reloption_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3376) + p.Reloption_elem() + } + p.SetState(3381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(3377) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3378) + p.Reloption_elem() + } + + p.SetState(3383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReloption_elemContext is an interface to support dynamic dispatch. +type IReloption_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCollabel() []ICollabelContext + Collabel(i int) ICollabelContext + EQUAL() antlr.TerminalNode + Def_arg() IDef_argContext + DOT() antlr.TerminalNode + + // IsReloption_elemContext differentiates from other interfaces. + IsReloption_elemContext() +} + +type Reloption_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReloption_elemContext() *Reloption_elemContext { + var p = new(Reloption_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reloption_elem + return p +} + +func InitEmptyReloption_elemContext(p *Reloption_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reloption_elem +} + +func (*Reloption_elemContext) IsReloption_elemContext() {} + +func NewReloption_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reloption_elemContext { + var p = new(Reloption_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reloption_elem + + return p +} + +func (s *Reloption_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reloption_elemContext) AllCollabel() []ICollabelContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICollabelContext); ok { + len++ + } + } + + tst := make([]ICollabelContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICollabelContext); ok { + tst[i] = t.(ICollabelContext) + i++ + } + } + + return tst +} + +func (s *Reloption_elemContext) Collabel(i int) ICollabelContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Reloption_elemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Reloption_elemContext) Def_arg() IDef_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDef_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDef_argContext) +} + +func (s *Reloption_elemContext) DOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, 0) +} + +func (s *Reloption_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reloption_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reloption_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReloption_elem(s) + } +} + +func (s *Reloption_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReloption_elem(s) + } +} + +func (s *Reloption_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReloption_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reloption_elem() (localctx IReloption_elemContext) { + localctx = NewReloption_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, RedshiftParserRULE_reloption_elem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3384) + p.Collabel() + } + p.SetState(3393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case RedshiftParserEQUAL: + { + p.SetState(3385) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3386) + p.Def_arg() + } + + case RedshiftParserDOT: + { + p.SetState(3387) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3388) + p.Collabel() + } + p.SetState(3391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL { + { + p.SetState(3389) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3390) + p.Def_arg() + } + + } + + case RedshiftParserCLOSE_PAREN, RedshiftParserCOMMA: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_identity_column_option_listContext is an interface to support dynamic dispatch. +type IAlter_identity_column_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_identity_column_option() []IAlter_identity_column_optionContext + Alter_identity_column_option(i int) IAlter_identity_column_optionContext + + // IsAlter_identity_column_option_listContext differentiates from other interfaces. + IsAlter_identity_column_option_listContext() +} + +type Alter_identity_column_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_identity_column_option_listContext() *Alter_identity_column_option_listContext { + var p = new(Alter_identity_column_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_identity_column_option_list + return p +} + +func InitEmptyAlter_identity_column_option_listContext(p *Alter_identity_column_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_identity_column_option_list +} + +func (*Alter_identity_column_option_listContext) IsAlter_identity_column_option_listContext() {} + +func NewAlter_identity_column_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identity_column_option_listContext { + var p = new(Alter_identity_column_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_identity_column_option_list + + return p +} + +func (s *Alter_identity_column_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_identity_column_option_listContext) AllAlter_identity_column_option() []IAlter_identity_column_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_identity_column_optionContext); ok { + len++ + } + } + + tst := make([]IAlter_identity_column_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_identity_column_optionContext); ok { + tst[i] = t.(IAlter_identity_column_optionContext) + i++ + } + } + + return tst +} + +func (s *Alter_identity_column_option_listContext) Alter_identity_column_option(i int) IAlter_identity_column_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_identity_column_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_identity_column_optionContext) +} + +func (s *Alter_identity_column_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_identity_column_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_identity_column_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_identity_column_option_list(s) + } +} + +func (s *Alter_identity_column_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_identity_column_option_list(s) + } +} + +func (s *Alter_identity_column_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_identity_column_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_identity_column_option_list() (localctx IAlter_identity_column_option_listContext) { + localctx = NewAlter_identity_column_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, RedshiftParserRULE_alter_identity_column_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserRESTART || _la == RedshiftParserSET { + { + p.SetState(3395) + p.Alter_identity_column_option() + } + + p.SetState(3398) + 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_identity_column_optionContext is an interface to support dynamic dispatch. +type IAlter_identity_column_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESTART() antlr.TerminalNode + Numericonly() INumericonlyContext + Opt_with() IOpt_withContext + SET() antlr.TerminalNode + Seqoptelem() ISeqoptelemContext + GENERATED() antlr.TerminalNode + Generated_when() IGenerated_whenContext + + // IsAlter_identity_column_optionContext differentiates from other interfaces. + IsAlter_identity_column_optionContext() +} + +type Alter_identity_column_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_identity_column_optionContext() *Alter_identity_column_optionContext { + var p = new(Alter_identity_column_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_identity_column_option + return p +} + +func InitEmptyAlter_identity_column_optionContext(p *Alter_identity_column_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_identity_column_option +} + +func (*Alter_identity_column_optionContext) IsAlter_identity_column_optionContext() {} + +func NewAlter_identity_column_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identity_column_optionContext { + var p = new(Alter_identity_column_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_identity_column_option + + return p +} + +func (s *Alter_identity_column_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_identity_column_optionContext) RESTART() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTART, 0) +} + +func (s *Alter_identity_column_optionContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Alter_identity_column_optionContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *Alter_identity_column_optionContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Alter_identity_column_optionContext) Seqoptelem() ISeqoptelemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeqoptelemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeqoptelemContext) +} + +func (s *Alter_identity_column_optionContext) GENERATED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGENERATED, 0) +} + +func (s *Alter_identity_column_optionContext) Generated_when() IGenerated_whenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_whenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_whenContext) +} + +func (s *Alter_identity_column_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_identity_column_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_identity_column_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_identity_column_option(s) + } +} + +func (s *Alter_identity_column_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_identity_column_option(s) + } +} + +func (s *Alter_identity_column_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_identity_column_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_identity_column_option() (localctx IAlter_identity_column_optionContext) { + localctx = NewAlter_identity_column_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, RedshiftParserRULE_alter_identity_column_option) + var _la int + + p.SetState(3413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserRESTART: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3400) + p.Match(RedshiftParserRESTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPLUS || _la == RedshiftParserMINUS || _la == RedshiftParserWITH || _la == RedshiftParserIntegral || _la == RedshiftParserNumeric { + p.SetState(3402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(3401) + p.Opt_with() + } + + } + { + p.SetState(3404) + p.Numericonly() + } + + } + + case RedshiftParserSET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3407) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAS, RedshiftParserCACHE, RedshiftParserCYCLE, RedshiftParserINCREMENT, RedshiftParserMAXVALUE, RedshiftParserMINVALUE, RedshiftParserNO, RedshiftParserOWNED, RedshiftParserRESTART, RedshiftParserSEQUENCE, RedshiftParserSTART, RedshiftParserUNLOGGED, RedshiftParserLOGGED: + { + p.SetState(3408) + p.Seqoptelem() + } + + case RedshiftParserGENERATED: + { + p.SetState(3409) + p.Match(RedshiftParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3410) + p.Generated_when() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionboundspecContext is an interface to support dynamic dispatch. +type IPartitionboundspecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + VALUES() antlr.TerminalNode + WITH() antlr.TerminalNode + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + Hash_partbound() IHash_partboundContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + IN_P() antlr.TerminalNode + AllExpr_list() []IExpr_listContext + Expr_list(i int) IExpr_listContext + FROM() antlr.TerminalNode + TO() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsPartitionboundspecContext differentiates from other interfaces. + IsPartitionboundspecContext() +} + +type PartitionboundspecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionboundspecContext() *PartitionboundspecContext { + var p = new(PartitionboundspecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partitionboundspec + return p +} + +func InitEmptyPartitionboundspecContext(p *PartitionboundspecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partitionboundspec +} + +func (*PartitionboundspecContext) IsPartitionboundspecContext() {} + +func NewPartitionboundspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionboundspecContext { + var p = new(PartitionboundspecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_partitionboundspec + + return p +} + +func (s *PartitionboundspecContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionboundspecContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *PartitionboundspecContext) VALUES() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUES, 0) +} + +func (s *PartitionboundspecContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *PartitionboundspecContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *PartitionboundspecContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *PartitionboundspecContext) Hash_partbound() IHash_partboundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partboundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partboundContext) +} + +func (s *PartitionboundspecContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *PartitionboundspecContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *PartitionboundspecContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *PartitionboundspecContext) AllExpr_list() []IExpr_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpr_listContext); ok { + len++ + } + } + + tst := make([]IExpr_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpr_listContext); ok { + tst[i] = t.(IExpr_listContext) + i++ + } + } + + return tst +} + +func (s *PartitionboundspecContext) Expr_list(i int) IExpr_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *PartitionboundspecContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *PartitionboundspecContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *PartitionboundspecContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *PartitionboundspecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionboundspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionboundspecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPartitionboundspec(s) + } +} + +func (s *PartitionboundspecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPartitionboundspec(s) + } +} + +func (s *PartitionboundspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPartitionboundspec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Partitionboundspec() (localctx IPartitionboundspecContext) { + localctx = NewPartitionboundspecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, RedshiftParserRULE_partitionboundspec) + p.SetState(3441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 115, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3415) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3416) + p.Match(RedshiftParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3417) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3418) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3419) + p.Hash_partbound() + } + { + p.SetState(3420) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3422) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3423) + p.Match(RedshiftParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3424) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3425) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3426) + p.Expr_list() + } + { + p.SetState(3427) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3429) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3430) + p.Match(RedshiftParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3431) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3432) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3433) + p.Expr_list() + } + { + p.SetState(3434) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3435) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3436) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3437) + p.Expr_list() + } + { + p.SetState(3438) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3440) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partbound_elemContext is an interface to support dynamic dispatch. +type IHash_partbound_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Nonreservedword() INonreservedwordContext + Iconst() IIconstContext + + // IsHash_partbound_elemContext differentiates from other interfaces. + IsHash_partbound_elemContext() +} + +type Hash_partbound_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partbound_elemContext() *Hash_partbound_elemContext { + var p = new(Hash_partbound_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hash_partbound_elem + return p +} + +func InitEmptyHash_partbound_elemContext(p *Hash_partbound_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hash_partbound_elem +} + +func (*Hash_partbound_elemContext) IsHash_partbound_elemContext() {} + +func NewHash_partbound_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partbound_elemContext { + var p = new(Hash_partbound_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_hash_partbound_elem + + return p +} + +func (s *Hash_partbound_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partbound_elemContext) Nonreservedword() INonreservedwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedwordContext) +} + +func (s *Hash_partbound_elemContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Hash_partbound_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partbound_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partbound_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHash_partbound_elem(s) + } +} + +func (s *Hash_partbound_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHash_partbound_elem(s) + } +} + +func (s *Hash_partbound_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHash_partbound_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Hash_partbound_elem() (localctx IHash_partbound_elemContext) { + localctx = NewHash_partbound_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, RedshiftParserRULE_hash_partbound_elem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3443) + p.Nonreservedword() + } + { + p.SetState(3444) + p.Iconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partboundContext is an interface to support dynamic dispatch. +type IHash_partboundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllHash_partbound_elem() []IHash_partbound_elemContext + Hash_partbound_elem(i int) IHash_partbound_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHash_partboundContext differentiates from other interfaces. + IsHash_partboundContext() +} + +type Hash_partboundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partboundContext() *Hash_partboundContext { + var p = new(Hash_partboundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hash_partbound + return p +} + +func InitEmptyHash_partboundContext(p *Hash_partboundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hash_partbound +} + +func (*Hash_partboundContext) IsHash_partboundContext() {} + +func NewHash_partboundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partboundContext { + var p = new(Hash_partboundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_hash_partbound + + return p +} + +func (s *Hash_partboundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partboundContext) AllHash_partbound_elem() []IHash_partbound_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHash_partbound_elemContext); ok { + len++ + } + } + + tst := make([]IHash_partbound_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHash_partbound_elemContext); ok { + tst[i] = t.(IHash_partbound_elemContext) + i++ + } + } + + return tst +} + +func (s *Hash_partboundContext) Hash_partbound_elem(i int) IHash_partbound_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partbound_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHash_partbound_elemContext) +} + +func (s *Hash_partboundContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Hash_partboundContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Hash_partboundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partboundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partboundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHash_partbound(s) + } +} + +func (s *Hash_partboundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHash_partbound(s) + } +} + +func (s *Hash_partboundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHash_partbound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Hash_partbound() (localctx IHash_partboundContext) { + localctx = NewHash_partboundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, RedshiftParserRULE_hash_partbound) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3446) + p.Hash_partbound_elem() + } + p.SetState(3451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(3447) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3448) + p.Hash_partbound_elem() + } + + p.SetState(3453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltercompositetypestmtContext is an interface to support dynamic dispatch. +type IAltercompositetypestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + Any_name() IAny_nameContext + Alter_type_cmds() IAlter_type_cmdsContext + + // IsAltercompositetypestmtContext differentiates from other interfaces. + IsAltercompositetypestmtContext() +} + +type AltercompositetypestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltercompositetypestmtContext() *AltercompositetypestmtContext { + var p = new(AltercompositetypestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altercompositetypestmt + return p +} + +func InitEmptyAltercompositetypestmtContext(p *AltercompositetypestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altercompositetypestmt +} + +func (*AltercompositetypestmtContext) IsAltercompositetypestmtContext() {} + +func NewAltercompositetypestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltercompositetypestmtContext { + var p = new(AltercompositetypestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altercompositetypestmt + + return p +} + +func (s *AltercompositetypestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltercompositetypestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltercompositetypestmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *AltercompositetypestmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AltercompositetypestmtContext) Alter_type_cmds() IAlter_type_cmdsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_type_cmdsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_type_cmdsContext) +} + +func (s *AltercompositetypestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltercompositetypestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltercompositetypestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltercompositetypestmt(s) + } +} + +func (s *AltercompositetypestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltercompositetypestmt(s) + } +} + +func (s *AltercompositetypestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltercompositetypestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altercompositetypestmt() (localctx IAltercompositetypestmtContext) { + localctx = NewAltercompositetypestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, RedshiftParserRULE_altercompositetypestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3454) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3455) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3456) + p.Any_name() + } + { + p.SetState(3457) + p.Alter_type_cmds() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_type_cmdsContext is an interface to support dynamic dispatch. +type IAlter_type_cmdsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_type_cmd() []IAlter_type_cmdContext + Alter_type_cmd(i int) IAlter_type_cmdContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_type_cmdsContext differentiates from other interfaces. + IsAlter_type_cmdsContext() +} + +type Alter_type_cmdsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_type_cmdsContext() *Alter_type_cmdsContext { + var p = new(Alter_type_cmdsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_type_cmds + return p +} + +func InitEmptyAlter_type_cmdsContext(p *Alter_type_cmdsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_type_cmds +} + +func (*Alter_type_cmdsContext) IsAlter_type_cmdsContext() {} + +func NewAlter_type_cmdsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_type_cmdsContext { + var p = new(Alter_type_cmdsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_type_cmds + + return p +} + +func (s *Alter_type_cmdsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_type_cmdsContext) AllAlter_type_cmd() []IAlter_type_cmdContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_type_cmdContext); ok { + len++ + } + } + + tst := make([]IAlter_type_cmdContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_type_cmdContext); ok { + tst[i] = t.(IAlter_type_cmdContext) + i++ + } + } + + return tst +} + +func (s *Alter_type_cmdsContext) Alter_type_cmd(i int) IAlter_type_cmdContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_type_cmdContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_type_cmdContext) +} + +func (s *Alter_type_cmdsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Alter_type_cmdsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Alter_type_cmdsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_type_cmdsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_type_cmdsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_type_cmds(s) + } +} + +func (s *Alter_type_cmdsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_type_cmds(s) + } +} + +func (s *Alter_type_cmdsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_type_cmds(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_type_cmds() (localctx IAlter_type_cmdsContext) { + localctx = NewAlter_type_cmdsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, RedshiftParserRULE_alter_type_cmds) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3459) + p.Alter_type_cmd() + } + p.SetState(3464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(3460) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3461) + p.Alter_type_cmd() + } + + p.SetState(3466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_type_cmdContext is an interface to support dynamic dispatch. +type IAlter_type_cmdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD_P() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + Tablefuncelement() ITablefuncelementContext + Opt_drop_behavior() IOpt_drop_behaviorContext + DROP() antlr.TerminalNode + Colid() IColidContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + ALTER() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + Typename() ITypenameContext + Opt_set_data() IOpt_set_dataContext + Opt_collate_clause() IOpt_collate_clauseContext + + // IsAlter_type_cmdContext differentiates from other interfaces. + IsAlter_type_cmdContext() +} + +type Alter_type_cmdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_type_cmdContext() *Alter_type_cmdContext { + var p = new(Alter_type_cmdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_type_cmd + return p +} + +func InitEmptyAlter_type_cmdContext(p *Alter_type_cmdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_type_cmd +} + +func (*Alter_type_cmdContext) IsAlter_type_cmdContext() {} + +func NewAlter_type_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_type_cmdContext { + var p = new(Alter_type_cmdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_type_cmd + + return p +} + +func (s *Alter_type_cmdContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_type_cmdContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *Alter_type_cmdContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTRIBUTE, 0) +} + +func (s *Alter_type_cmdContext) Tablefuncelement() ITablefuncelementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablefuncelementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablefuncelementContext) +} + +func (s *Alter_type_cmdContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Alter_type_cmdContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Alter_type_cmdContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Alter_type_cmdContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *Alter_type_cmdContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *Alter_type_cmdContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Alter_type_cmdContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Alter_type_cmdContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Alter_type_cmdContext) Opt_set_data() IOpt_set_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_set_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_set_dataContext) +} + +func (s *Alter_type_cmdContext) Opt_collate_clause() IOpt_collate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_collate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_collate_clauseContext) +} + +func (s *Alter_type_cmdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_type_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_type_cmdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_type_cmd(s) + } +} + +func (s *Alter_type_cmdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_type_cmd(s) + } +} + +func (s *Alter_type_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_type_cmd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_type_cmd() (localctx IAlter_type_cmdContext) { + localctx = NewAlter_type_cmdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, RedshiftParserRULE_alter_type_cmd) + var _la int + + p.SetState(3497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserADD_P: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3467) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3468) + p.Match(RedshiftParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3469) + p.Tablefuncelement() + } + p.SetState(3471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(3470) + p.Opt_drop_behavior() + } + + } + + case RedshiftParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3473) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3474) + p.Match(RedshiftParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3477) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 119, p.GetParserRuleContext()) == 1 { + { + p.SetState(3475) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3476) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3479) + p.Colid() + } + p.SetState(3481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(3480) + p.Opt_drop_behavior() + } + + } + + case RedshiftParserALTER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3483) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3484) + p.Match(RedshiftParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3485) + p.Colid() + } + p.SetState(3487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSET { + { + p.SetState(3486) + p.Opt_set_data() + } + + } + { + p.SetState(3489) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3490) + p.Typename() + } + p.SetState(3492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLLATE { + { + p.SetState(3491) + p.Opt_collate_clause() + } + + } + p.SetState(3495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(3494) + p.Opt_drop_behavior() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICloseportalstmtContext is an interface to support dynamic dispatch. +type ICloseportalstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLOSE() antlr.TerminalNode + Cursor_name() ICursor_nameContext + ALL() antlr.TerminalNode + + // IsCloseportalstmtContext differentiates from other interfaces. + IsCloseportalstmtContext() +} + +type CloseportalstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCloseportalstmtContext() *CloseportalstmtContext { + var p = new(CloseportalstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_closeportalstmt + return p +} + +func InitEmptyCloseportalstmtContext(p *CloseportalstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_closeportalstmt +} + +func (*CloseportalstmtContext) IsCloseportalstmtContext() {} + +func NewCloseportalstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CloseportalstmtContext { + var p = new(CloseportalstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_closeportalstmt + + return p +} + +func (s *CloseportalstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CloseportalstmtContext) CLOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE, 0) +} + +func (s *CloseportalstmtContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *CloseportalstmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *CloseportalstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CloseportalstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CloseportalstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCloseportalstmt(s) + } +} + +func (s *CloseportalstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCloseportalstmt(s) + } +} + +func (s *CloseportalstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCloseportalstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Closeportalstmt() (localctx ICloseportalstmtContext) { + localctx = NewCloseportalstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, RedshiftParserRULE_closeportalstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3499) + p.Match(RedshiftParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(3500) + p.Cursor_name() + } + + case RedshiftParserALL: + { + p.SetState(3501) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopystmtContext is an interface to support dynamic dispatch. +type ICopystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COPY() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Copy_from() ICopy_fromContext + Copy_file_name() ICopy_file_nameContext + Copy_options() ICopy_optionsContext + Opt_binary() IOpt_binaryContext + Opt_column_list() IOpt_column_listContext + Opt_program() IOpt_programContext + Copy_delimiter() ICopy_delimiterContext + Opt_with() IOpt_withContext + Where_clause() IWhere_clauseContext + OPEN_PAREN() antlr.TerminalNode + Preparablestmt() IPreparablestmtContext + CLOSE_PAREN() antlr.TerminalNode + TO() antlr.TerminalNode + FROM() antlr.TerminalNode + Sconst() ISconstContext + Redshift_copy_authorization() IRedshift_copy_authorizationContext + Redshift_copy_format() IRedshift_copy_formatContext + AllRedshift_copy_parameter() []IRedshift_copy_parameterContext + Redshift_copy_parameter(i int) IRedshift_copy_parameterContext + + // IsCopystmtContext differentiates from other interfaces. + IsCopystmtContext() +} + +type CopystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopystmtContext() *CopystmtContext { + var p = new(CopystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copystmt + return p +} + +func InitEmptyCopystmtContext(p *CopystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copystmt +} + +func (*CopystmtContext) IsCopystmtContext() {} + +func NewCopystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CopystmtContext { + var p = new(CopystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copystmt + + return p +} + +func (s *CopystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CopystmtContext) COPY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOPY, 0) +} + +func (s *CopystmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CopystmtContext) Copy_from() ICopy_fromContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_fromContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_fromContext) +} + +func (s *CopystmtContext) Copy_file_name() ICopy_file_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_file_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_file_nameContext) +} + +func (s *CopystmtContext) Copy_options() ICopy_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_optionsContext) +} + +func (s *CopystmtContext) Opt_binary() IOpt_binaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_binaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_binaryContext) +} + +func (s *CopystmtContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *CopystmtContext) Opt_program() IOpt_programContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_programContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_programContext) +} + +func (s *CopystmtContext) Copy_delimiter() ICopy_delimiterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_delimiterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_delimiterContext) +} + +func (s *CopystmtContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *CopystmtContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *CopystmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CopystmtContext) Preparablestmt() IPreparablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPreparablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPreparablestmtContext) +} + +func (s *CopystmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CopystmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *CopystmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *CopystmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CopystmtContext) Redshift_copy_authorization() IRedshift_copy_authorizationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedshift_copy_authorizationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedshift_copy_authorizationContext) +} + +func (s *CopystmtContext) Redshift_copy_format() IRedshift_copy_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedshift_copy_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedshift_copy_formatContext) +} + +func (s *CopystmtContext) AllRedshift_copy_parameter() []IRedshift_copy_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRedshift_copy_parameterContext); ok { + len++ + } + } + + tst := make([]IRedshift_copy_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRedshift_copy_parameterContext); ok { + tst[i] = t.(IRedshift_copy_parameterContext) + i++ + } + } + + return tst +} + +func (s *CopystmtContext) Redshift_copy_parameter(i int) IRedshift_copy_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedshift_copy_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRedshift_copy_parameterContext) +} + +func (s *CopystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CopystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CopystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopystmt(s) + } +} + +func (s *CopystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopystmt(s) + } +} + +func (s *CopystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copystmt() (localctx ICopystmtContext) { + localctx = NewCopystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, RedshiftParserRULE_copystmt) + var _la int + + var _alt int + + p.SetState(3558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 137, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3504) + p.Match(RedshiftParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserBINARY { + { + p.SetState(3505) + p.Opt_binary() + } + + } + { + p.SetState(3508) + p.Qualified_name() + } + p.SetState(3510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(3509) + p.Opt_column_list() + } + + } + { + p.SetState(3512) + p.Copy_from() + } + p.SetState(3514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROGRAM { + { + p.SetState(3513) + p.Opt_program() + } + + } + { + p.SetState(3516) + p.Copy_file_name() + } + p.SetState(3518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING || _la == RedshiftParserDELIMITERS { + { + p.SetState(3517) + p.Copy_delimiter() + } + + } + p.SetState(3521) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 130, p.GetParserRuleContext()) == 1 { + { + p.SetState(3520) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3523) + p.Copy_options() + } + p.SetState(3525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(3524) + p.Where_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3527) + p.Match(RedshiftParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3528) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3529) + p.Preparablestmt() + } + { + p.SetState(3530) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3531) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROGRAM { + { + p.SetState(3532) + p.Opt_program() + } + + } + { + p.SetState(3535) + p.Copy_file_name() + } + p.SetState(3537) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 133, p.GetParserRuleContext()) == 1 { + { + p.SetState(3536) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3539) + p.Copy_options() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3541) + p.Match(RedshiftParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3542) + p.Qualified_name() + } + p.SetState(3544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(3543) + p.Opt_column_list() + } + + } + { + p.SetState(3546) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3547) + p.Sconst() + } + { + p.SetState(3548) + p.Redshift_copy_authorization() + } + p.SetState(3550) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 135, p.GetParserRuleContext()) == 1 { + { + p.SetState(3549) + p.Redshift_copy_format() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 136, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3552) + p.Redshift_copy_parameter() + } + + } + p.SetState(3557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 136, 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 +} + +// IRedshift_copy_authorizationContext is an interface to support dynamic dispatch. +type IRedshift_copy_authorizationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IAM_ROLE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + CREDENTIALS() antlr.TerminalNode + ACCESS_KEY_ID() antlr.TerminalNode + SECRET_ACCESS_KEY() antlr.TerminalNode + SESSION_TOKEN_KW() antlr.TerminalNode + + // IsRedshift_copy_authorizationContext differentiates from other interfaces. + IsRedshift_copy_authorizationContext() +} + +type Redshift_copy_authorizationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedshift_copy_authorizationContext() *Redshift_copy_authorizationContext { + var p = new(Redshift_copy_authorizationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshift_copy_authorization + return p +} + +func InitEmptyRedshift_copy_authorizationContext(p *Redshift_copy_authorizationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshift_copy_authorization +} + +func (*Redshift_copy_authorizationContext) IsRedshift_copy_authorizationContext() {} + +func NewRedshift_copy_authorizationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Redshift_copy_authorizationContext { + var p = new(Redshift_copy_authorizationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_redshift_copy_authorization + + return p +} + +func (s *Redshift_copy_authorizationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Redshift_copy_authorizationContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *Redshift_copy_authorizationContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Redshift_copy_authorizationContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Redshift_copy_authorizationContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Redshift_copy_authorizationContext) CREDENTIALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREDENTIALS, 0) +} + +func (s *Redshift_copy_authorizationContext) ACCESS_KEY_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS_KEY_ID, 0) +} + +func (s *Redshift_copy_authorizationContext) SECRET_ACCESS_KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECRET_ACCESS_KEY, 0) +} + +func (s *Redshift_copy_authorizationContext) SESSION_TOKEN_KW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_TOKEN_KW, 0) +} + +func (s *Redshift_copy_authorizationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Redshift_copy_authorizationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Redshift_copy_authorizationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRedshift_copy_authorization(s) + } +} + +func (s *Redshift_copy_authorizationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRedshift_copy_authorization(s) + } +} + +func (s *Redshift_copy_authorizationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRedshift_copy_authorization(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Redshift_copy_authorization() (localctx IRedshift_copy_authorizationContext) { + localctx = NewRedshift_copy_authorizationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, RedshiftParserRULE_redshift_copy_authorization) + p.SetState(3575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIAM_ROLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3560) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + { + p.SetState(3561) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(3562) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case RedshiftParserCREDENTIALS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3565) + p.Match(RedshiftParserCREDENTIALS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3566) + p.Sconst() + } + + case RedshiftParserACCESS_KEY_ID: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3567) + p.Match(RedshiftParserACCESS_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3568) + p.Sconst() + } + { + p.SetState(3569) + p.Match(RedshiftParserSECRET_ACCESS_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3570) + p.Sconst() + } + p.SetState(3573) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 139, p.GetParserRuleContext()) == 1 { + { + p.SetState(3571) + p.Match(RedshiftParserSESSION_TOKEN_KW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3572) + p.Sconst() + } + + } 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 +} + +// IRedshift_copy_formatContext is an interface to support dynamic dispatch. +type IRedshift_copy_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CSV() antlr.TerminalNode + PARQUET() antlr.TerminalNode + ORC() antlr.TerminalNode + JSON() antlr.TerminalNode + AVRO() antlr.TerminalNode + FORMAT() antlr.TerminalNode + AS() antlr.TerminalNode + Sconst() ISconstContext + + // IsRedshift_copy_formatContext differentiates from other interfaces. + IsRedshift_copy_formatContext() +} + +type Redshift_copy_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedshift_copy_formatContext() *Redshift_copy_formatContext { + var p = new(Redshift_copy_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshift_copy_format + return p +} + +func InitEmptyRedshift_copy_formatContext(p *Redshift_copy_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshift_copy_format +} + +func (*Redshift_copy_formatContext) IsRedshift_copy_formatContext() {} + +func NewRedshift_copy_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Redshift_copy_formatContext { + var p = new(Redshift_copy_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_redshift_copy_format + + return p +} + +func (s *Redshift_copy_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Redshift_copy_formatContext) CSV() antlr.TerminalNode { + return s.GetToken(RedshiftParserCSV, 0) +} + +func (s *Redshift_copy_formatContext) PARQUET() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARQUET, 0) +} + +func (s *Redshift_copy_formatContext) ORC() antlr.TerminalNode { + return s.GetToken(RedshiftParserORC, 0) +} + +func (s *Redshift_copy_formatContext) JSON() antlr.TerminalNode { + return s.GetToken(RedshiftParserJSON, 0) +} + +func (s *Redshift_copy_formatContext) AVRO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAVRO, 0) +} + +func (s *Redshift_copy_formatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORMAT, 0) +} + +func (s *Redshift_copy_formatContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Redshift_copy_formatContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Redshift_copy_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Redshift_copy_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Redshift_copy_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRedshift_copy_format(s) + } +} + +func (s *Redshift_copy_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRedshift_copy_format(s) + } +} + +func (s *Redshift_copy_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRedshift_copy_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Redshift_copy_format() (localctx IRedshift_copy_formatContext) { + localctx = NewRedshift_copy_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, RedshiftParserRULE_redshift_copy_format) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFORMAT { + { + p.SetState(3577) + p.Match(RedshiftParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(3580) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3583) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCSV || _la == RedshiftParserJSON || ((int64((_la-513)) & ^0x3f) == 0 && ((int64(1)<<(_la-513))&273) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-862)) & ^0x3f) == 0 && ((int64(1)<<(_la-862))&67108885) != 0 { + { + p.SetState(3584) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRedshift_copy_parameterContext is an interface to support dynamic dispatch. +type IRedshift_copy_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Copy_param_name() ICopy_param_nameContext + Copy_param_value() ICopy_param_valueContext + AS() antlr.TerminalNode + + // IsRedshift_copy_parameterContext differentiates from other interfaces. + IsRedshift_copy_parameterContext() +} + +type Redshift_copy_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedshift_copy_parameterContext() *Redshift_copy_parameterContext { + var p = new(Redshift_copy_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshift_copy_parameter + return p +} + +func InitEmptyRedshift_copy_parameterContext(p *Redshift_copy_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshift_copy_parameter +} + +func (*Redshift_copy_parameterContext) IsRedshift_copy_parameterContext() {} + +func NewRedshift_copy_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Redshift_copy_parameterContext { + var p = new(Redshift_copy_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_redshift_copy_parameter + + return p +} + +func (s *Redshift_copy_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Redshift_copy_parameterContext) Copy_param_name() ICopy_param_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_param_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_param_nameContext) +} + +func (s *Redshift_copy_parameterContext) Copy_param_value() ICopy_param_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_param_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_param_valueContext) +} + +func (s *Redshift_copy_parameterContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Redshift_copy_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Redshift_copy_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Redshift_copy_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRedshift_copy_parameter(s) + } +} + +func (s *Redshift_copy_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRedshift_copy_parameter(s) + } +} + +func (s *Redshift_copy_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRedshift_copy_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Redshift_copy_parameter() (localctx IRedshift_copy_parameterContext) { + localctx = NewRedshift_copy_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, RedshiftParserRULE_redshift_copy_parameter) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3587) + p.Copy_param_name() + } + p.SetState(3592) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 145, p.GetParserRuleContext()) == 1 { + p.SetState(3589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(3588) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3591) + p.Copy_param_value() + } + + } 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 +} + +// ICopy_param_nameContext is an interface to support dynamic dispatch. +type ICopy_param_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + NULL_P() antlr.TerminalNode + + // IsCopy_param_nameContext differentiates from other interfaces. + IsCopy_param_nameContext() +} + +type Copy_param_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_param_nameContext() *Copy_param_nameContext { + var p = new(Copy_param_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_param_name + return p +} + +func InitEmptyCopy_param_nameContext(p *Copy_param_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_param_name +} + +func (*Copy_param_nameContext) IsCopy_param_nameContext() {} + +func NewCopy_param_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_param_nameContext { + var p = new(Copy_param_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_param_name + + return p +} + +func (s *Copy_param_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_param_nameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Copy_param_nameContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Copy_param_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_param_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_param_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_param_name(s) + } +} + +func (s *Copy_param_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_param_name(s) + } +} + +func (s *Copy_param_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_param_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_param_name() (localctx ICopy_param_nameContext) { + localctx = NewCopy_param_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, RedshiftParserRULE_copy_param_name) + p.SetState(3596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3594) + p.Colid() + } + + case RedshiftParserNULL_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3595) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_param_valueContext is an interface to support dynamic dispatch. +type ICopy_param_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + Iconst() IIconstContext + Colid() IColidContext + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + TRUE_P() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + PRESET() antlr.TerminalNode + AUTO() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCopy_param_valueContext differentiates from other interfaces. + IsCopy_param_valueContext() +} + +type Copy_param_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_param_valueContext() *Copy_param_valueContext { + var p = new(Copy_param_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_param_value + return p +} + +func InitEmptyCopy_param_valueContext(p *Copy_param_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_param_value +} + +func (*Copy_param_valueContext) IsCopy_param_valueContext() {} + +func NewCopy_param_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_param_valueContext { + var p = new(Copy_param_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_param_value + + return p +} + +func (s *Copy_param_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_param_valueContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Copy_param_valueContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Copy_param_valueContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Copy_param_valueContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Copy_param_valueContext) OFF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFF, 0) +} + +func (s *Copy_param_valueContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *Copy_param_valueContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *Copy_param_valueContext) PRESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRESET, 0) +} + +func (s *Copy_param_valueContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *Copy_param_valueContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Copy_param_valueContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *Copy_param_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_param_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_param_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_param_value(s) + } +} + +func (s *Copy_param_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_param_value(s) + } +} + +func (s *Copy_param_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_param_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_param_value() (localctx ICopy_param_valueContext) { + localctx = NewCopy_param_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, RedshiftParserRULE_copy_param_value) + p.SetState(3609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 147, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3598) + p.Sconst() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3599) + p.Iconst() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3600) + p.Colid() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3601) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3602) + p.Match(RedshiftParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3603) + p.Match(RedshiftParserTRUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3604) + p.Match(RedshiftParserFALSE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3605) + p.Match(RedshiftParserPRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3606) + p.Match(RedshiftParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3607) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3608) + p.Match(RedshiftParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_fromContext is an interface to support dynamic dispatch. +type ICopy_fromContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + TO() antlr.TerminalNode + + // IsCopy_fromContext differentiates from other interfaces. + IsCopy_fromContext() +} + +type Copy_fromContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_fromContext() *Copy_fromContext { + var p = new(Copy_fromContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_from + return p +} + +func InitEmptyCopy_fromContext(p *Copy_fromContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_from +} + +func (*Copy_fromContext) IsCopy_fromContext() {} + +func NewCopy_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_fromContext { + var p = new(Copy_fromContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_from + + return p +} + +func (s *Copy_fromContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_fromContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Copy_fromContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Copy_fromContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_fromContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_from(s) + } +} + +func (s *Copy_fromContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_from(s) + } +} + +func (s *Copy_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_from(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_from() (localctx ICopy_fromContext) { + localctx = NewCopy_fromContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, RedshiftParserRULE_copy_from) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3611) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFROM || _la == RedshiftParserTO) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_programContext is an interface to support dynamic dispatch. +type IOpt_programContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROGRAM() antlr.TerminalNode + + // IsOpt_programContext differentiates from other interfaces. + IsOpt_programContext() +} + +type Opt_programContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_programContext() *Opt_programContext { + var p = new(Opt_programContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_program + return p +} + +func InitEmptyOpt_programContext(p *Opt_programContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_program +} + +func (*Opt_programContext) IsOpt_programContext() {} + +func NewOpt_programContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_programContext { + var p = new(Opt_programContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_program + + return p +} + +func (s *Opt_programContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_programContext) PROGRAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROGRAM, 0) +} + +func (s *Opt_programContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_programContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_programContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_program(s) + } +} + +func (s *Opt_programContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_program(s) + } +} + +func (s *Opt_programContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_program(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_program() (localctx IOpt_programContext) { + localctx = NewOpt_programContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, RedshiftParserRULE_opt_program) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3613) + p.Match(RedshiftParserPROGRAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_file_nameContext is an interface to support dynamic dispatch. +type ICopy_file_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + STDIN() antlr.TerminalNode + STDOUT() antlr.TerminalNode + + // IsCopy_file_nameContext differentiates from other interfaces. + IsCopy_file_nameContext() +} + +type Copy_file_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_file_nameContext() *Copy_file_nameContext { + var p = new(Copy_file_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_file_name + return p +} + +func InitEmptyCopy_file_nameContext(p *Copy_file_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_file_name +} + +func (*Copy_file_nameContext) IsCopy_file_nameContext() {} + +func NewCopy_file_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_file_nameContext { + var p = new(Copy_file_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_file_name + + return p +} + +func (s *Copy_file_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_file_nameContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Copy_file_nameContext) STDIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTDIN, 0) +} + +func (s *Copy_file_nameContext) STDOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTDOUT, 0) +} + +func (s *Copy_file_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_file_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_file_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_file_name(s) + } +} + +func (s *Copy_file_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_file_name(s) + } +} + +func (s *Copy_file_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_file_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_file_name() (localctx ICopy_file_nameContext) { + localctx = NewCopy_file_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, RedshiftParserRULE_copy_file_name) + p.SetState(3618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3615) + p.Sconst() + } + + case RedshiftParserSTDIN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3616) + p.Match(RedshiftParserSTDIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSTDOUT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3617) + p.Match(RedshiftParserSTDOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_optionsContext is an interface to support dynamic dispatch. +type ICopy_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Copy_opt_list() ICopy_opt_listContext + OPEN_PAREN() antlr.TerminalNode + Copy_generic_opt_list() ICopy_generic_opt_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsCopy_optionsContext differentiates from other interfaces. + IsCopy_optionsContext() +} + +type Copy_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_optionsContext() *Copy_optionsContext { + var p = new(Copy_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_options + return p +} + +func InitEmptyCopy_optionsContext(p *Copy_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_options +} + +func (*Copy_optionsContext) IsCopy_optionsContext() {} + +func NewCopy_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_optionsContext { + var p = new(Copy_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_options + + return p +} + +func (s *Copy_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_optionsContext) Copy_opt_list() ICopy_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_opt_listContext) +} + +func (s *Copy_optionsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Copy_optionsContext) Copy_generic_opt_list() ICopy_generic_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_generic_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_generic_opt_listContext) +} + +func (s *Copy_optionsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Copy_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_options(s) + } +} + +func (s *Copy_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_options(s) + } +} + +func (s *Copy_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_options() (localctx ICopy_optionsContext) { + localctx = NewCopy_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, RedshiftParserRULE_copy_options) + p.SetState(3625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 149, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3620) + p.Copy_opt_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3621) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3622) + p.Copy_generic_opt_list() + } + { + p.SetState(3623) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_opt_listContext is an interface to support dynamic dispatch. +type ICopy_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCopy_opt_item() []ICopy_opt_itemContext + Copy_opt_item(i int) ICopy_opt_itemContext + + // IsCopy_opt_listContext differentiates from other interfaces. + IsCopy_opt_listContext() +} + +type Copy_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_opt_listContext() *Copy_opt_listContext { + var p = new(Copy_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_opt_list + return p +} + +func InitEmptyCopy_opt_listContext(p *Copy_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_opt_list +} + +func (*Copy_opt_listContext) IsCopy_opt_listContext() {} + +func NewCopy_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_opt_listContext { + var p = new(Copy_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_opt_list + + return p +} + +func (s *Copy_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_opt_listContext) AllCopy_opt_item() []ICopy_opt_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICopy_opt_itemContext); ok { + len++ + } + } + + tst := make([]ICopy_opt_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICopy_opt_itemContext); ok { + tst[i] = t.(ICopy_opt_itemContext) + i++ + } + } + + return tst +} + +func (s *Copy_opt_listContext) Copy_opt_item(i int) ICopy_opt_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_opt_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICopy_opt_itemContext) +} + +func (s *Copy_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_opt_list(s) + } +} + +func (s *Copy_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_opt_list(s) + } +} + +func (s *Copy_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_opt_list() (localctx ICopy_opt_listContext) { + localctx = NewCopy_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, RedshiftParserRULE_copy_opt_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-78)) & ^0x3f) == 0 && ((int64(1)<<(_la-78))&69793218561) != 0) || ((int64((_la-173)) & ^0x3f) == 0 && ((int64(1)<<(_la-173))&141837301989377) != 0) || _la == RedshiftParserQUOTE { + { + p.SetState(3627) + p.Copy_opt_item() + } + + p.SetState(3632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_opt_itemContext is an interface to support dynamic dispatch. +type ICopy_opt_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BINARY() antlr.TerminalNode + FREEZE() antlr.TerminalNode + DELIMITER() antlr.TerminalNode + Sconst() ISconstContext + Opt_as() IOpt_asContext + NULL_P() antlr.TerminalNode + CSV() antlr.TerminalNode + HEADER_P() antlr.TerminalNode + QUOTE() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + FORCE() antlr.TerminalNode + Columnlist() IColumnlistContext + STAR() antlr.TerminalNode + NOT() antlr.TerminalNode + ENCODING() antlr.TerminalNode + + // IsCopy_opt_itemContext differentiates from other interfaces. + IsCopy_opt_itemContext() +} + +type Copy_opt_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_opt_itemContext() *Copy_opt_itemContext { + var p = new(Copy_opt_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_opt_item + return p +} + +func InitEmptyCopy_opt_itemContext(p *Copy_opt_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_opt_item +} + +func (*Copy_opt_itemContext) IsCopy_opt_itemContext() {} + +func NewCopy_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_opt_itemContext { + var p = new(Copy_opt_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_opt_item + + return p +} + +func (s *Copy_opt_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_opt_itemContext) BINARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBINARY, 0) +} + +func (s *Copy_opt_itemContext) FREEZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFREEZE, 0) +} + +func (s *Copy_opt_itemContext) DELIMITER() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELIMITER, 0) +} + +func (s *Copy_opt_itemContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Copy_opt_itemContext) Opt_as() IOpt_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_asContext) +} + +func (s *Copy_opt_itemContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Copy_opt_itemContext) CSV() antlr.TerminalNode { + return s.GetToken(RedshiftParserCSV, 0) +} + +func (s *Copy_opt_itemContext) HEADER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserHEADER_P, 0) +} + +func (s *Copy_opt_itemContext) QUOTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTE, 0) +} + +func (s *Copy_opt_itemContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserESCAPE, 0) +} + +func (s *Copy_opt_itemContext) FORCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORCE, 0) +} + +func (s *Copy_opt_itemContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Copy_opt_itemContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *Copy_opt_itemContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Copy_opt_itemContext) ENCODING() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODING, 0) +} + +func (s *Copy_opt_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_opt_item(s) + } +} + +func (s *Copy_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_opt_item(s) + } +} + +func (s *Copy_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_opt_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_opt_item() (localctx ICopy_opt_itemContext) { + localctx = NewCopy_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, RedshiftParserRULE_copy_opt_item) + var _la int + + p.SetState(3672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 155, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3633) + p.Match(RedshiftParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3634) + p.Match(RedshiftParserFREEZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3635) + p.Match(RedshiftParserDELIMITER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(3636) + p.Opt_as() + } + + } + { + p.SetState(3639) + p.Sconst() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3640) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(3641) + p.Opt_as() + } + + } + { + p.SetState(3644) + p.Sconst() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3645) + p.Match(RedshiftParserCSV) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3646) + p.Match(RedshiftParserHEADER_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3647) + p.Match(RedshiftParserQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(3648) + p.Opt_as() + } + + } + { + p.SetState(3651) + p.Sconst() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3652) + p.Match(RedshiftParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(3653) + p.Opt_as() + } + + } + { + p.SetState(3656) + p.Sconst() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3657) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3658) + p.Match(RedshiftParserQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3659) + p.Columnlist() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3660) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3661) + p.Match(RedshiftParserQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3662) + p.Match(RedshiftParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3663) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3664) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3665) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3666) + p.Columnlist() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3667) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3668) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3669) + p.Columnlist() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(3670) + p.Match(RedshiftParserENCODING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3671) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_binaryContext is an interface to support dynamic dispatch. +type IOpt_binaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BINARY() antlr.TerminalNode + + // IsOpt_binaryContext differentiates from other interfaces. + IsOpt_binaryContext() +} + +type Opt_binaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_binaryContext() *Opt_binaryContext { + var p = new(Opt_binaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_binary + return p +} + +func InitEmptyOpt_binaryContext(p *Opt_binaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_binary +} + +func (*Opt_binaryContext) IsOpt_binaryContext() {} + +func NewOpt_binaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_binaryContext { + var p = new(Opt_binaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_binary + + return p +} + +func (s *Opt_binaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_binaryContext) BINARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBINARY, 0) +} + +func (s *Opt_binaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_binaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_binaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_binary(s) + } +} + +func (s *Opt_binaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_binary(s) + } +} + +func (s *Opt_binaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_binary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_binary() (localctx IOpt_binaryContext) { + localctx = NewOpt_binaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, RedshiftParserRULE_opt_binary) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3674) + p.Match(RedshiftParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_delimiterContext is an interface to support dynamic dispatch. +type ICopy_delimiterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITERS() antlr.TerminalNode + Sconst() ISconstContext + Opt_using() IOpt_usingContext + + // IsCopy_delimiterContext differentiates from other interfaces. + IsCopy_delimiterContext() +} + +type Copy_delimiterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_delimiterContext() *Copy_delimiterContext { + var p = new(Copy_delimiterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_delimiter + return p +} + +func InitEmptyCopy_delimiterContext(p *Copy_delimiterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_delimiter +} + +func (*Copy_delimiterContext) IsCopy_delimiterContext() {} + +func NewCopy_delimiterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_delimiterContext { + var p = new(Copy_delimiterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_delimiter + + return p +} + +func (s *Copy_delimiterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_delimiterContext) DELIMITERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELIMITERS, 0) +} + +func (s *Copy_delimiterContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Copy_delimiterContext) Opt_using() IOpt_usingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_usingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_usingContext) +} + +func (s *Copy_delimiterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_delimiterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_delimiterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_delimiter(s) + } +} + +func (s *Copy_delimiterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_delimiter(s) + } +} + +func (s *Copy_delimiterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_delimiter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_delimiter() (localctx ICopy_delimiterContext) { + localctx = NewCopy_delimiterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, RedshiftParserRULE_copy_delimiter) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(3676) + p.Opt_using() + } + + } + { + p.SetState(3679) + p.Match(RedshiftParserDELIMITERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3680) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_usingContext is an interface to support dynamic dispatch. +type IOpt_usingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + + // IsOpt_usingContext differentiates from other interfaces. + IsOpt_usingContext() +} + +type Opt_usingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_usingContext() *Opt_usingContext { + var p = new(Opt_usingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_using + return p +} + +func InitEmptyOpt_usingContext(p *Opt_usingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_using +} + +func (*Opt_usingContext) IsOpt_usingContext() {} + +func NewOpt_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_usingContext { + var p = new(Opt_usingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_using + + return p +} + +func (s *Opt_usingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_usingContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Opt_usingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_usingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_using(s) + } +} + +func (s *Opt_usingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_using(s) + } +} + +func (s *Opt_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_using(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_using() (localctx IOpt_usingContext) { + localctx = NewOpt_usingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, RedshiftParserRULE_opt_using) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3682) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_generic_opt_listContext is an interface to support dynamic dispatch. +type ICopy_generic_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCopy_generic_opt_elem() []ICopy_generic_opt_elemContext + Copy_generic_opt_elem(i int) ICopy_generic_opt_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCopy_generic_opt_listContext differentiates from other interfaces. + IsCopy_generic_opt_listContext() +} + +type Copy_generic_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_generic_opt_listContext() *Copy_generic_opt_listContext { + var p = new(Copy_generic_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_list + return p +} + +func InitEmptyCopy_generic_opt_listContext(p *Copy_generic_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_list +} + +func (*Copy_generic_opt_listContext) IsCopy_generic_opt_listContext() {} + +func NewCopy_generic_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_listContext { + var p = new(Copy_generic_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_list + + return p +} + +func (s *Copy_generic_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_generic_opt_listContext) AllCopy_generic_opt_elem() []ICopy_generic_opt_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICopy_generic_opt_elemContext); ok { + len++ + } + } + + tst := make([]ICopy_generic_opt_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICopy_generic_opt_elemContext); ok { + tst[i] = t.(ICopy_generic_opt_elemContext) + i++ + } + } + + return tst +} + +func (s *Copy_generic_opt_listContext) Copy_generic_opt_elem(i int) ICopy_generic_opt_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_generic_opt_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICopy_generic_opt_elemContext) +} + +func (s *Copy_generic_opt_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Copy_generic_opt_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Copy_generic_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_generic_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_generic_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_generic_opt_list(s) + } +} + +func (s *Copy_generic_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_generic_opt_list(s) + } +} + +func (s *Copy_generic_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_generic_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_generic_opt_list() (localctx ICopy_generic_opt_listContext) { + localctx = NewCopy_generic_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, RedshiftParserRULE_copy_generic_opt_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3684) + p.Copy_generic_opt_elem() + } + p.SetState(3689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(3685) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3686) + p.Copy_generic_opt_elem() + } + + p.SetState(3691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_generic_opt_elemContext is an interface to support dynamic dispatch. +type ICopy_generic_opt_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Collabel() ICollabelContext + Copy_generic_opt_arg() ICopy_generic_opt_argContext + + // IsCopy_generic_opt_elemContext differentiates from other interfaces. + IsCopy_generic_opt_elemContext() +} + +type Copy_generic_opt_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_generic_opt_elemContext() *Copy_generic_opt_elemContext { + var p = new(Copy_generic_opt_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_elem + return p +} + +func InitEmptyCopy_generic_opt_elemContext(p *Copy_generic_opt_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_elem +} + +func (*Copy_generic_opt_elemContext) IsCopy_generic_opt_elemContext() {} + +func NewCopy_generic_opt_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_elemContext { + var p = new(Copy_generic_opt_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_elem + + return p +} + +func (s *Copy_generic_opt_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_generic_opt_elemContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Copy_generic_opt_elemContext) Copy_generic_opt_arg() ICopy_generic_opt_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_generic_opt_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_generic_opt_argContext) +} + +func (s *Copy_generic_opt_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_generic_opt_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_generic_opt_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_generic_opt_elem(s) + } +} + +func (s *Copy_generic_opt_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_generic_opt_elem(s) + } +} + +func (s *Copy_generic_opt_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_generic_opt_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_generic_opt_elem() (localctx ICopy_generic_opt_elemContext) { + localctx = NewCopy_generic_opt_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, RedshiftParserRULE_copy_generic_opt_elem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3692) + p.Collabel() + } + p.SetState(3694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3616452116379349508) != 0) || ((int64((_la-79)) & ^0x3f) == 0 && ((int64(1)<<(_la-79))&-567349341831037) != 0) || ((int64((_la-143)) & ^0x3f) == 0 && ((int64(1)<<(_la-143))&-34359738369) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&-1266637395197953) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&-65537) != 0) || ((int64((_la-335)) & ^0x3f) == 0 && ((int64(1)<<(_la-335))&-359162070282797057) != 0) || ((int64((_la-399)) & ^0x3f) == 0 && ((int64(1)<<(_la-399))&-1) != 0) || ((int64((_la-463)) & ^0x3f) == 0 && ((int64(1)<<(_la-463))&-1) != 0) || ((int64((_la-527)) & ^0x3f) == 0 && ((int64(1)<<(_la-527))&-1) != 0) || ((int64((_la-591)) & ^0x3f) == 0 && ((int64(1)<<(_la-591))&-4611967493403049985) != 0) || ((int64((_la-655)) & ^0x3f) == 0 && ((int64(1)<<(_la-655))&9222668349412999167) != 0) || ((int64((_la-719)) & ^0x3f) == 0 && ((int64(1)<<(_la-719))&-1) != 0) || ((int64((_la-783)) & ^0x3f) == 0 && ((int64(1)<<(_la-783))&4503599627370495) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137925535881) != 0) { + { + p.SetState(3693) + p.Copy_generic_opt_arg() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_generic_opt_argContext is an interface to support dynamic dispatch. +type ICopy_generic_opt_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_boolean_or_string() IOpt_boolean_or_stringContext + Numericonly() INumericonlyContext + STAR() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Copy_generic_opt_arg_list() ICopy_generic_opt_arg_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsCopy_generic_opt_argContext differentiates from other interfaces. + IsCopy_generic_opt_argContext() +} + +type Copy_generic_opt_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_generic_opt_argContext() *Copy_generic_opt_argContext { + var p = new(Copy_generic_opt_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg + return p +} + +func InitEmptyCopy_generic_opt_argContext(p *Copy_generic_opt_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg +} + +func (*Copy_generic_opt_argContext) IsCopy_generic_opt_argContext() {} + +func NewCopy_generic_opt_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_argContext { + var p = new(Copy_generic_opt_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg + + return p +} + +func (s *Copy_generic_opt_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_generic_opt_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_boolean_or_stringContext) +} + +func (s *Copy_generic_opt_argContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Copy_generic_opt_argContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *Copy_generic_opt_argContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Copy_generic_opt_argContext) Copy_generic_opt_arg_list() ICopy_generic_opt_arg_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_generic_opt_arg_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_generic_opt_arg_listContext) +} + +func (s *Copy_generic_opt_argContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Copy_generic_opt_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_generic_opt_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_generic_opt_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_generic_opt_arg(s) + } +} + +func (s *Copy_generic_opt_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_generic_opt_arg(s) + } +} + +func (s *Copy_generic_opt_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_generic_opt_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_generic_opt_arg() (localctx ICopy_generic_opt_argContext) { + localctx = NewCopy_generic_opt_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, RedshiftParserRULE_copy_generic_opt_arg) + p.SetState(3703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3696) + p.Opt_boolean_or_string() + } + + case RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserIntegral, RedshiftParserNumeric: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3697) + p.Numericonly() + } + + case RedshiftParserSTAR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3698) + p.Match(RedshiftParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserOPEN_PAREN: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3699) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3700) + p.Copy_generic_opt_arg_list() + } + { + p.SetState(3701) + p.Match(RedshiftParserCLOSE_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 +} + +// ICopy_generic_opt_arg_listContext is an interface to support dynamic dispatch. +type ICopy_generic_opt_arg_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCopy_generic_opt_arg_list_item() []ICopy_generic_opt_arg_list_itemContext + Copy_generic_opt_arg_list_item(i int) ICopy_generic_opt_arg_list_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCopy_generic_opt_arg_listContext differentiates from other interfaces. + IsCopy_generic_opt_arg_listContext() +} + +type Copy_generic_opt_arg_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_generic_opt_arg_listContext() *Copy_generic_opt_arg_listContext { + var p = new(Copy_generic_opt_arg_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg_list + return p +} + +func InitEmptyCopy_generic_opt_arg_listContext(p *Copy_generic_opt_arg_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg_list +} + +func (*Copy_generic_opt_arg_listContext) IsCopy_generic_opt_arg_listContext() {} + +func NewCopy_generic_opt_arg_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_arg_listContext { + var p = new(Copy_generic_opt_arg_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg_list + + return p +} + +func (s *Copy_generic_opt_arg_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_generic_opt_arg_listContext) AllCopy_generic_opt_arg_list_item() []ICopy_generic_opt_arg_list_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok { + len++ + } + } + + tst := make([]ICopy_generic_opt_arg_list_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok { + tst[i] = t.(ICopy_generic_opt_arg_list_itemContext) + i++ + } + } + + return tst +} + +func (s *Copy_generic_opt_arg_listContext) Copy_generic_opt_arg_list_item(i int) ICopy_generic_opt_arg_list_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_generic_opt_arg_list_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICopy_generic_opt_arg_list_itemContext) +} + +func (s *Copy_generic_opt_arg_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Copy_generic_opt_arg_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Copy_generic_opt_arg_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_generic_opt_arg_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_generic_opt_arg_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_generic_opt_arg_list(s) + } +} + +func (s *Copy_generic_opt_arg_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_generic_opt_arg_list(s) + } +} + +func (s *Copy_generic_opt_arg_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_generic_opt_arg_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_generic_opt_arg_list() (localctx ICopy_generic_opt_arg_listContext) { + localctx = NewCopy_generic_opt_arg_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, RedshiftParserRULE_copy_generic_opt_arg_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3705) + p.Copy_generic_opt_arg_list_item() + } + p.SetState(3710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(3706) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3707) + p.Copy_generic_opt_arg_list_item() + } + + p.SetState(3712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_generic_opt_arg_list_itemContext is an interface to support dynamic dispatch. +type ICopy_generic_opt_arg_list_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_boolean_or_string() IOpt_boolean_or_stringContext + + // IsCopy_generic_opt_arg_list_itemContext differentiates from other interfaces. + IsCopy_generic_opt_arg_list_itemContext() +} + +type Copy_generic_opt_arg_list_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_generic_opt_arg_list_itemContext() *Copy_generic_opt_arg_list_itemContext { + var p = new(Copy_generic_opt_arg_list_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg_list_item + return p +} + +func InitEmptyCopy_generic_opt_arg_list_itemContext(p *Copy_generic_opt_arg_list_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg_list_item +} + +func (*Copy_generic_opt_arg_list_itemContext) IsCopy_generic_opt_arg_list_itemContext() {} + +func NewCopy_generic_opt_arg_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_generic_opt_arg_list_itemContext { + var p = new(Copy_generic_opt_arg_list_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_generic_opt_arg_list_item + + return p +} + +func (s *Copy_generic_opt_arg_list_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_generic_opt_arg_list_itemContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_boolean_or_stringContext) +} + +func (s *Copy_generic_opt_arg_list_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_generic_opt_arg_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_generic_opt_arg_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_generic_opt_arg_list_item(s) + } +} + +func (s *Copy_generic_opt_arg_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_generic_opt_arg_list_item(s) + } +} + +func (s *Copy_generic_opt_arg_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_generic_opt_arg_list_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_generic_opt_arg_list_item() (localctx ICopy_generic_opt_arg_list_itemContext) { + localctx = NewCopy_generic_opt_arg_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, RedshiftParserRULE_copy_generic_opt_arg_list_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3713) + p.Opt_boolean_or_string() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatestmtContext is an interface to support dynamic dispatch. +type ICreatestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Table_name() ITable_nameContext + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Opttemp() IOpttempContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Opttableelementlist() IOpttableelementlistContext + Opt_backup_clause() IOpt_backup_clauseContext + AllOpt_table_attributes() []IOpt_table_attributesContext + Opt_table_attributes(i int) IOpt_table_attributesContext + + // IsCreatestmtContext differentiates from other interfaces. + IsCreatestmtContext() +} + +type CreatestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatestmtContext() *CreatestmtContext { + var p = new(CreatestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createstmt + return p +} + +func InitEmptyCreatestmtContext(p *CreatestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createstmt +} + +func (*CreatestmtContext) IsCreatestmtContext() {} + +func NewCreatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatestmtContext { + var p = new(CreatestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createstmt + + return p +} + +func (s *CreatestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *CreatestmtContext) 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 *CreatestmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreatestmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreatestmtContext) Opttemp() IOpttempContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttempContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttempContext) +} + +func (s *CreatestmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreatestmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreatestmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreatestmtContext) Opttableelementlist() IOpttableelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttableelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttableelementlistContext) +} + +func (s *CreatestmtContext) Opt_backup_clause() IOpt_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_backup_clauseContext) +} + +func (s *CreatestmtContext) AllOpt_table_attributes() []IOpt_table_attributesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpt_table_attributesContext); ok { + len++ + } + } + + tst := make([]IOpt_table_attributesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpt_table_attributesContext); ok { + tst[i] = t.(IOpt_table_attributesContext) + i++ + } + } + + return tst +} + +func (s *CreatestmtContext) Opt_table_attributes(i int) IOpt_table_attributesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_table_attributesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpt_table_attributesContext) +} + +func (s *CreatestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatestmt(s) + } +} + +func (s *CreatestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatestmt(s) + } +} + +func (s *CreatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createstmt() (localctx ICreatestmtContext) { + localctx = NewCreatestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, RedshiftParserRULE_createstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3715) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLOCAL || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY { + { + p.SetState(3716) + p.Opttemp() + } + + } + { + p.SetState(3719) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3723) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 162, p.GetParserRuleContext()) == 1 { + { + p.SetState(3720) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3721) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3722) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3725) + p.Table_name() + } + + { + p.SetState(3726) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1166502673593671173) != 0) || ((int64((_la-99)) & ^0x3f) == 0 && ((int64(1)<<(_la-99))&-3543662591) != 0) || ((int64((_la-163)) & ^0x3f) == 0 && ((int64(1)<<(_la-163))&-32769) != 0) || ((int64((_la-227)) & ^0x3f) == 0 && ((int64(1)<<(_la-227))&-1152921505814806529) != 0) || ((int64((_la-291)) & ^0x3f) == 0 && ((int64(1)<<(_la-291))&-1) != 0) || ((int64((_la-355)) & ^0x3f) == 0 && ((int64(1)<<(_la-355))&-342523641857) != 0) || ((int64((_la-419)) & ^0x3f) == 0 && ((int64(1)<<(_la-419))&-1) != 0) || ((int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&-1) != 0) || ((int64((_la-547)) & ^0x3f) == 0 && ((int64(1)<<(_la-547))&-1) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(3727) + p.Opttableelementlist() + } + + } + { + p.SetState(3730) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserBACKUP { + { + p.SetState(3731) + p.Opt_backup_clause() + } + + } + p.SetState(3737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for (int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&111) != 0 { + { + p.SetState(3734) + p.Opt_table_attributes() + } + + p.SetState(3739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_table_attributesContext is an interface to support dynamic dispatch. +type IOpt_table_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDistkey_identifier returns the distkey_identifier rule contexts. + GetDistkey_identifier() IColidContext + + // GetSortkey_columnlist returns the sortkey_columnlist rule contexts. + GetSortkey_columnlist() IColumnlistContext + + // SetDistkey_identifier sets the distkey_identifier rule contexts. + SetDistkey_identifier(IColidContext) + + // SetSortkey_columnlist sets the sortkey_columnlist rule contexts. + SetSortkey_columnlist(IColumnlistContext) + + // Getter signatures + DISTSTYLE() antlr.TerminalNode + AUTO() antlr.TerminalNode + EVEN() antlr.TerminalNode + KEY() antlr.TerminalNode + ALL() antlr.TerminalNode + DISTKEY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Colid() IColidContext + SORTKEY() antlr.TerminalNode + Columnlist() IColumnlistContext + COMPOUND() antlr.TerminalNode + INTERLEAVED() antlr.TerminalNode + ENCODE() antlr.TerminalNode + + // IsOpt_table_attributesContext differentiates from other interfaces. + IsOpt_table_attributesContext() +} + +type Opt_table_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + distkey_identifier IColidContext + sortkey_columnlist IColumnlistContext +} + +func NewEmptyOpt_table_attributesContext() *Opt_table_attributesContext { + var p = new(Opt_table_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_table_attributes + return p +} + +func InitEmptyOpt_table_attributesContext(p *Opt_table_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_table_attributes +} + +func (*Opt_table_attributesContext) IsOpt_table_attributesContext() {} + +func NewOpt_table_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_table_attributesContext { + var p = new(Opt_table_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_table_attributes + + return p +} + +func (s *Opt_table_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_table_attributesContext) GetDistkey_identifier() IColidContext { + return s.distkey_identifier +} + +func (s *Opt_table_attributesContext) GetSortkey_columnlist() IColumnlistContext { + return s.sortkey_columnlist +} + +func (s *Opt_table_attributesContext) SetDistkey_identifier(v IColidContext) { + s.distkey_identifier = v +} + +func (s *Opt_table_attributesContext) SetSortkey_columnlist(v IColumnlistContext) { + s.sortkey_columnlist = v +} + +func (s *Opt_table_attributesContext) DISTSTYLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTSTYLE, 0) +} + +func (s *Opt_table_attributesContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *Opt_table_attributesContext) EVEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVEN, 0) +} + +func (s *Opt_table_attributesContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *Opt_table_attributesContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Opt_table_attributesContext) DISTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTKEY, 0) +} + +func (s *Opt_table_attributesContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_table_attributesContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_table_attributesContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Opt_table_attributesContext) SORTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSORTKEY, 0) +} + +func (s *Opt_table_attributesContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Opt_table_attributesContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPOUND, 0) +} + +func (s *Opt_table_attributesContext) INTERLEAVED() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTERLEAVED, 0) +} + +func (s *Opt_table_attributesContext) ENCODE() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODE, 0) +} + +func (s *Opt_table_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_table_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_table_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_table_attributes(s) + } +} + +func (s *Opt_table_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_table_attributes(s) + } +} + +func (s *Opt_table_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_table_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_table_attributes() (localctx IOpt_table_attributesContext) { + localctx = NewOpt_table_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, RedshiftParserRULE_opt_table_attributes) + var _la int + + p.SetState(3757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDISTSTYLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3740) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3741) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || _la == RedshiftParserKEY || _la == RedshiftParserAUTO || _la == RedshiftParserEVEN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserDISTKEY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3742) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3743) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3744) + + var _x = p.Colid() + + localctx.(*Opt_table_attributesContext).distkey_identifier = _x + } + { + p.SetState(3745) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSORTKEY, RedshiftParserCOMPOUND, RedshiftParserINTERLEAVED: + p.EnterOuterAlt(localctx, 3) + p.SetState(3748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMPOUND || _la == RedshiftParserINTERLEAVED { + { + p.SetState(3747) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCOMPOUND || _la == RedshiftParserINTERLEAVED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(3750) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3751) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3752) + + var _x = p.Columnlist() + + localctx.(*Opt_table_attributesContext).sortkey_columnlist = _x + } + { + p.SetState(3753) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserENCODE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3755) + p.Match(RedshiftParserENCODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3756) + p.Match(RedshiftParserAUTO) + 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 +} + +// IOpttempContext is an interface to support dynamic dispatch. +type IOpttempContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMPORARY() antlr.TerminalNode + TEMP() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsOpttempContext differentiates from other interfaces. + IsOpttempContext() +} + +type OpttempContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpttempContext() *OpttempContext { + var p = new(OpttempContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttemp + return p +} + +func InitEmptyOpttempContext(p *OpttempContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttemp +} + +func (*OpttempContext) IsOpttempContext() {} + +func NewOpttempContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttempContext { + var p = new(OpttempContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opttemp + + return p +} + +func (s *OpttempContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpttempContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPORARY, 0) +} + +func (s *OpttempContext) TEMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMP, 0) +} + +func (s *OpttempContext) LOCAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCAL, 0) +} + +func (s *OpttempContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpttempContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpttempContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpttemp(s) + } +} + +func (s *OpttempContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpttemp(s) + } +} + +func (s *OpttempContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpttemp(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opttemp() (localctx IOpttempContext) { + localctx = NewOpttempContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, RedshiftParserRULE_opttemp) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3760) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLOCAL { + { + p.SetState(3759) + p.Match(RedshiftParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3762) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY) { + 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 +} + +// IOpttableelementlistContext is an interface to support dynamic dispatch. +type IOpttableelementlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableelementlist() ITableelementlistContext + + // IsOpttableelementlistContext differentiates from other interfaces. + IsOpttableelementlistContext() +} + +type OpttableelementlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpttableelementlistContext() *OpttableelementlistContext { + var p = new(OpttableelementlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttableelementlist + return p +} + +func InitEmptyOpttableelementlistContext(p *OpttableelementlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttableelementlist +} + +func (*OpttableelementlistContext) IsOpttableelementlistContext() {} + +func NewOpttableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttableelementlistContext { + var p = new(OpttableelementlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opttableelementlist + + return p +} + +func (s *OpttableelementlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpttableelementlistContext) Tableelementlist() ITableelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableelementlistContext) +} + +func (s *OpttableelementlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpttableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpttableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpttableelementlist(s) + } +} + +func (s *OpttableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpttableelementlist(s) + } +} + +func (s *OpttableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpttableelementlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opttableelementlist() (localctx IOpttableelementlistContext) { + localctx = NewOpttableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, RedshiftParserRULE_opttableelementlist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3764) + p.Tableelementlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpttypedtableelementlistContext is an interface to support dynamic dispatch. +type IOpttypedtableelementlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Typedtableelementlist() ITypedtableelementlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpttypedtableelementlistContext differentiates from other interfaces. + IsOpttypedtableelementlistContext() +} + +type OpttypedtableelementlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpttypedtableelementlistContext() *OpttypedtableelementlistContext { + var p = new(OpttypedtableelementlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttypedtableelementlist + return p +} + +func InitEmptyOpttypedtableelementlistContext(p *OpttypedtableelementlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttypedtableelementlist +} + +func (*OpttypedtableelementlistContext) IsOpttypedtableelementlistContext() {} + +func NewOpttypedtableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttypedtableelementlistContext { + var p = new(OpttypedtableelementlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opttypedtableelementlist + + return p +} + +func (s *OpttypedtableelementlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpttypedtableelementlistContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *OpttypedtableelementlistContext) Typedtableelementlist() ITypedtableelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypedtableelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypedtableelementlistContext) +} + +func (s *OpttypedtableelementlistContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *OpttypedtableelementlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpttypedtableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpttypedtableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpttypedtableelementlist(s) + } +} + +func (s *OpttypedtableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpttypedtableelementlist(s) + } +} + +func (s *OpttypedtableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpttypedtableelementlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opttypedtableelementlist() (localctx IOpttypedtableelementlistContext) { + localctx = NewOpttypedtableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, RedshiftParserRULE_opttypedtableelementlist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3766) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3767) + p.Typedtableelementlist() + } + { + p.SetState(3768) + p.Match(RedshiftParserCLOSE_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 +} + +// ITableelementlistContext is an interface to support dynamic dispatch. +type ITableelementlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTableelement() []ITableelementContext + Tableelement(i int) ITableelementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTableelementlistContext differentiates from other interfaces. + IsTableelementlistContext() +} + +type TableelementlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableelementlistContext() *TableelementlistContext { + var p = new(TableelementlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tableelementlist + return p +} + +func InitEmptyTableelementlistContext(p *TableelementlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tableelementlist +} + +func (*TableelementlistContext) IsTableelementlistContext() {} + +func NewTableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableelementlistContext { + var p = new(TableelementlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tableelementlist + + return p +} + +func (s *TableelementlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableelementlistContext) AllTableelement() []ITableelementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableelementContext); ok { + len++ + } + } + + tst := make([]ITableelementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableelementContext); ok { + tst[i] = t.(ITableelementContext) + i++ + } + } + + return tst +} + +func (s *TableelementlistContext) Tableelement(i int) ITableelementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableelementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableelementContext) +} + +func (s *TableelementlistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *TableelementlistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *TableelementlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTableelementlist(s) + } +} + +func (s *TableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTableelementlist(s) + } +} + +func (s *TableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTableelementlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tableelementlist() (localctx ITableelementlistContext) { + localctx = NewTableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, RedshiftParserRULE_tableelementlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3770) + p.Tableelement() + } + p.SetState(3775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(3771) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3772) + p.Tableelement() + } + + p.SetState(3777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITypedtableelementlistContext is an interface to support dynamic dispatch. +type ITypedtableelementlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTypedtableelement() []ITypedtableelementContext + Typedtableelement(i int) ITypedtableelementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTypedtableelementlistContext differentiates from other interfaces. + IsTypedtableelementlistContext() +} + +type TypedtableelementlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypedtableelementlistContext() *TypedtableelementlistContext { + var p = new(TypedtableelementlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_typedtableelementlist + return p +} + +func InitEmptyTypedtableelementlistContext(p *TypedtableelementlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_typedtableelementlist +} + +func (*TypedtableelementlistContext) IsTypedtableelementlistContext() {} + +func NewTypedtableelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypedtableelementlistContext { + var p = new(TypedtableelementlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_typedtableelementlist + + return p +} + +func (s *TypedtableelementlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypedtableelementlistContext) AllTypedtableelement() []ITypedtableelementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypedtableelementContext); ok { + len++ + } + } + + tst := make([]ITypedtableelementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypedtableelementContext); ok { + tst[i] = t.(ITypedtableelementContext) + i++ + } + } + + return tst +} + +func (s *TypedtableelementlistContext) Typedtableelement(i int) ITypedtableelementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypedtableelementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypedtableelementContext) +} + +func (s *TypedtableelementlistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *TypedtableelementlistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *TypedtableelementlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypedtableelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypedtableelementlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTypedtableelementlist(s) + } +} + +func (s *TypedtableelementlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTypedtableelementlist(s) + } +} + +func (s *TypedtableelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTypedtableelementlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Typedtableelementlist() (localctx ITypedtableelementlistContext) { + localctx = NewTypedtableelementlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, RedshiftParserRULE_typedtableelementlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3778) + p.Typedtableelement() + } + p.SetState(3783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(3779) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3780) + p.Typedtableelement() + } + + p.SetState(3785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableelementContext is an interface to support dynamic dispatch. +type ITableelementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableconstraint() ITableconstraintContext + Tablelikeclause() ITablelikeclauseContext + ColumnDef() IColumnDefContext + + // IsTableelementContext differentiates from other interfaces. + IsTableelementContext() +} + +type TableelementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableelementContext() *TableelementContext { + var p = new(TableelementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tableelement + return p +} + +func InitEmptyTableelementContext(p *TableelementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tableelement +} + +func (*TableelementContext) IsTableelementContext() {} + +func NewTableelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableelementContext { + var p = new(TableelementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tableelement + + return p +} + +func (s *TableelementContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableelementContext) Tableconstraint() ITableconstraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableconstraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableconstraintContext) +} + +func (s *TableelementContext) Tablelikeclause() ITablelikeclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablelikeclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablelikeclauseContext) +} + +func (s *TableelementContext) ColumnDef() IColumnDefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnDefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnDefContext) +} + +func (s *TableelementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableelementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTableelement(s) + } +} + +func (s *TableelementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTableelement(s) + } +} + +func (s *TableelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTableelement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tableelement() (localctx ITableelementContext) { + localctx = NewTableelementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, RedshiftParserRULE_tableelement) + p.SetState(3789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 171, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3786) + p.Tableconstraint() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3787) + p.Tablelikeclause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3788) + p.ColumnDef() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITypedtableelementContext is an interface to support dynamic dispatch. +type ITypedtableelementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ColumnOptions() IColumnOptionsContext + Tableconstraint() ITableconstraintContext + + // IsTypedtableelementContext differentiates from other interfaces. + IsTypedtableelementContext() +} + +type TypedtableelementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypedtableelementContext() *TypedtableelementContext { + var p = new(TypedtableelementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_typedtableelement + return p +} + +func InitEmptyTypedtableelementContext(p *TypedtableelementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_typedtableelement +} + +func (*TypedtableelementContext) IsTypedtableelementContext() {} + +func NewTypedtableelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypedtableelementContext { + var p = new(TypedtableelementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_typedtableelement + + return p +} + +func (s *TypedtableelementContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypedtableelementContext) ColumnOptions() IColumnOptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnOptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnOptionsContext) +} + +func (s *TypedtableelementContext) Tableconstraint() ITableconstraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableconstraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableconstraintContext) +} + +func (s *TypedtableelementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypedtableelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypedtableelementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTypedtableelement(s) + } +} + +func (s *TypedtableelementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTypedtableelement(s) + } +} + +func (s *TypedtableelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTypedtableelement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Typedtableelement() (localctx ITypedtableelementContext) { + localctx = NewTypedtableelementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, RedshiftParserRULE_typedtableelement) + p.SetState(3793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 172, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3791) + p.ColumnOptions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3792) + p.Tableconstraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnDefContext is an interface to support dynamic dispatch. +type IColumnDefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Extern_typename() IExtern_typenameContext + Create_generic_options() ICreate_generic_optionsContext + Rs_colattributes() IRs_colattributesContext + + // IsColumnDefContext differentiates from other interfaces. + IsColumnDefContext() +} + +type ColumnDefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnDefContext() *ColumnDefContext { + var p = new(ColumnDefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnDef + return p +} + +func InitEmptyColumnDefContext(p *ColumnDefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnDef +} + +func (*ColumnDefContext) IsColumnDefContext() {} + +func NewColumnDefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnDefContext { + var p = new(ColumnDefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_columnDef + + return p +} + +func (s *ColumnDefContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnDefContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ColumnDefContext) Extern_typename() IExtern_typenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtern_typenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtern_typenameContext) +} + +func (s *ColumnDefContext) Create_generic_options() ICreate_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_generic_optionsContext) +} + +func (s *ColumnDefContext) Rs_colattributes() IRs_colattributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRs_colattributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRs_colattributesContext) +} + +func (s *ColumnDefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnDefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnDefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumnDef(s) + } +} + +func (s *ColumnDefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumnDef(s) + } +} + +func (s *ColumnDefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumnDef(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) ColumnDef() (localctx IColumnDefContext) { + localctx = NewColumnDefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, RedshiftParserRULE_columnDef) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3795) + p.Colid() + } + { + p.SetState(3796) + p.Extern_typename() + } + p.SetState(3798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(3797) + p.Create_generic_options() + } + + } + p.SetState(3801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-43)) & ^0x3f) == 0 && ((int64(1)<<(_la-43))&72079635810092033) != 0) || _la == RedshiftParserIDENTITY_P || _la == RedshiftParserGENERATED || ((int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&7) != 0) { + { + p.SetState(3800) + p.Rs_colattributes() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRs_colattributesContext is an interface to support dynamic dispatch. +type IRs_colattributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRs_colattribute() []IRs_colattributeContext + Rs_colattribute(i int) IRs_colattributeContext + + // IsRs_colattributesContext differentiates from other interfaces. + IsRs_colattributesContext() +} + +type Rs_colattributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRs_colattributesContext() *Rs_colattributesContext { + var p = new(Rs_colattributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rs_colattributes + return p +} + +func InitEmptyRs_colattributesContext(p *Rs_colattributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rs_colattributes +} + +func (*Rs_colattributesContext) IsRs_colattributesContext() {} + +func NewRs_colattributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rs_colattributesContext { + var p = new(Rs_colattributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rs_colattributes + + return p +} + +func (s *Rs_colattributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rs_colattributesContext) AllRs_colattribute() []IRs_colattributeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRs_colattributeContext); ok { + len++ + } + } + + tst := make([]IRs_colattributeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRs_colattributeContext); ok { + tst[i] = t.(IRs_colattributeContext) + i++ + } + } + + return tst +} + +func (s *Rs_colattributesContext) Rs_colattribute(i int) IRs_colattributeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRs_colattributeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRs_colattributeContext) +} + +func (s *Rs_colattributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rs_colattributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rs_colattributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRs_colattributes(s) + } +} + +func (s *Rs_colattributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRs_colattributes(s) + } +} + +func (s *Rs_colattributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRs_colattributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rs_colattributes() (localctx IRs_colattributesContext) { + localctx = NewRs_colattributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, RedshiftParserRULE_rs_colattributes) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-43)) & ^0x3f) == 0 && ((int64(1)<<(_la-43))&72079635810092033) != 0) || _la == RedshiftParserIDENTITY_P || _la == RedshiftParserGENERATED || ((int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&7) != 0) { + { + p.SetState(3803) + p.Rs_colattribute() + } + + p.SetState(3806) + 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 +} + +// IRs_colattributeContext is an interface to support dynamic dispatch. +type IRs_colattributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSeed returns the seed rule contexts. + GetSeed() IIconstContext + + // GetStep returns the step rule contexts. + GetStep() IIconstContext + + // SetSeed sets the seed rule contexts. + SetSeed(IIconstContext) + + // SetStep sets the step rule contexts. + SetStep(IIconstContext) + + // Getter signatures + DEFAULT() antlr.TerminalNode + B_expr() IB_exprContext + IDENTITY_P() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + COMMA() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + AllIconst() []IIconstContext + Iconst(i int) IIconstContext + GENERATED() antlr.TerminalNode + Generated_when() IGenerated_whenContext + AS() antlr.TerminalNode + ENCODE() antlr.TerminalNode + Colid() IColidContext + DISTKEY() antlr.TerminalNode + SORTKEY() antlr.TerminalNode + COLLATE() antlr.TerminalNode + CASE_SENSITIVE() antlr.TerminalNode + CASE_INSENSITIVE() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_P() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_column_list() IOpt_column_listContext + + // IsRs_colattributeContext differentiates from other interfaces. + IsRs_colattributeContext() +} + +type Rs_colattributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + seed IIconstContext + step IIconstContext +} + +func NewEmptyRs_colattributeContext() *Rs_colattributeContext { + var p = new(Rs_colattributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rs_colattribute + return p +} + +func InitEmptyRs_colattributeContext(p *Rs_colattributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rs_colattribute +} + +func (*Rs_colattributeContext) IsRs_colattributeContext() {} + +func NewRs_colattributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rs_colattributeContext { + var p = new(Rs_colattributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rs_colattribute + + return p +} + +func (s *Rs_colattributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rs_colattributeContext) GetSeed() IIconstContext { return s.seed } + +func (s *Rs_colattributeContext) GetStep() IIconstContext { return s.step } + +func (s *Rs_colattributeContext) SetSeed(v IIconstContext) { s.seed = v } + +func (s *Rs_colattributeContext) SetStep(v IIconstContext) { s.step = v } + +func (s *Rs_colattributeContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Rs_colattributeContext) B_expr() IB_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IB_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IB_exprContext) +} + +func (s *Rs_colattributeContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *Rs_colattributeContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Rs_colattributeContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Rs_colattributeContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Rs_colattributeContext) AllIconst() []IIconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIconstContext); ok { + len++ + } + } + + tst := make([]IIconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIconstContext); ok { + tst[i] = t.(IIconstContext) + i++ + } + } + + return tst +} + +func (s *Rs_colattributeContext) Iconst(i int) IIconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Rs_colattributeContext) GENERATED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGENERATED, 0) +} + +func (s *Rs_colattributeContext) Generated_when() IGenerated_whenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_whenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_whenContext) +} + +func (s *Rs_colattributeContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Rs_colattributeContext) ENCODE() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODE, 0) +} + +func (s *Rs_colattributeContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Rs_colattributeContext) DISTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTKEY, 0) +} + +func (s *Rs_colattributeContext) SORTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSORTKEY, 0) +} + +func (s *Rs_colattributeContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Rs_colattributeContext) CASE_SENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_SENSITIVE, 0) +} + +func (s *Rs_colattributeContext) CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_INSENSITIVE, 0) +} + +func (s *Rs_colattributeContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Rs_colattributeContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Rs_colattributeContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIQUE, 0) +} + +func (s *Rs_colattributeContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIMARY, 0) +} + +func (s *Rs_colattributeContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *Rs_colattributeContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCES, 0) +} + +func (s *Rs_colattributeContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Rs_colattributeContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *Rs_colattributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rs_colattributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rs_colattributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRs_colattribute(s) + } +} + +func (s *Rs_colattributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRs_colattribute(s) + } +} + +func (s *Rs_colattributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRs_colattribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rs_colattribute() (localctx IRs_colattributeContext) { + localctx = NewRs_colattributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, RedshiftParserRULE_rs_colattribute) + var _la int + + p.SetState(3846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3808) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3809) + p.b_expr(0) + } + + case RedshiftParserIDENTITY_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3810) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3811) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3812) + + var _x = p.Iconst() + + localctx.(*Rs_colattributeContext).seed = _x + } + { + p.SetState(3813) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3814) + + var _x = p.Iconst() + + localctx.(*Rs_colattributeContext).step = _x + } + { + p.SetState(3815) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserGENERATED: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3817) + p.Match(RedshiftParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3818) + p.Generated_when() + } + { + p.SetState(3819) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3820) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(3821) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3822) + + var _x = p.Iconst() + + localctx.(*Rs_colattributeContext).seed = _x + } + { + p.SetState(3823) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3824) + + var _x = p.Iconst() + + localctx.(*Rs_colattributeContext).step = _x + } + { + p.SetState(3825) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case RedshiftParserENCODE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3829) + p.Match(RedshiftParserENCODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3830) + p.Colid() + } + + case RedshiftParserDISTKEY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3831) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSORTKEY: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3832) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCOLLATE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3833) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3834) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASE_SENSITIVE || _la == RedshiftParserCASE_INSENSITIVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserNOT: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3835) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3836) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNULL_P: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3837) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUNIQUE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3838) + p.Match(RedshiftParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserPRIMARY: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3839) + p.Match(RedshiftParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3840) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserREFERENCES: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3841) + p.Match(RedshiftParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3842) + p.Qualified_name() + } + p.SetState(3844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(3843) + p.Opt_column_list() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnOptionsContext is an interface to support dynamic dispatch. +type IColumnOptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Colquallist() IColquallistContext + WITH() antlr.TerminalNode + OPTIONS() antlr.TerminalNode + + // IsColumnOptionsContext differentiates from other interfaces. + IsColumnOptionsContext() +} + +type ColumnOptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnOptionsContext() *ColumnOptionsContext { + var p = new(ColumnOptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnOptions + return p +} + +func InitEmptyColumnOptionsContext(p *ColumnOptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnOptions +} + +func (*ColumnOptionsContext) IsColumnOptionsContext() {} + +func NewColumnOptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnOptionsContext { + var p = new(ColumnOptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_columnOptions + + return p +} + +func (s *ColumnOptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnOptionsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ColumnOptionsContext) Colquallist() IColquallistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColquallistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColquallistContext) +} + +func (s *ColumnOptionsContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *ColumnOptionsContext) OPTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTIONS, 0) +} + +func (s *ColumnOptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnOptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnOptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumnOptions(s) + } +} + +func (s *ColumnOptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumnOptions(s) + } +} + +func (s *ColumnOptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumnOptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) ColumnOptions() (localctx IColumnOptionsContext) { + localctx = NewColumnOptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, RedshiftParserRULE_columnOptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3848) + p.Colid() + } + p.SetState(3851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(3849) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3850) + p.Match(RedshiftParserOPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3853) + p.Colquallist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColquallistContext is an interface to support dynamic dispatch. +type IColquallistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColconstraint() []IColconstraintContext + Colconstraint(i int) IColconstraintContext + + // IsColquallistContext differentiates from other interfaces. + IsColquallistContext() +} + +type ColquallistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColquallistContext() *ColquallistContext { + var p = new(ColquallistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colquallist + return p +} + +func InitEmptyColquallistContext(p *ColquallistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colquallist +} + +func (*ColquallistContext) IsColquallistContext() {} + +func NewColquallistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColquallistContext { + var p = new(ColquallistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_colquallist + + return p +} + +func (s *ColquallistContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColquallistContext) AllColconstraint() []IColconstraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColconstraintContext); ok { + len++ + } + } + + tst := make([]IColconstraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColconstraintContext); ok { + tst[i] = t.(IColconstraintContext) + i++ + } + } + + return tst +} + +func (s *ColquallistContext) Colconstraint(i int) IColconstraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColconstraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColconstraintContext) +} + +func (s *ColquallistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColquallistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColquallistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColquallist(s) + } +} + +func (s *ColquallistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColquallist(s) + } +} + +func (s *ColquallistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColquallist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Colquallist() (localctx IColquallistContext) { + localctx = NewColquallistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, RedshiftParserRULE_colquallist) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-42)) & ^0x3f) == 0 && ((int64(1)<<(_la-42))&144159271754405899) != 0) || _la == RedshiftParserGENERATED { + { + p.SetState(3855) + p.Colconstraint() + } + + p.SetState(3860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColconstraintContext is an interface to support dynamic dispatch. +type IColconstraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRAINT() antlr.TerminalNode + Name() INameContext + Colconstraintelem() IColconstraintelemContext + Constraintattr() IConstraintattrContext + COLLATE() antlr.TerminalNode + Any_name() IAny_nameContext + + // IsColconstraintContext differentiates from other interfaces. + IsColconstraintContext() +} + +type ColconstraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColconstraintContext() *ColconstraintContext { + var p = new(ColconstraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colconstraint + return p +} + +func InitEmptyColconstraintContext(p *ColconstraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colconstraint +} + +func (*ColconstraintContext) IsColconstraintContext() {} + +func NewColconstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColconstraintContext { + var p = new(ColconstraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_colconstraint + + return p +} + +func (s *ColconstraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColconstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *ColconstraintContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *ColconstraintContext) Colconstraintelem() IColconstraintelemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColconstraintelemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColconstraintelemContext) +} + +func (s *ColconstraintContext) Constraintattr() IConstraintattrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintattrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintattrContext) +} + +func (s *ColconstraintContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *ColconstraintContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *ColconstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColconstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColconstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColconstraint(s) + } +} + +func (s *ColconstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColconstraint(s) + } +} + +func (s *ColconstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColconstraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Colconstraint() (localctx IColconstraintContext) { + localctx = NewColconstraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, RedshiftParserRULE_colconstraint) + p.SetState(3869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 181, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3861) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3862) + p.Name() + } + { + p.SetState(3863) + p.Colconstraintelem() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3865) + p.Colconstraintelem() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3866) + p.Constraintattr() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3867) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3868) + p.Any_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColconstraintelemContext is an interface to support dynamic dispatch. +type IColconstraintelemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT() antlr.TerminalNode + NULL_P() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + Opt_unique_null_treatment() IOpt_unique_null_treatmentContext + Opt_definition() IOpt_definitionContext + Optconstablespace() IOptconstablespaceContext + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + CHECK() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + Opt_no_inherit() IOpt_no_inheritContext + DEFAULT() antlr.TerminalNode + B_expr() IB_exprContext + GENERATED() antlr.TerminalNode + Generated_when() IGenerated_whenContext + AS() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + STORED() antlr.TerminalNode + Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext + REFERENCES() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_column_list() IOpt_column_listContext + Key_match() IKey_matchContext + Key_actions() IKey_actionsContext + + // IsColconstraintelemContext differentiates from other interfaces. + IsColconstraintelemContext() +} + +type ColconstraintelemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColconstraintelemContext() *ColconstraintelemContext { + var p = new(ColconstraintelemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colconstraintelem + return p +} + +func InitEmptyColconstraintelemContext(p *ColconstraintelemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colconstraintelem +} + +func (*ColconstraintelemContext) IsColconstraintelemContext() {} + +func NewColconstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColconstraintelemContext { + var p = new(ColconstraintelemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_colconstraintelem + + return p +} + +func (s *ColconstraintelemContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColconstraintelemContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *ColconstraintelemContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *ColconstraintelemContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIQUE, 0) +} + +func (s *ColconstraintelemContext) Opt_unique_null_treatment() IOpt_unique_null_treatmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_unique_null_treatmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_unique_null_treatmentContext) +} + +func (s *ColconstraintelemContext) Opt_definition() IOpt_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_definitionContext) +} + +func (s *ColconstraintelemContext) Optconstablespace() IOptconstablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptconstablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptconstablespaceContext) +} + +func (s *ColconstraintelemContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIMARY, 0) +} + +func (s *ColconstraintelemContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *ColconstraintelemContext) CHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECK, 0) +} + +func (s *ColconstraintelemContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ColconstraintelemContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *ColconstraintelemContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ColconstraintelemContext) Opt_no_inherit() IOpt_no_inheritContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_no_inheritContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_no_inheritContext) +} + +func (s *ColconstraintelemContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *ColconstraintelemContext) B_expr() IB_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IB_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IB_exprContext) +} + +func (s *ColconstraintelemContext) GENERATED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGENERATED, 0) +} + +func (s *ColconstraintelemContext) Generated_when() IGenerated_whenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerated_whenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerated_whenContext) +} + +func (s *ColconstraintelemContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *ColconstraintelemContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *ColconstraintelemContext) STORED() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTORED, 0) +} + +func (s *ColconstraintelemContext) Optparenthesizedseqoptlist() IOptparenthesizedseqoptlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptparenthesizedseqoptlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptparenthesizedseqoptlistContext) +} + +func (s *ColconstraintelemContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCES, 0) +} + +func (s *ColconstraintelemContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ColconstraintelemContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *ColconstraintelemContext) Key_match() IKey_matchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_matchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_matchContext) +} + +func (s *ColconstraintelemContext) Key_actions() IKey_actionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_actionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_actionsContext) +} + +func (s *ColconstraintelemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColconstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColconstraintelemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColconstraintelem(s) + } +} + +func (s *ColconstraintelemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColconstraintelem(s) + } +} + +func (s *ColconstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColconstraintelem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Colconstraintelem() (localctx IColconstraintelemContext) { + localctx = NewColconstraintelemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, RedshiftParserRULE_colconstraintelem) + var _la int + + p.SetState(3926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNOT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3871) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3872) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNULL_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3873) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUNIQUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3874) + p.Match(RedshiftParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNULLS_P { + { + p.SetState(3875) + p.Opt_unique_null_treatment() + } + + } + p.SetState(3879) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 183, p.GetParserRuleContext()) == 1 { + { + p.SetState(3878) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(3881) + p.Optconstablespace() + } + + } + + case RedshiftParserPRIMARY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3884) + p.Match(RedshiftParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3885) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3887) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 185, p.GetParserRuleContext()) == 1 { + { + p.SetState(3886) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(3889) + p.Optconstablespace() + } + + } + + case RedshiftParserCHECK: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3892) + p.Match(RedshiftParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3893) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3894) + p.A_expr() + } + { + p.SetState(3895) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(3896) + p.Opt_no_inherit() + } + + } + + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3899) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3900) + p.b_expr(0) + } + + case RedshiftParserGENERATED: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3901) + p.Match(RedshiftParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3902) + p.Generated_when() + } + { + p.SetState(3903) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIDENTITY_P: + { + p.SetState(3904) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3906) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 188, p.GetParserRuleContext()) == 1 { + { + p.SetState(3905) + p.Optparenthesizedseqoptlist() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserOPEN_PAREN: + { + p.SetState(3908) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3909) + p.A_expr() + } + { + p.SetState(3910) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3911) + p.Match(RedshiftParserSTORED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case RedshiftParserREFERENCES: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3915) + p.Match(RedshiftParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3916) + p.Qualified_name() + } + p.SetState(3918) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 190, p.GetParserRuleContext()) == 1 { + { + p.SetState(3917) + p.Opt_column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMATCH { + { + p.SetState(3920) + p.Key_match() + } + + } + p.SetState(3924) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserON { + { + p.SetState(3923) + p.Key_actions() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_unique_null_treatmentContext is an interface to support dynamic dispatch. +type IOpt_unique_null_treatmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULLS_P() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsOpt_unique_null_treatmentContext differentiates from other interfaces. + IsOpt_unique_null_treatmentContext() +} + +type Opt_unique_null_treatmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_unique_null_treatmentContext() *Opt_unique_null_treatmentContext { + var p = new(Opt_unique_null_treatmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_unique_null_treatment + return p +} + +func InitEmptyOpt_unique_null_treatmentContext(p *Opt_unique_null_treatmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_unique_null_treatment +} + +func (*Opt_unique_null_treatmentContext) IsOpt_unique_null_treatmentContext() {} + +func NewOpt_unique_null_treatmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_unique_null_treatmentContext { + var p = new(Opt_unique_null_treatmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_unique_null_treatment + + return p +} + +func (s *Opt_unique_null_treatmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_unique_null_treatmentContext) NULLS_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULLS_P, 0) +} + +func (s *Opt_unique_null_treatmentContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTINCT, 0) +} + +func (s *Opt_unique_null_treatmentContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Opt_unique_null_treatmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_unique_null_treatmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_unique_null_treatmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_unique_null_treatment(s) + } +} + +func (s *Opt_unique_null_treatmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_unique_null_treatment(s) + } +} + +func (s *Opt_unique_null_treatmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_unique_null_treatment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_unique_null_treatment() (localctx IOpt_unique_null_treatmentContext) { + localctx = NewOpt_unique_null_treatmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, RedshiftParserRULE_opt_unique_null_treatment) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3928) + p.Match(RedshiftParserNULLS_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(3929) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3932) + p.Match(RedshiftParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGenerated_whenContext is an interface to support dynamic dispatch. +type IGenerated_whenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALWAYS() antlr.TerminalNode + BY() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsGenerated_whenContext differentiates from other interfaces. + IsGenerated_whenContext() +} + +type Generated_whenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGenerated_whenContext() *Generated_whenContext { + var p = new(Generated_whenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generated_when + return p +} + +func InitEmptyGenerated_whenContext(p *Generated_whenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generated_when +} + +func (*Generated_whenContext) IsGenerated_whenContext() {} + +func NewGenerated_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generated_whenContext { + var p = new(Generated_whenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generated_when + + return p +} + +func (s *Generated_whenContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generated_whenContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(RedshiftParserALWAYS, 0) +} + +func (s *Generated_whenContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Generated_whenContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Generated_whenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generated_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generated_whenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGenerated_when(s) + } +} + +func (s *Generated_whenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGenerated_when(s) + } +} + +func (s *Generated_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGenerated_when(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generated_when() (localctx IGenerated_whenContext) { + localctx = NewGenerated_whenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, RedshiftParserRULE_generated_when) + p.SetState(3937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserALWAYS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3934) + p.Match(RedshiftParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserBY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3935) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3936) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraintattrContext is an interface to support dynamic dispatch. +type IConstraintattrContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFERRABLE() antlr.TerminalNode + NOT() antlr.TerminalNode + INITIALLY() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + + // IsConstraintattrContext differentiates from other interfaces. + IsConstraintattrContext() +} + +type ConstraintattrContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraintattrContext() *ConstraintattrContext { + var p = new(ConstraintattrContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintattr + return p +} + +func InitEmptyConstraintattrContext(p *ConstraintattrContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintattr +} + +func (*ConstraintattrContext) IsConstraintattrContext() {} + +func NewConstraintattrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattrContext { + var p = new(ConstraintattrContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constraintattr + + return p +} + +func (s *ConstraintattrContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstraintattrContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRABLE, 0) +} + +func (s *ConstraintattrContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *ConstraintattrContext) INITIALLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserINITIALLY, 0) +} + +func (s *ConstraintattrContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRED, 0) +} + +func (s *ConstraintattrContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMEDIATE, 0) +} + +func (s *ConstraintattrContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintattrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstraintattrContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstraintattr(s) + } +} + +func (s *ConstraintattrContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstraintattr(s) + } +} + +func (s *ConstraintattrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstraintattr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constraintattr() (localctx IConstraintattrContext) { + localctx = NewConstraintattrContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, RedshiftParserRULE_constraintattr) + var _la int + + p.SetState(3944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFERRABLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3939) + p.Match(RedshiftParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNOT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3940) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3941) + p.Match(RedshiftParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserINITIALLY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3942) + p.Match(RedshiftParserINITIALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3943) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserDEFERRED || _la == RedshiftParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablelikeclauseContext is an interface to support dynamic dispatch. +type ITablelikeclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Tablelikeoptionlist() ITablelikeoptionlistContext + + // IsTablelikeclauseContext differentiates from other interfaces. + IsTablelikeclauseContext() +} + +type TablelikeclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablelikeclauseContext() *TablelikeclauseContext { + var p = new(TablelikeclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablelikeclause + return p +} + +func InitEmptyTablelikeclauseContext(p *TablelikeclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablelikeclause +} + +func (*TablelikeclauseContext) IsTablelikeclauseContext() {} + +func NewTablelikeclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeclauseContext { + var p = new(TablelikeclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tablelikeclause + + return p +} + +func (s *TablelikeclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablelikeclauseContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *TablelikeclauseContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *TablelikeclauseContext) Tablelikeoptionlist() ITablelikeoptionlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablelikeoptionlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablelikeoptionlistContext) +} + +func (s *TablelikeclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablelikeclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablelikeclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTablelikeclause(s) + } +} + +func (s *TablelikeclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTablelikeclause(s) + } +} + +func (s *TablelikeclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTablelikeclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tablelikeclause() (localctx ITablelikeclauseContext) { + localctx = NewTablelikeclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, RedshiftParserRULE_tablelikeclause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3946) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3947) + p.Qualified_name() + } + { + p.SetState(3948) + p.Tablelikeoptionlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablelikeoptionlistContext is an interface to support dynamic dispatch. +type ITablelikeoptionlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTablelikeoption() []ITablelikeoptionContext + Tablelikeoption(i int) ITablelikeoptionContext + AllINCLUDING() []antlr.TerminalNode + INCLUDING(i int) antlr.TerminalNode + AllEXCLUDING() []antlr.TerminalNode + EXCLUDING(i int) antlr.TerminalNode + + // IsTablelikeoptionlistContext differentiates from other interfaces. + IsTablelikeoptionlistContext() +} + +type TablelikeoptionlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablelikeoptionlistContext() *TablelikeoptionlistContext { + var p = new(TablelikeoptionlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablelikeoptionlist + return p +} + +func InitEmptyTablelikeoptionlistContext(p *TablelikeoptionlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablelikeoptionlist +} + +func (*TablelikeoptionlistContext) IsTablelikeoptionlistContext() {} + +func NewTablelikeoptionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeoptionlistContext { + var p = new(TablelikeoptionlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tablelikeoptionlist + + return p +} + +func (s *TablelikeoptionlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablelikeoptionlistContext) AllTablelikeoption() []ITablelikeoptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablelikeoptionContext); ok { + len++ + } + } + + tst := make([]ITablelikeoptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablelikeoptionContext); ok { + tst[i] = t.(ITablelikeoptionContext) + i++ + } + } + + return tst +} + +func (s *TablelikeoptionlistContext) Tablelikeoption(i int) ITablelikeoptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablelikeoptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablelikeoptionContext) +} + +func (s *TablelikeoptionlistContext) AllINCLUDING() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserINCLUDING) +} + +func (s *TablelikeoptionlistContext) INCLUDING(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDING, i) +} + +func (s *TablelikeoptionlistContext) AllEXCLUDING() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserEXCLUDING) +} + +func (s *TablelikeoptionlistContext) EXCLUDING(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDING, i) +} + +func (s *TablelikeoptionlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablelikeoptionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablelikeoptionlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTablelikeoptionlist(s) + } +} + +func (s *TablelikeoptionlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTablelikeoptionlist(s) + } +} + +func (s *TablelikeoptionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTablelikeoptionlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tablelikeoptionlist() (localctx ITablelikeoptionlistContext) { + localctx = NewTablelikeoptionlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, RedshiftParserRULE_tablelikeoptionlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(3954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserEXCLUDING || _la == RedshiftParserINCLUDING { + { + p.SetState(3950) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXCLUDING || _la == RedshiftParserINCLUDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3951) + p.Tablelikeoption() + } + + p.SetState(3956) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablelikeoptionContext is an interface to support dynamic dispatch. +type ITablelikeoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENTS() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + DEFAULTS() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + GENERATED() antlr.TerminalNode + INDEXES() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + STORAGE() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsTablelikeoptionContext differentiates from other interfaces. + IsTablelikeoptionContext() +} + +type TablelikeoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablelikeoptionContext() *TablelikeoptionContext { + var p = new(TablelikeoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablelikeoption + return p +} + +func InitEmptyTablelikeoptionContext(p *TablelikeoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablelikeoption +} + +func (*TablelikeoptionContext) IsTablelikeoptionContext() {} + +func NewTablelikeoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablelikeoptionContext { + var p = new(TablelikeoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tablelikeoption + + return p +} + +func (s *TablelikeoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablelikeoptionContext) COMMENTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMENTS, 0) +} + +func (s *TablelikeoptionContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINTS, 0) +} + +func (s *TablelikeoptionContext) DEFAULTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULTS, 0) +} + +func (s *TablelikeoptionContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *TablelikeoptionContext) GENERATED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGENERATED, 0) +} + +func (s *TablelikeoptionContext) INDEXES() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEXES, 0) +} + +func (s *TablelikeoptionContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *TablelikeoptionContext) STORAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTORAGE, 0) +} + +func (s *TablelikeoptionContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *TablelikeoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablelikeoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablelikeoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTablelikeoption(s) + } +} + +func (s *TablelikeoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTablelikeoption(s) + } +} + +func (s *TablelikeoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTablelikeoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tablelikeoption() (localctx ITablelikeoptionContext) { + localctx = NewTablelikeoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, RedshiftParserRULE_tablelikeoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3957) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || ((int64((_la-162)) & ^0x3f) == 0 && ((int64(1)<<(_la-162))&2305843009215791137) != 0) || _la == RedshiftParserINDEXES || _la == RedshiftParserSTATISTICS || _la == RedshiftParserSTORAGE || _la == RedshiftParserGENERATED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITableconstraintContext is an interface to support dynamic dispatch. +type ITableconstraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRAINT() antlr.TerminalNode + Name() INameContext + Constraintelem() IConstraintelemContext + + // IsTableconstraintContext differentiates from other interfaces. + IsTableconstraintContext() +} + +type TableconstraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableconstraintContext() *TableconstraintContext { + var p = new(TableconstraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tableconstraint + return p +} + +func InitEmptyTableconstraintContext(p *TableconstraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tableconstraint +} + +func (*TableconstraintContext) IsTableconstraintContext() {} + +func NewTableconstraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TableconstraintContext { + var p = new(TableconstraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tableconstraint + + return p +} + +func (s *TableconstraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *TableconstraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *TableconstraintContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *TableconstraintContext) Constraintelem() IConstraintelemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintelemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintelemContext) +} + +func (s *TableconstraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TableconstraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TableconstraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTableconstraint(s) + } +} + +func (s *TableconstraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTableconstraint(s) + } +} + +func (s *TableconstraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTableconstraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tableconstraint() (localctx ITableconstraintContext) { + localctx = NewTableconstraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, RedshiftParserRULE_tableconstraint) + p.SetState(3964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCONSTRAINT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3959) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3960) + p.Name() + } + { + p.SetState(3961) + p.Constraintelem() + } + + case RedshiftParserCHECK, RedshiftParserFOREIGN, RedshiftParserPRIMARY, RedshiftParserUNIQUE, RedshiftParserEXCLUDE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3963) + p.Constraintelem() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraintelemContext is an interface to support dynamic dispatch. +type IConstraintelemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + Constraintattributespec() IConstraintattributespecContext + UNIQUE() antlr.TerminalNode + Columnlist() IColumnlistContext + Existingindex() IExistingindexContext + Opt_unique_null_treatment() IOpt_unique_null_treatmentContext + Opt_c_include() IOpt_c_includeContext + Opt_definition() IOpt_definitionContext + Optconstablespace() IOptconstablespaceContext + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + Exclusionconstraintlist() IExclusionconstraintlistContext + Access_method_clause() IAccess_method_clauseContext + Exclusionwhereclause() IExclusionwhereclauseContext + FOREIGN() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_column_list() IOpt_column_listContext + Key_match() IKey_matchContext + Key_actions() IKey_actionsContext + + // IsConstraintelemContext differentiates from other interfaces. + IsConstraintelemContext() +} + +type ConstraintelemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraintelemContext() *ConstraintelemContext { + var p = new(ConstraintelemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintelem + return p +} + +func InitEmptyConstraintelemContext(p *ConstraintelemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintelem +} + +func (*ConstraintelemContext) IsConstraintelemContext() {} + +func NewConstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintelemContext { + var p = new(ConstraintelemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constraintelem + + return p +} + +func (s *ConstraintelemContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstraintelemContext) CHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECK, 0) +} + +func (s *ConstraintelemContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ConstraintelemContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *ConstraintelemContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ConstraintelemContext) Constraintattributespec() IConstraintattributespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintattributespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintattributespecContext) +} + +func (s *ConstraintelemContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIQUE, 0) +} + +func (s *ConstraintelemContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *ConstraintelemContext) Existingindex() IExistingindexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExistingindexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExistingindexContext) +} + +func (s *ConstraintelemContext) Opt_unique_null_treatment() IOpt_unique_null_treatmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_unique_null_treatmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_unique_null_treatmentContext) +} + +func (s *ConstraintelemContext) Opt_c_include() IOpt_c_includeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_c_includeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_c_includeContext) +} + +func (s *ConstraintelemContext) Opt_definition() IOpt_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_definitionContext) +} + +func (s *ConstraintelemContext) Optconstablespace() IOptconstablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptconstablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptconstablespaceContext) +} + +func (s *ConstraintelemContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIMARY, 0) +} + +func (s *ConstraintelemContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *ConstraintelemContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDE, 0) +} + +func (s *ConstraintelemContext) Exclusionconstraintlist() IExclusionconstraintlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExclusionconstraintlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExclusionconstraintlistContext) +} + +func (s *ConstraintelemContext) Access_method_clause() IAccess_method_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccess_method_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccess_method_clauseContext) +} + +func (s *ConstraintelemContext) Exclusionwhereclause() IExclusionwhereclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExclusionwhereclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExclusionwhereclauseContext) +} + +func (s *ConstraintelemContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *ConstraintelemContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCES, 0) +} + +func (s *ConstraintelemContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ConstraintelemContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *ConstraintelemContext) Key_match() IKey_matchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_matchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_matchContext) +} + +func (s *ConstraintelemContext) Key_actions() IKey_actionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_actionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_actionsContext) +} + +func (s *ConstraintelemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstraintelemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstraintelem(s) + } +} + +func (s *ConstraintelemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstraintelem(s) + } +} + +func (s *ConstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstraintelem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constraintelem() (localctx IConstraintelemContext) { + localctx = NewConstraintelemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, RedshiftParserRULE_constraintelem) + var _la int + + p.SetState(4055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCHECK: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3966) + p.Match(RedshiftParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3967) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3968) + p.A_expr() + } + { + p.SetState(3969) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3970) + p.Constraintattributespec() + } + + case RedshiftParserUNIQUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3972) + p.Match(RedshiftParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNULLS_P { + { + p.SetState(3973) + p.Opt_unique_null_treatment() + } + + } + p.SetState(3993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN: + { + p.SetState(3976) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3977) + p.Columnlist() + } + { + p.SetState(3978) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINCLUDE { + { + p.SetState(3979) + p.Opt_c_include() + } + + } + p.SetState(3983) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 201, p.GetParserRuleContext()) == 1 { + { + p.SetState(3982) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(3985) + p.Optconstablespace() + } + + } + { + p.SetState(3988) + p.Constraintattributespec() + } + + case RedshiftParserUSING: + { + p.SetState(3990) + p.Existingindex() + } + { + p.SetState(3991) + p.Constraintattributespec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case RedshiftParserPRIMARY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3995) + p.Match(RedshiftParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3996) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN: + { + p.SetState(3997) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3998) + p.Columnlist() + } + { + p.SetState(3999) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINCLUDE { + { + p.SetState(4000) + p.Opt_c_include() + } + + } + p.SetState(4004) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 205, p.GetParserRuleContext()) == 1 { + { + p.SetState(4003) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(4006) + p.Optconstablespace() + } + + } + { + p.SetState(4009) + p.Constraintattributespec() + } + + case RedshiftParserUSING: + { + p.SetState(4011) + p.Existingindex() + } + { + p.SetState(4012) + p.Constraintattributespec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case RedshiftParserEXCLUDE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4016) + p.Match(RedshiftParserEXCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(4017) + p.Access_method_clause() + } + + } + { + p.SetState(4020) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4021) + p.Exclusionconstraintlist() + } + { + p.SetState(4022) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINCLUDE { + { + p.SetState(4023) + p.Opt_c_include() + } + + } + p.SetState(4027) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 210, p.GetParserRuleContext()) == 1 { + { + p.SetState(4026) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(4029) + p.Optconstablespace() + } + + } + p.SetState(4033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(4032) + p.Exclusionwhereclause() + } + + } + { + p.SetState(4035) + p.Constraintattributespec() + } + + case RedshiftParserFOREIGN: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4037) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4038) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4039) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4040) + p.Columnlist() + } + { + p.SetState(4041) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4042) + p.Match(RedshiftParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4043) + p.Qualified_name() + } + p.SetState(4045) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 213, p.GetParserRuleContext()) == 1 { + { + p.SetState(4044) + p.Opt_column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMATCH { + { + p.SetState(4047) + p.Key_match() + } + + } + p.SetState(4051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserON { + { + p.SetState(4050) + p.Key_actions() + } + + } + { + p.SetState(4053) + p.Constraintattributespec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_no_inheritContext is an interface to support dynamic dispatch. +type IOpt_no_inheritContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + INHERIT() antlr.TerminalNode + + // IsOpt_no_inheritContext differentiates from other interfaces. + IsOpt_no_inheritContext() +} + +type Opt_no_inheritContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_no_inheritContext() *Opt_no_inheritContext { + var p = new(Opt_no_inheritContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_no_inherit + return p +} + +func InitEmptyOpt_no_inheritContext(p *Opt_no_inheritContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_no_inherit +} + +func (*Opt_no_inheritContext) IsOpt_no_inheritContext() {} + +func NewOpt_no_inheritContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_no_inheritContext { + var p = new(Opt_no_inheritContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_no_inherit + + return p +} + +func (s *Opt_no_inheritContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_no_inheritContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_no_inheritContext) INHERIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINHERIT, 0) +} + +func (s *Opt_no_inheritContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_no_inheritContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_no_inheritContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_no_inherit(s) + } +} + +func (s *Opt_no_inheritContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_no_inherit(s) + } +} + +func (s *Opt_no_inheritContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_no_inherit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_no_inherit() (localctx IOpt_no_inheritContext) { + localctx = NewOpt_no_inheritContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, RedshiftParserRULE_opt_no_inherit) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4057) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4058) + p.Match(RedshiftParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_column_listContext is an interface to support dynamic dispatch. +type IOpt_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_column_listContext differentiates from other interfaces. + IsOpt_column_listContext() +} + +type Opt_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_column_listContext() *Opt_column_listContext { + var p = new(Opt_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_column_list + return p +} + +func InitEmptyOpt_column_listContext(p *Opt_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_column_list +} + +func (*Opt_column_listContext) IsOpt_column_listContext() {} + +func NewOpt_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_column_listContext { + var p = new(Opt_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_column_list + + return p +} + +func (s *Opt_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_column_listContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_column_listContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Opt_column_listContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_column_list(s) + } +} + +func (s *Opt_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_column_list(s) + } +} + +func (s *Opt_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_column_list() (localctx IOpt_column_listContext) { + localctx = NewOpt_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, RedshiftParserRULE_opt_column_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4060) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4061) + p.Columnlist() + } + { + p.SetState(4062) + p.Match(RedshiftParserCLOSE_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 +} + +// IColumnlistContext is an interface to support dynamic dispatch. +type IColumnlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumnElem() []IColumnElemContext + ColumnElem(i int) IColumnElemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumnlistContext differentiates from other interfaces. + IsColumnlistContext() +} + +type ColumnlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnlistContext() *ColumnlistContext { + var p = new(ColumnlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnlist + return p +} + +func InitEmptyColumnlistContext(p *ColumnlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnlist +} + +func (*ColumnlistContext) IsColumnlistContext() {} + +func NewColumnlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnlistContext { + var p = new(ColumnlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_columnlist + + return p +} + +func (s *ColumnlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnlistContext) AllColumnElem() []IColumnElemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumnElemContext); ok { + len++ + } + } + + tst := make([]IColumnElemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumnElemContext); ok { + tst[i] = t.(IColumnElemContext) + i++ + } + } + + return tst +} + +func (s *ColumnlistContext) ColumnElem(i int) IColumnElemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnElemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumnElemContext) +} + +func (s *ColumnlistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *ColumnlistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *ColumnlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumnlist(s) + } +} + +func (s *ColumnlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumnlist(s) + } +} + +func (s *ColumnlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumnlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Columnlist() (localctx IColumnlistContext) { + localctx = NewColumnlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, RedshiftParserRULE_columnlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4064) + p.ColumnElem() + } + p.SetState(4069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(4065) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4066) + p.ColumnElem() + } + + p.SetState(4071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnElemContext is an interface to support dynamic dispatch. +type IColumnElemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + + // IsColumnElemContext differentiates from other interfaces. + IsColumnElemContext() +} + +type ColumnElemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnElemContext() *ColumnElemContext { + var p = new(ColumnElemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnElem + return p +} + +func InitEmptyColumnElemContext(p *ColumnElemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnElem +} + +func (*ColumnElemContext) IsColumnElemContext() {} + +func NewColumnElemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnElemContext { + var p = new(ColumnElemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_columnElem + + return p +} + +func (s *ColumnElemContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnElemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ColumnElemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnElemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnElemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumnElem(s) + } +} + +func (s *ColumnElemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumnElem(s) + } +} + +func (s *ColumnElemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumnElem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) ColumnElem() (localctx IColumnElemContext) { + localctx = NewColumnElemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, RedshiftParserRULE_columnElem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4072) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_c_includeContext is an interface to support dynamic dispatch. +type IOpt_c_includeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCLUDE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_c_includeContext differentiates from other interfaces. + IsOpt_c_includeContext() +} + +type Opt_c_includeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_c_includeContext() *Opt_c_includeContext { + var p = new(Opt_c_includeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_c_include + return p +} + +func InitEmptyOpt_c_includeContext(p *Opt_c_includeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_c_include +} + +func (*Opt_c_includeContext) IsOpt_c_includeContext() {} + +func NewOpt_c_includeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_c_includeContext { + var p = new(Opt_c_includeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_c_include + + return p +} + +func (s *Opt_c_includeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_c_includeContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDE, 0) +} + +func (s *Opt_c_includeContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_c_includeContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Opt_c_includeContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_c_includeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_c_includeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_c_includeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_c_include(s) + } +} + +func (s *Opt_c_includeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_c_include(s) + } +} + +func (s *Opt_c_includeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_c_include(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_c_include() (localctx IOpt_c_includeContext) { + localctx = NewOpt_c_includeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, RedshiftParserRULE_opt_c_include) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4074) + p.Match(RedshiftParserINCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4075) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4076) + p.Columnlist() + } + { + p.SetState(4077) + p.Match(RedshiftParserCLOSE_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_matchContext is an interface to support dynamic dispatch. +type IKey_matchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATCH() antlr.TerminalNode + FULL() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + + // IsKey_matchContext differentiates from other interfaces. + IsKey_matchContext() +} + +type Key_matchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_matchContext() *Key_matchContext { + var p = new(Key_matchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_match + return p +} + +func InitEmptyKey_matchContext(p *Key_matchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_match +} + +func (*Key_matchContext) IsKey_matchContext() {} + +func NewKey_matchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_matchContext { + var p = new(Key_matchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_key_match + + return p +} + +func (s *Key_matchContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_matchContext) MATCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATCH, 0) +} + +func (s *Key_matchContext) FULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserFULL, 0) +} + +func (s *Key_matchContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTIAL, 0) +} + +func (s *Key_matchContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIMPLE, 0) +} + +func (s *Key_matchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_matchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_matchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterKey_match(s) + } +} + +func (s *Key_matchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitKey_match(s) + } +} + +func (s *Key_matchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitKey_match(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Key_match() (localctx IKey_matchContext) { + localctx = NewKey_matchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, RedshiftParserRULE_key_match) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4079) + p.Match(RedshiftParserMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4080) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFULL || _la == RedshiftParserPARTIAL || _la == RedshiftParserSIMPLE) { + 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 +} + +// IExclusionconstraintlistContext is an interface to support dynamic dispatch. +type IExclusionconstraintlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExclusionconstraintelem() []IExclusionconstraintelemContext + Exclusionconstraintelem(i int) IExclusionconstraintelemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExclusionconstraintlistContext differentiates from other interfaces. + IsExclusionconstraintlistContext() +} + +type ExclusionconstraintlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExclusionconstraintlistContext() *ExclusionconstraintlistContext { + var p = new(ExclusionconstraintlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclusionconstraintlist + return p +} + +func InitEmptyExclusionconstraintlistContext(p *ExclusionconstraintlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclusionconstraintlist +} + +func (*ExclusionconstraintlistContext) IsExclusionconstraintlistContext() {} + +func NewExclusionconstraintlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionconstraintlistContext { + var p = new(ExclusionconstraintlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_exclusionconstraintlist + + return p +} + +func (s *ExclusionconstraintlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExclusionconstraintlistContext) AllExclusionconstraintelem() []IExclusionconstraintelemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExclusionconstraintelemContext); ok { + len++ + } + } + + tst := make([]IExclusionconstraintelemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExclusionconstraintelemContext); ok { + tst[i] = t.(IExclusionconstraintelemContext) + i++ + } + } + + return tst +} + +func (s *ExclusionconstraintlistContext) Exclusionconstraintelem(i int) IExclusionconstraintelemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExclusionconstraintelemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExclusionconstraintelemContext) +} + +func (s *ExclusionconstraintlistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *ExclusionconstraintlistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *ExclusionconstraintlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExclusionconstraintlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExclusionconstraintlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExclusionconstraintlist(s) + } +} + +func (s *ExclusionconstraintlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExclusionconstraintlist(s) + } +} + +func (s *ExclusionconstraintlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExclusionconstraintlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Exclusionconstraintlist() (localctx IExclusionconstraintlistContext) { + localctx = NewExclusionconstraintlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, RedshiftParserRULE_exclusionconstraintlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4082) + p.Exclusionconstraintelem() + } + p.SetState(4087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(4083) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4084) + p.Exclusionconstraintelem() + } + + p.SetState(4089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExclusionconstraintelemContext is an interface to support dynamic dispatch. +type IExclusionconstraintelemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_elem() IIndex_elemContext + WITH() antlr.TerminalNode + Any_operator() IAny_operatorContext + OPERATOR() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + + // IsExclusionconstraintelemContext differentiates from other interfaces. + IsExclusionconstraintelemContext() +} + +type ExclusionconstraintelemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExclusionconstraintelemContext() *ExclusionconstraintelemContext { + var p = new(ExclusionconstraintelemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclusionconstraintelem + return p +} + +func InitEmptyExclusionconstraintelemContext(p *ExclusionconstraintelemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclusionconstraintelem +} + +func (*ExclusionconstraintelemContext) IsExclusionconstraintelemContext() {} + +func NewExclusionconstraintelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionconstraintelemContext { + var p = new(ExclusionconstraintelemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_exclusionconstraintelem + + return p +} + +func (s *ExclusionconstraintelemContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExclusionconstraintelemContext) Index_elem() IIndex_elemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_elemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_elemContext) +} + +func (s *ExclusionconstraintelemContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *ExclusionconstraintelemContext) Any_operator() IAny_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_operatorContext) +} + +func (s *ExclusionconstraintelemContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *ExclusionconstraintelemContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ExclusionconstraintelemContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ExclusionconstraintelemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExclusionconstraintelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExclusionconstraintelemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExclusionconstraintelem(s) + } +} + +func (s *ExclusionconstraintelemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExclusionconstraintelem(s) + } +} + +func (s *ExclusionconstraintelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExclusionconstraintelem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Exclusionconstraintelem() (localctx IExclusionconstraintelemContext) { + localctx = NewExclusionconstraintelemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, RedshiftParserRULE_exclusionconstraintelem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4090) + p.Index_elem() + } + { + p.SetState(4091) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 219, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4092) + p.Any_operator() + } + + case 2: + { + p.SetState(4093) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4094) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4095) + p.Any_operator() + } + { + p.SetState(4096) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExclusionwhereclauseContext is an interface to support dynamic dispatch. +type IExclusionwhereclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsExclusionwhereclauseContext differentiates from other interfaces. + IsExclusionwhereclauseContext() +} + +type ExclusionwhereclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExclusionwhereclauseContext() *ExclusionwhereclauseContext { + var p = new(ExclusionwhereclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclusionwhereclause + return p +} + +func InitEmptyExclusionwhereclauseContext(p *ExclusionwhereclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclusionwhereclause +} + +func (*ExclusionwhereclauseContext) IsExclusionwhereclauseContext() {} + +func NewExclusionwhereclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExclusionwhereclauseContext { + var p = new(ExclusionwhereclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_exclusionwhereclause + + return p +} + +func (s *ExclusionwhereclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExclusionwhereclauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHERE, 0) +} + +func (s *ExclusionwhereclauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ExclusionwhereclauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *ExclusionwhereclauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ExclusionwhereclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExclusionwhereclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExclusionwhereclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExclusionwhereclause(s) + } +} + +func (s *ExclusionwhereclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExclusionwhereclause(s) + } +} + +func (s *ExclusionwhereclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExclusionwhereclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Exclusionwhereclause() (localctx IExclusionwhereclauseContext) { + localctx = NewExclusionwhereclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, RedshiftParserRULE_exclusionwhereclause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4100) + p.Match(RedshiftParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4101) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4102) + p.A_expr() + } + { + p.SetState(4103) + p.Match(RedshiftParserCLOSE_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_actionsContext is an interface to support dynamic dispatch. +type IKey_actionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Key_update() IKey_updateContext + Key_delete() IKey_deleteContext + + // IsKey_actionsContext differentiates from other interfaces. + IsKey_actionsContext() +} + +type Key_actionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_actionsContext() *Key_actionsContext { + var p = new(Key_actionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_actions + return p +} + +func InitEmptyKey_actionsContext(p *Key_actionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_actions +} + +func (*Key_actionsContext) IsKey_actionsContext() {} + +func NewKey_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_actionsContext { + var p = new(Key_actionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_key_actions + + return p +} + +func (s *Key_actionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_actionsContext) Key_update() IKey_updateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_updateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_updateContext) +} + +func (s *Key_actionsContext) Key_delete() IKey_deleteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_deleteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_deleteContext) +} + +func (s *Key_actionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_actionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterKey_actions(s) + } +} + +func (s *Key_actionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitKey_actions(s) + } +} + +func (s *Key_actionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitKey_actions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Key_actions() (localctx IKey_actionsContext) { + localctx = NewKey_actionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, RedshiftParserRULE_key_actions) + p.SetState(4113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 220, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4105) + p.Key_update() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4106) + p.Key_delete() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4107) + p.Key_update() + } + { + p.SetState(4108) + p.Key_delete() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4110) + p.Key_delete() + } + { + p.SetState(4111) + p.Key_update() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_updateContext is an interface to support dynamic dispatch. +type IKey_updateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + UPDATE() antlr.TerminalNode + Key_action() IKey_actionContext + + // IsKey_updateContext differentiates from other interfaces. + IsKey_updateContext() +} + +type Key_updateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_updateContext() *Key_updateContext { + var p = new(Key_updateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_update + return p +} + +func InitEmptyKey_updateContext(p *Key_updateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_update +} + +func (*Key_updateContext) IsKey_updateContext() {} + +func NewKey_updateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_updateContext { + var p = new(Key_updateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_key_update + + return p +} + +func (s *Key_updateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_updateContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Key_updateContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Key_updateContext) Key_action() IKey_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_actionContext) +} + +func (s *Key_updateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_updateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_updateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterKey_update(s) + } +} + +func (s *Key_updateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitKey_update(s) + } +} + +func (s *Key_updateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitKey_update(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Key_update() (localctx IKey_updateContext) { + localctx = NewKey_updateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, RedshiftParserRULE_key_update) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4115) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4116) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4117) + p.Key_action() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_deleteContext is an interface to support dynamic dispatch. +type IKey_deleteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + Key_action() IKey_actionContext + + // IsKey_deleteContext differentiates from other interfaces. + IsKey_deleteContext() +} + +type Key_deleteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_deleteContext() *Key_deleteContext { + var p = new(Key_deleteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_delete + return p +} + +func InitEmptyKey_deleteContext(p *Key_deleteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_delete +} + +func (*Key_deleteContext) IsKey_deleteContext() {} + +func NewKey_deleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_deleteContext { + var p = new(Key_deleteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_key_delete + + return p +} + +func (s *Key_deleteContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_deleteContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Key_deleteContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *Key_deleteContext) Key_action() IKey_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_actionContext) +} + +func (s *Key_deleteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_deleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_deleteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterKey_delete(s) + } +} + +func (s *Key_deleteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitKey_delete(s) + } +} + +func (s *Key_deleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitKey_delete(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Key_delete() (localctx IKey_deleteContext) { + localctx = NewKey_deleteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, RedshiftParserRULE_key_delete) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4119) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4120) + p.Match(RedshiftParserDELETE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4121) + p.Key_action() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_actionContext is an interface to support dynamic dispatch. +type IKey_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + ACTION() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_P() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Opt_column_list() IOpt_column_listContext + + // IsKey_actionContext differentiates from other interfaces. + IsKey_actionContext() +} + +type Key_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_actionContext() *Key_actionContext { + var p = new(Key_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_action + return p +} + +func InitEmptyKey_actionContext(p *Key_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_key_action +} + +func (*Key_actionContext) IsKey_actionContext() {} + +func NewKey_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_actionContext { + var p = new(Key_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_key_action + + return p +} + +func (s *Key_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_actionContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Key_actionContext) ACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserACTION, 0) +} + +func (s *Key_actionContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *Key_actionContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *Key_actionContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Key_actionContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Key_actionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Key_actionContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *Key_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterKey_action(s) + } +} + +func (s *Key_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitKey_action(s) + } +} + +func (s *Key_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitKey_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Key_action() (localctx IKey_actionContext) { + localctx = NewKey_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, RedshiftParserRULE_key_action) + var _la int + + p.SetState(4132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNO: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4123) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4124) + p.Match(RedshiftParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserRESTRICT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4125) + p.Match(RedshiftParserRESTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCASCADE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4126) + p.Match(RedshiftParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSET: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4127) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4128) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserDEFAULT || _la == RedshiftParserNULL_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4130) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 221, p.GetParserRuleContext()) == 1 { + { + p.SetState(4129) + p.Opt_column_list() + } + + } 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 +} + +// IOptinheritContext is an interface to support dynamic dispatch. +type IOptinheritContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INHERITS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOptinheritContext differentiates from other interfaces. + IsOptinheritContext() +} + +type OptinheritContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptinheritContext() *OptinheritContext { + var p = new(OptinheritContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optinherit + return p +} + +func InitEmptyOptinheritContext(p *OptinheritContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optinherit +} + +func (*OptinheritContext) IsOptinheritContext() {} + +func NewOptinheritContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptinheritContext { + var p = new(OptinheritContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optinherit + + return p +} + +func (s *OptinheritContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptinheritContext) INHERITS() antlr.TerminalNode { + return s.GetToken(RedshiftParserINHERITS, 0) +} + +func (s *OptinheritContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *OptinheritContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *OptinheritContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *OptinheritContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptinheritContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptinheritContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptinherit(s) + } +} + +func (s *OptinheritContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptinherit(s) + } +} + +func (s *OptinheritContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptinherit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optinherit() (localctx IOptinheritContext) { + localctx = NewOptinheritContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, RedshiftParserRULE_optinherit) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4134) + p.Match(RedshiftParserINHERITS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4135) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4136) + p.Qualified_name_list() + } + { + p.SetState(4137) + p.Match(RedshiftParserCLOSE_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 +} + +// IOptpartitionspecContext is an interface to support dynamic dispatch. +type IOptpartitionspecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partitionspec() IPartitionspecContext + + // IsOptpartitionspecContext differentiates from other interfaces. + IsOptpartitionspecContext() +} + +type OptpartitionspecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptpartitionspecContext() *OptpartitionspecContext { + var p = new(OptpartitionspecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optpartitionspec + return p +} + +func InitEmptyOptpartitionspecContext(p *OptpartitionspecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optpartitionspec +} + +func (*OptpartitionspecContext) IsOptpartitionspecContext() {} + +func NewOptpartitionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptpartitionspecContext { + var p = new(OptpartitionspecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optpartitionspec + + return p +} + +func (s *OptpartitionspecContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptpartitionspecContext) Partitionspec() IPartitionspecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionspecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionspecContext) +} + +func (s *OptpartitionspecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptpartitionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptpartitionspecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptpartitionspec(s) + } +} + +func (s *OptpartitionspecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptpartitionspec(s) + } +} + +func (s *OptpartitionspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptpartitionspec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optpartitionspec() (localctx IOptpartitionspecContext) { + localctx = NewOptpartitionspecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, RedshiftParserRULE_optpartitionspec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4139) + p.Partitionspec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitionspecContext is an interface to support dynamic dispatch. +type IPartitionspecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Colid() IColidContext + OPEN_PAREN() antlr.TerminalNode + Part_params() IPart_paramsContext + CLOSE_PAREN() antlr.TerminalNode + + // IsPartitionspecContext differentiates from other interfaces. + IsPartitionspecContext() +} + +type PartitionspecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionspecContext() *PartitionspecContext { + var p = new(PartitionspecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partitionspec + return p +} + +func InitEmptyPartitionspecContext(p *PartitionspecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partitionspec +} + +func (*PartitionspecContext) IsPartitionspecContext() {} + +func NewPartitionspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionspecContext { + var p = new(PartitionspecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_partitionspec + + return p +} + +func (s *PartitionspecContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionspecContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *PartitionspecContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *PartitionspecContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *PartitionspecContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *PartitionspecContext) Part_params() IPart_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPart_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPart_paramsContext) +} + +func (s *PartitionspecContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *PartitionspecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionspecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPartitionspec(s) + } +} + +func (s *PartitionspecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPartitionspec(s) + } +} + +func (s *PartitionspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPartitionspec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Partitionspec() (localctx IPartitionspecContext) { + localctx = NewPartitionspecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, RedshiftParserRULE_partitionspec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4141) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4142) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4143) + p.Colid() + } + { + p.SetState(4144) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4145) + p.Part_params() + } + { + p.SetState(4146) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPart_paramsContext is an interface to support dynamic dispatch. +type IPart_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPart_elem() []IPart_elemContext + Part_elem(i int) IPart_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPart_paramsContext differentiates from other interfaces. + IsPart_paramsContext() +} + +type Part_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPart_paramsContext() *Part_paramsContext { + var p = new(Part_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_part_params + return p +} + +func InitEmptyPart_paramsContext(p *Part_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_part_params +} + +func (*Part_paramsContext) IsPart_paramsContext() {} + +func NewPart_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Part_paramsContext { + var p = new(Part_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_part_params + + return p +} + +func (s *Part_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Part_paramsContext) AllPart_elem() []IPart_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPart_elemContext); ok { + len++ + } + } + + tst := make([]IPart_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPart_elemContext); ok { + tst[i] = t.(IPart_elemContext) + i++ + } + } + + return tst +} + +func (s *Part_paramsContext) Part_elem(i int) IPart_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPart_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPart_elemContext) +} + +func (s *Part_paramsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Part_paramsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Part_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Part_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Part_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPart_params(s) + } +} + +func (s *Part_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPart_params(s) + } +} + +func (s *Part_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPart_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Part_params() (localctx IPart_paramsContext) { + localctx = NewPart_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, RedshiftParserRULE_part_params) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4148) + p.Part_elem() + } + p.SetState(4153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(4149) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4150) + p.Part_elem() + } + + p.SetState(4155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPart_elemContext is an interface to support dynamic dispatch. +type IPart_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Opt_collate() IOpt_collateContext + Opt_class() IOpt_classContext + Func_expr_windowless() IFunc_expr_windowlessContext + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsPart_elemContext differentiates from other interfaces. + IsPart_elemContext() +} + +type Part_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPart_elemContext() *Part_elemContext { + var p = new(Part_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_part_elem + return p +} + +func InitEmptyPart_elemContext(p *Part_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_part_elem +} + +func (*Part_elemContext) IsPart_elemContext() {} + +func NewPart_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Part_elemContext { + var p = new(Part_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_part_elem + + return p +} + +func (s *Part_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Part_elemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Part_elemContext) Opt_collate() IOpt_collateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_collateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_collateContext) +} + +func (s *Part_elemContext) Opt_class() IOpt_classContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_classContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_classContext) +} + +func (s *Part_elemContext) Func_expr_windowless() IFunc_expr_windowlessContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_expr_windowlessContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_expr_windowlessContext) +} + +func (s *Part_elemContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Part_elemContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Part_elemContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Part_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Part_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Part_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPart_elem(s) + } +} + +func (s *Part_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPart_elem(s) + } +} + +func (s *Part_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPart_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Part_elem() (localctx IPart_elemContext) { + localctx = NewPart_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, RedshiftParserRULE_part_elem) + var _la int + + p.SetState(4179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 230, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4156) + p.Colid() + } + p.SetState(4158) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 224, p.GetParserRuleContext()) == 1 { + { + p.SetState(4157) + p.Opt_collate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(4160) + p.Opt_class() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4163) + p.Func_expr_windowless() + } + p.SetState(4165) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 226, p.GetParserRuleContext()) == 1 { + { + p.SetState(4164) + p.Opt_collate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(4167) + p.Opt_class() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4170) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4171) + p.A_expr() + } + { + p.SetState(4172) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4174) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 228, p.GetParserRuleContext()) == 1 { + { + p.SetState(4173) + p.Opt_collate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(4176) + p.Opt_class() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_access_method_clauseContext is an interface to support dynamic dispatch. +type ITable_access_method_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Name() INameContext + + // IsTable_access_method_clauseContext differentiates from other interfaces. + IsTable_access_method_clauseContext() +} + +type Table_access_method_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_access_method_clauseContext() *Table_access_method_clauseContext { + var p = new(Table_access_method_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_access_method_clause + return p +} + +func InitEmptyTable_access_method_clauseContext(p *Table_access_method_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_access_method_clause +} + +func (*Table_access_method_clauseContext) IsTable_access_method_clauseContext() {} + +func NewTable_access_method_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_access_method_clauseContext { + var p = new(Table_access_method_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_access_method_clause + + return p +} + +func (s *Table_access_method_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_access_method_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Table_access_method_clauseContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Table_access_method_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_access_method_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_access_method_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_access_method_clause(s) + } +} + +func (s *Table_access_method_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_access_method_clause(s) + } +} + +func (s *Table_access_method_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_access_method_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_access_method_clause() (localctx ITable_access_method_clauseContext) { + localctx = NewTable_access_method_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, RedshiftParserRULE_table_access_method_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4181) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4182) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptwithContext is an interface to support dynamic dispatch. +type IOptwithContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + Reloptions() IReloptionsContext + WITHOUT() antlr.TerminalNode + OIDS() antlr.TerminalNode + + // IsOptwithContext differentiates from other interfaces. + IsOptwithContext() +} + +type OptwithContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptwithContext() *OptwithContext { + var p = new(OptwithContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optwith + return p +} + +func InitEmptyOptwithContext(p *OptwithContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optwith +} + +func (*OptwithContext) IsOptwithContext() {} + +func NewOptwithContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptwithContext { + var p = new(OptwithContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optwith + + return p +} + +func (s *OptwithContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptwithContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *OptwithContext) Reloptions() IReloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReloptionsContext) +} + +func (s *OptwithContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHOUT, 0) +} + +func (s *OptwithContext) OIDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOIDS, 0) +} + +func (s *OptwithContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptwithContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptwithContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptwith(s) + } +} + +func (s *OptwithContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptwith(s) + } +} + +func (s *OptwithContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptwith(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optwith() (localctx IOptwithContext) { + localctx = NewOptwithContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, RedshiftParserRULE_optwith) + p.SetState(4188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserWITH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4184) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4185) + p.Reloptions() + } + + case RedshiftParserWITHOUT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4186) + p.Match(RedshiftParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4187) + p.Match(RedshiftParserOIDS) + 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 +} + +// IOncommitoptionContext is an interface to support dynamic dispatch. +type IOncommitoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + DROP() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + ROWS() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + + // IsOncommitoptionContext differentiates from other interfaces. + IsOncommitoptionContext() +} + +type OncommitoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOncommitoptionContext() *OncommitoptionContext { + var p = new(OncommitoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_oncommitoption + return p +} + +func InitEmptyOncommitoptionContext(p *OncommitoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_oncommitoption +} + +func (*OncommitoptionContext) IsOncommitoptionContext() {} + +func NewOncommitoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OncommitoptionContext { + var p = new(OncommitoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_oncommitoption + + return p +} + +func (s *OncommitoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *OncommitoptionContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *OncommitoptionContext) COMMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMIT, 0) +} + +func (s *OncommitoptionContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *OncommitoptionContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *OncommitoptionContext) ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWS, 0) +} + +func (s *OncommitoptionContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRESERVE, 0) +} + +func (s *OncommitoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OncommitoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OncommitoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOncommitoption(s) + } +} + +func (s *OncommitoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOncommitoption(s) + } +} + +func (s *OncommitoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOncommitoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Oncommitoption() (localctx IOncommitoptionContext) { + localctx = NewOncommitoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, RedshiftParserRULE_oncommitoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4190) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4191) + p.Match(RedshiftParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDROP: + { + p.SetState(4192) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDELETE_P: + { + p.SetState(4193) + p.Match(RedshiftParserDELETE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4194) + p.Match(RedshiftParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserPRESERVE: + { + p.SetState(4195) + p.Match(RedshiftParserPRESERVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4196) + p.Match(RedshiftParserROWS) + 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 +} + +// IOpttablespaceContext is an interface to support dynamic dispatch. +type IOpttablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + Name() INameContext + + // IsOpttablespaceContext differentiates from other interfaces. + IsOpttablespaceContext() +} + +type OpttablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpttablespaceContext() *OpttablespaceContext { + var p = new(OpttablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttablespace + return p +} + +func InitEmptyOpttablespaceContext(p *OpttablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttablespace +} + +func (*OpttablespaceContext) IsOpttablespaceContext() {} + +func NewOpttablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablespaceContext { + var p = new(OpttablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opttablespace + + return p +} + +func (s *OpttablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpttablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *OpttablespaceContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *OpttablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpttablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpttablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpttablespace(s) + } +} + +func (s *OpttablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpttablespace(s) + } +} + +func (s *OpttablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpttablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opttablespace() (localctx IOpttablespaceContext) { + localctx = NewOpttablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, RedshiftParserRULE_opttablespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4199) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4200) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptredshifttableoptionsContext is an interface to support dynamic dispatch. +type IOptredshifttableoptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRedshifttableoption() []IRedshifttableoptionContext + Redshifttableoption(i int) IRedshifttableoptionContext + + // IsOptredshifttableoptionsContext differentiates from other interfaces. + IsOptredshifttableoptionsContext() +} + +type OptredshifttableoptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptredshifttableoptionsContext() *OptredshifttableoptionsContext { + var p = new(OptredshifttableoptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optredshifttableoptions + return p +} + +func InitEmptyOptredshifttableoptionsContext(p *OptredshifttableoptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optredshifttableoptions +} + +func (*OptredshifttableoptionsContext) IsOptredshifttableoptionsContext() {} + +func NewOptredshifttableoptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptredshifttableoptionsContext { + var p = new(OptredshifttableoptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optredshifttableoptions + + return p +} + +func (s *OptredshifttableoptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptredshifttableoptionsContext) AllRedshifttableoption() []IRedshifttableoptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRedshifttableoptionContext); ok { + len++ + } + } + + tst := make([]IRedshifttableoptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRedshifttableoptionContext); ok { + tst[i] = t.(IRedshifttableoptionContext) + i++ + } + } + + return tst +} + +func (s *OptredshifttableoptionsContext) Redshifttableoption(i int) IRedshifttableoptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedshifttableoptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRedshifttableoptionContext) +} + +func (s *OptredshifttableoptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptredshifttableoptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptredshifttableoptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptredshifttableoptions(s) + } +} + +func (s *OptredshifttableoptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptredshifttableoptions(s) + } +} + +func (s *OptredshifttableoptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptredshifttableoptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optredshifttableoptions() (localctx IOptredshifttableoptionsContext) { + localctx = NewOptredshifttableoptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, RedshiftParserRULE_optredshifttableoptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&127) != 0) { + { + p.SetState(4202) + p.Redshifttableoption() + } + + p.SetState(4205) + 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 +} + +// IRedshifttableoptionContext is an interface to support dynamic dispatch. +type IRedshifttableoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BACKUP() antlr.TerminalNode + YES_P() antlr.TerminalNode + NO() antlr.TerminalNode + DISTSTYLE() antlr.TerminalNode + ALL() antlr.TerminalNode + EVEN() antlr.TerminalNode + KEY() antlr.TerminalNode + AUTO() antlr.TerminalNode + DISTKEY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Colid() IColidContext + CLOSE_PAREN() antlr.TerminalNode + Sortkeyclause() ISortkeyclauseContext + ENCODE() antlr.TerminalNode + + // IsRedshifttableoptionContext differentiates from other interfaces. + IsRedshifttableoptionContext() +} + +type RedshifttableoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedshifttableoptionContext() *RedshifttableoptionContext { + var p = new(RedshifttableoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshifttableoption + return p +} + +func InitEmptyRedshifttableoptionContext(p *RedshifttableoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_redshifttableoption +} + +func (*RedshifttableoptionContext) IsRedshifttableoptionContext() {} + +func NewRedshifttableoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RedshifttableoptionContext { + var p = new(RedshifttableoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_redshifttableoption + + return p +} + +func (s *RedshifttableoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *RedshifttableoptionContext) BACKUP() antlr.TerminalNode { + return s.GetToken(RedshiftParserBACKUP, 0) +} + +func (s *RedshifttableoptionContext) YES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYES_P, 0) +} + +func (s *RedshifttableoptionContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *RedshifttableoptionContext) DISTSTYLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTSTYLE, 0) +} + +func (s *RedshifttableoptionContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *RedshifttableoptionContext) EVEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVEN, 0) +} + +func (s *RedshifttableoptionContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *RedshifttableoptionContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *RedshifttableoptionContext) DISTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTKEY, 0) +} + +func (s *RedshifttableoptionContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *RedshifttableoptionContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *RedshifttableoptionContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *RedshifttableoptionContext) Sortkeyclause() ISortkeyclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortkeyclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortkeyclauseContext) +} + +func (s *RedshifttableoptionContext) ENCODE() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODE, 0) +} + +func (s *RedshifttableoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RedshifttableoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RedshifttableoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRedshifttableoption(s) + } +} + +func (s *RedshifttableoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRedshifttableoption(s) + } +} + +func (s *RedshifttableoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRedshifttableoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Redshifttableoption() (localctx IRedshifttableoptionContext) { + localctx = NewRedshifttableoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, RedshiftParserRULE_redshifttableoption) + var _la int + + p.SetState(4219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserBACKUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4207) + p.Match(RedshiftParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4208) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserNO || _la == RedshiftParserYES_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserDISTSTYLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4209) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4210) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || _la == RedshiftParserKEY || _la == RedshiftParserAUTO || _la == RedshiftParserEVEN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserDISTKEY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4211) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4212) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4213) + p.Colid() + } + { + p.SetState(4214) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSORTKEY, RedshiftParserCOMPOUND, RedshiftParserINTERLEAVED: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4216) + p.Sortkeyclause() + } + + case RedshiftParserENCODE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4217) + p.Match(RedshiftParserENCODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4218) + p.Match(RedshiftParserAUTO) + 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 +} + +// ISortkeyclauseContext is an interface to support dynamic dispatch. +type ISortkeyclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SORTKEY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + Sortkeyclausetype() ISortkeyclausetypeContext + + // IsSortkeyclauseContext differentiates from other interfaces. + IsSortkeyclauseContext() +} + +type SortkeyclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySortkeyclauseContext() *SortkeyclauseContext { + var p = new(SortkeyclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortkeyclause + return p +} + +func InitEmptySortkeyclauseContext(p *SortkeyclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortkeyclause +} + +func (*SortkeyclauseContext) IsSortkeyclauseContext() {} + +func NewSortkeyclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortkeyclauseContext { + var p = new(SortkeyclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sortkeyclause + + return p +} + +func (s *SortkeyclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *SortkeyclauseContext) SORTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSORTKEY, 0) +} + +func (s *SortkeyclauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *SortkeyclauseContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *SortkeyclauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *SortkeyclauseContext) Sortkeyclausetype() ISortkeyclausetypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortkeyclausetypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortkeyclausetypeContext) +} + +func (s *SortkeyclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SortkeyclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SortkeyclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSortkeyclause(s) + } +} + +func (s *SortkeyclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSortkeyclause(s) + } +} + +func (s *SortkeyclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSortkeyclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sortkeyclause() (localctx ISortkeyclauseContext) { + localctx = NewSortkeyclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, RedshiftParserRULE_sortkeyclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMPOUND || _la == RedshiftParserINTERLEAVED { + { + p.SetState(4221) + p.Sortkeyclausetype() + } + + } + { + p.SetState(4224) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4225) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4226) + p.Columnlist() + } + { + p.SetState(4227) + p.Match(RedshiftParserCLOSE_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 +} + +// ISortkeyclausetypeContext is an interface to support dynamic dispatch. +type ISortkeyclausetypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPOUND() antlr.TerminalNode + INTERLEAVED() antlr.TerminalNode + + // IsSortkeyclausetypeContext differentiates from other interfaces. + IsSortkeyclausetypeContext() +} + +type SortkeyclausetypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySortkeyclausetypeContext() *SortkeyclausetypeContext { + var p = new(SortkeyclausetypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortkeyclausetype + return p +} + +func InitEmptySortkeyclausetypeContext(p *SortkeyclausetypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortkeyclausetype +} + +func (*SortkeyclausetypeContext) IsSortkeyclausetypeContext() {} + +func NewSortkeyclausetypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortkeyclausetypeContext { + var p = new(SortkeyclausetypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sortkeyclausetype + + return p +} + +func (s *SortkeyclausetypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *SortkeyclausetypeContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPOUND, 0) +} + +func (s *SortkeyclausetypeContext) INTERLEAVED() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTERLEAVED, 0) +} + +func (s *SortkeyclausetypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SortkeyclausetypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SortkeyclausetypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSortkeyclausetype(s) + } +} + +func (s *SortkeyclausetypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSortkeyclausetype(s) + } +} + +func (s *SortkeyclausetypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSortkeyclausetype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sortkeyclausetype() (localctx ISortkeyclausetypeContext) { + localctx = NewSortkeyclausetypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, RedshiftParserRULE_sortkeyclausetype) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4229) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCOMPOUND || _la == RedshiftParserINTERLEAVED) { + 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 +} + +// IOptconstablespaceContext is an interface to support dynamic dispatch. +type IOptconstablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Name() INameContext + + // IsOptconstablespaceContext differentiates from other interfaces. + IsOptconstablespaceContext() +} + +type OptconstablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptconstablespaceContext() *OptconstablespaceContext { + var p = new(OptconstablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optconstablespace + return p +} + +func InitEmptyOptconstablespaceContext(p *OptconstablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optconstablespace +} + +func (*OptconstablespaceContext) IsOptconstablespaceContext() {} + +func NewOptconstablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptconstablespaceContext { + var p = new(OptconstablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optconstablespace + + return p +} + +func (s *OptconstablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptconstablespaceContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *OptconstablespaceContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *OptconstablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *OptconstablespaceContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *OptconstablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptconstablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptconstablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptconstablespace(s) + } +} + +func (s *OptconstablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptconstablespace(s) + } +} + +func (s *OptconstablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptconstablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optconstablespace() (localctx IOptconstablespaceContext) { + localctx = NewOptconstablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, RedshiftParserRULE_optconstablespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4231) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4232) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4233) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4234) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExistingindexContext is an interface to support dynamic dispatch. +type IExistingindexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + Name() INameContext + + // IsExistingindexContext differentiates from other interfaces. + IsExistingindexContext() +} + +type ExistingindexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExistingindexContext() *ExistingindexContext { + var p = new(ExistingindexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_existingindex + return p +} + +func InitEmptyExistingindexContext(p *ExistingindexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_existingindex +} + +func (*ExistingindexContext) IsExistingindexContext() {} + +func NewExistingindexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExistingindexContext { + var p = new(ExistingindexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_existingindex + + return p +} + +func (s *ExistingindexContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExistingindexContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *ExistingindexContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *ExistingindexContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *ExistingindexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExistingindexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExistingindexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExistingindex(s) + } +} + +func (s *ExistingindexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExistingindex(s) + } +} + +func (s *ExistingindexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExistingindex(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Existingindex() (localctx IExistingindexContext) { + localctx = NewExistingindexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, RedshiftParserRULE_existingindex) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4236) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4237) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4238) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatestatsstmtContext is an interface to support dynamic dispatch. +type ICreatestatsstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + Any_name() IAny_nameContext + ON() antlr.TerminalNode + Expr_list() IExpr_listContext + FROM() antlr.TerminalNode + From_list() IFrom_listContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Opt_name_list() IOpt_name_listContext + + // IsCreatestatsstmtContext differentiates from other interfaces. + IsCreatestatsstmtContext() +} + +type CreatestatsstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatestatsstmtContext() *CreatestatsstmtContext { + var p = new(CreatestatsstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createstatsstmt + return p +} + +func InitEmptyCreatestatsstmtContext(p *CreatestatsstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createstatsstmt +} + +func (*CreatestatsstmtContext) IsCreatestatsstmtContext() {} + +func NewCreatestatsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatestatsstmtContext { + var p = new(CreatestatsstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createstatsstmt + + return p +} + +func (s *CreatestatsstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatestatsstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatestatsstmtContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *CreatestatsstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *CreatestatsstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *CreatestatsstmtContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *CreatestatsstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *CreatestatsstmtContext) From_list() IFrom_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_listContext) +} + +func (s *CreatestatsstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreatestatsstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreatestatsstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreatestatsstmtContext) Opt_name_list() IOpt_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_name_listContext) +} + +func (s *CreatestatsstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatestatsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatestatsstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatestatsstmt(s) + } +} + +func (s *CreatestatsstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatestatsstmt(s) + } +} + +func (s *CreatestatsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatestatsstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createstatsstmt() (localctx ICreatestatsstmtContext) { + localctx = NewCreatestatsstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, RedshiftParserRULE_createstatsstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4240) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4241) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4245) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 236, p.GetParserRuleContext()) == 1 { + { + p.SetState(4242) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4243) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4244) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4247) + p.Any_name() + } + p.SetState(4249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(4248) + p.Opt_name_list() + } + + } + { + p.SetState(4251) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4252) + p.Expr_list() + } + { + p.SetState(4253) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4254) + p.From_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterstatsstmtContext is an interface to support dynamic dispatch. +type IAlterstatsstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AllSTATISTICS() []antlr.TerminalNode + STATISTICS(i int) antlr.TerminalNode + Any_name() IAny_nameContext + SET() antlr.TerminalNode + Signediconst() ISignediconstContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsAlterstatsstmtContext differentiates from other interfaces. + IsAlterstatsstmtContext() +} + +type AlterstatsstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterstatsstmtContext() *AlterstatsstmtContext { + var p = new(AlterstatsstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterstatsstmt + return p +} + +func InitEmptyAlterstatsstmtContext(p *AlterstatsstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterstatsstmt +} + +func (*AlterstatsstmtContext) IsAlterstatsstmtContext() {} + +func NewAlterstatsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterstatsstmtContext { + var p = new(AlterstatsstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterstatsstmt + + return p +} + +func (s *AlterstatsstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterstatsstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterstatsstmtContext) AllSTATISTICS() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserSTATISTICS) +} + +func (s *AlterstatsstmtContext) STATISTICS(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, i) +} + +func (s *AlterstatsstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AlterstatsstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlterstatsstmtContext) Signediconst() ISignediconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignediconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignediconstContext) +} + +func (s *AlterstatsstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *AlterstatsstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *AlterstatsstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterstatsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterstatsstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterstatsstmt(s) + } +} + +func (s *AlterstatsstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterstatsstmt(s) + } +} + +func (s *AlterstatsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterstatsstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterstatsstmt() (localctx IAlterstatsstmtContext) { + localctx = NewAlterstatsstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, RedshiftParserRULE_alterstatsstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4256) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4257) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4260) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 238, p.GetParserRuleContext()) == 1 { + { + p.SetState(4258) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4259) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4262) + p.Any_name() + } + { + p.SetState(4263) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4264) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4265) + p.Signediconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateasstmtContext is an interface to support dynamic dispatch. +type ICreateasstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Create_as_target() ICreate_as_targetContext + AS() antlr.TerminalNode + Selectstmt() ISelectstmtContext + Opttemp() IOpttempContext + + // IsCreateasstmtContext differentiates from other interfaces. + IsCreateasstmtContext() +} + +type CreateasstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateasstmtContext() *CreateasstmtContext { + var p = new(CreateasstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createasstmt + return p +} + +func InitEmptyCreateasstmtContext(p *CreateasstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createasstmt +} + +func (*CreateasstmtContext) IsCreateasstmtContext() {} + +func NewCreateasstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateasstmtContext { + var p = new(CreateasstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createasstmt + + return p +} + +func (s *CreateasstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateasstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateasstmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *CreateasstmtContext) Create_as_target() ICreate_as_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_as_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_as_targetContext) +} + +func (s *CreateasstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CreateasstmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *CreateasstmtContext) Opttemp() IOpttempContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttempContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttempContext) +} + +func (s *CreateasstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateasstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateasstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateasstmt(s) + } +} + +func (s *CreateasstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateasstmt(s) + } +} + +func (s *CreateasstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateasstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createasstmt() (localctx ICreateasstmtContext) { + localctx = NewCreateasstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, RedshiftParserRULE_createasstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4267) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLOCAL || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY { + { + p.SetState(4268) + p.Opttemp() + } + + } + { + p.SetState(4271) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4272) + p.Create_as_target() + } + { + p.SetState(4273) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4274) + p.Selectstmt() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_as_targetContext is an interface to support dynamic dispatch. +type ICreate_as_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_name() ITable_nameContext + Opt_column_list() IOpt_column_listContext + Opt_backup_clause_table_attributes() IOpt_backup_clause_table_attributesContext + + // IsCreate_as_targetContext differentiates from other interfaces. + IsCreate_as_targetContext() +} + +type Create_as_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_as_targetContext() *Create_as_targetContext { + var p = new(Create_as_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_as_target + return p +} + +func InitEmptyCreate_as_targetContext(p *Create_as_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_as_target +} + +func (*Create_as_targetContext) IsCreate_as_targetContext() {} + +func NewCreate_as_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_as_targetContext { + var p = new(Create_as_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_create_as_target + + return p +} + +func (s *Create_as_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_as_targetContext) 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_as_targetContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *Create_as_targetContext) Opt_backup_clause_table_attributes() IOpt_backup_clause_table_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_backup_clause_table_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_backup_clause_table_attributesContext) +} + +func (s *Create_as_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_as_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_as_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreate_as_target(s) + } +} + +func (s *Create_as_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreate_as_target(s) + } +} + +func (s *Create_as_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreate_as_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Create_as_target() (localctx ICreate_as_targetContext) { + localctx = NewCreate_as_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, RedshiftParserRULE_create_as_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4276) + p.Table_name() + } + p.SetState(4278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(4277) + p.Opt_column_list() + } + + } + p.SetState(4281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&127) != 0 { + { + p.SetState(4280) + p.Opt_backup_clause_table_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 +} + +// IOpt_backup_clause_table_attributesContext is an interface to support dynamic dispatch. +type IOpt_backup_clause_table_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_backup_clause() IOpt_backup_clauseContext + AllOpt_table_attributes() []IOpt_table_attributesContext + Opt_table_attributes(i int) IOpt_table_attributesContext + + // IsOpt_backup_clause_table_attributesContext differentiates from other interfaces. + IsOpt_backup_clause_table_attributesContext() +} + +type Opt_backup_clause_table_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_backup_clause_table_attributesContext() *Opt_backup_clause_table_attributesContext { + var p = new(Opt_backup_clause_table_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_backup_clause_table_attributes + return p +} + +func InitEmptyOpt_backup_clause_table_attributesContext(p *Opt_backup_clause_table_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_backup_clause_table_attributes +} + +func (*Opt_backup_clause_table_attributesContext) IsOpt_backup_clause_table_attributesContext() {} + +func NewOpt_backup_clause_table_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_backup_clause_table_attributesContext { + var p = new(Opt_backup_clause_table_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_backup_clause_table_attributes + + return p +} + +func (s *Opt_backup_clause_table_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_backup_clause_table_attributesContext) Opt_backup_clause() IOpt_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_backup_clauseContext) +} + +func (s *Opt_backup_clause_table_attributesContext) AllOpt_table_attributes() []IOpt_table_attributesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpt_table_attributesContext); ok { + len++ + } + } + + tst := make([]IOpt_table_attributesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpt_table_attributesContext); ok { + tst[i] = t.(IOpt_table_attributesContext) + i++ + } + } + + return tst +} + +func (s *Opt_backup_clause_table_attributesContext) Opt_table_attributes(i int) IOpt_table_attributesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_table_attributesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpt_table_attributesContext) +} + +func (s *Opt_backup_clause_table_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_backup_clause_table_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_backup_clause_table_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_backup_clause_table_attributes(s) + } +} + +func (s *Opt_backup_clause_table_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_backup_clause_table_attributes(s) + } +} + +func (s *Opt_backup_clause_table_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_backup_clause_table_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_backup_clause_table_attributes() (localctx IOpt_backup_clause_table_attributesContext) { + localctx = NewOpt_backup_clause_table_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, RedshiftParserRULE_opt_backup_clause_table_attributes) + var _la int + + var _alt int + + p.SetState(4304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserBACKUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4283) + p.Opt_backup_clause() + } + p.SetState(4287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for (int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&111) != 0 { + { + p.SetState(4284) + p.Opt_table_attributes() + } + + p.SetState(4289) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserENCODE, RedshiftParserDISTKEY, RedshiftParserSORTKEY, RedshiftParserDISTSTYLE, RedshiftParserCOMPOUND, RedshiftParserINTERLEAVED: + p.EnterOuterAlt(localctx, 2) + p.SetState(4291) + 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(4290) + p.Opt_table_attributes() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4293) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 243, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserBACKUP { + { + p.SetState(4295) + p.Opt_backup_clause() + } + + } + p.SetState(4301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for (int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&111) != 0 { + { + p.SetState(4298) + p.Opt_table_attributes() + } + + p.SetState(4303) + 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 +} + +// ITable_attributesContext is an interface to support dynamic dispatch. +type ITable_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDistkey_identifier returns the distkey_identifier rule contexts. + GetDistkey_identifier() IColidContext + + // GetSortkey_columnlist returns the sortkey_columnlist rule contexts. + GetSortkey_columnlist() IColumnlistContext + + // SetDistkey_identifier sets the distkey_identifier rule contexts. + SetDistkey_identifier(IColidContext) + + // SetSortkey_columnlist sets the sortkey_columnlist rule contexts. + SetSortkey_columnlist(IColumnlistContext) + + // Getter signatures + DISTSTYLE() antlr.TerminalNode + AUTO() antlr.TerminalNode + EVEN() antlr.TerminalNode + ALL() antlr.TerminalNode + KEY() antlr.TerminalNode + DISTKEY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Colid() IColidContext + SORTKEY() antlr.TerminalNode + Columnlist() IColumnlistContext + COMPOUND() antlr.TerminalNode + INTERLEAVED() antlr.TerminalNode + + // IsTable_attributesContext differentiates from other interfaces. + IsTable_attributesContext() +} + +type Table_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + distkey_identifier IColidContext + sortkey_columnlist IColumnlistContext +} + +func NewEmptyTable_attributesContext() *Table_attributesContext { + var p = new(Table_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_attributes + return p +} + +func InitEmptyTable_attributesContext(p *Table_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_attributes +} + +func (*Table_attributesContext) IsTable_attributesContext() {} + +func NewTable_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_attributesContext { + var p = new(Table_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_attributes + + return p +} + +func (s *Table_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_attributesContext) GetDistkey_identifier() IColidContext { return s.distkey_identifier } + +func (s *Table_attributesContext) GetSortkey_columnlist() IColumnlistContext { + return s.sortkey_columnlist +} + +func (s *Table_attributesContext) SetDistkey_identifier(v IColidContext) { s.distkey_identifier = v } + +func (s *Table_attributesContext) SetSortkey_columnlist(v IColumnlistContext) { + s.sortkey_columnlist = v +} + +func (s *Table_attributesContext) DISTSTYLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTSTYLE, 0) +} + +func (s *Table_attributesContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *Table_attributesContext) EVEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVEN, 0) +} + +func (s *Table_attributesContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Table_attributesContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *Table_attributesContext) DISTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTKEY, 0) +} + +func (s *Table_attributesContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Table_attributesContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Table_attributesContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Table_attributesContext) SORTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSORTKEY, 0) +} + +func (s *Table_attributesContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Table_attributesContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPOUND, 0) +} + +func (s *Table_attributesContext) INTERLEAVED() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTERLEAVED, 0) +} + +func (s *Table_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_attributes(s) + } +} + +func (s *Table_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_attributes(s) + } +} + +func (s *Table_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_attributes() (localctx ITable_attributesContext) { + localctx = NewTable_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, RedshiftParserRULE_table_attributes) + var _la int + + p.SetState(4321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDISTSTYLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4306) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4307) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || _la == RedshiftParserKEY || _la == RedshiftParserAUTO || _la == RedshiftParserEVEN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserDISTKEY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4308) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4309) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4310) + + var _x = p.Colid() + + localctx.(*Table_attributesContext).distkey_identifier = _x + } + { + p.SetState(4311) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSORTKEY, RedshiftParserCOMPOUND, RedshiftParserINTERLEAVED: + p.EnterOuterAlt(localctx, 3) + p.SetState(4314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMPOUND || _la == RedshiftParserINTERLEAVED { + { + p.SetState(4313) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCOMPOUND || _la == RedshiftParserINTERLEAVED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(4316) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4317) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4318) + + var _x = p.Columnlist() + + localctx.(*Table_attributesContext).sortkey_columnlist = _x + } + { + p.SetState(4319) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_backup_clauseContext is an interface to support dynamic dispatch. +type IOpt_backup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BACKUP() antlr.TerminalNode + YES_P() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsOpt_backup_clauseContext differentiates from other interfaces. + IsOpt_backup_clauseContext() +} + +type Opt_backup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_backup_clauseContext() *Opt_backup_clauseContext { + var p = new(Opt_backup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_backup_clause + return p +} + +func InitEmptyOpt_backup_clauseContext(p *Opt_backup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_backup_clause +} + +func (*Opt_backup_clauseContext) IsOpt_backup_clauseContext() {} + +func NewOpt_backup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_backup_clauseContext { + var p = new(Opt_backup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_backup_clause + + return p +} + +func (s *Opt_backup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_backup_clauseContext) BACKUP() antlr.TerminalNode { + return s.GetToken(RedshiftParserBACKUP, 0) +} + +func (s *Opt_backup_clauseContext) YES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYES_P, 0) +} + +func (s *Opt_backup_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_backup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_backup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_backup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_backup_clause(s) + } +} + +func (s *Opt_backup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_backup_clause(s) + } +} + +func (s *Opt_backup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_backup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_backup_clause() (localctx IOpt_backup_clauseContext) { + localctx = NewOpt_backup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, RedshiftParserRULE_opt_backup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4323) + p.Match(RedshiftParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4324) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserNO || _la == RedshiftParserYES_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_with_dataContext is an interface to support dynamic dispatch. +type IOpt_with_dataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + DATA_P() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsOpt_with_dataContext differentiates from other interfaces. + IsOpt_with_dataContext() +} + +type Opt_with_dataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_with_dataContext() *Opt_with_dataContext { + var p = new(Opt_with_dataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_data + return p +} + +func InitEmptyOpt_with_dataContext(p *Opt_with_dataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_data +} + +func (*Opt_with_dataContext) IsOpt_with_dataContext() {} + +func NewOpt_with_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_dataContext { + var p = new(Opt_with_dataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_with_data + + return p +} + +func (s *Opt_with_dataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_with_dataContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_with_dataContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *Opt_with_dataContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_with_dataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_with_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_with_dataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_with_data(s) + } +} + +func (s *Opt_with_dataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_with_data(s) + } +} + +func (s *Opt_with_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_with_data(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_with_data() (localctx IOpt_with_dataContext) { + localctx = NewOpt_with_dataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, RedshiftParserRULE_opt_with_data) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4326) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDATA_P: + { + p.SetState(4327) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNO: + { + p.SetState(4328) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4329) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatematviewstmtContext is an interface to support dynamic dispatch. +type ICreatematviewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + AS() antlr.TerminalNode + Selectstmt() ISelectstmtContext + Opt_backup_clause() IOpt_backup_clauseContext + AllOpt_table_attributes() []IOpt_table_attributesContext + Opt_table_attributes(i int) IOpt_table_attributesContext + Opt_auto_refresh() IOpt_auto_refreshContext + + // IsCreatematviewstmtContext differentiates from other interfaces. + IsCreatematviewstmtContext() +} + +type CreatematviewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatematviewstmtContext() *CreatematviewstmtContext { + var p = new(CreatematviewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_creatematviewstmt + return p +} + +func InitEmptyCreatematviewstmtContext(p *CreatematviewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_creatematviewstmt +} + +func (*CreatematviewstmtContext) IsCreatematviewstmtContext() {} + +func NewCreatematviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatematviewstmtContext { + var p = new(CreatematviewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_creatematviewstmt + + return p +} + +func (s *CreatematviewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatematviewstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatematviewstmtContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *CreatematviewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *CreatematviewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreatematviewstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CreatematviewstmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *CreatematviewstmtContext) Opt_backup_clause() IOpt_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_backup_clauseContext) +} + +func (s *CreatematviewstmtContext) AllOpt_table_attributes() []IOpt_table_attributesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpt_table_attributesContext); ok { + len++ + } + } + + tst := make([]IOpt_table_attributesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpt_table_attributesContext); ok { + tst[i] = t.(IOpt_table_attributesContext) + i++ + } + } + + return tst +} + +func (s *CreatematviewstmtContext) Opt_table_attributes(i int) IOpt_table_attributesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_table_attributesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpt_table_attributesContext) +} + +func (s *CreatematviewstmtContext) Opt_auto_refresh() IOpt_auto_refreshContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_auto_refreshContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_auto_refreshContext) +} + +func (s *CreatematviewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatematviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatematviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatematviewstmt(s) + } +} + +func (s *CreatematviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatematviewstmt(s) + } +} + +func (s *CreatematviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatematviewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Creatematviewstmt() (localctx ICreatematviewstmtContext) { + localctx = NewCreatematviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, RedshiftParserRULE_creatematviewstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4332) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4333) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4334) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4335) + p.Qualified_name() + } + p.SetState(4337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserBACKUP { + { + p.SetState(4336) + p.Opt_backup_clause() + } + + } + p.SetState(4342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for (int64((_la-835)) & ^0x3f) == 0 && ((int64(1)<<(_la-835))&111) != 0 { + { + p.SetState(4339) + p.Opt_table_attributes() + } + + p.SetState(4344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAUTO { + { + p.SetState(4345) + p.Opt_auto_refresh() + } + + } + { + p.SetState(4348) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4349) + p.Selectstmt() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_auto_refreshContext is an interface to support dynamic dispatch. +type IOpt_auto_refreshContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTO() antlr.TerminalNode + REFRESH() antlr.TerminalNode + YES_P() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsOpt_auto_refreshContext differentiates from other interfaces. + IsOpt_auto_refreshContext() +} + +type Opt_auto_refreshContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_auto_refreshContext() *Opt_auto_refreshContext { + var p = new(Opt_auto_refreshContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_auto_refresh + return p +} + +func InitEmptyOpt_auto_refreshContext(p *Opt_auto_refreshContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_auto_refresh +} + +func (*Opt_auto_refreshContext) IsOpt_auto_refreshContext() {} + +func NewOpt_auto_refreshContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_auto_refreshContext { + var p = new(Opt_auto_refreshContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_auto_refresh + + return p +} + +func (s *Opt_auto_refreshContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_auto_refreshContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *Opt_auto_refreshContext) REFRESH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFRESH, 0) +} + +func (s *Opt_auto_refreshContext) YES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYES_P, 0) +} + +func (s *Opt_auto_refreshContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_auto_refreshContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_auto_refreshContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_auto_refreshContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_auto_refresh(s) + } +} + +func (s *Opt_auto_refreshContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_auto_refresh(s) + } +} + +func (s *Opt_auto_refreshContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_auto_refresh(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_auto_refresh() (localctx IOpt_auto_refreshContext) { + localctx = NewOpt_auto_refreshContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, RedshiftParserRULE_opt_auto_refresh) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4351) + p.Match(RedshiftParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4352) + p.Match(RedshiftParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4353) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserNO || _la == RedshiftParserYES_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRefreshmatviewstmtContext is an interface to support dynamic dispatch. +type IRefreshmatviewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFRESH() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_concurrently() IOpt_concurrentlyContext + Opt_with_data() IOpt_with_dataContext + RESTRICT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + + // IsRefreshmatviewstmtContext differentiates from other interfaces. + IsRefreshmatviewstmtContext() +} + +type RefreshmatviewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRefreshmatviewstmtContext() *RefreshmatviewstmtContext { + var p = new(RefreshmatviewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_refreshmatviewstmt + return p +} + +func InitEmptyRefreshmatviewstmtContext(p *RefreshmatviewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_refreshmatviewstmt +} + +func (*RefreshmatviewstmtContext) IsRefreshmatviewstmtContext() {} + +func NewRefreshmatviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RefreshmatviewstmtContext { + var p = new(RefreshmatviewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_refreshmatviewstmt + + return p +} + +func (s *RefreshmatviewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RefreshmatviewstmtContext) REFRESH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFRESH, 0) +} + +func (s *RefreshmatviewstmtContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *RefreshmatviewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *RefreshmatviewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *RefreshmatviewstmtContext) Opt_concurrently() IOpt_concurrentlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_concurrentlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_concurrentlyContext) +} + +func (s *RefreshmatviewstmtContext) Opt_with_data() IOpt_with_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_dataContext) +} + +func (s *RefreshmatviewstmtContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *RefreshmatviewstmtContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *RefreshmatviewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RefreshmatviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RefreshmatviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRefreshmatviewstmt(s) + } +} + +func (s *RefreshmatviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRefreshmatviewstmt(s) + } +} + +func (s *RefreshmatviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRefreshmatviewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Refreshmatviewstmt() (localctx IRefreshmatviewstmtContext) { + localctx = NewRefreshmatviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, RedshiftParserRULE_refreshmatviewstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4355) + p.Match(RedshiftParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4356) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4357) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONCURRENTLY { + { + p.SetState(4358) + p.Opt_concurrently() + } + + } + { + p.SetState(4361) + p.Qualified_name() + } + p.SetState(4363) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 254, p.GetParserRuleContext()) == 1 { + { + p.SetState(4362) + p.Opt_with_data() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(4365) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT) { + 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 +} + +// ICreateseqstmtContext is an interface to support dynamic dispatch. +type ICreateseqstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opttemp() IOpttempContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Optseqoptlist() IOptseqoptlistContext + + // IsCreateseqstmtContext differentiates from other interfaces. + IsCreateseqstmtContext() +} + +type CreateseqstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateseqstmtContext() *CreateseqstmtContext { + var p = new(CreateseqstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createseqstmt + return p +} + +func InitEmptyCreateseqstmtContext(p *CreateseqstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createseqstmt +} + +func (*CreateseqstmtContext) IsCreateseqstmtContext() {} + +func NewCreateseqstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateseqstmtContext { + var p = new(CreateseqstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createseqstmt + + return p +} + +func (s *CreateseqstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateseqstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateseqstmtContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *CreateseqstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreateseqstmtContext) Opttemp() IOpttempContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttempContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttempContext) +} + +func (s *CreateseqstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreateseqstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreateseqstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreateseqstmtContext) Optseqoptlist() IOptseqoptlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptseqoptlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptseqoptlistContext) +} + +func (s *CreateseqstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateseqstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateseqstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateseqstmt(s) + } +} + +func (s *CreateseqstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateseqstmt(s) + } +} + +func (s *CreateseqstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateseqstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createseqstmt() (localctx ICreateseqstmtContext) { + localctx = NewCreateseqstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, RedshiftParserRULE_createseqstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4368) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLOCAL || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY { + { + p.SetState(4369) + p.Opttemp() + } + + } + { + p.SetState(4372) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4376) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 257, p.GetParserRuleContext()) == 1 { + { + p.SetState(4373) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4374) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4375) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4378) + p.Qualified_name() + } + p.SetState(4380) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 258, p.GetParserRuleContext()) == 1 { + { + p.SetState(4379) + p.Optseqoptlist() + } + + } 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 +} + +// IAlterseqstmtContext is an interface to support dynamic dispatch. +type IAlterseqstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Seqoptlist() ISeqoptlistContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsAlterseqstmtContext differentiates from other interfaces. + IsAlterseqstmtContext() +} + +type AlterseqstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterseqstmtContext() *AlterseqstmtContext { + var p = new(AlterseqstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterseqstmt + return p +} + +func InitEmptyAlterseqstmtContext(p *AlterseqstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterseqstmt +} + +func (*AlterseqstmtContext) IsAlterseqstmtContext() {} + +func NewAlterseqstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterseqstmtContext { + var p = new(AlterseqstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterseqstmt + + return p +} + +func (s *AlterseqstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterseqstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterseqstmtContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *AlterseqstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AlterseqstmtContext) Seqoptlist() ISeqoptlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeqoptlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeqoptlistContext) +} + +func (s *AlterseqstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *AlterseqstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *AlterseqstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterseqstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterseqstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterseqstmt(s) + } +} + +func (s *AlterseqstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterseqstmt(s) + } +} + +func (s *AlterseqstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterseqstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterseqstmt() (localctx IAlterseqstmtContext) { + localctx = NewAlterseqstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, RedshiftParserRULE_alterseqstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4382) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4383) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4386) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 259, p.GetParserRuleContext()) == 1 { + { + p.SetState(4384) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4385) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4388) + p.Qualified_name() + } + { + p.SetState(4389) + p.Seqoptlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptseqoptlistContext is an interface to support dynamic dispatch. +type IOptseqoptlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Seqoptlist() ISeqoptlistContext + + // IsOptseqoptlistContext differentiates from other interfaces. + IsOptseqoptlistContext() +} + +type OptseqoptlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptseqoptlistContext() *OptseqoptlistContext { + var p = new(OptseqoptlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optseqoptlist + return p +} + +func InitEmptyOptseqoptlistContext(p *OptseqoptlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optseqoptlist +} + +func (*OptseqoptlistContext) IsOptseqoptlistContext() {} + +func NewOptseqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptseqoptlistContext { + var p = new(OptseqoptlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optseqoptlist + + return p +} + +func (s *OptseqoptlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptseqoptlistContext) Seqoptlist() ISeqoptlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeqoptlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeqoptlistContext) +} + +func (s *OptseqoptlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptseqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptseqoptlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptseqoptlist(s) + } +} + +func (s *OptseqoptlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptseqoptlist(s) + } +} + +func (s *OptseqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptseqoptlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optseqoptlist() (localctx IOptseqoptlistContext) { + localctx = NewOptseqoptlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, RedshiftParserRULE_optseqoptlist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4391) + p.Seqoptlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptparenthesizedseqoptlistContext is an interface to support dynamic dispatch. +type IOptparenthesizedseqoptlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Seqoptlist() ISeqoptlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOptparenthesizedseqoptlistContext differentiates from other interfaces. + IsOptparenthesizedseqoptlistContext() +} + +type OptparenthesizedseqoptlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptparenthesizedseqoptlistContext() *OptparenthesizedseqoptlistContext { + var p = new(OptparenthesizedseqoptlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optparenthesizedseqoptlist + return p +} + +func InitEmptyOptparenthesizedseqoptlistContext(p *OptparenthesizedseqoptlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optparenthesizedseqoptlist +} + +func (*OptparenthesizedseqoptlistContext) IsOptparenthesizedseqoptlistContext() {} + +func NewOptparenthesizedseqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptparenthesizedseqoptlistContext { + var p = new(OptparenthesizedseqoptlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optparenthesizedseqoptlist + + return p +} + +func (s *OptparenthesizedseqoptlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptparenthesizedseqoptlistContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *OptparenthesizedseqoptlistContext) Seqoptlist() ISeqoptlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeqoptlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeqoptlistContext) +} + +func (s *OptparenthesizedseqoptlistContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *OptparenthesizedseqoptlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptparenthesizedseqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptparenthesizedseqoptlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptparenthesizedseqoptlist(s) + } +} + +func (s *OptparenthesizedseqoptlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptparenthesizedseqoptlist(s) + } +} + +func (s *OptparenthesizedseqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptparenthesizedseqoptlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optparenthesizedseqoptlist() (localctx IOptparenthesizedseqoptlistContext) { + localctx = NewOptparenthesizedseqoptlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, RedshiftParserRULE_optparenthesizedseqoptlist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4393) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4394) + p.Seqoptlist() + } + { + p.SetState(4395) + p.Match(RedshiftParserCLOSE_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 +} + +// ISeqoptlistContext is an interface to support dynamic dispatch. +type ISeqoptlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSeqoptelem() []ISeqoptelemContext + Seqoptelem(i int) ISeqoptelemContext + + // IsSeqoptlistContext differentiates from other interfaces. + IsSeqoptlistContext() +} + +type SeqoptlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeqoptlistContext() *SeqoptlistContext { + var p = new(SeqoptlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_seqoptlist + return p +} + +func InitEmptySeqoptlistContext(p *SeqoptlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_seqoptlist +} + +func (*SeqoptlistContext) IsSeqoptlistContext() {} + +func NewSeqoptlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeqoptlistContext { + var p = new(SeqoptlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_seqoptlist + + return p +} + +func (s *SeqoptlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *SeqoptlistContext) AllSeqoptelem() []ISeqoptelemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISeqoptelemContext); ok { + len++ + } + } + + tst := make([]ISeqoptelemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISeqoptelemContext); ok { + tst[i] = t.(ISeqoptelemContext) + i++ + } + } + + return tst +} + +func (s *SeqoptlistContext) Seqoptelem(i int) ISeqoptelemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeqoptelemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISeqoptelemContext) +} + +func (s *SeqoptlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SeqoptlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SeqoptlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSeqoptlist(s) + } +} + +func (s *SeqoptlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSeqoptlist(s) + } +} + +func (s *SeqoptlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSeqoptlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Seqoptlist() (localctx ISeqoptlistContext) { + localctx = NewSeqoptlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, RedshiftParserRULE_seqoptlist) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4398) + 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(4397) + p.Seqoptelem() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4400) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 260, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISeqoptelemContext is an interface to support dynamic dispatch. +type ISeqoptelemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + Simpletypename() ISimpletypenameContext + CACHE() antlr.TerminalNode + Numericonly() INumericonlyContext + CYCLE() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + Opt_by() IOpt_byContext + LOGGED() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + NO() antlr.TerminalNode + OWNED() antlr.TerminalNode + BY() antlr.TerminalNode + Any_name() IAny_nameContext + SEQUENCE() antlr.TerminalNode + NAME_P() antlr.TerminalNode + START() antlr.TerminalNode + Opt_with() IOpt_withContext + RESTART() antlr.TerminalNode + UNLOGGED() antlr.TerminalNode + + // IsSeqoptelemContext differentiates from other interfaces. + IsSeqoptelemContext() +} + +type SeqoptelemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeqoptelemContext() *SeqoptelemContext { + var p = new(SeqoptelemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_seqoptelem + return p +} + +func InitEmptySeqoptelemContext(p *SeqoptelemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_seqoptelem +} + +func (*SeqoptelemContext) IsSeqoptelemContext() {} + +func NewSeqoptelemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeqoptelemContext { + var p = new(SeqoptelemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_seqoptelem + + return p +} + +func (s *SeqoptelemContext) GetParser() antlr.Parser { return s.parser } + +func (s *SeqoptelemContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *SeqoptelemContext) Simpletypename() ISimpletypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpletypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpletypenameContext) +} + +func (s *SeqoptelemContext) CACHE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCACHE, 0) +} + +func (s *SeqoptelemContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *SeqoptelemContext) CYCLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCYCLE, 0) +} + +func (s *SeqoptelemContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCREMENT, 0) +} + +func (s *SeqoptelemContext) Opt_by() IOpt_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_byContext) +} + +func (s *SeqoptelemContext) LOGGED() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOGGED, 0) +} + +func (s *SeqoptelemContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAXVALUE, 0) +} + +func (s *SeqoptelemContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINVALUE, 0) +} + +func (s *SeqoptelemContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *SeqoptelemContext) OWNED() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNED, 0) +} + +func (s *SeqoptelemContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *SeqoptelemContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *SeqoptelemContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *SeqoptelemContext) NAME_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAME_P, 0) +} + +func (s *SeqoptelemContext) START() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTART, 0) +} + +func (s *SeqoptelemContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *SeqoptelemContext) RESTART() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTART, 0) +} + +func (s *SeqoptelemContext) UNLOGGED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLOGGED, 0) +} + +func (s *SeqoptelemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SeqoptelemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SeqoptelemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSeqoptelem(s) + } +} + +func (s *SeqoptelemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSeqoptelem(s) + } +} + +func (s *SeqoptelemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSeqoptelem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Seqoptelem() (localctx ISeqoptelemContext) { + localctx = NewSeqoptelemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, RedshiftParserRULE_seqoptelem) + var _la int + + p.SetState(4438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4402) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4403) + p.Simpletypename() + } + + case RedshiftParserCACHE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4404) + p.Match(RedshiftParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4405) + p.Numericonly() + } + + case RedshiftParserCYCLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4406) + p.Match(RedshiftParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserINCREMENT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4407) + p.Match(RedshiftParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserBY { + { + p.SetState(4408) + p.Opt_by() + } + + } + { + p.SetState(4411) + p.Numericonly() + } + + case RedshiftParserLOGGED: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4412) + p.Match(RedshiftParserLOGGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserMAXVALUE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4413) + p.Match(RedshiftParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4414) + p.Numericonly() + } + + case RedshiftParserMINVALUE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4415) + p.Match(RedshiftParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4416) + p.Numericonly() + } + + case RedshiftParserNO: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4417) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4418) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCYCLE || _la == RedshiftParserMAXVALUE || _la == RedshiftParserMINVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserOWNED: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4419) + p.Match(RedshiftParserOWNED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4420) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4421) + p.Any_name() + } + + case RedshiftParserSEQUENCE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4422) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4423) + p.Match(RedshiftParserNAME_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4424) + p.Any_name() + } + + case RedshiftParserSTART: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4425) + p.Match(RedshiftParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(4426) + p.Opt_with() + } + + } + { + p.SetState(4429) + p.Numericonly() + } + + case RedshiftParserRESTART: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(4430) + p.Match(RedshiftParserRESTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4432) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) == 1 { + { + p.SetState(4431) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPLUS || _la == RedshiftParserMINUS || _la == RedshiftParserIntegral || _la == RedshiftParserNumeric { + { + p.SetState(4434) + p.Numericonly() + } + + } + + case RedshiftParserUNLOGGED: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(4437) + p.Match(RedshiftParserUNLOGGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_byContext is an interface to support dynamic dispatch. +type IOpt_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + + // IsOpt_byContext differentiates from other interfaces. + IsOpt_byContext() +} + +type Opt_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_byContext() *Opt_byContext { + var p = new(Opt_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_by + return p +} + +func InitEmptyOpt_byContext(p *Opt_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_by +} + +func (*Opt_byContext) IsOpt_byContext() {} + +func NewOpt_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_byContext { + var p = new(Opt_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_by + + return p +} + +func (s *Opt_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_byContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Opt_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_by(s) + } +} + +func (s *Opt_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_by(s) + } +} + +func (s *Opt_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_by() (localctx IOpt_byContext) { + localctx = NewOpt_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, RedshiftParserRULE_opt_by) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4440) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumericonlyContext is an interface to support dynamic dispatch. +type INumericonlyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Fconst() IFconstContext + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + Signediconst() ISignediconstContext + + // IsNumericonlyContext differentiates from other interfaces. + IsNumericonlyContext() +} + +type NumericonlyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumericonlyContext() *NumericonlyContext { + var p = new(NumericonlyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_numericonly + return p +} + +func InitEmptyNumericonlyContext(p *NumericonlyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_numericonly +} + +func (*NumericonlyContext) IsNumericonlyContext() {} + +func NewNumericonlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericonlyContext { + var p = new(NumericonlyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_numericonly + + return p +} + +func (s *NumericonlyContext) GetParser() antlr.Parser { return s.parser } + +func (s *NumericonlyContext) Fconst() IFconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFconstContext) +} + +func (s *NumericonlyContext) PLUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLUS, 0) +} + +func (s *NumericonlyContext) MINUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUS, 0) +} + +func (s *NumericonlyContext) Signediconst() ISignediconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignediconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignediconstContext) +} + +func (s *NumericonlyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumericonlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NumericonlyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNumericonly(s) + } +} + +func (s *NumericonlyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNumericonly(s) + } +} + +func (s *NumericonlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNumericonly(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Numericonly() (localctx INumericonlyContext) { + localctx = NewNumericonlyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, RedshiftParserRULE_numericonly) + p.SetState(4448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 266, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4442) + p.Fconst() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4443) + p.Match(RedshiftParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4444) + p.Fconst() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4445) + p.Match(RedshiftParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4446) + p.Fconst() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4447) + p.Signediconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INumericonly_listContext is an interface to support dynamic dispatch. +type INumericonly_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllNumericonly() []INumericonlyContext + Numericonly(i int) INumericonlyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsNumericonly_listContext differentiates from other interfaces. + IsNumericonly_listContext() +} + +type Numericonly_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumericonly_listContext() *Numericonly_listContext { + var p = new(Numericonly_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_numericonly_list + return p +} + +func InitEmptyNumericonly_listContext(p *Numericonly_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_numericonly_list +} + +func (*Numericonly_listContext) IsNumericonly_listContext() {} + +func NewNumericonly_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numericonly_listContext { + var p = new(Numericonly_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_numericonly_list + + return p +} + +func (s *Numericonly_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numericonly_listContext) AllNumericonly() []INumericonlyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericonlyContext); ok { + len++ + } + } + + tst := make([]INumericonlyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericonlyContext); ok { + tst[i] = t.(INumericonlyContext) + i++ + } + } + + return tst +} + +func (s *Numericonly_listContext) Numericonly(i int) INumericonlyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Numericonly_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Numericonly_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Numericonly_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numericonly_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numericonly_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNumericonly_list(s) + } +} + +func (s *Numericonly_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNumericonly_list(s) + } +} + +func (s *Numericonly_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNumericonly_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Numericonly_list() (localctx INumericonly_listContext) { + localctx = NewNumericonly_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, RedshiftParserRULE_numericonly_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4450) + p.Numericonly() + } + p.SetState(4455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(4451) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4452) + p.Numericonly() + } + + p.SetState(4457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateplangstmtContext is an interface to support dynamic dispatch. +type ICreateplangstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + Name() INameContext + Opt_or_replace() IOpt_or_replaceContext + Opt_trusted() IOpt_trustedContext + Opt_procedural() IOpt_proceduralContext + HANDLER() antlr.TerminalNode + Handler_name() IHandler_nameContext + Opt_inline_handler() IOpt_inline_handlerContext + Opt_validator() IOpt_validatorContext + + // IsCreateplangstmtContext differentiates from other interfaces. + IsCreateplangstmtContext() +} + +type CreateplangstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateplangstmtContext() *CreateplangstmtContext { + var p = new(CreateplangstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createplangstmt + return p +} + +func InitEmptyCreateplangstmtContext(p *CreateplangstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createplangstmt +} + +func (*CreateplangstmtContext) IsCreateplangstmtContext() {} + +func NewCreateplangstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateplangstmtContext { + var p = new(CreateplangstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createplangstmt + + return p +} + +func (s *CreateplangstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateplangstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateplangstmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *CreateplangstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateplangstmtContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *CreateplangstmtContext) Opt_trusted() IOpt_trustedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_trustedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_trustedContext) +} + +func (s *CreateplangstmtContext) Opt_procedural() IOpt_proceduralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_proceduralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_proceduralContext) +} + +func (s *CreateplangstmtContext) HANDLER() antlr.TerminalNode { + return s.GetToken(RedshiftParserHANDLER, 0) +} + +func (s *CreateplangstmtContext) Handler_name() IHandler_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandler_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandler_nameContext) +} + +func (s *CreateplangstmtContext) Opt_inline_handler() IOpt_inline_handlerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_inline_handlerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_inline_handlerContext) +} + +func (s *CreateplangstmtContext) Opt_validator() IOpt_validatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_validatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_validatorContext) +} + +func (s *CreateplangstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateplangstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateplangstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateplangstmt(s) + } +} + +func (s *CreateplangstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateplangstmt(s) + } +} + +func (s *CreateplangstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateplangstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createplangstmt() (localctx ICreateplangstmtContext) { + localctx = NewCreateplangstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, RedshiftParserRULE_createplangstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4458) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(4459) + p.Opt_or_replace() + } + + } + p.SetState(4463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRUSTED { + { + p.SetState(4462) + p.Opt_trusted() + } + + } + p.SetState(4466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROCEDURAL { + { + p.SetState(4465) + p.Opt_procedural() + } + + } + { + p.SetState(4468) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4469) + p.Name() + } + p.SetState(4478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserHANDLER { + { + p.SetState(4470) + p.Match(RedshiftParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4471) + p.Handler_name() + } + p.SetState(4473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINLINE_P { + { + p.SetState(4472) + p.Opt_inline_handler() + } + + } + p.SetState(4476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO || _la == RedshiftParserVALIDATOR { + { + p.SetState(4475) + p.Opt_validator() + } + + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_trustedContext is an interface to support dynamic dispatch. +type IOpt_trustedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUSTED() antlr.TerminalNode + + // IsOpt_trustedContext differentiates from other interfaces. + IsOpt_trustedContext() +} + +type Opt_trustedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_trustedContext() *Opt_trustedContext { + var p = new(Opt_trustedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_trusted + return p +} + +func InitEmptyOpt_trustedContext(p *Opt_trustedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_trusted +} + +func (*Opt_trustedContext) IsOpt_trustedContext() {} + +func NewOpt_trustedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_trustedContext { + var p = new(Opt_trustedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_trusted + + return p +} + +func (s *Opt_trustedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_trustedContext) TRUSTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUSTED, 0) +} + +func (s *Opt_trustedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_trustedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_trustedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_trusted(s) + } +} + +func (s *Opt_trustedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_trusted(s) + } +} + +func (s *Opt_trustedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_trusted(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_trusted() (localctx IOpt_trustedContext) { + localctx = NewOpt_trustedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, RedshiftParserRULE_opt_trusted) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4480) + p.Match(RedshiftParserTRUSTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHandler_nameContext is an interface to support dynamic dispatch. +type IHandler_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + Attrs() IAttrsContext + + // IsHandler_nameContext differentiates from other interfaces. + IsHandler_nameContext() +} + +type Handler_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHandler_nameContext() *Handler_nameContext { + var p = new(Handler_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_handler_name + return p +} + +func InitEmptyHandler_nameContext(p *Handler_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_handler_name +} + +func (*Handler_nameContext) IsHandler_nameContext() {} + +func NewHandler_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Handler_nameContext { + var p = new(Handler_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_handler_name + + return p +} + +func (s *Handler_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Handler_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Handler_nameContext) Attrs() IAttrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttrsContext) +} + +func (s *Handler_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Handler_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Handler_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHandler_name(s) + } +} + +func (s *Handler_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHandler_name(s) + } +} + +func (s *Handler_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHandler_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Handler_name() (localctx IHandler_nameContext) { + localctx = NewHandler_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, RedshiftParserRULE_handler_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4482) + p.Name() + } + p.SetState(4484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDOT { + { + p.SetState(4483) + p.Attrs() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_inline_handlerContext is an interface to support dynamic dispatch. +type IOpt_inline_handlerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INLINE_P() antlr.TerminalNode + Handler_name() IHandler_nameContext + + // IsOpt_inline_handlerContext differentiates from other interfaces. + IsOpt_inline_handlerContext() +} + +type Opt_inline_handlerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_inline_handlerContext() *Opt_inline_handlerContext { + var p = new(Opt_inline_handlerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_inline_handler + return p +} + +func InitEmptyOpt_inline_handlerContext(p *Opt_inline_handlerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_inline_handler +} + +func (*Opt_inline_handlerContext) IsOpt_inline_handlerContext() {} + +func NewOpt_inline_handlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_inline_handlerContext { + var p = new(Opt_inline_handlerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_inline_handler + + return p +} + +func (s *Opt_inline_handlerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_inline_handlerContext) INLINE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINLINE_P, 0) +} + +func (s *Opt_inline_handlerContext) Handler_name() IHandler_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandler_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandler_nameContext) +} + +func (s *Opt_inline_handlerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_inline_handlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_inline_handlerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_inline_handler(s) + } +} + +func (s *Opt_inline_handlerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_inline_handler(s) + } +} + +func (s *Opt_inline_handlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_inline_handler(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_inline_handler() (localctx IOpt_inline_handlerContext) { + localctx = NewOpt_inline_handlerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, RedshiftParserRULE_opt_inline_handler) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4486) + p.Match(RedshiftParserINLINE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4487) + p.Handler_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValidator_clauseContext is an interface to support dynamic dispatch. +type IValidator_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALIDATOR() antlr.TerminalNode + Handler_name() IHandler_nameContext + NO() antlr.TerminalNode + + // IsValidator_clauseContext differentiates from other interfaces. + IsValidator_clauseContext() +} + +type Validator_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValidator_clauseContext() *Validator_clauseContext { + var p = new(Validator_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_validator_clause + return p +} + +func InitEmptyValidator_clauseContext(p *Validator_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_validator_clause +} + +func (*Validator_clauseContext) IsValidator_clauseContext() {} + +func NewValidator_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Validator_clauseContext { + var p = new(Validator_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_validator_clause + + return p +} + +func (s *Validator_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Validator_clauseContext) VALIDATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALIDATOR, 0) +} + +func (s *Validator_clauseContext) Handler_name() IHandler_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandler_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandler_nameContext) +} + +func (s *Validator_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Validator_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Validator_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Validator_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterValidator_clause(s) + } +} + +func (s *Validator_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitValidator_clause(s) + } +} + +func (s *Validator_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitValidator_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Validator_clause() (localctx IValidator_clauseContext) { + localctx = NewValidator_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, RedshiftParserRULE_validator_clause) + p.SetState(4493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserVALIDATOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4489) + p.Match(RedshiftParserVALIDATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4490) + p.Handler_name() + } + + case RedshiftParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4491) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4492) + p.Match(RedshiftParserVALIDATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_validatorContext is an interface to support dynamic dispatch. +type IOpt_validatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Validator_clause() IValidator_clauseContext + + // IsOpt_validatorContext differentiates from other interfaces. + IsOpt_validatorContext() +} + +type Opt_validatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_validatorContext() *Opt_validatorContext { + var p = new(Opt_validatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_validator + return p +} + +func InitEmptyOpt_validatorContext(p *Opt_validatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_validator +} + +func (*Opt_validatorContext) IsOpt_validatorContext() {} + +func NewOpt_validatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_validatorContext { + var p = new(Opt_validatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_validator + + return p +} + +func (s *Opt_validatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_validatorContext) Validator_clause() IValidator_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValidator_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValidator_clauseContext) +} + +func (s *Opt_validatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_validatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_validatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_validator(s) + } +} + +func (s *Opt_validatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_validator(s) + } +} + +func (s *Opt_validatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_validator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_validator() (localctx IOpt_validatorContext) { + localctx = NewOpt_validatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, RedshiftParserRULE_opt_validator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4495) + p.Validator_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_proceduralContext is an interface to support dynamic dispatch. +type IOpt_proceduralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURAL() antlr.TerminalNode + + // IsOpt_proceduralContext differentiates from other interfaces. + IsOpt_proceduralContext() +} + +type Opt_proceduralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_proceduralContext() *Opt_proceduralContext { + var p = new(Opt_proceduralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_procedural + return p +} + +func InitEmptyOpt_proceduralContext(p *Opt_proceduralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_procedural +} + +func (*Opt_proceduralContext) IsOpt_proceduralContext() {} + +func NewOpt_proceduralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_proceduralContext { + var p = new(Opt_proceduralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_procedural + + return p +} + +func (s *Opt_proceduralContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_proceduralContext) PROCEDURAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURAL, 0) +} + +func (s *Opt_proceduralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_proceduralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_proceduralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_procedural(s) + } +} + +func (s *Opt_proceduralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_procedural(s) + } +} + +func (s *Opt_proceduralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_procedural(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_procedural() (localctx IOpt_proceduralContext) { + localctx = NewOpt_proceduralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, RedshiftParserRULE_opt_procedural) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4497) + p.Match(RedshiftParserPROCEDURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatetablespacestmtContext is an interface to support dynamic dispatch. +type ICreatetablespacestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Name() INameContext + LOCATION() antlr.TerminalNode + Sconst() ISconstContext + Opttablespaceowner() IOpttablespaceownerContext + Opt_reloptions() IOpt_reloptionsContext + + // IsCreatetablespacestmtContext differentiates from other interfaces. + IsCreatetablespacestmtContext() +} + +type CreatetablespacestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatetablespacestmtContext() *CreatetablespacestmtContext { + var p = new(CreatetablespacestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createtablespacestmt + return p +} + +func InitEmptyCreatetablespacestmtContext(p *CreatetablespacestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createtablespacestmt +} + +func (*CreatetablespacestmtContext) IsCreatetablespacestmtContext() {} + +func NewCreatetablespacestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetablespacestmtContext { + var p = new(CreatetablespacestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createtablespacestmt + + return p +} + +func (s *CreatetablespacestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatetablespacestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatetablespacestmtContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *CreatetablespacestmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatetablespacestmtContext) LOCATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCATION, 0) +} + +func (s *CreatetablespacestmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreatetablespacestmtContext) Opttablespaceowner() IOpttablespaceownerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttablespaceownerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttablespaceownerContext) +} + +func (s *CreatetablespacestmtContext) Opt_reloptions() IOpt_reloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_reloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_reloptionsContext) +} + +func (s *CreatetablespacestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatetablespacestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatetablespacestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatetablespacestmt(s) + } +} + +func (s *CreatetablespacestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatetablespacestmt(s) + } +} + +func (s *CreatetablespacestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatetablespacestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createtablespacestmt() (localctx ICreatetablespacestmtContext) { + localctx = NewCreatetablespacestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, RedshiftParserRULE_createtablespacestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4499) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4500) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4501) + p.Name() + } + p.SetState(4503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOWNER { + { + p.SetState(4502) + p.Opttablespaceowner() + } + + } + { + p.SetState(4505) + p.Match(RedshiftParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4506) + p.Sconst() + } + p.SetState(4508) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 277, p.GetParserRuleContext()) == 1 { + { + p.SetState(4507) + p.Opt_reloptions() + } + + } 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 +} + +// IOpttablespaceownerContext is an interface to support dynamic dispatch. +type IOpttablespaceownerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OWNER() antlr.TerminalNode + Rolespec() IRolespecContext + + // IsOpttablespaceownerContext differentiates from other interfaces. + IsOpttablespaceownerContext() +} + +type OpttablespaceownerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpttablespaceownerContext() *OpttablespaceownerContext { + var p = new(OpttablespaceownerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttablespaceowner + return p +} + +func InitEmptyOpttablespaceownerContext(p *OpttablespaceownerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttablespaceowner +} + +func (*OpttablespaceownerContext) IsOpttablespaceownerContext() {} + +func NewOpttablespaceownerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablespaceownerContext { + var p = new(OpttablespaceownerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opttablespaceowner + + return p +} + +func (s *OpttablespaceownerContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpttablespaceownerContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *OpttablespaceownerContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *OpttablespaceownerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpttablespaceownerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpttablespaceownerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpttablespaceowner(s) + } +} + +func (s *OpttablespaceownerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpttablespaceowner(s) + } +} + +func (s *OpttablespaceownerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpttablespaceowner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opttablespaceowner() (localctx IOpttablespaceownerContext) { + localctx = NewOpttablespaceownerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, RedshiftParserRULE_opttablespaceowner) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4510) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4511) + p.Rolespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDroptablespacestmtContext is an interface to support dynamic dispatch. +type IDroptablespacestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Name() INameContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDroptablespacestmtContext differentiates from other interfaces. + IsDroptablespacestmtContext() +} + +type DroptablespacestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDroptablespacestmtContext() *DroptablespacestmtContext { + var p = new(DroptablespacestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droptablespacestmt + return p +} + +func InitEmptyDroptablespacestmtContext(p *DroptablespacestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droptablespacestmt +} + +func (*DroptablespacestmtContext) IsDroptablespacestmtContext() {} + +func NewDroptablespacestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroptablespacestmtContext { + var p = new(DroptablespacestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_droptablespacestmt + + return p +} + +func (s *DroptablespacestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DroptablespacestmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DroptablespacestmtContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *DroptablespacestmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DroptablespacestmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *DroptablespacestmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *DroptablespacestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DroptablespacestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DroptablespacestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDroptablespacestmt(s) + } +} + +func (s *DroptablespacestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDroptablespacestmt(s) + } +} + +func (s *DroptablespacestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDroptablespacestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Droptablespacestmt() (localctx IDroptablespacestmtContext) { + localctx = NewDroptablespacestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, RedshiftParserRULE_droptablespacestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4513) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4514) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4517) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 278, p.GetParserRuleContext()) == 1 { + { + p.SetState(4515) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4516) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4519) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateextensionstmtContext is an interface to support dynamic dispatch. +type ICreateextensionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + Name() INameContext + Create_extension_opt_list() ICreate_extension_opt_listContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Opt_with() IOpt_withContext + + // IsCreateextensionstmtContext differentiates from other interfaces. + IsCreateextensionstmtContext() +} + +type CreateextensionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateextensionstmtContext() *CreateextensionstmtContext { + var p = new(CreateextensionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createextensionstmt + return p +} + +func InitEmptyCreateextensionstmtContext(p *CreateextensionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createextensionstmt +} + +func (*CreateextensionstmtContext) IsCreateextensionstmtContext() {} + +func NewCreateextensionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateextensionstmtContext { + var p = new(CreateextensionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createextensionstmt + + return p +} + +func (s *CreateextensionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateextensionstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateextensionstmtContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *CreateextensionstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateextensionstmtContext) Create_extension_opt_list() ICreate_extension_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_extension_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_extension_opt_listContext) +} + +func (s *CreateextensionstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreateextensionstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreateextensionstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreateextensionstmtContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *CreateextensionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateextensionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateextensionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateextensionstmt(s) + } +} + +func (s *CreateextensionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateextensionstmt(s) + } +} + +func (s *CreateextensionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateextensionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createextensionstmt() (localctx ICreateextensionstmtContext) { + localctx = NewCreateextensionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, RedshiftParserRULE_createextensionstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4521) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4522) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4526) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 279, p.GetParserRuleContext()) == 1 { + { + p.SetState(4523) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4524) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4525) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4528) + p.Name() + } + p.SetState(4530) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 280, p.GetParserRuleContext()) == 1 { + { + p.SetState(4529) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4532) + p.Create_extension_opt_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_extension_opt_listContext is an interface to support dynamic dispatch. +type ICreate_extension_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCreate_extension_opt_item() []ICreate_extension_opt_itemContext + Create_extension_opt_item(i int) ICreate_extension_opt_itemContext + + // IsCreate_extension_opt_listContext differentiates from other interfaces. + IsCreate_extension_opt_listContext() +} + +type Create_extension_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_extension_opt_listContext() *Create_extension_opt_listContext { + var p = new(Create_extension_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_extension_opt_list + return p +} + +func InitEmptyCreate_extension_opt_listContext(p *Create_extension_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_extension_opt_list +} + +func (*Create_extension_opt_listContext) IsCreate_extension_opt_listContext() {} + +func NewCreate_extension_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_extension_opt_listContext { + var p = new(Create_extension_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_create_extension_opt_list + + return p +} + +func (s *Create_extension_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_extension_opt_listContext) AllCreate_extension_opt_item() []ICreate_extension_opt_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreate_extension_opt_itemContext); ok { + len++ + } + } + + tst := make([]ICreate_extension_opt_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreate_extension_opt_itemContext); ok { + tst[i] = t.(ICreate_extension_opt_itemContext) + i++ + } + } + + return tst +} + +func (s *Create_extension_opt_listContext) Create_extension_opt_item(i int) ICreate_extension_opt_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_extension_opt_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreate_extension_opt_itemContext) +} + +func (s *Create_extension_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_extension_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_extension_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreate_extension_opt_list(s) + } +} + +func (s *Create_extension_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreate_extension_opt_list(s) + } +} + +func (s *Create_extension_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreate_extension_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Create_extension_opt_list() (localctx ICreate_extension_opt_listContext) { + localctx = NewCreate_extension_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, RedshiftParserRULE_create_extension_opt_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserFROM || _la == RedshiftParserCASCADE || _la == RedshiftParserSCHEMA || _la == RedshiftParserVERSION_P { + { + p.SetState(4534) + p.Create_extension_opt_item() + } + + p.SetState(4539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_extension_opt_itemContext is an interface to support dynamic dispatch. +type ICreate_extension_opt_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCHEMA() antlr.TerminalNode + Name() INameContext + VERSION_P() antlr.TerminalNode + Nonreservedword_or_sconst() INonreservedword_or_sconstContext + FROM() antlr.TerminalNode + CASCADE() antlr.TerminalNode + + // IsCreate_extension_opt_itemContext differentiates from other interfaces. + IsCreate_extension_opt_itemContext() +} + +type Create_extension_opt_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_extension_opt_itemContext() *Create_extension_opt_itemContext { + var p = new(Create_extension_opt_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_extension_opt_item + return p +} + +func InitEmptyCreate_extension_opt_itemContext(p *Create_extension_opt_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_extension_opt_item +} + +func (*Create_extension_opt_itemContext) IsCreate_extension_opt_itemContext() {} + +func NewCreate_extension_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_extension_opt_itemContext { + var p = new(Create_extension_opt_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_create_extension_opt_item + + return p +} + +func (s *Create_extension_opt_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_extension_opt_itemContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Create_extension_opt_itemContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Create_extension_opt_itemContext) VERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERSION_P, 0) +} + +func (s *Create_extension_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedword_or_sconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedword_or_sconstContext) +} + +func (s *Create_extension_opt_itemContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Create_extension_opt_itemContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *Create_extension_opt_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_extension_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_extension_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreate_extension_opt_item(s) + } +} + +func (s *Create_extension_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreate_extension_opt_item(s) + } +} + +func (s *Create_extension_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreate_extension_opt_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Create_extension_opt_item() (localctx ICreate_extension_opt_itemContext) { + localctx = NewCreate_extension_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, RedshiftParserRULE_create_extension_opt_item) + p.SetState(4547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4540) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4541) + p.Name() + } + + case RedshiftParserVERSION_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4542) + p.Match(RedshiftParserVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4543) + p.Nonreservedword_or_sconst() + } + + case RedshiftParserFROM: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4544) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4545) + p.Nonreservedword_or_sconst() + } + + case RedshiftParserCASCADE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4546) + p.Match(RedshiftParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterextensionstmtContext is an interface to support dynamic dispatch. +type IAlterextensionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + Name() INameContext + UPDATE() antlr.TerminalNode + Alter_extension_opt_list() IAlter_extension_opt_listContext + + // IsAlterextensionstmtContext differentiates from other interfaces. + IsAlterextensionstmtContext() +} + +type AlterextensionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterextensionstmtContext() *AlterextensionstmtContext { + var p = new(AlterextensionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterextensionstmt + return p +} + +func InitEmptyAlterextensionstmtContext(p *AlterextensionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterextensionstmt +} + +func (*AlterextensionstmtContext) IsAlterextensionstmtContext() {} + +func NewAlterextensionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterextensionstmtContext { + var p = new(AlterextensionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterextensionstmt + + return p +} + +func (s *AlterextensionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterextensionstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterextensionstmtContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *AlterextensionstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterextensionstmtContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *AlterextensionstmtContext) Alter_extension_opt_list() IAlter_extension_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_extension_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_extension_opt_listContext) +} + +func (s *AlterextensionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterextensionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterextensionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterextensionstmt(s) + } +} + +func (s *AlterextensionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterextensionstmt(s) + } +} + +func (s *AlterextensionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterextensionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterextensionstmt() (localctx IAlterextensionstmtContext) { + localctx = NewAlterextensionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, RedshiftParserRULE_alterextensionstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4549) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4550) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4551) + p.Name() + } + { + p.SetState(4552) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4553) + p.Alter_extension_opt_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_extension_opt_listContext is an interface to support dynamic dispatch. +type IAlter_extension_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_extension_opt_item() []IAlter_extension_opt_itemContext + Alter_extension_opt_item(i int) IAlter_extension_opt_itemContext + + // IsAlter_extension_opt_listContext differentiates from other interfaces. + IsAlter_extension_opt_listContext() +} + +type Alter_extension_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_extension_opt_listContext() *Alter_extension_opt_listContext { + var p = new(Alter_extension_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_extension_opt_list + return p +} + +func InitEmptyAlter_extension_opt_listContext(p *Alter_extension_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_extension_opt_list +} + +func (*Alter_extension_opt_listContext) IsAlter_extension_opt_listContext() {} + +func NewAlter_extension_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_extension_opt_listContext { + var p = new(Alter_extension_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_extension_opt_list + + return p +} + +func (s *Alter_extension_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_extension_opt_listContext) AllAlter_extension_opt_item() []IAlter_extension_opt_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_extension_opt_itemContext); ok { + len++ + } + } + + tst := make([]IAlter_extension_opt_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_extension_opt_itemContext); ok { + tst[i] = t.(IAlter_extension_opt_itemContext) + i++ + } + } + + return tst +} + +func (s *Alter_extension_opt_listContext) Alter_extension_opt_item(i int) IAlter_extension_opt_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_extension_opt_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_extension_opt_itemContext) +} + +func (s *Alter_extension_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_extension_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_extension_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_extension_opt_list(s) + } +} + +func (s *Alter_extension_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_extension_opt_list(s) + } +} + +func (s *Alter_extension_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_extension_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_extension_opt_list() (localctx IAlter_extension_opt_listContext) { + localctx = NewAlter_extension_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, RedshiftParserRULE_alter_extension_opt_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserTO { + { + p.SetState(4555) + p.Alter_extension_opt_item() + } + + p.SetState(4560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_extension_opt_itemContext is an interface to support dynamic dispatch. +type IAlter_extension_opt_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TO() antlr.TerminalNode + Nonreservedword_or_sconst() INonreservedword_or_sconstContext + + // IsAlter_extension_opt_itemContext differentiates from other interfaces. + IsAlter_extension_opt_itemContext() +} + +type Alter_extension_opt_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_extension_opt_itemContext() *Alter_extension_opt_itemContext { + var p = new(Alter_extension_opt_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_extension_opt_item + return p +} + +func InitEmptyAlter_extension_opt_itemContext(p *Alter_extension_opt_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_extension_opt_item +} + +func (*Alter_extension_opt_itemContext) IsAlter_extension_opt_itemContext() {} + +func NewAlter_extension_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_extension_opt_itemContext { + var p = new(Alter_extension_opt_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_extension_opt_item + + return p +} + +func (s *Alter_extension_opt_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_extension_opt_itemContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Alter_extension_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedword_or_sconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedword_or_sconstContext) +} + +func (s *Alter_extension_opt_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_extension_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_extension_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_extension_opt_item(s) + } +} + +func (s *Alter_extension_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_extension_opt_item(s) + } +} + +func (s *Alter_extension_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_extension_opt_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_extension_opt_item() (localctx IAlter_extension_opt_itemContext) { + localctx = NewAlter_extension_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, RedshiftParserRULE_alter_extension_opt_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4561) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4562) + p.Nonreservedword_or_sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterextensioncontentsstmtContext is an interface to support dynamic dispatch. +type IAlterextensioncontentsstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + AllName() []INameContext + Name(i int) INameContext + Add_drop() IAdd_dropContext + Object_type_name() IObject_type_nameContext + Object_type_any_name() IObject_type_any_nameContext + Any_name() IAny_nameContext + AGGREGATE() antlr.TerminalNode + Aggregate_with_argtypes() IAggregate_with_argtypesContext + CAST() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + AS() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + DOMAIN_P() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + OPERATOR() antlr.TerminalNode + Operator_with_argtypes() IOperator_with_argtypesContext + CLASS() antlr.TerminalNode + USING() antlr.TerminalNode + FAMILY() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + FOR() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + + // IsAlterextensioncontentsstmtContext differentiates from other interfaces. + IsAlterextensioncontentsstmtContext() +} + +type AlterextensioncontentsstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterextensioncontentsstmtContext() *AlterextensioncontentsstmtContext { + var p = new(AlterextensioncontentsstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterextensioncontentsstmt + return p +} + +func InitEmptyAlterextensioncontentsstmtContext(p *AlterextensioncontentsstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterextensioncontentsstmt +} + +func (*AlterextensioncontentsstmtContext) IsAlterextensioncontentsstmtContext() {} + +func NewAlterextensioncontentsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterextensioncontentsstmtContext { + var p = new(AlterextensioncontentsstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterextensioncontentsstmt + + return p +} + +func (s *AlterextensioncontentsstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterextensioncontentsstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterextensioncontentsstmtContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *AlterextensioncontentsstmtContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *AlterextensioncontentsstmtContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterextensioncontentsstmtContext) Add_drop() IAdd_dropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_dropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_dropContext) +} + +func (s *AlterextensioncontentsstmtContext) Object_type_name() IObject_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_nameContext) +} + +func (s *AlterextensioncontentsstmtContext) Object_type_any_name() IObject_type_any_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_any_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_any_nameContext) +} + +func (s *AlterextensioncontentsstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AlterextensioncontentsstmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *AlterextensioncontentsstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypesContext) +} + +func (s *AlterextensioncontentsstmtContext) CAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCAST, 0) +} + +func (s *AlterextensioncontentsstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AlterextensioncontentsstmtContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *AlterextensioncontentsstmtContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *AlterextensioncontentsstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *AlterextensioncontentsstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AlterextensioncontentsstmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *AlterextensioncontentsstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *AlterextensioncontentsstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *AlterextensioncontentsstmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *AlterextensioncontentsstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypesContext) +} + +func (s *AlterextensioncontentsstmtContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *AlterextensioncontentsstmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *AlterextensioncontentsstmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *AlterextensioncontentsstmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *AlterextensioncontentsstmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *AlterextensioncontentsstmtContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSFORM, 0) +} + +func (s *AlterextensioncontentsstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *AlterextensioncontentsstmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *AlterextensioncontentsstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *AlterextensioncontentsstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterextensioncontentsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterextensioncontentsstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterextensioncontentsstmt(s) + } +} + +func (s *AlterextensioncontentsstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterextensioncontentsstmt(s) + } +} + +func (s *AlterextensioncontentsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterextensioncontentsstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterextensioncontentsstmt() (localctx IAlterextensioncontentsstmtContext) { + localctx = NewAlterextensioncontentsstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, RedshiftParserRULE_alterextensioncontentsstmt) + p.SetState(4668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 284, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4564) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4565) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4566) + p.Name() + } + { + p.SetState(4567) + p.Add_drop() + } + { + p.SetState(4568) + p.Object_type_name() + } + { + p.SetState(4569) + p.Name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4571) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4572) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4573) + p.Name() + } + { + p.SetState(4574) + p.Add_drop() + } + { + p.SetState(4575) + p.Object_type_any_name() + } + { + p.SetState(4576) + p.Any_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4578) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4579) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4580) + p.Name() + } + { + p.SetState(4581) + p.Add_drop() + } + { + p.SetState(4582) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4583) + p.Aggregate_with_argtypes() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4585) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4586) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4587) + p.Name() + } + { + p.SetState(4588) + p.Add_drop() + } + { + p.SetState(4589) + p.Match(RedshiftParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4590) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4591) + p.Typename() + } + { + p.SetState(4592) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4593) + p.Typename() + } + { + p.SetState(4594) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4596) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4597) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4598) + p.Name() + } + { + p.SetState(4599) + p.Add_drop() + } + { + p.SetState(4600) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4601) + p.Typename() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4603) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4604) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4605) + p.Name() + } + { + p.SetState(4606) + p.Add_drop() + } + { + p.SetState(4607) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4608) + p.Function_with_argtypes() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4610) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4611) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4612) + p.Name() + } + { + p.SetState(4613) + p.Add_drop() + } + { + p.SetState(4614) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4615) + p.Operator_with_argtypes() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4617) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4618) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4619) + p.Name() + } + { + p.SetState(4620) + p.Add_drop() + } + { + p.SetState(4621) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4622) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4623) + p.Any_name() + } + { + p.SetState(4624) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4625) + p.Name() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4627) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4628) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4629) + p.Name() + } + { + p.SetState(4630) + p.Add_drop() + } + { + p.SetState(4631) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4632) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4633) + p.Any_name() + } + { + p.SetState(4634) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4635) + p.Name() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4637) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4638) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4639) + p.Name() + } + { + p.SetState(4640) + p.Add_drop() + } + { + p.SetState(4641) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4642) + p.Function_with_argtypes() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4644) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4645) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4646) + p.Name() + } + { + p.SetState(4647) + p.Add_drop() + } + { + p.SetState(4648) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4649) + p.Function_with_argtypes() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(4651) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4652) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4653) + p.Name() + } + { + p.SetState(4654) + p.Add_drop() + } + { + p.SetState(4655) + p.Match(RedshiftParserTRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4656) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4657) + p.Typename() + } + { + p.SetState(4658) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4659) + p.Name() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(4661) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4662) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4663) + p.Name() + } + { + p.SetState(4664) + p.Add_drop() + } + { + p.SetState(4665) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4666) + p.Typename() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatefdwstmtContext is an interface to support dynamic dispatch. +type ICreatefdwstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + DATA_P() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + Name() INameContext + Opt_fdw_options() IOpt_fdw_optionsContext + Create_generic_options() ICreate_generic_optionsContext + + // IsCreatefdwstmtContext differentiates from other interfaces. + IsCreatefdwstmtContext() +} + +type CreatefdwstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatefdwstmtContext() *CreatefdwstmtContext { + var p = new(CreatefdwstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfdwstmt + return p +} + +func InitEmptyCreatefdwstmtContext(p *CreatefdwstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfdwstmt +} + +func (*CreatefdwstmtContext) IsCreatefdwstmtContext() {} + +func NewCreatefdwstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatefdwstmtContext { + var p = new(CreatefdwstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createfdwstmt + + return p +} + +func (s *CreatefdwstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatefdwstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatefdwstmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *CreatefdwstmtContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *CreatefdwstmtContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *CreatefdwstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatefdwstmtContext) Opt_fdw_options() IOpt_fdw_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_fdw_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_fdw_optionsContext) +} + +func (s *CreatefdwstmtContext) Create_generic_options() ICreate_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_generic_optionsContext) +} + +func (s *CreatefdwstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatefdwstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatefdwstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatefdwstmt(s) + } +} + +func (s *CreatefdwstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatefdwstmt(s) + } +} + +func (s *CreatefdwstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatefdwstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createfdwstmt() (localctx ICreatefdwstmtContext) { + localctx = NewCreatefdwstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, RedshiftParserRULE_createfdwstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4670) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4671) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4672) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4673) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4674) + p.Name() + } + p.SetState(4676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserHANDLER || _la == RedshiftParserNO || _la == RedshiftParserVALIDATOR { + { + p.SetState(4675) + p.Opt_fdw_options() + } + + } + p.SetState(4679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4678) + p.Create_generic_options() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFdw_optionContext is an interface to support dynamic dispatch. +type IFdw_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HANDLER() antlr.TerminalNode + Handler_name() IHandler_nameContext + NO() antlr.TerminalNode + VALIDATOR() antlr.TerminalNode + + // IsFdw_optionContext differentiates from other interfaces. + IsFdw_optionContext() +} + +type Fdw_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFdw_optionContext() *Fdw_optionContext { + var p = new(Fdw_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fdw_option + return p +} + +func InitEmptyFdw_optionContext(p *Fdw_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fdw_option +} + +func (*Fdw_optionContext) IsFdw_optionContext() {} + +func NewFdw_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fdw_optionContext { + var p = new(Fdw_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fdw_option + + return p +} + +func (s *Fdw_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fdw_optionContext) HANDLER() antlr.TerminalNode { + return s.GetToken(RedshiftParserHANDLER, 0) +} + +func (s *Fdw_optionContext) Handler_name() IHandler_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandler_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandler_nameContext) +} + +func (s *Fdw_optionContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Fdw_optionContext) VALIDATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALIDATOR, 0) +} + +func (s *Fdw_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fdw_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fdw_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFdw_option(s) + } +} + +func (s *Fdw_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFdw_option(s) + } +} + +func (s *Fdw_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFdw_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fdw_option() (localctx IFdw_optionContext) { + localctx = NewFdw_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, RedshiftParserRULE_fdw_option) + p.SetState(4689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 287, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4681) + p.Match(RedshiftParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4682) + p.Handler_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4683) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4684) + p.Match(RedshiftParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4685) + p.Match(RedshiftParserVALIDATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4686) + p.Handler_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4687) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4688) + p.Match(RedshiftParserVALIDATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFdw_optionsContext is an interface to support dynamic dispatch. +type IFdw_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFdw_option() []IFdw_optionContext + Fdw_option(i int) IFdw_optionContext + + // IsFdw_optionsContext differentiates from other interfaces. + IsFdw_optionsContext() +} + +type Fdw_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFdw_optionsContext() *Fdw_optionsContext { + var p = new(Fdw_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fdw_options + return p +} + +func InitEmptyFdw_optionsContext(p *Fdw_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fdw_options +} + +func (*Fdw_optionsContext) IsFdw_optionsContext() {} + +func NewFdw_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fdw_optionsContext { + var p = new(Fdw_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fdw_options + + return p +} + +func (s *Fdw_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fdw_optionsContext) AllFdw_option() []IFdw_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFdw_optionContext); ok { + len++ + } + } + + tst := make([]IFdw_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFdw_optionContext); ok { + tst[i] = t.(IFdw_optionContext) + i++ + } + } + + return tst +} + +func (s *Fdw_optionsContext) Fdw_option(i int) IFdw_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFdw_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFdw_optionContext) +} + +func (s *Fdw_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fdw_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fdw_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFdw_options(s) + } +} + +func (s *Fdw_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFdw_options(s) + } +} + +func (s *Fdw_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFdw_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fdw_options() (localctx IFdw_optionsContext) { + localctx = NewFdw_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, RedshiftParserRULE_fdw_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserHANDLER || _la == RedshiftParserNO || _la == RedshiftParserVALIDATOR { + { + p.SetState(4691) + p.Fdw_option() + } + + p.SetState(4694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_fdw_optionsContext is an interface to support dynamic dispatch. +type IOpt_fdw_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Fdw_options() IFdw_optionsContext + + // IsOpt_fdw_optionsContext differentiates from other interfaces. + IsOpt_fdw_optionsContext() +} + +type Opt_fdw_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_fdw_optionsContext() *Opt_fdw_optionsContext { + var p = new(Opt_fdw_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_fdw_options + return p +} + +func InitEmptyOpt_fdw_optionsContext(p *Opt_fdw_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_fdw_options +} + +func (*Opt_fdw_optionsContext) IsOpt_fdw_optionsContext() {} + +func NewOpt_fdw_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fdw_optionsContext { + var p = new(Opt_fdw_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_fdw_options + + return p +} + +func (s *Opt_fdw_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_fdw_optionsContext) Fdw_options() IFdw_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFdw_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFdw_optionsContext) +} + +func (s *Opt_fdw_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_fdw_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_fdw_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_fdw_options(s) + } +} + +func (s *Opt_fdw_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_fdw_options(s) + } +} + +func (s *Opt_fdw_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_fdw_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_fdw_options() (localctx IOpt_fdw_optionsContext) { + localctx = NewOpt_fdw_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, RedshiftParserRULE_opt_fdw_options) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4696) + p.Fdw_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 +} + +// IAlterfdwstmtContext is an interface to support dynamic dispatch. +type IAlterfdwstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + DATA_P() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + Name() INameContext + Alter_generic_options() IAlter_generic_optionsContext + Opt_fdw_options() IOpt_fdw_optionsContext + Fdw_options() IFdw_optionsContext + + // IsAlterfdwstmtContext differentiates from other interfaces. + IsAlterfdwstmtContext() +} + +type AlterfdwstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterfdwstmtContext() *AlterfdwstmtContext { + var p = new(AlterfdwstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterfdwstmt + return p +} + +func InitEmptyAlterfdwstmtContext(p *AlterfdwstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterfdwstmt +} + +func (*AlterfdwstmtContext) IsAlterfdwstmtContext() {} + +func NewAlterfdwstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterfdwstmtContext { + var p = new(AlterfdwstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterfdwstmt + + return p +} + +func (s *AlterfdwstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterfdwstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterfdwstmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *AlterfdwstmtContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *AlterfdwstmtContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *AlterfdwstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterfdwstmtContext) Alter_generic_options() IAlter_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_generic_optionsContext) +} + +func (s *AlterfdwstmtContext) Opt_fdw_options() IOpt_fdw_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_fdw_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_fdw_optionsContext) +} + +func (s *AlterfdwstmtContext) Fdw_options() IFdw_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFdw_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFdw_optionsContext) +} + +func (s *AlterfdwstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterfdwstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterfdwstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterfdwstmt(s) + } +} + +func (s *AlterfdwstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterfdwstmt(s) + } +} + +func (s *AlterfdwstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterfdwstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterfdwstmt() (localctx IAlterfdwstmtContext) { + localctx = NewAlterfdwstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, RedshiftParserRULE_alterfdwstmt) + var _la int + + p.SetState(4715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 290, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4698) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4699) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4700) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4701) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4702) + p.Name() + } + p.SetState(4704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserHANDLER || _la == RedshiftParserNO || _la == RedshiftParserVALIDATOR { + { + p.SetState(4703) + p.Opt_fdw_options() + } + + } + { + p.SetState(4706) + p.Alter_generic_options() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4708) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4709) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4710) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4711) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4712) + p.Name() + } + { + p.SetState(4713) + p.Fdw_options() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_generic_optionsContext is an interface to support dynamic dispatch. +type ICreate_generic_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPTIONS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Generic_option_list() IGeneric_option_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsCreate_generic_optionsContext differentiates from other interfaces. + IsCreate_generic_optionsContext() +} + +type Create_generic_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_generic_optionsContext() *Create_generic_optionsContext { + var p = new(Create_generic_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_generic_options + return p +} + +func InitEmptyCreate_generic_optionsContext(p *Create_generic_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_create_generic_options +} + +func (*Create_generic_optionsContext) IsCreate_generic_optionsContext() {} + +func NewCreate_generic_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_generic_optionsContext { + var p = new(Create_generic_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_create_generic_options + + return p +} + +func (s *Create_generic_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_generic_optionsContext) OPTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTIONS, 0) +} + +func (s *Create_generic_optionsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Create_generic_optionsContext) Generic_option_list() IGeneric_option_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_option_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_option_listContext) +} + +func (s *Create_generic_optionsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Create_generic_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_generic_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_generic_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreate_generic_options(s) + } +} + +func (s *Create_generic_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreate_generic_options(s) + } +} + +func (s *Create_generic_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreate_generic_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Create_generic_options() (localctx ICreate_generic_optionsContext) { + localctx = NewCreate_generic_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, RedshiftParserRULE_create_generic_options) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4717) + p.Match(RedshiftParserOPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4718) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4719) + p.Generic_option_list() + } + { + p.SetState(4720) + p.Match(RedshiftParserCLOSE_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 +} + +// IGeneric_option_listContext is an interface to support dynamic dispatch. +type IGeneric_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGeneric_option_elem() []IGeneric_option_elemContext + Generic_option_elem(i int) IGeneric_option_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGeneric_option_listContext differentiates from other interfaces. + IsGeneric_option_listContext() +} + +type Generic_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_option_listContext() *Generic_option_listContext { + var p = new(Generic_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_list + return p +} + +func InitEmptyGeneric_option_listContext(p *Generic_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_list +} + +func (*Generic_option_listContext) IsGeneric_option_listContext() {} + +func NewGeneric_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_listContext { + var p = new(Generic_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generic_option_list + + return p +} + +func (s *Generic_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_option_listContext) AllGeneric_option_elem() []IGeneric_option_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneric_option_elemContext); ok { + len++ + } + } + + tst := make([]IGeneric_option_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneric_option_elemContext); ok { + tst[i] = t.(IGeneric_option_elemContext) + i++ + } + } + + return tst +} + +func (s *Generic_option_listContext) Generic_option_elem(i int) IGeneric_option_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_option_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_option_elemContext) +} + +func (s *Generic_option_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Generic_option_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Generic_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGeneric_option_list(s) + } +} + +func (s *Generic_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGeneric_option_list(s) + } +} + +func (s *Generic_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGeneric_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generic_option_list() (localctx IGeneric_option_listContext) { + localctx = NewGeneric_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, RedshiftParserRULE_generic_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4722) + p.Generic_option_elem() + } + p.SetState(4727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(4723) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4724) + p.Generic_option_elem() + } + + p.SetState(4729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_generic_optionsContext is an interface to support dynamic dispatch. +type IAlter_generic_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPTIONS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Alter_generic_option_list() IAlter_generic_option_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsAlter_generic_optionsContext differentiates from other interfaces. + IsAlter_generic_optionsContext() +} + +type Alter_generic_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_generic_optionsContext() *Alter_generic_optionsContext { + var p = new(Alter_generic_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_generic_options + return p +} + +func InitEmptyAlter_generic_optionsContext(p *Alter_generic_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_generic_options +} + +func (*Alter_generic_optionsContext) IsAlter_generic_optionsContext() {} + +func NewAlter_generic_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_optionsContext { + var p = new(Alter_generic_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_generic_options + + return p +} + +func (s *Alter_generic_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_generic_optionsContext) OPTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTIONS, 0) +} + +func (s *Alter_generic_optionsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Alter_generic_optionsContext) Alter_generic_option_list() IAlter_generic_option_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_generic_option_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_generic_option_listContext) +} + +func (s *Alter_generic_optionsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Alter_generic_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_generic_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_generic_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_generic_options(s) + } +} + +func (s *Alter_generic_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_generic_options(s) + } +} + +func (s *Alter_generic_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_generic_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_generic_options() (localctx IAlter_generic_optionsContext) { + localctx = NewAlter_generic_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, RedshiftParserRULE_alter_generic_options) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4730) + p.Match(RedshiftParserOPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4731) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4732) + p.Alter_generic_option_list() + } + { + p.SetState(4733) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_generic_option_listContext is an interface to support dynamic dispatch. +type IAlter_generic_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_generic_option_elem() []IAlter_generic_option_elemContext + Alter_generic_option_elem(i int) IAlter_generic_option_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_generic_option_listContext differentiates from other interfaces. + IsAlter_generic_option_listContext() +} + +type Alter_generic_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_generic_option_listContext() *Alter_generic_option_listContext { + var p = new(Alter_generic_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_generic_option_list + return p +} + +func InitEmptyAlter_generic_option_listContext(p *Alter_generic_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_generic_option_list +} + +func (*Alter_generic_option_listContext) IsAlter_generic_option_listContext() {} + +func NewAlter_generic_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_option_listContext { + var p = new(Alter_generic_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_generic_option_list + + return p +} + +func (s *Alter_generic_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_generic_option_listContext) AllAlter_generic_option_elem() []IAlter_generic_option_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_generic_option_elemContext); ok { + len++ + } + } + + tst := make([]IAlter_generic_option_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_generic_option_elemContext); ok { + tst[i] = t.(IAlter_generic_option_elemContext) + i++ + } + } + + return tst +} + +func (s *Alter_generic_option_listContext) Alter_generic_option_elem(i int) IAlter_generic_option_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_generic_option_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_generic_option_elemContext) +} + +func (s *Alter_generic_option_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Alter_generic_option_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Alter_generic_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_generic_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_generic_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_generic_option_list(s) + } +} + +func (s *Alter_generic_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_generic_option_list(s) + } +} + +func (s *Alter_generic_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_generic_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_generic_option_list() (localctx IAlter_generic_option_listContext) { + localctx = NewAlter_generic_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, RedshiftParserRULE_alter_generic_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4735) + p.Alter_generic_option_elem() + } + p.SetState(4740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(4736) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4737) + p.Alter_generic_option_elem() + } + + p.SetState(4742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_generic_option_elemContext is an interface to support dynamic dispatch. +type IAlter_generic_option_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generic_option_elem() IGeneric_option_elemContext + SET() antlr.TerminalNode + ADD_P() antlr.TerminalNode + DROP() antlr.TerminalNode + Generic_option_name() IGeneric_option_nameContext + + // IsAlter_generic_option_elemContext differentiates from other interfaces. + IsAlter_generic_option_elemContext() +} + +type Alter_generic_option_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_generic_option_elemContext() *Alter_generic_option_elemContext { + var p = new(Alter_generic_option_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_generic_option_elem + return p +} + +func InitEmptyAlter_generic_option_elemContext(p *Alter_generic_option_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alter_generic_option_elem +} + +func (*Alter_generic_option_elemContext) IsAlter_generic_option_elemContext() {} + +func NewAlter_generic_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_generic_option_elemContext { + var p = new(Alter_generic_option_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alter_generic_option_elem + + return p +} + +func (s *Alter_generic_option_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_generic_option_elemContext) Generic_option_elem() IGeneric_option_elemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_option_elemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_option_elemContext) +} + +func (s *Alter_generic_option_elemContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Alter_generic_option_elemContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *Alter_generic_option_elemContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Alter_generic_option_elemContext) Generic_option_name() IGeneric_option_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_option_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_option_nameContext) +} + +func (s *Alter_generic_option_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_generic_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_generic_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlter_generic_option_elem(s) + } +} + +func (s *Alter_generic_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlter_generic_option_elem(s) + } +} + +func (s *Alter_generic_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlter_generic_option_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alter_generic_option_elem() (localctx IAlter_generic_option_elemContext) { + localctx = NewAlter_generic_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, RedshiftParserRULE_alter_generic_option_elem) + p.SetState(4750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 293, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4743) + p.Generic_option_elem() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4744) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4745) + p.Generic_option_elem() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4746) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4747) + p.Generic_option_elem() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4748) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4749) + p.Generic_option_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_option_elemContext is an interface to support dynamic dispatch. +type IGeneric_option_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generic_option_name() IGeneric_option_nameContext + Generic_option_arg() IGeneric_option_argContext + + // IsGeneric_option_elemContext differentiates from other interfaces. + IsGeneric_option_elemContext() +} + +type Generic_option_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_option_elemContext() *Generic_option_elemContext { + var p = new(Generic_option_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_elem + return p +} + +func InitEmptyGeneric_option_elemContext(p *Generic_option_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_elem +} + +func (*Generic_option_elemContext) IsGeneric_option_elemContext() {} + +func NewGeneric_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_elemContext { + var p = new(Generic_option_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generic_option_elem + + return p +} + +func (s *Generic_option_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_option_elemContext) Generic_option_name() IGeneric_option_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_option_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_option_nameContext) +} + +func (s *Generic_option_elemContext) Generic_option_arg() IGeneric_option_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_option_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_option_argContext) +} + +func (s *Generic_option_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGeneric_option_elem(s) + } +} + +func (s *Generic_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGeneric_option_elem(s) + } +} + +func (s *Generic_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGeneric_option_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generic_option_elem() (localctx IGeneric_option_elemContext) { + localctx = NewGeneric_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, RedshiftParserRULE_generic_option_elem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4752) + p.Generic_option_name() + } + { + p.SetState(4753) + p.Generic_option_arg() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_option_nameContext is an interface to support dynamic dispatch. +type IGeneric_option_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Collabel() ICollabelContext + + // IsGeneric_option_nameContext differentiates from other interfaces. + IsGeneric_option_nameContext() +} + +type Generic_option_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_option_nameContext() *Generic_option_nameContext { + var p = new(Generic_option_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_name + return p +} + +func InitEmptyGeneric_option_nameContext(p *Generic_option_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_name +} + +func (*Generic_option_nameContext) IsGeneric_option_nameContext() {} + +func NewGeneric_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_nameContext { + var p = new(Generic_option_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generic_option_name + + return p +} + +func (s *Generic_option_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_option_nameContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Generic_option_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_option_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGeneric_option_name(s) + } +} + +func (s *Generic_option_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGeneric_option_name(s) + } +} + +func (s *Generic_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGeneric_option_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generic_option_name() (localctx IGeneric_option_nameContext) { + localctx = NewGeneric_option_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, RedshiftParserRULE_generic_option_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4755) + p.Collabel() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGeneric_option_argContext is an interface to support dynamic dispatch. +type IGeneric_option_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + + // IsGeneric_option_argContext differentiates from other interfaces. + IsGeneric_option_argContext() +} + +type Generic_option_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneric_option_argContext() *Generic_option_argContext { + var p = new(Generic_option_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_arg + return p +} + +func InitEmptyGeneric_option_argContext(p *Generic_option_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generic_option_arg +} + +func (*Generic_option_argContext) IsGeneric_option_argContext() {} + +func NewGeneric_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_option_argContext { + var p = new(Generic_option_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generic_option_arg + + return p +} + +func (s *Generic_option_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Generic_option_argContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Generic_option_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Generic_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Generic_option_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGeneric_option_arg(s) + } +} + +func (s *Generic_option_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGeneric_option_arg(s) + } +} + +func (s *Generic_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGeneric_option_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generic_option_arg() (localctx IGeneric_option_argContext) { + localctx = NewGeneric_option_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, RedshiftParserRULE_generic_option_arg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4757) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateforeignserverstmtContext is an interface to support dynamic dispatch. +type ICreateforeignserverstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SERVER() antlr.TerminalNode + AllName() []INameContext + Name(i int) INameContext + FOREIGN() antlr.TerminalNode + DATA_P() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + Opt_type() IOpt_typeContext + Opt_foreign_server_version() IOpt_foreign_server_versionContext + Create_generic_options() ICreate_generic_optionsContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsCreateforeignserverstmtContext differentiates from other interfaces. + IsCreateforeignserverstmtContext() +} + +type CreateforeignserverstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateforeignserverstmtContext() *CreateforeignserverstmtContext { + var p = new(CreateforeignserverstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createforeignserverstmt + return p +} + +func InitEmptyCreateforeignserverstmtContext(p *CreateforeignserverstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createforeignserverstmt +} + +func (*CreateforeignserverstmtContext) IsCreateforeignserverstmtContext() {} + +func NewCreateforeignserverstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateforeignserverstmtContext { + var p = new(CreateforeignserverstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createforeignserverstmt + + return p +} + +func (s *CreateforeignserverstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateforeignserverstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateforeignserverstmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *CreateforeignserverstmtContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *CreateforeignserverstmtContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateforeignserverstmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *CreateforeignserverstmtContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *CreateforeignserverstmtContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *CreateforeignserverstmtContext) Opt_type() IOpt_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_typeContext) +} + +func (s *CreateforeignserverstmtContext) Opt_foreign_server_version() IOpt_foreign_server_versionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_foreign_server_versionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_foreign_server_versionContext) +} + +func (s *CreateforeignserverstmtContext) Create_generic_options() ICreate_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_generic_optionsContext) +} + +func (s *CreateforeignserverstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreateforeignserverstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreateforeignserverstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreateforeignserverstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateforeignserverstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateforeignserverstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateforeignserverstmt(s) + } +} + +func (s *CreateforeignserverstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateforeignserverstmt(s) + } +} + +func (s *CreateforeignserverstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateforeignserverstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createforeignserverstmt() (localctx ICreateforeignserverstmtContext) { + localctx = NewCreateforeignserverstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, RedshiftParserRULE_createforeignserverstmt) + var _la int + + p.SetState(4794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 300, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4759) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4760) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4761) + p.Name() + } + p.SetState(4763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTYPE_P { + { + p.SetState(4762) + p.Opt_type() + } + + } + p.SetState(4766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERSION_P { + { + p.SetState(4765) + p.Opt_foreign_server_version() + } + + } + { + p.SetState(4768) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4769) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4770) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4771) + p.Name() + } + p.SetState(4773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4772) + p.Create_generic_options() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4775) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4776) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4777) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4778) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4779) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4780) + p.Name() + } + p.SetState(4782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTYPE_P { + { + p.SetState(4781) + p.Opt_type() + } + + } + p.SetState(4785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERSION_P { + { + p.SetState(4784) + p.Opt_foreign_server_version() + } + + } + { + p.SetState(4787) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4788) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4789) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4790) + p.Name() + } + p.SetState(4792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4791) + p.Create_generic_options() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_typeContext is an interface to support dynamic dispatch. +type IOpt_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TYPE_P() antlr.TerminalNode + Sconst() ISconstContext + + // IsOpt_typeContext differentiates from other interfaces. + IsOpt_typeContext() +} + +type Opt_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_typeContext() *Opt_typeContext { + var p = new(Opt_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_type + return p +} + +func InitEmptyOpt_typeContext(p *Opt_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_type +} + +func (*Opt_typeContext) IsOpt_typeContext() {} + +func NewOpt_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_typeContext { + var p = new(Opt_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_type + + return p +} + +func (s *Opt_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_typeContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Opt_typeContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Opt_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_type(s) + } +} + +func (s *Opt_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_type(s) + } +} + +func (s *Opt_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_type() (localctx IOpt_typeContext) { + localctx = NewOpt_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, RedshiftParserRULE_opt_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4796) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4797) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeign_server_versionContext is an interface to support dynamic dispatch. +type IForeign_server_versionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSION_P() antlr.TerminalNode + Sconst() ISconstContext + NULL_P() antlr.TerminalNode + + // IsForeign_server_versionContext differentiates from other interfaces. + IsForeign_server_versionContext() +} + +type Foreign_server_versionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_server_versionContext() *Foreign_server_versionContext { + var p = new(Foreign_server_versionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_foreign_server_version + return p +} + +func InitEmptyForeign_server_versionContext(p *Foreign_server_versionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_foreign_server_version +} + +func (*Foreign_server_versionContext) IsForeign_server_versionContext() {} + +func NewForeign_server_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_server_versionContext { + var p = new(Foreign_server_versionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_foreign_server_version + + return p +} + +func (s *Foreign_server_versionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_server_versionContext) VERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERSION_P, 0) +} + +func (s *Foreign_server_versionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Foreign_server_versionContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Foreign_server_versionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_server_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_server_versionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterForeign_server_version(s) + } +} + +func (s *Foreign_server_versionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitForeign_server_version(s) + } +} + +func (s *Foreign_server_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitForeign_server_version(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Foreign_server_version() (localctx IForeign_server_versionContext) { + localctx = NewForeign_server_versionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, RedshiftParserRULE_foreign_server_version) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4799) + p.Match(RedshiftParserVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(4800) + p.Sconst() + } + + case RedshiftParserNULL_P: + { + p.SetState(4801) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_foreign_server_versionContext is an interface to support dynamic dispatch. +type IOpt_foreign_server_versionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Foreign_server_version() IForeign_server_versionContext + + // IsOpt_foreign_server_versionContext differentiates from other interfaces. + IsOpt_foreign_server_versionContext() +} + +type Opt_foreign_server_versionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_foreign_server_versionContext() *Opt_foreign_server_versionContext { + var p = new(Opt_foreign_server_versionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_foreign_server_version + return p +} + +func InitEmptyOpt_foreign_server_versionContext(p *Opt_foreign_server_versionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_foreign_server_version +} + +func (*Opt_foreign_server_versionContext) IsOpt_foreign_server_versionContext() {} + +func NewOpt_foreign_server_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_foreign_server_versionContext { + var p = new(Opt_foreign_server_versionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_foreign_server_version + + return p +} + +func (s *Opt_foreign_server_versionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_foreign_server_versionContext) Foreign_server_version() IForeign_server_versionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_server_versionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_server_versionContext) +} + +func (s *Opt_foreign_server_versionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_foreign_server_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_foreign_server_versionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_foreign_server_version(s) + } +} + +func (s *Opt_foreign_server_versionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_foreign_server_version(s) + } +} + +func (s *Opt_foreign_server_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_foreign_server_version(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_foreign_server_version() (localctx IOpt_foreign_server_versionContext) { + localctx = NewOpt_foreign_server_versionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, RedshiftParserRULE_opt_foreign_server_version) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4804) + p.Foreign_server_version() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterforeignserverstmtContext is an interface to support dynamic dispatch. +type IAlterforeignserverstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SERVER() antlr.TerminalNode + Name() INameContext + Alter_generic_options() IAlter_generic_optionsContext + Foreign_server_version() IForeign_server_versionContext + + // IsAlterforeignserverstmtContext differentiates from other interfaces. + IsAlterforeignserverstmtContext() +} + +type AlterforeignserverstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterforeignserverstmtContext() *AlterforeignserverstmtContext { + var p = new(AlterforeignserverstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterforeignserverstmt + return p +} + +func InitEmptyAlterforeignserverstmtContext(p *AlterforeignserverstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterforeignserverstmt +} + +func (*AlterforeignserverstmtContext) IsAlterforeignserverstmtContext() {} + +func NewAlterforeignserverstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterforeignserverstmtContext { + var p = new(AlterforeignserverstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterforeignserverstmt + + return p +} + +func (s *AlterforeignserverstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterforeignserverstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterforeignserverstmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *AlterforeignserverstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterforeignserverstmtContext) Alter_generic_options() IAlter_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_generic_optionsContext) +} + +func (s *AlterforeignserverstmtContext) Foreign_server_version() IForeign_server_versionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_server_versionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_server_versionContext) +} + +func (s *AlterforeignserverstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterforeignserverstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterforeignserverstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterforeignserverstmt(s) + } +} + +func (s *AlterforeignserverstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterforeignserverstmt(s) + } +} + +func (s *AlterforeignserverstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterforeignserverstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterforeignserverstmt() (localctx IAlterforeignserverstmtContext) { + localctx = NewAlterforeignserverstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, RedshiftParserRULE_alterforeignserverstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4806) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4807) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4808) + p.Name() + } + p.SetState(4814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPTIONS: + { + p.SetState(4809) + p.Alter_generic_options() + } + + case RedshiftParserVERSION_P: + { + p.SetState(4810) + p.Foreign_server_version() + } + p.SetState(4812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4811) + p.Alter_generic_options() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateforeigntablestmtContext is an interface to support dynamic dispatch. +type ICreateforeigntablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + SERVER() antlr.TerminalNode + Name() INameContext + Opttableelementlist() IOpttableelementlistContext + Optinherit() IOptinheritContext + Create_generic_options() ICreate_generic_optionsContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + PARTITION() antlr.TerminalNode + OF() antlr.TerminalNode + Partitionboundspec() IPartitionboundspecContext + Opttypedtableelementlist() IOpttypedtableelementlistContext + + // IsCreateforeigntablestmtContext differentiates from other interfaces. + IsCreateforeigntablestmtContext() +} + +type CreateforeigntablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateforeigntablestmtContext() *CreateforeigntablestmtContext { + var p = new(CreateforeigntablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createforeigntablestmt + return p +} + +func InitEmptyCreateforeigntablestmtContext(p *CreateforeigntablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createforeigntablestmt +} + +func (*CreateforeigntablestmtContext) IsCreateforeigntablestmtContext() {} + +func NewCreateforeigntablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateforeigntablestmtContext { + var p = new(CreateforeigntablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createforeigntablestmt + + return p +} + +func (s *CreateforeigntablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateforeigntablestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateforeigntablestmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *CreateforeigntablestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *CreateforeigntablestmtContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *CreateforeigntablestmtContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreateforeigntablestmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreateforeigntablestmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreateforeigntablestmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *CreateforeigntablestmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateforeigntablestmtContext) Opttableelementlist() IOpttableelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttableelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttableelementlistContext) +} + +func (s *CreateforeigntablestmtContext) Optinherit() IOptinheritContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptinheritContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptinheritContext) +} + +func (s *CreateforeigntablestmtContext) Create_generic_options() ICreate_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_generic_optionsContext) +} + +func (s *CreateforeigntablestmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreateforeigntablestmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreateforeigntablestmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreateforeigntablestmtContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *CreateforeigntablestmtContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *CreateforeigntablestmtContext) Partitionboundspec() IPartitionboundspecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionboundspecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionboundspecContext) +} + +func (s *CreateforeigntablestmtContext) Opttypedtableelementlist() IOpttypedtableelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttypedtableelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttypedtableelementlistContext) +} + +func (s *CreateforeigntablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateforeigntablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateforeigntablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateforeigntablestmt(s) + } +} + +func (s *CreateforeigntablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateforeigntablestmt(s) + } +} + +func (s *CreateforeigntablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateforeigntablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createforeigntablestmt() (localctx ICreateforeigntablestmtContext) { + localctx = NewCreateforeigntablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, RedshiftParserRULE_createforeigntablestmt) + var _la int + + p.SetState(4888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 314, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4816) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4817) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4818) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4819) + p.Qualified_name() + } + { + p.SetState(4820) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1166502673593671173) != 0) || ((int64((_la-99)) & ^0x3f) == 0 && ((int64(1)<<(_la-99))&-3543662591) != 0) || ((int64((_la-163)) & ^0x3f) == 0 && ((int64(1)<<(_la-163))&-32769) != 0) || ((int64((_la-227)) & ^0x3f) == 0 && ((int64(1)<<(_la-227))&-1152921505814806529) != 0) || ((int64((_la-291)) & ^0x3f) == 0 && ((int64(1)<<(_la-291))&-1) != 0) || ((int64((_la-355)) & ^0x3f) == 0 && ((int64(1)<<(_la-355))&-342523641857) != 0) || ((int64((_la-419)) & ^0x3f) == 0 && ((int64(1)<<(_la-419))&-1) != 0) || ((int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&-1) != 0) || ((int64((_la-547)) & ^0x3f) == 0 && ((int64(1)<<(_la-547))&-1) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(4821) + p.Opttableelementlist() + } + + } + { + p.SetState(4824) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINHERITS { + { + p.SetState(4825) + p.Optinherit() + } + + } + { + p.SetState(4828) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4829) + p.Name() + } + p.SetState(4831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4830) + p.Create_generic_options() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4833) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4834) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4835) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4836) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4837) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4838) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4839) + p.Qualified_name() + } + { + p.SetState(4840) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1166502673593671173) != 0) || ((int64((_la-99)) & ^0x3f) == 0 && ((int64(1)<<(_la-99))&-3543662591) != 0) || ((int64((_la-163)) & ^0x3f) == 0 && ((int64(1)<<(_la-163))&-32769) != 0) || ((int64((_la-227)) & ^0x3f) == 0 && ((int64(1)<<(_la-227))&-1152921505814806529) != 0) || ((int64((_la-291)) & ^0x3f) == 0 && ((int64(1)<<(_la-291))&-1) != 0) || ((int64((_la-355)) & ^0x3f) == 0 && ((int64(1)<<(_la-355))&-342523641857) != 0) || ((int64((_la-419)) & ^0x3f) == 0 && ((int64(1)<<(_la-419))&-1) != 0) || ((int64((_la-483)) & ^0x3f) == 0 && ((int64(1)<<(_la-483))&-1) != 0) || ((int64((_la-547)) & ^0x3f) == 0 && ((int64(1)<<(_la-547))&-1) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(4841) + p.Opttableelementlist() + } + + } + { + p.SetState(4844) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINHERITS { + { + p.SetState(4845) + p.Optinherit() + } + + } + { + p.SetState(4848) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4849) + p.Name() + } + p.SetState(4851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4850) + p.Create_generic_options() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4853) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4854) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4855) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4856) + p.Qualified_name() + } + { + p.SetState(4857) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4858) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4859) + p.Qualified_name() + } + p.SetState(4861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(4860) + p.Opttypedtableelementlist() + } + + } + { + p.SetState(4863) + p.Partitionboundspec() + } + { + p.SetState(4864) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4865) + p.Name() + } + p.SetState(4867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4866) + p.Create_generic_options() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4869) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4870) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4871) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4872) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4873) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4874) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4875) + p.Qualified_name() + } + { + p.SetState(4876) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4877) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4878) + p.Qualified_name() + } + p.SetState(4880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(4879) + p.Opttypedtableelementlist() + } + + } + { + p.SetState(4882) + p.Partitionboundspec() + } + { + p.SetState(4883) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4884) + p.Name() + } + p.SetState(4886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4885) + p.Create_generic_options() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImportforeignschemastmtContext is an interface to support dynamic dispatch. +type IImportforeignschemastmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IMPORT_P() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AllName() []INameContext + Name(i int) INameContext + FROM() antlr.TerminalNode + SERVER() antlr.TerminalNode + INTO() antlr.TerminalNode + Import_qualification() IImport_qualificationContext + Create_generic_options() ICreate_generic_optionsContext + + // IsImportforeignschemastmtContext differentiates from other interfaces. + IsImportforeignschemastmtContext() +} + +type ImportforeignschemastmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImportforeignschemastmtContext() *ImportforeignschemastmtContext { + var p = new(ImportforeignschemastmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_importforeignschemastmt + return p +} + +func InitEmptyImportforeignschemastmtContext(p *ImportforeignschemastmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_importforeignschemastmt +} + +func (*ImportforeignschemastmtContext) IsImportforeignschemastmtContext() {} + +func NewImportforeignschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImportforeignschemastmtContext { + var p = new(ImportforeignschemastmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_importforeignschemastmt + + return p +} + +func (s *ImportforeignschemastmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImportforeignschemastmtContext) IMPORT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMPORT_P, 0) +} + +func (s *ImportforeignschemastmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *ImportforeignschemastmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *ImportforeignschemastmtContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *ImportforeignschemastmtContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *ImportforeignschemastmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *ImportforeignschemastmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *ImportforeignschemastmtContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *ImportforeignschemastmtContext) Import_qualification() IImport_qualificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImport_qualificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImport_qualificationContext) +} + +func (s *ImportforeignschemastmtContext) Create_generic_options() ICreate_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_generic_optionsContext) +} + +func (s *ImportforeignschemastmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImportforeignschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImportforeignschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterImportforeignschemastmt(s) + } +} + +func (s *ImportforeignschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitImportforeignschemastmt(s) + } +} + +func (s *ImportforeignschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitImportforeignschemastmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Importforeignschemastmt() (localctx IImportforeignschemastmtContext) { + localctx = NewImportforeignschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, RedshiftParserRULE_importforeignschemastmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4890) + p.Match(RedshiftParserIMPORT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4891) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4892) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4893) + p.Name() + } + p.SetState(4895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCEPT || _la == RedshiftParserLIMIT { + { + p.SetState(4894) + p.Import_qualification() + } + + } + { + p.SetState(4897) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4898) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4899) + p.Name() + } + { + p.SetState(4900) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4901) + p.Name() + } + p.SetState(4903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4902) + p.Create_generic_options() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImport_qualification_typeContext is an interface to support dynamic dispatch. +type IImport_qualification_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIMIT() antlr.TerminalNode + TO() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsImport_qualification_typeContext differentiates from other interfaces. + IsImport_qualification_typeContext() +} + +type Import_qualification_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImport_qualification_typeContext() *Import_qualification_typeContext { + var p = new(Import_qualification_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_import_qualification_type + return p +} + +func InitEmptyImport_qualification_typeContext(p *Import_qualification_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_import_qualification_type +} + +func (*Import_qualification_typeContext) IsImport_qualification_typeContext() {} + +func NewImport_qualification_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_qualification_typeContext { + var p = new(Import_qualification_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_import_qualification_type + + return p +} + +func (s *Import_qualification_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Import_qualification_typeContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *Import_qualification_typeContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Import_qualification_typeContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCEPT, 0) +} + +func (s *Import_qualification_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Import_qualification_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Import_qualification_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterImport_qualification_type(s) + } +} + +func (s *Import_qualification_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitImport_qualification_type(s) + } +} + +func (s *Import_qualification_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitImport_qualification_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Import_qualification_type() (localctx IImport_qualification_typeContext) { + localctx = NewImport_qualification_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, RedshiftParserRULE_import_qualification_type) + p.SetState(4908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserLIMIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4905) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4906) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEXCEPT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4907) + p.Match(RedshiftParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImport_qualificationContext is an interface to support dynamic dispatch. +type IImport_qualificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Import_qualification_type() IImport_qualification_typeContext + OPEN_PAREN() antlr.TerminalNode + Relation_expr_list() IRelation_expr_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsImport_qualificationContext differentiates from other interfaces. + IsImport_qualificationContext() +} + +type Import_qualificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImport_qualificationContext() *Import_qualificationContext { + var p = new(Import_qualificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_import_qualification + return p +} + +func InitEmptyImport_qualificationContext(p *Import_qualificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_import_qualification +} + +func (*Import_qualificationContext) IsImport_qualificationContext() {} + +func NewImport_qualificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_qualificationContext { + var p = new(Import_qualificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_import_qualification + + return p +} + +func (s *Import_qualificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Import_qualificationContext) Import_qualification_type() IImport_qualification_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImport_qualification_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImport_qualification_typeContext) +} + +func (s *Import_qualificationContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Import_qualificationContext) Relation_expr_list() IRelation_expr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_expr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_expr_listContext) +} + +func (s *Import_qualificationContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Import_qualificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Import_qualificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Import_qualificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterImport_qualification(s) + } +} + +func (s *Import_qualificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitImport_qualification(s) + } +} + +func (s *Import_qualificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitImport_qualification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Import_qualification() (localctx IImport_qualificationContext) { + localctx = NewImport_qualificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, RedshiftParserRULE_import_qualification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4910) + p.Import_qualification_type() + } + { + p.SetState(4911) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4912) + p.Relation_expr_list() + } + { + p.SetState(4913) + p.Match(RedshiftParserCLOSE_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 +} + +// ICreateusermappingstmtContext is an interface to support dynamic dispatch. +type ICreateusermappingstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + USER() antlr.TerminalNode + MAPPING() antlr.TerminalNode + FOR() antlr.TerminalNode + Auth_ident() IAuth_identContext + SERVER() antlr.TerminalNode + Name() INameContext + Create_generic_options() ICreate_generic_optionsContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsCreateusermappingstmtContext differentiates from other interfaces. + IsCreateusermappingstmtContext() +} + +type CreateusermappingstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateusermappingstmtContext() *CreateusermappingstmtContext { + var p = new(CreateusermappingstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createusermappingstmt + return p +} + +func InitEmptyCreateusermappingstmtContext(p *CreateusermappingstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createusermappingstmt +} + +func (*CreateusermappingstmtContext) IsCreateusermappingstmtContext() {} + +func NewCreateusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateusermappingstmtContext { + var p = new(CreateusermappingstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createusermappingstmt + + return p +} + +func (s *CreateusermappingstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateusermappingstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateusermappingstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *CreateusermappingstmtContext) MAPPING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAPPING, 0) +} + +func (s *CreateusermappingstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *CreateusermappingstmtContext) Auth_ident() IAuth_identContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuth_identContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuth_identContext) +} + +func (s *CreateusermappingstmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *CreateusermappingstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateusermappingstmtContext) Create_generic_options() ICreate_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_generic_optionsContext) +} + +func (s *CreateusermappingstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreateusermappingstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreateusermappingstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreateusermappingstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateusermappingstmt(s) + } +} + +func (s *CreateusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateusermappingstmt(s) + } +} + +func (s *CreateusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateusermappingstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createusermappingstmt() (localctx ICreateusermappingstmtContext) { + localctx = NewCreateusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, RedshiftParserRULE_createusermappingstmt) + var _la int + + p.SetState(4938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 320, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4915) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4916) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4917) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4918) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4919) + p.Auth_ident() + } + { + p.SetState(4920) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4921) + p.Name() + } + p.SetState(4923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4922) + p.Create_generic_options() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4925) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4926) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4927) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4928) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4929) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4930) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4931) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4932) + p.Auth_ident() + } + { + p.SetState(4933) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4934) + p.Name() + } + p.SetState(4936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPTIONS { + { + p.SetState(4935) + p.Create_generic_options() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuth_identContext is an interface to support dynamic dispatch. +type IAuth_identContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rolespec() IRolespecContext + USER() antlr.TerminalNode + + // IsAuth_identContext differentiates from other interfaces. + IsAuth_identContext() +} + +type Auth_identContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuth_identContext() *Auth_identContext { + var p = new(Auth_identContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_auth_ident + return p +} + +func InitEmptyAuth_identContext(p *Auth_identContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_auth_ident +} + +func (*Auth_identContext) IsAuth_identContext() {} + +func NewAuth_identContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auth_identContext { + var p = new(Auth_identContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_auth_ident + + return p +} + +func (s *Auth_identContext) GetParser() antlr.Parser { return s.parser } + +func (s *Auth_identContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Auth_identContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *Auth_identContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Auth_identContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Auth_identContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAuth_ident(s) + } +} + +func (s *Auth_identContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAuth_ident(s) + } +} + +func (s *Auth_identContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAuth_ident(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Auth_ident() (localctx IAuth_identContext) { + localctx = NewAuth_identContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, RedshiftParserRULE_auth_ident) + p.SetState(4942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserSESSION_USER, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserNamespaceUser, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4940) + p.Rolespec() + } + + case RedshiftParserUSER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4941) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropusermappingstmtContext is an interface to support dynamic dispatch. +type IDropusermappingstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + USER() antlr.TerminalNode + MAPPING() antlr.TerminalNode + FOR() antlr.TerminalNode + Auth_ident() IAuth_identContext + SERVER() antlr.TerminalNode + Name() INameContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDropusermappingstmtContext differentiates from other interfaces. + IsDropusermappingstmtContext() +} + +type DropusermappingstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropusermappingstmtContext() *DropusermappingstmtContext { + var p = new(DropusermappingstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropusermappingstmt + return p +} + +func InitEmptyDropusermappingstmtContext(p *DropusermappingstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropusermappingstmt +} + +func (*DropusermappingstmtContext) IsDropusermappingstmtContext() {} + +func NewDropusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropusermappingstmtContext { + var p = new(DropusermappingstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropusermappingstmt + + return p +} + +func (s *DropusermappingstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropusermappingstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropusermappingstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *DropusermappingstmtContext) MAPPING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAPPING, 0) +} + +func (s *DropusermappingstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *DropusermappingstmtContext) Auth_ident() IAuth_identContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuth_identContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuth_identContext) +} + +func (s *DropusermappingstmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *DropusermappingstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DropusermappingstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *DropusermappingstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *DropusermappingstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropusermappingstmt(s) + } +} + +func (s *DropusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropusermappingstmt(s) + } +} + +func (s *DropusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropusermappingstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropusermappingstmt() (localctx IDropusermappingstmtContext) { + localctx = NewDropusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, RedshiftParserRULE_dropusermappingstmt) + p.SetState(4962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 322, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4944) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4945) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4946) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4947) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4948) + p.Auth_ident() + } + { + p.SetState(4949) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4950) + p.Name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4952) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4953) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4954) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4955) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4956) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4957) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4958) + p.Auth_ident() + } + { + p.SetState(4959) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4960) + p.Name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterusermappingstmtContext is an interface to support dynamic dispatch. +type IAlterusermappingstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + USER() antlr.TerminalNode + MAPPING() antlr.TerminalNode + FOR() antlr.TerminalNode + Auth_ident() IAuth_identContext + SERVER() antlr.TerminalNode + Name() INameContext + Alter_generic_options() IAlter_generic_optionsContext + + // IsAlterusermappingstmtContext differentiates from other interfaces. + IsAlterusermappingstmtContext() +} + +type AlterusermappingstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterusermappingstmtContext() *AlterusermappingstmtContext { + var p = new(AlterusermappingstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterusermappingstmt + return p +} + +func InitEmptyAlterusermappingstmtContext(p *AlterusermappingstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterusermappingstmt +} + +func (*AlterusermappingstmtContext) IsAlterusermappingstmtContext() {} + +func NewAlterusermappingstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterusermappingstmtContext { + var p = new(AlterusermappingstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterusermappingstmt + + return p +} + +func (s *AlterusermappingstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterusermappingstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterusermappingstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *AlterusermappingstmtContext) MAPPING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAPPING, 0) +} + +func (s *AlterusermappingstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *AlterusermappingstmtContext) Auth_ident() IAuth_identContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuth_identContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuth_identContext) +} + +func (s *AlterusermappingstmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *AlterusermappingstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterusermappingstmtContext) Alter_generic_options() IAlter_generic_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_generic_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_generic_optionsContext) +} + +func (s *AlterusermappingstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterusermappingstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterusermappingstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterusermappingstmt(s) + } +} + +func (s *AlterusermappingstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterusermappingstmt(s) + } +} + +func (s *AlterusermappingstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterusermappingstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterusermappingstmt() (localctx IAlterusermappingstmtContext) { + localctx = NewAlterusermappingstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, RedshiftParserRULE_alterusermappingstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4964) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4965) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4966) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4967) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4968) + p.Auth_ident() + } + { + p.SetState(4969) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4970) + p.Name() + } + { + p.SetState(4971) + p.Alter_generic_options() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatepolicystmtContext is an interface to support dynamic dispatch. +type ICreatepolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + POLICY() antlr.TerminalNode + Name() INameContext + ON() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Rowsecuritydefaultpermissive() IRowsecuritydefaultpermissiveContext + Rowsecuritydefaultforcmd() IRowsecuritydefaultforcmdContext + Rowsecuritydefaulttorole() IRowsecuritydefaulttoroleContext + Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext + Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext + + // IsCreatepolicystmtContext differentiates from other interfaces. + IsCreatepolicystmtContext() +} + +type CreatepolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatepolicystmtContext() *CreatepolicystmtContext { + var p = new(CreatepolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createpolicystmt + return p +} + +func InitEmptyCreatepolicystmtContext(p *CreatepolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createpolicystmt +} + +func (*CreatepolicystmtContext) IsCreatepolicystmtContext() {} + +func NewCreatepolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatepolicystmtContext { + var p = new(CreatepolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createpolicystmt + + return p +} + +func (s *CreatepolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatepolicystmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatepolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *CreatepolicystmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatepolicystmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *CreatepolicystmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreatepolicystmtContext) Rowsecuritydefaultpermissive() IRowsecuritydefaultpermissiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecuritydefaultpermissiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecuritydefaultpermissiveContext) +} + +func (s *CreatepolicystmtContext) Rowsecuritydefaultforcmd() IRowsecuritydefaultforcmdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecuritydefaultforcmdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecuritydefaultforcmdContext) +} + +func (s *CreatepolicystmtContext) Rowsecuritydefaulttorole() IRowsecuritydefaulttoroleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecuritydefaulttoroleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecuritydefaulttoroleContext) +} + +func (s *CreatepolicystmtContext) Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecurityoptionalexprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecurityoptionalexprContext) +} + +func (s *CreatepolicystmtContext) Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecurityoptionalwithcheckContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecurityoptionalwithcheckContext) +} + +func (s *CreatepolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatepolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatepolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatepolicystmt(s) + } +} + +func (s *CreatepolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatepolicystmt(s) + } +} + +func (s *CreatepolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatepolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createpolicystmt() (localctx ICreatepolicystmtContext) { + localctx = NewCreatepolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, RedshiftParserRULE_createpolicystmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4973) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4974) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4975) + p.Name() + } + { + p.SetState(4976) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4977) + p.Qualified_name() + } + p.SetState(4979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(4978) + p.Rowsecuritydefaultpermissive() + } + + } + p.SetState(4982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(4981) + p.Rowsecuritydefaultforcmd() + } + + } + p.SetState(4985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTO { + { + p.SetState(4984) + p.Rowsecuritydefaulttorole() + } + + } + p.SetState(4988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(4987) + p.Rowsecurityoptionalexpr() + } + + } + p.SetState(4991) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 327, p.GetParserRuleContext()) == 1 { + { + p.SetState(4990) + p.Rowsecurityoptionalwithcheck() + } + + } 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 +} + +// IAlterpolicystmtContext is an interface to support dynamic dispatch. +type IAlterpolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + POLICY() antlr.TerminalNode + Name() INameContext + ON() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Rowsecurityoptionaltorole() IRowsecurityoptionaltoroleContext + Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext + Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext + + // IsAlterpolicystmtContext differentiates from other interfaces. + IsAlterpolicystmtContext() +} + +type AlterpolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterpolicystmtContext() *AlterpolicystmtContext { + var p = new(AlterpolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterpolicystmt + return p +} + +func InitEmptyAlterpolicystmtContext(p *AlterpolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterpolicystmt +} + +func (*AlterpolicystmtContext) IsAlterpolicystmtContext() {} + +func NewAlterpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterpolicystmtContext { + var p = new(AlterpolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterpolicystmt + + return p +} + +func (s *AlterpolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterpolicystmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterpolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *AlterpolicystmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterpolicystmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *AlterpolicystmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AlterpolicystmtContext) Rowsecurityoptionaltorole() IRowsecurityoptionaltoroleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecurityoptionaltoroleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecurityoptionaltoroleContext) +} + +func (s *AlterpolicystmtContext) Rowsecurityoptionalexpr() IRowsecurityoptionalexprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecurityoptionalexprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecurityoptionalexprContext) +} + +func (s *AlterpolicystmtContext) Rowsecurityoptionalwithcheck() IRowsecurityoptionalwithcheckContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsecurityoptionalwithcheckContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsecurityoptionalwithcheckContext) +} + +func (s *AlterpolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterpolicystmt(s) + } +} + +func (s *AlterpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterpolicystmt(s) + } +} + +func (s *AlterpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterpolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterpolicystmt() (localctx IAlterpolicystmtContext) { + localctx = NewAlterpolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, RedshiftParserRULE_alterpolicystmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4993) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4994) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4995) + p.Name() + } + { + p.SetState(4996) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4997) + p.Qualified_name() + } + p.SetState(4999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTO { + { + p.SetState(4998) + p.Rowsecurityoptionaltorole() + } + + } + p.SetState(5002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(5001) + p.Rowsecurityoptionalexpr() + } + + } + p.SetState(5005) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 330, p.GetParserRuleContext()) == 1 { + { + p.SetState(5004) + p.Rowsecurityoptionalwithcheck() + } + + } 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 +} + +// IRowsecurityoptionalexprContext is an interface to support dynamic dispatch. +type IRowsecurityoptionalexprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsRowsecurityoptionalexprContext differentiates from other interfaces. + IsRowsecurityoptionalexprContext() +} + +type RowsecurityoptionalexprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsecurityoptionalexprContext() *RowsecurityoptionalexprContext { + var p = new(RowsecurityoptionalexprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionalexpr + return p +} + +func InitEmptyRowsecurityoptionalexprContext(p *RowsecurityoptionalexprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionalexpr +} + +func (*RowsecurityoptionalexprContext) IsRowsecurityoptionalexprContext() {} + +func NewRowsecurityoptionalexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionalexprContext { + var p = new(RowsecurityoptionalexprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionalexpr + + return p +} + +func (s *RowsecurityoptionalexprContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowsecurityoptionalexprContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *RowsecurityoptionalexprContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *RowsecurityoptionalexprContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *RowsecurityoptionalexprContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *RowsecurityoptionalexprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowsecurityoptionalexprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowsecurityoptionalexprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsecurityoptionalexpr(s) + } +} + +func (s *RowsecurityoptionalexprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsecurityoptionalexpr(s) + } +} + +func (s *RowsecurityoptionalexprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsecurityoptionalexpr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsecurityoptionalexpr() (localctx IRowsecurityoptionalexprContext) { + localctx = NewRowsecurityoptionalexprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, RedshiftParserRULE_rowsecurityoptionalexpr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5007) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5008) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5009) + p.A_expr() + } + { + p.SetState(5010) + p.Match(RedshiftParserCLOSE_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 +} + +// IRowsecurityoptionalwithcheckContext is an interface to support dynamic dispatch. +type IRowsecurityoptionalwithcheckContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + CHECK() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsRowsecurityoptionalwithcheckContext differentiates from other interfaces. + IsRowsecurityoptionalwithcheckContext() +} + +type RowsecurityoptionalwithcheckContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsecurityoptionalwithcheckContext() *RowsecurityoptionalwithcheckContext { + var p = new(RowsecurityoptionalwithcheckContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionalwithcheck + return p +} + +func InitEmptyRowsecurityoptionalwithcheckContext(p *RowsecurityoptionalwithcheckContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionalwithcheck +} + +func (*RowsecurityoptionalwithcheckContext) IsRowsecurityoptionalwithcheckContext() {} + +func NewRowsecurityoptionalwithcheckContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionalwithcheckContext { + var p = new(RowsecurityoptionalwithcheckContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionalwithcheck + + return p +} + +func (s *RowsecurityoptionalwithcheckContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowsecurityoptionalwithcheckContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *RowsecurityoptionalwithcheckContext) CHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECK, 0) +} + +func (s *RowsecurityoptionalwithcheckContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *RowsecurityoptionalwithcheckContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *RowsecurityoptionalwithcheckContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *RowsecurityoptionalwithcheckContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowsecurityoptionalwithcheckContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowsecurityoptionalwithcheckContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsecurityoptionalwithcheck(s) + } +} + +func (s *RowsecurityoptionalwithcheckContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsecurityoptionalwithcheck(s) + } +} + +func (s *RowsecurityoptionalwithcheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsecurityoptionalwithcheck(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsecurityoptionalwithcheck() (localctx IRowsecurityoptionalwithcheckContext) { + localctx = NewRowsecurityoptionalwithcheckContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, RedshiftParserRULE_rowsecurityoptionalwithcheck) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5012) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5013) + p.Match(RedshiftParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5014) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5015) + p.A_expr() + } + { + p.SetState(5016) + p.Match(RedshiftParserCLOSE_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 +} + +// IRowsecuritydefaulttoroleContext is an interface to support dynamic dispatch. +type IRowsecuritydefaulttoroleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TO() antlr.TerminalNode + Role_list() IRole_listContext + + // IsRowsecuritydefaulttoroleContext differentiates from other interfaces. + IsRowsecuritydefaulttoroleContext() +} + +type RowsecuritydefaulttoroleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsecuritydefaulttoroleContext() *RowsecuritydefaulttoroleContext { + var p = new(RowsecuritydefaulttoroleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaulttorole + return p +} + +func InitEmptyRowsecuritydefaulttoroleContext(p *RowsecuritydefaulttoroleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaulttorole +} + +func (*RowsecuritydefaulttoroleContext) IsRowsecuritydefaulttoroleContext() {} + +func NewRowsecuritydefaulttoroleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaulttoroleContext { + var p = new(RowsecuritydefaulttoroleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaulttorole + + return p +} + +func (s *RowsecuritydefaulttoroleContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowsecuritydefaulttoroleContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *RowsecuritydefaulttoroleContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *RowsecuritydefaulttoroleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowsecuritydefaulttoroleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowsecuritydefaulttoroleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsecuritydefaulttorole(s) + } +} + +func (s *RowsecuritydefaulttoroleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsecuritydefaulttorole(s) + } +} + +func (s *RowsecuritydefaulttoroleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsecuritydefaulttorole(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsecuritydefaulttorole() (localctx IRowsecuritydefaulttoroleContext) { + localctx = NewRowsecuritydefaulttoroleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, RedshiftParserRULE_rowsecuritydefaulttorole) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5018) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5019) + p.Role_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRowsecurityoptionaltoroleContext is an interface to support dynamic dispatch. +type IRowsecurityoptionaltoroleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TO() antlr.TerminalNode + Role_list() IRole_listContext + + // IsRowsecurityoptionaltoroleContext differentiates from other interfaces. + IsRowsecurityoptionaltoroleContext() +} + +type RowsecurityoptionaltoroleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsecurityoptionaltoroleContext() *RowsecurityoptionaltoroleContext { + var p = new(RowsecurityoptionaltoroleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionaltorole + return p +} + +func InitEmptyRowsecurityoptionaltoroleContext(p *RowsecurityoptionaltoroleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionaltorole +} + +func (*RowsecurityoptionaltoroleContext) IsRowsecurityoptionaltoroleContext() {} + +func NewRowsecurityoptionaltoroleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecurityoptionaltoroleContext { + var p = new(RowsecurityoptionaltoroleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsecurityoptionaltorole + + return p +} + +func (s *RowsecurityoptionaltoroleContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowsecurityoptionaltoroleContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *RowsecurityoptionaltoroleContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *RowsecurityoptionaltoroleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowsecurityoptionaltoroleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowsecurityoptionaltoroleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsecurityoptionaltorole(s) + } +} + +func (s *RowsecurityoptionaltoroleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsecurityoptionaltorole(s) + } +} + +func (s *RowsecurityoptionaltoroleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsecurityoptionaltorole(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsecurityoptionaltorole() (localctx IRowsecurityoptionaltoroleContext) { + localctx = NewRowsecurityoptionaltoroleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, RedshiftParserRULE_rowsecurityoptionaltorole) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5021) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5022) + p.Role_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRowsecuritydefaultpermissiveContext is an interface to support dynamic dispatch. +type IRowsecuritydefaultpermissiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsRowsecuritydefaultpermissiveContext differentiates from other interfaces. + IsRowsecuritydefaultpermissiveContext() +} + +type RowsecuritydefaultpermissiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsecuritydefaultpermissiveContext() *RowsecuritydefaultpermissiveContext { + var p = new(RowsecuritydefaultpermissiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaultpermissive + return p +} + +func InitEmptyRowsecuritydefaultpermissiveContext(p *RowsecuritydefaultpermissiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaultpermissive +} + +func (*RowsecuritydefaultpermissiveContext) IsRowsecuritydefaultpermissiveContext() {} + +func NewRowsecuritydefaultpermissiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaultpermissiveContext { + var p = new(RowsecuritydefaultpermissiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaultpermissive + + return p +} + +func (s *RowsecuritydefaultpermissiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowsecuritydefaultpermissiveContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *RowsecuritydefaultpermissiveContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *RowsecuritydefaultpermissiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowsecuritydefaultpermissiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowsecuritydefaultpermissiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsecuritydefaultpermissive(s) + } +} + +func (s *RowsecuritydefaultpermissiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsecuritydefaultpermissive(s) + } +} + +func (s *RowsecuritydefaultpermissiveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsecuritydefaultpermissive(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsecuritydefaultpermissive() (localctx IRowsecuritydefaultpermissiveContext) { + localctx = NewRowsecuritydefaultpermissiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, RedshiftParserRULE_rowsecuritydefaultpermissive) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5024) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5025) + 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 +} + +// IRowsecuritydefaultforcmdContext is an interface to support dynamic dispatch. +type IRowsecuritydefaultforcmdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Row_security_cmd() IRow_security_cmdContext + + // IsRowsecuritydefaultforcmdContext differentiates from other interfaces. + IsRowsecuritydefaultforcmdContext() +} + +type RowsecuritydefaultforcmdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsecuritydefaultforcmdContext() *RowsecuritydefaultforcmdContext { + var p = new(RowsecuritydefaultforcmdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaultforcmd + return p +} + +func InitEmptyRowsecuritydefaultforcmdContext(p *RowsecuritydefaultforcmdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaultforcmd +} + +func (*RowsecuritydefaultforcmdContext) IsRowsecuritydefaultforcmdContext() {} + +func NewRowsecuritydefaultforcmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowsecuritydefaultforcmdContext { + var p = new(RowsecuritydefaultforcmdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsecuritydefaultforcmd + + return p +} + +func (s *RowsecuritydefaultforcmdContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowsecuritydefaultforcmdContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *RowsecuritydefaultforcmdContext) Row_security_cmd() IRow_security_cmdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_security_cmdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_security_cmdContext) +} + +func (s *RowsecuritydefaultforcmdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowsecuritydefaultforcmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowsecuritydefaultforcmdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsecuritydefaultforcmd(s) + } +} + +func (s *RowsecuritydefaultforcmdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsecuritydefaultforcmd(s) + } +} + +func (s *RowsecuritydefaultforcmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsecuritydefaultforcmd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsecuritydefaultforcmd() (localctx IRowsecuritydefaultforcmdContext) { + localctx = NewRowsecuritydefaultforcmdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, RedshiftParserRULE_rowsecuritydefaultforcmd) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5027) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5028) + p.Row_security_cmd() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_security_cmdContext is an interface to support dynamic dispatch. +type IRow_security_cmdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + SELECT() antlr.TerminalNode + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + + // IsRow_security_cmdContext differentiates from other interfaces. + IsRow_security_cmdContext() +} + +type Row_security_cmdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_security_cmdContext() *Row_security_cmdContext { + var p = new(Row_security_cmdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row_security_cmd + return p +} + +func InitEmptyRow_security_cmdContext(p *Row_security_cmdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row_security_cmd +} + +func (*Row_security_cmdContext) IsRow_security_cmdContext() {} + +func NewRow_security_cmdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_security_cmdContext { + var p = new(Row_security_cmdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_row_security_cmd + + return p +} + +func (s *Row_security_cmdContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_security_cmdContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Row_security_cmdContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Row_security_cmdContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *Row_security_cmdContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Row_security_cmdContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *Row_security_cmdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_security_cmdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_security_cmdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRow_security_cmd(s) + } +} + +func (s *Row_security_cmdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRow_security_cmd(s) + } +} + +func (s *Row_security_cmdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRow_security_cmd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Row_security_cmd() (localctx IRow_security_cmdContext) { + localctx = NewRow_security_cmdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, RedshiftParserRULE_row_security_cmd) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5030) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || _la == RedshiftParserSELECT || _la == RedshiftParserDELETE_P || _la == RedshiftParserINSERT || _la == RedshiftParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateamstmtContext is an interface to support dynamic dispatch. +type ICreateamstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ACCESS() antlr.TerminalNode + METHOD() antlr.TerminalNode + Name() INameContext + TYPE_P() antlr.TerminalNode + Am_type() IAm_typeContext + HANDLER() antlr.TerminalNode + Handler_name() IHandler_nameContext + + // IsCreateamstmtContext differentiates from other interfaces. + IsCreateamstmtContext() +} + +type CreateamstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateamstmtContext() *CreateamstmtContext { + var p = new(CreateamstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createamstmt + return p +} + +func InitEmptyCreateamstmtContext(p *CreateamstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createamstmt +} + +func (*CreateamstmtContext) IsCreateamstmtContext() {} + +func NewCreateamstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateamstmtContext { + var p = new(CreateamstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createamstmt + + return p +} + +func (s *CreateamstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateamstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateamstmtContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *CreateamstmtContext) METHOD() antlr.TerminalNode { + return s.GetToken(RedshiftParserMETHOD, 0) +} + +func (s *CreateamstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateamstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *CreateamstmtContext) Am_type() IAm_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAm_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAm_typeContext) +} + +func (s *CreateamstmtContext) HANDLER() antlr.TerminalNode { + return s.GetToken(RedshiftParserHANDLER, 0) +} + +func (s *CreateamstmtContext) Handler_name() IHandler_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHandler_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHandler_nameContext) +} + +func (s *CreateamstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateamstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateamstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateamstmt(s) + } +} + +func (s *CreateamstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateamstmt(s) + } +} + +func (s *CreateamstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateamstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createamstmt() (localctx ICreateamstmtContext) { + localctx = NewCreateamstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, RedshiftParserRULE_createamstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5032) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5033) + p.Match(RedshiftParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5034) + p.Match(RedshiftParserMETHOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5035) + p.Name() + } + { + p.SetState(5036) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5037) + p.Am_type() + } + { + p.SetState(5038) + p.Match(RedshiftParserHANDLER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5039) + p.Handler_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAm_typeContext is an interface to support dynamic dispatch. +type IAm_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEX() antlr.TerminalNode + TABLE() antlr.TerminalNode + + // IsAm_typeContext differentiates from other interfaces. + IsAm_typeContext() +} + +type Am_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAm_typeContext() *Am_typeContext { + var p = new(Am_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_am_type + return p +} + +func InitEmptyAm_typeContext(p *Am_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_am_type +} + +func (*Am_typeContext) IsAm_typeContext() {} + +func NewAm_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Am_typeContext { + var p = new(Am_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_am_type + + return p +} + +func (s *Am_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Am_typeContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *Am_typeContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Am_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Am_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Am_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAm_type(s) + } +} + +func (s *Am_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAm_type(s) + } +} + +func (s *Am_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAm_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Am_type() (localctx IAm_typeContext) { + localctx = NewAm_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, RedshiftParserRULE_am_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5041) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTABLE || _la == RedshiftParserINDEX) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatetrigstmtContext is an interface to support dynamic dispatch. +type ICreatetrigstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Name() INameContext + Triggeractiontime() ITriggeractiontimeContext + Triggerevents() ITriggereventsContext + ON() antlr.TerminalNode + Qualified_name() IQualified_nameContext + EXECUTE() antlr.TerminalNode + Function_or_procedure() IFunction_or_procedureContext + Func_name() IFunc_nameContext + OPEN_PAREN() antlr.TerminalNode + Triggerfuncargs() ITriggerfuncargsContext + CLOSE_PAREN() antlr.TerminalNode + Triggerreferencing() ITriggerreferencingContext + Triggerforspec() ITriggerforspecContext + Triggerwhen() ITriggerwhenContext + CONSTRAINT() antlr.TerminalNode + AFTER() antlr.TerminalNode + Constraintattributespec() IConstraintattributespecContext + FOR() antlr.TerminalNode + EACH() antlr.TerminalNode + ROW() antlr.TerminalNode + Optconstrfromtable() IOptconstrfromtableContext + + // IsCreatetrigstmtContext differentiates from other interfaces. + IsCreatetrigstmtContext() +} + +type CreatetrigstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatetrigstmtContext() *CreatetrigstmtContext { + var p = new(CreatetrigstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createtrigstmt + return p +} + +func InitEmptyCreatetrigstmtContext(p *CreatetrigstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createtrigstmt +} + +func (*CreatetrigstmtContext) IsCreatetrigstmtContext() {} + +func NewCreatetrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetrigstmtContext { + var p = new(CreatetrigstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createtrigstmt + + return p +} + +func (s *CreatetrigstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatetrigstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatetrigstmtContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *CreatetrigstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatetrigstmtContext) Triggeractiontime() ITriggeractiontimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggeractiontimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggeractiontimeContext) +} + +func (s *CreatetrigstmtContext) Triggerevents() ITriggereventsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggereventsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggereventsContext) +} + +func (s *CreatetrigstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *CreatetrigstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreatetrigstmtContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *CreatetrigstmtContext) Function_or_procedure() IFunction_or_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_or_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_or_procedureContext) +} + +func (s *CreatetrigstmtContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *CreatetrigstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreatetrigstmtContext) Triggerfuncargs() ITriggerfuncargsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerfuncargsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerfuncargsContext) +} + +func (s *CreatetrigstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreatetrigstmtContext) Triggerreferencing() ITriggerreferencingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerreferencingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerreferencingContext) +} + +func (s *CreatetrigstmtContext) Triggerforspec() ITriggerforspecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerforspecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerforspecContext) +} + +func (s *CreatetrigstmtContext) Triggerwhen() ITriggerwhenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerwhenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerwhenContext) +} + +func (s *CreatetrigstmtContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *CreatetrigstmtContext) AFTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserAFTER, 0) +} + +func (s *CreatetrigstmtContext) Constraintattributespec() IConstraintattributespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintattributespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintattributespecContext) +} + +func (s *CreatetrigstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *CreatetrigstmtContext) EACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserEACH, 0) +} + +func (s *CreatetrigstmtContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *CreatetrigstmtContext) Optconstrfromtable() IOptconstrfromtableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOptconstrfromtableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOptconstrfromtableContext) +} + +func (s *CreatetrigstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatetrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatetrigstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatetrigstmt(s) + } +} + +func (s *CreatetrigstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatetrigstmt(s) + } +} + +func (s *CreatetrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatetrigstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createtrigstmt() (localctx ICreatetrigstmtContext) { + localctx = NewCreatetrigstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, RedshiftParserRULE_createtrigstmt) + var _la int + + p.SetState(5091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 336, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5043) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5044) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5045) + p.Name() + } + { + p.SetState(5046) + p.Triggeractiontime() + } + { + p.SetState(5047) + p.Triggerevents() + } + { + p.SetState(5048) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5049) + p.Qualified_name() + } + p.SetState(5051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserREFERENCING { + { + p.SetState(5050) + p.Triggerreferencing() + } + + } + p.SetState(5054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(5053) + p.Triggerforspec() + } + + } + p.SetState(5057) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHEN { + { + p.SetState(5056) + p.Triggerwhen() + } + + } + { + p.SetState(5059) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5060) + p.Function_or_procedure() + } + { + p.SetState(5061) + p.Func_name() + } + { + p.SetState(5062) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5063) + p.Triggerfuncargs() + } + { + p.SetState(5064) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5066) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5067) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5068) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5069) + p.Name() + } + { + p.SetState(5070) + p.Match(RedshiftParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5071) + p.Triggerevents() + } + { + p.SetState(5072) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5073) + p.Qualified_name() + } + p.SetState(5075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(5074) + p.Optconstrfromtable() + } + + } + { + p.SetState(5077) + p.Constraintattributespec() + } + { + p.SetState(5078) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5079) + p.Match(RedshiftParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5080) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHEN { + { + p.SetState(5081) + p.Triggerwhen() + } + + } + { + p.SetState(5084) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5085) + p.Function_or_procedure() + } + { + p.SetState(5086) + p.Func_name() + } + { + p.SetState(5087) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5088) + p.Triggerfuncargs() + } + { + p.SetState(5089) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggeractiontimeContext is an interface to support dynamic dispatch. +type ITriggeractiontimeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEFORE() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + OF() antlr.TerminalNode + + // IsTriggeractiontimeContext differentiates from other interfaces. + IsTriggeractiontimeContext() +} + +type TriggeractiontimeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggeractiontimeContext() *TriggeractiontimeContext { + var p = new(TriggeractiontimeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggeractiontime + return p +} + +func InitEmptyTriggeractiontimeContext(p *TriggeractiontimeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggeractiontime +} + +func (*TriggeractiontimeContext) IsTriggeractiontimeContext() {} + +func NewTriggeractiontimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggeractiontimeContext { + var p = new(TriggeractiontimeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggeractiontime + + return p +} + +func (s *TriggeractiontimeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggeractiontimeContext) BEFORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEFORE, 0) +} + +func (s *TriggeractiontimeContext) AFTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserAFTER, 0) +} + +func (s *TriggeractiontimeContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSTEAD, 0) +} + +func (s *TriggeractiontimeContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *TriggeractiontimeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggeractiontimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggeractiontimeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggeractiontime(s) + } +} + +func (s *TriggeractiontimeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggeractiontime(s) + } +} + +func (s *TriggeractiontimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggeractiontime(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggeractiontime() (localctx ITriggeractiontimeContext) { + localctx = NewTriggeractiontimeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, RedshiftParserRULE_triggeractiontime) + p.SetState(5097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserBEFORE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5093) + p.Match(RedshiftParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserAFTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5094) + p.Match(RedshiftParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserINSTEAD: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5095) + p.Match(RedshiftParserINSTEAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5096) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggereventsContext is an interface to support dynamic dispatch. +type ITriggereventsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTriggeroneevent() []ITriggeroneeventContext + Triggeroneevent(i int) ITriggeroneeventContext + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + + // IsTriggereventsContext differentiates from other interfaces. + IsTriggereventsContext() +} + +type TriggereventsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggereventsContext() *TriggereventsContext { + var p = new(TriggereventsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerevents + return p +} + +func InitEmptyTriggereventsContext(p *TriggereventsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerevents +} + +func (*TriggereventsContext) IsTriggereventsContext() {} + +func NewTriggereventsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggereventsContext { + var p = new(TriggereventsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerevents + + return p +} + +func (s *TriggereventsContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggereventsContext) AllTriggeroneevent() []ITriggeroneeventContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITriggeroneeventContext); ok { + len++ + } + } + + tst := make([]ITriggeroneeventContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITriggeroneeventContext); ok { + tst[i] = t.(ITriggeroneeventContext) + i++ + } + } + + return tst +} + +func (s *TriggereventsContext) Triggeroneevent(i int) ITriggeroneeventContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggeroneeventContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITriggeroneeventContext) +} + +func (s *TriggereventsContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOR) +} + +func (s *TriggereventsContext) OR(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, i) +} + +func (s *TriggereventsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggereventsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggereventsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerevents(s) + } +} + +func (s *TriggereventsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerevents(s) + } +} + +func (s *TriggereventsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerevents(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerevents() (localctx ITriggereventsContext) { + localctx = NewTriggereventsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, RedshiftParserRULE_triggerevents) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5099) + p.Triggeroneevent() + } + p.SetState(5104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserOR { + { + p.SetState(5100) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5101) + p.Triggeroneevent() + } + + p.SetState(5106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggeroneeventContext is an interface to support dynamic dispatch. +type ITriggeroneeventContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + UPDATE() antlr.TerminalNode + OF() antlr.TerminalNode + Columnlist() IColumnlistContext + TRUNCATE() antlr.TerminalNode + + // IsTriggeroneeventContext differentiates from other interfaces. + IsTriggeroneeventContext() +} + +type TriggeroneeventContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggeroneeventContext() *TriggeroneeventContext { + var p = new(TriggeroneeventContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggeroneevent + return p +} + +func InitEmptyTriggeroneeventContext(p *TriggeroneeventContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggeroneevent +} + +func (*TriggeroneeventContext) IsTriggeroneeventContext() {} + +func NewTriggeroneeventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggeroneeventContext { + var p = new(TriggeroneeventContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggeroneevent + + return p +} + +func (s *TriggeroneeventContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggeroneeventContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *TriggeroneeventContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *TriggeroneeventContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *TriggeroneeventContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *TriggeroneeventContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *TriggeroneeventContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNCATE, 0) +} + +func (s *TriggeroneeventContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggeroneeventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggeroneeventContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggeroneevent(s) + } +} + +func (s *TriggeroneeventContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggeroneevent(s) + } +} + +func (s *TriggeroneeventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggeroneevent(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggeroneevent() (localctx ITriggeroneeventContext) { + localctx = NewTriggeroneeventContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, RedshiftParserRULE_triggeroneevent) + p.SetState(5114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 339, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5107) + p.Match(RedshiftParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5108) + p.Match(RedshiftParserDELETE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5109) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5110) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5111) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5112) + p.Columnlist() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5113) + p.Match(RedshiftParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerreferencingContext is an interface to support dynamic dispatch. +type ITriggerreferencingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCING() antlr.TerminalNode + Triggertransitions() ITriggertransitionsContext + + // IsTriggerreferencingContext differentiates from other interfaces. + IsTriggerreferencingContext() +} + +type TriggerreferencingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerreferencingContext() *TriggerreferencingContext { + var p = new(TriggerreferencingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerreferencing + return p +} + +func InitEmptyTriggerreferencingContext(p *TriggerreferencingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerreferencing +} + +func (*TriggerreferencingContext) IsTriggerreferencingContext() {} + +func NewTriggerreferencingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerreferencingContext { + var p = new(TriggerreferencingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerreferencing + + return p +} + +func (s *TriggerreferencingContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerreferencingContext) REFERENCING() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCING, 0) +} + +func (s *TriggerreferencingContext) Triggertransitions() ITriggertransitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggertransitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggertransitionsContext) +} + +func (s *TriggerreferencingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerreferencingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerreferencingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerreferencing(s) + } +} + +func (s *TriggerreferencingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerreferencing(s) + } +} + +func (s *TriggerreferencingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerreferencing(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerreferencing() (localctx ITriggerreferencingContext) { + localctx = NewTriggerreferencingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, RedshiftParserRULE_triggerreferencing) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5116) + p.Match(RedshiftParserREFERENCING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5117) + p.Triggertransitions() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggertransitionsContext is an interface to support dynamic dispatch. +type ITriggertransitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTriggertransition() []ITriggertransitionContext + Triggertransition(i int) ITriggertransitionContext + + // IsTriggertransitionsContext differentiates from other interfaces. + IsTriggertransitionsContext() +} + +type TriggertransitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggertransitionsContext() *TriggertransitionsContext { + var p = new(TriggertransitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggertransitions + return p +} + +func InitEmptyTriggertransitionsContext(p *TriggertransitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggertransitions +} + +func (*TriggertransitionsContext) IsTriggertransitionsContext() {} + +func NewTriggertransitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggertransitionsContext { + var p = new(TriggertransitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggertransitions + + return p +} + +func (s *TriggertransitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggertransitionsContext) AllTriggertransition() []ITriggertransitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITriggertransitionContext); ok { + len++ + } + } + + tst := make([]ITriggertransitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITriggertransitionContext); ok { + tst[i] = t.(ITriggertransitionContext) + i++ + } + } + + return tst +} + +func (s *TriggertransitionsContext) Triggertransition(i int) ITriggertransitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggertransitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITriggertransitionContext) +} + +func (s *TriggertransitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggertransitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggertransitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggertransitions(s) + } +} + +func (s *TriggertransitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggertransitions(s) + } +} + +func (s *TriggertransitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggertransitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggertransitions() (localctx ITriggertransitionsContext) { + localctx = NewTriggertransitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, RedshiftParserRULE_triggertransitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserNEW || _la == RedshiftParserOLD { + { + p.SetState(5119) + p.Triggertransition() + } + + p.SetState(5122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggertransitionContext is an interface to support dynamic dispatch. +type ITriggertransitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Transitionoldornew() ITransitionoldornewContext + Transitionrowortable() ITransitionrowortableContext + Transitionrelname() ITransitionrelnameContext + Opt_as() IOpt_asContext + + // IsTriggertransitionContext differentiates from other interfaces. + IsTriggertransitionContext() +} + +type TriggertransitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggertransitionContext() *TriggertransitionContext { + var p = new(TriggertransitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggertransition + return p +} + +func InitEmptyTriggertransitionContext(p *TriggertransitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggertransition +} + +func (*TriggertransitionContext) IsTriggertransitionContext() {} + +func NewTriggertransitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggertransitionContext { + var p = new(TriggertransitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggertransition + + return p +} + +func (s *TriggertransitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggertransitionContext) Transitionoldornew() ITransitionoldornewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransitionoldornewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransitionoldornewContext) +} + +func (s *TriggertransitionContext) Transitionrowortable() ITransitionrowortableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransitionrowortableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransitionrowortableContext) +} + +func (s *TriggertransitionContext) Transitionrelname() ITransitionrelnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransitionrelnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransitionrelnameContext) +} + +func (s *TriggertransitionContext) Opt_as() IOpt_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_asContext) +} + +func (s *TriggertransitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggertransitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggertransitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggertransition(s) + } +} + +func (s *TriggertransitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggertransition(s) + } +} + +func (s *TriggertransitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggertransition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggertransition() (localctx ITriggertransitionContext) { + localctx = NewTriggertransitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, RedshiftParserRULE_triggertransition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5124) + p.Transitionoldornew() + } + { + p.SetState(5125) + p.Transitionrowortable() + } + p.SetState(5127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(5126) + p.Opt_as() + } + + } + { + p.SetState(5129) + p.Transitionrelname() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransitionoldornewContext is an interface to support dynamic dispatch. +type ITransitionoldornewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEW() antlr.TerminalNode + OLD() antlr.TerminalNode + + // IsTransitionoldornewContext differentiates from other interfaces. + IsTransitionoldornewContext() +} + +type TransitionoldornewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransitionoldornewContext() *TransitionoldornewContext { + var p = new(TransitionoldornewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transitionoldornew + return p +} + +func InitEmptyTransitionoldornewContext(p *TransitionoldornewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transitionoldornew +} + +func (*TransitionoldornewContext) IsTransitionoldornewContext() {} + +func NewTransitionoldornewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionoldornewContext { + var p = new(TransitionoldornewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transitionoldornew + + return p +} + +func (s *TransitionoldornewContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransitionoldornewContext) NEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEW, 0) +} + +func (s *TransitionoldornewContext) OLD() antlr.TerminalNode { + return s.GetToken(RedshiftParserOLD, 0) +} + +func (s *TransitionoldornewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransitionoldornewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransitionoldornewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransitionoldornew(s) + } +} + +func (s *TransitionoldornewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransitionoldornew(s) + } +} + +func (s *TransitionoldornewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransitionoldornew(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transitionoldornew() (localctx ITransitionoldornewContext) { + localctx = NewTransitionoldornewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, RedshiftParserRULE_transitionoldornew) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5131) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserNEW || _la == RedshiftParserOLD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransitionrowortableContext is an interface to support dynamic dispatch. +type ITransitionrowortableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + ROW() antlr.TerminalNode + + // IsTransitionrowortableContext differentiates from other interfaces. + IsTransitionrowortableContext() +} + +type TransitionrowortableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransitionrowortableContext() *TransitionrowortableContext { + var p = new(TransitionrowortableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transitionrowortable + return p +} + +func InitEmptyTransitionrowortableContext(p *TransitionrowortableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transitionrowortable +} + +func (*TransitionrowortableContext) IsTransitionrowortableContext() {} + +func NewTransitionrowortableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionrowortableContext { + var p = new(TransitionrowortableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transitionrowortable + + return p +} + +func (s *TransitionrowortableContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransitionrowortableContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *TransitionrowortableContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *TransitionrowortableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransitionrowortableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransitionrowortableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransitionrowortable(s) + } +} + +func (s *TransitionrowortableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransitionrowortable(s) + } +} + +func (s *TransitionrowortableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransitionrowortable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transitionrowortable() (localctx ITransitionrowortableContext) { + localctx = NewTransitionrowortableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, RedshiftParserRULE_transitionrowortable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5133) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTABLE || _la == RedshiftParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransitionrelnameContext is an interface to support dynamic dispatch. +type ITransitionrelnameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + + // IsTransitionrelnameContext differentiates from other interfaces. + IsTransitionrelnameContext() +} + +type TransitionrelnameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransitionrelnameContext() *TransitionrelnameContext { + var p = new(TransitionrelnameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transitionrelname + return p +} + +func InitEmptyTransitionrelnameContext(p *TransitionrelnameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transitionrelname +} + +func (*TransitionrelnameContext) IsTransitionrelnameContext() {} + +func NewTransitionrelnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransitionrelnameContext { + var p = new(TransitionrelnameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transitionrelname + + return p +} + +func (s *TransitionrelnameContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransitionrelnameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *TransitionrelnameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransitionrelnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransitionrelnameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransitionrelname(s) + } +} + +func (s *TransitionrelnameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransitionrelname(s) + } +} + +func (s *TransitionrelnameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransitionrelname(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transitionrelname() (localctx ITransitionrelnameContext) { + localctx = NewTransitionrelnameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, RedshiftParserRULE_transitionrelname) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5135) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerforspecContext is an interface to support dynamic dispatch. +type ITriggerforspecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Triggerfortype() ITriggerfortypeContext + Triggerforopteach() ITriggerforopteachContext + + // IsTriggerforspecContext differentiates from other interfaces. + IsTriggerforspecContext() +} + +type TriggerforspecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerforspecContext() *TriggerforspecContext { + var p = new(TriggerforspecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerforspec + return p +} + +func InitEmptyTriggerforspecContext(p *TriggerforspecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerforspec +} + +func (*TriggerforspecContext) IsTriggerforspecContext() {} + +func NewTriggerforspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerforspecContext { + var p = new(TriggerforspecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerforspec + + return p +} + +func (s *TriggerforspecContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerforspecContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *TriggerforspecContext) Triggerfortype() ITriggerfortypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerfortypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerfortypeContext) +} + +func (s *TriggerforspecContext) Triggerforopteach() ITriggerforopteachContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerforopteachContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITriggerforopteachContext) +} + +func (s *TriggerforspecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerforspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerforspecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerforspec(s) + } +} + +func (s *TriggerforspecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerforspec(s) + } +} + +func (s *TriggerforspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerforspec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerforspec() (localctx ITriggerforspecContext) { + localctx = NewTriggerforspecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, RedshiftParserRULE_triggerforspec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5137) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEACH { + { + p.SetState(5138) + p.Triggerforopteach() + } + + } + { + p.SetState(5141) + p.Triggerfortype() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerforopteachContext is an interface to support dynamic dispatch. +type ITriggerforopteachContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EACH() antlr.TerminalNode + + // IsTriggerforopteachContext differentiates from other interfaces. + IsTriggerforopteachContext() +} + +type TriggerforopteachContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerforopteachContext() *TriggerforopteachContext { + var p = new(TriggerforopteachContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerforopteach + return p +} + +func InitEmptyTriggerforopteachContext(p *TriggerforopteachContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerforopteach +} + +func (*TriggerforopteachContext) IsTriggerforopteachContext() {} + +func NewTriggerforopteachContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerforopteachContext { + var p = new(TriggerforopteachContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerforopteach + + return p +} + +func (s *TriggerforopteachContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerforopteachContext) EACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserEACH, 0) +} + +func (s *TriggerforopteachContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerforopteachContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerforopteachContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerforopteach(s) + } +} + +func (s *TriggerforopteachContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerforopteach(s) + } +} + +func (s *TriggerforopteachContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerforopteach(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerforopteach() (localctx ITriggerforopteachContext) { + localctx = NewTriggerforopteachContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, RedshiftParserRULE_triggerforopteach) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5143) + p.Match(RedshiftParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerfortypeContext is an interface to support dynamic dispatch. +type ITriggerfortypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + + // IsTriggerfortypeContext differentiates from other interfaces. + IsTriggerfortypeContext() +} + +type TriggerfortypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerfortypeContext() *TriggerfortypeContext { + var p = new(TriggerfortypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerfortype + return p +} + +func InitEmptyTriggerfortypeContext(p *TriggerfortypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerfortype +} + +func (*TriggerfortypeContext) IsTriggerfortypeContext() {} + +func NewTriggerfortypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfortypeContext { + var p = new(TriggerfortypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerfortype + + return p +} + +func (s *TriggerfortypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerfortypeContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *TriggerfortypeContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATEMENT, 0) +} + +func (s *TriggerfortypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerfortypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerfortypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerfortype(s) + } +} + +func (s *TriggerfortypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerfortype(s) + } +} + +func (s *TriggerfortypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerfortype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerfortype() (localctx ITriggerfortypeContext) { + localctx = NewTriggerfortypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, RedshiftParserRULE_triggerfortype) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5145) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserSTATEMENT || _la == RedshiftParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerwhenContext is an interface to support dynamic dispatch. +type ITriggerwhenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsTriggerwhenContext differentiates from other interfaces. + IsTriggerwhenContext() +} + +type TriggerwhenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerwhenContext() *TriggerwhenContext { + var p = new(TriggerwhenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerwhen + return p +} + +func InitEmptyTriggerwhenContext(p *TriggerwhenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerwhen +} + +func (*TriggerwhenContext) IsTriggerwhenContext() {} + +func NewTriggerwhenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerwhenContext { + var p = new(TriggerwhenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerwhen + + return p +} + +func (s *TriggerwhenContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerwhenContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *TriggerwhenContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *TriggerwhenContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *TriggerwhenContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *TriggerwhenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerwhenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerwhenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerwhen(s) + } +} + +func (s *TriggerwhenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerwhen(s) + } +} + +func (s *TriggerwhenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerwhen(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerwhen() (localctx ITriggerwhenContext) { + localctx = NewTriggerwhenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, RedshiftParserRULE_triggerwhen) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5147) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5148) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5149) + p.A_expr() + } + { + p.SetState(5150) + p.Match(RedshiftParserCLOSE_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 +} + +// IFunction_or_procedureContext is an interface to support dynamic dispatch. +type IFunction_or_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + + // IsFunction_or_procedureContext differentiates from other interfaces. + IsFunction_or_procedureContext() +} + +type Function_or_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_or_procedureContext() *Function_or_procedureContext { + var p = new(Function_or_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_or_procedure + return p +} + +func InitEmptyFunction_or_procedureContext(p *Function_or_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_or_procedure +} + +func (*Function_or_procedureContext) IsFunction_or_procedureContext() {} + +func NewFunction_or_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_or_procedureContext { + var p = new(Function_or_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_function_or_procedure + + return p +} + +func (s *Function_or_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_or_procedureContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Function_or_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *Function_or_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_or_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_or_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunction_or_procedure(s) + } +} + +func (s *Function_or_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunction_or_procedure(s) + } +} + +func (s *Function_or_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunction_or_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Function_or_procedure() (localctx IFunction_or_procedureContext) { + localctx = NewFunction_or_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, RedshiftParserRULE_function_or_procedure) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5152) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFUNCTION || _la == RedshiftParserPROCEDURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerfuncargsContext is an interface to support dynamic dispatch. +type ITriggerfuncargsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTriggerfuncarg() []ITriggerfuncargContext + Triggerfuncarg(i int) ITriggerfuncargContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTriggerfuncargsContext differentiates from other interfaces. + IsTriggerfuncargsContext() +} + +type TriggerfuncargsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerfuncargsContext() *TriggerfuncargsContext { + var p = new(TriggerfuncargsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerfuncargs + return p +} + +func InitEmptyTriggerfuncargsContext(p *TriggerfuncargsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerfuncargs +} + +func (*TriggerfuncargsContext) IsTriggerfuncargsContext() {} + +func NewTriggerfuncargsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfuncargsContext { + var p = new(TriggerfuncargsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerfuncargs + + return p +} + +func (s *TriggerfuncargsContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerfuncargsContext) AllTriggerfuncarg() []ITriggerfuncargContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITriggerfuncargContext); ok { + len++ + } + } + + tst := make([]ITriggerfuncargContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITriggerfuncargContext); ok { + tst[i] = t.(ITriggerfuncargContext) + i++ + } + } + + return tst +} + +func (s *TriggerfuncargsContext) Triggerfuncarg(i int) ITriggerfuncargContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerfuncargContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITriggerfuncargContext) +} + +func (s *TriggerfuncargsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *TriggerfuncargsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *TriggerfuncargsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerfuncargsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerfuncargsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerfuncargs(s) + } +} + +func (s *TriggerfuncargsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerfuncargs(s) + } +} + +func (s *TriggerfuncargsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerfuncargs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerfuncargs() (localctx ITriggerfuncargsContext) { + localctx = NewTriggerfuncargsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, RedshiftParserRULE_triggerfuncargs) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserALL, RedshiftParserANALYSE, RedshiftParserANALYZE, RedshiftParserAND, RedshiftParserANY, RedshiftParserARRAY, RedshiftParserAS, RedshiftParserASC, RedshiftParserASYMMETRIC, RedshiftParserBOTH, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCHECK, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCREATE, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDEFERRABLE, RedshiftParserDESC, RedshiftParserDISTINCT, RedshiftParserDO, RedshiftParserELSE, RedshiftParserEXCEPT, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserFOR, RedshiftParserFOREIGN, RedshiftParserFROM, RedshiftParserGRANT, RedshiftParserGROUP_P, RedshiftParserHAVING, RedshiftParserIN_P, RedshiftParserINITIALLY, RedshiftParserINTERSECT, RedshiftParserLATERAL_P, RedshiftParserLEADING, RedshiftParserLIMIT, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserONLY, RedshiftParserOR, RedshiftParserORDER, RedshiftParserPLACING, RedshiftParserPRIMARY, RedshiftParserPUBLIC, RedshiftParserREFERENCES, RedshiftParserRETURNING, RedshiftParserSELECT, RedshiftParserSESSION_USER, RedshiftParserSOME, RedshiftParserSYMMETRIC, RedshiftParserTABLE, RedshiftParserTHEN, RedshiftParserTO, RedshiftParserTRAILING, RedshiftParserTRUE_P, RedshiftParserUNION, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserUSING, RedshiftParserVARIADIC, RedshiftParserWHEN, RedshiftParserWHERE, RedshiftParserWINDOW, RedshiftParserWITH, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserEND_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserIntegral, RedshiftParserNumeric, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + { + p.SetState(5154) + p.Triggerfuncarg() + } + + case RedshiftParserCLOSE_PAREN, RedshiftParserCOMMA: + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(5162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5158) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5159) + p.Triggerfuncarg() + } + + p.SetState(5164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITriggerfuncargContext is an interface to support dynamic dispatch. +type ITriggerfuncargContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Iconst() IIconstContext + Fconst() IFconstContext + Sconst() ISconstContext + Collabel() ICollabelContext + + // IsTriggerfuncargContext differentiates from other interfaces. + IsTriggerfuncargContext() +} + +type TriggerfuncargContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerfuncargContext() *TriggerfuncargContext { + var p = new(TriggerfuncargContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerfuncarg + return p +} + +func InitEmptyTriggerfuncargContext(p *TriggerfuncargContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_triggerfuncarg +} + +func (*TriggerfuncargContext) IsTriggerfuncargContext() {} + +func NewTriggerfuncargContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerfuncargContext { + var p = new(TriggerfuncargContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_triggerfuncarg + + return p +} + +func (s *TriggerfuncargContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerfuncargContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *TriggerfuncargContext) Fconst() IFconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFconstContext) +} + +func (s *TriggerfuncargContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *TriggerfuncargContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *TriggerfuncargContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerfuncargContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerfuncargContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTriggerfuncarg(s) + } +} + +func (s *TriggerfuncargContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTriggerfuncarg(s) + } +} + +func (s *TriggerfuncargContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTriggerfuncarg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Triggerfuncarg() (localctx ITriggerfuncargContext) { + localctx = NewTriggerfuncargContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, RedshiftParserRULE_triggerfuncarg) + p.SetState(5169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5165) + p.Iconst() + } + + case RedshiftParserNumeric: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5166) + p.Fconst() + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5167) + p.Sconst() + } + + case RedshiftParserALL, RedshiftParserANALYSE, RedshiftParserANALYZE, RedshiftParserAND, RedshiftParserANY, RedshiftParserARRAY, RedshiftParserAS, RedshiftParserASC, RedshiftParserASYMMETRIC, RedshiftParserBOTH, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCHECK, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCREATE, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDEFERRABLE, RedshiftParserDESC, RedshiftParserDISTINCT, RedshiftParserDO, RedshiftParserELSE, RedshiftParserEXCEPT, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserFOR, RedshiftParserFOREIGN, RedshiftParserFROM, RedshiftParserGRANT, RedshiftParserGROUP_P, RedshiftParserHAVING, RedshiftParserIN_P, RedshiftParserINITIALLY, RedshiftParserINTERSECT, RedshiftParserLATERAL_P, RedshiftParserLEADING, RedshiftParserLIMIT, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserONLY, RedshiftParserOR, RedshiftParserORDER, RedshiftParserPLACING, RedshiftParserPRIMARY, RedshiftParserPUBLIC, RedshiftParserREFERENCES, RedshiftParserRETURNING, RedshiftParserSELECT, RedshiftParserSESSION_USER, RedshiftParserSOME, RedshiftParserSYMMETRIC, RedshiftParserTABLE, RedshiftParserTHEN, RedshiftParserTO, RedshiftParserTRAILING, RedshiftParserTRUE_P, RedshiftParserUNION, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserUSING, RedshiftParserVARIADIC, RedshiftParserWHEN, RedshiftParserWHERE, RedshiftParserWINDOW, RedshiftParserWITH, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserEND_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5168) + p.Collabel() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOptconstrfromtableContext is an interface to support dynamic dispatch. +type IOptconstrfromtableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + Qualified_name() IQualified_nameContext + + // IsOptconstrfromtableContext differentiates from other interfaces. + IsOptconstrfromtableContext() +} + +type OptconstrfromtableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOptconstrfromtableContext() *OptconstrfromtableContext { + var p = new(OptconstrfromtableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optconstrfromtable + return p +} + +func InitEmptyOptconstrfromtableContext(p *OptconstrfromtableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_optconstrfromtable +} + +func (*OptconstrfromtableContext) IsOptconstrfromtableContext() {} + +func NewOptconstrfromtableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OptconstrfromtableContext { + var p = new(OptconstrfromtableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_optconstrfromtable + + return p +} + +func (s *OptconstrfromtableContext) GetParser() antlr.Parser { return s.parser } + +func (s *OptconstrfromtableContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *OptconstrfromtableContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *OptconstrfromtableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OptconstrfromtableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OptconstrfromtableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOptconstrfromtable(s) + } +} + +func (s *OptconstrfromtableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOptconstrfromtable(s) + } +} + +func (s *OptconstrfromtableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOptconstrfromtable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Optconstrfromtable() (localctx IOptconstrfromtableContext) { + localctx = NewOptconstrfromtableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, RedshiftParserRULE_optconstrfromtable) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5171) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5172) + p.Qualified_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraintattributespecContext is an interface to support dynamic dispatch. +type IConstraintattributespecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConstraintattributeElem() []IConstraintattributeElemContext + ConstraintattributeElem(i int) IConstraintattributeElemContext + + // IsConstraintattributespecContext differentiates from other interfaces. + IsConstraintattributespecContext() +} + +type ConstraintattributespecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraintattributespecContext() *ConstraintattributespecContext { + var p = new(ConstraintattributespecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintattributespec + return p +} + +func InitEmptyConstraintattributespecContext(p *ConstraintattributespecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintattributespec +} + +func (*ConstraintattributespecContext) IsConstraintattributespecContext() {} + +func NewConstraintattributespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattributespecContext { + var p = new(ConstraintattributespecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constraintattributespec + + return p +} + +func (s *ConstraintattributespecContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstraintattributespecContext) AllConstraintattributeElem() []IConstraintattributeElemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstraintattributeElemContext); ok { + len++ + } + } + + tst := make([]IConstraintattributeElemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstraintattributeElemContext); ok { + tst[i] = t.(IConstraintattributeElemContext) + i++ + } + } + + return tst +} + +func (s *ConstraintattributespecContext) ConstraintattributeElem(i int) IConstraintattributeElemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintattributeElemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstraintattributeElemContext) +} + +func (s *ConstraintattributespecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintattributespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstraintattributespecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstraintattributespec(s) + } +} + +func (s *ConstraintattributespecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstraintattributespec(s) + } +} + +func (s *ConstraintattributespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstraintattributespec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constraintattributespec() (localctx IConstraintattributespecContext) { + localctx = NewConstraintattributespecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, RedshiftParserRULE_constraintattributespec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-54)) & ^0x3f) == 0 && ((int64(1)<<(_la-54))&8421377) != 0) || _la == RedshiftParserNO { + { + p.SetState(5174) + p.ConstraintattributeElem() + } + + p.SetState(5179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstraintattributeElemContext is an interface to support dynamic dispatch. +type IConstraintattributeElemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT() antlr.TerminalNode + DEFERRABLE() antlr.TerminalNode + INITIALLY() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + VALID() antlr.TerminalNode + NO() antlr.TerminalNode + INHERIT() antlr.TerminalNode + + // IsConstraintattributeElemContext differentiates from other interfaces. + IsConstraintattributeElemContext() +} + +type ConstraintattributeElemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraintattributeElemContext() *ConstraintattributeElemContext { + var p = new(ConstraintattributeElemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintattributeElem + return p +} + +func InitEmptyConstraintattributeElemContext(p *ConstraintattributeElemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constraintattributeElem +} + +func (*ConstraintattributeElemContext) IsConstraintattributeElemContext() {} + +func NewConstraintattributeElemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstraintattributeElemContext { + var p = new(ConstraintattributeElemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constraintattributeElem + + return p +} + +func (s *ConstraintattributeElemContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstraintattributeElemContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *ConstraintattributeElemContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRABLE, 0) +} + +func (s *ConstraintattributeElemContext) INITIALLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserINITIALLY, 0) +} + +func (s *ConstraintattributeElemContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMEDIATE, 0) +} + +func (s *ConstraintattributeElemContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRED, 0) +} + +func (s *ConstraintattributeElemContext) VALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALID, 0) +} + +func (s *ConstraintattributeElemContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *ConstraintattributeElemContext) INHERIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINHERIT, 0) +} + +func (s *ConstraintattributeElemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstraintattributeElemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstraintattributeElemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstraintattributeElem(s) + } +} + +func (s *ConstraintattributeElemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstraintattributeElem(s) + } +} + +func (s *ConstraintattributeElemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstraintattributeElem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) ConstraintattributeElem() (localctx IConstraintattributeElemContext) { + localctx = NewConstraintattributeElemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, RedshiftParserRULE_constraintattributeElem) + p.SetState(5191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 347, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5180) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5181) + p.Match(RedshiftParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5182) + p.Match(RedshiftParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5183) + p.Match(RedshiftParserINITIALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5184) + p.Match(RedshiftParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5185) + p.Match(RedshiftParserINITIALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5186) + p.Match(RedshiftParserDEFERRED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5187) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5188) + p.Match(RedshiftParserVALID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5189) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5190) + p.Match(RedshiftParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateeventtrigstmtContext is an interface to support dynamic dispatch. +type ICreateeventtrigstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EVENT() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Name() INameContext + ON() antlr.TerminalNode + Collabel() ICollabelContext + EXECUTE() antlr.TerminalNode + Function_or_procedure() IFunction_or_procedureContext + Func_name() IFunc_nameContext + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + WHEN() antlr.TerminalNode + Event_trigger_when_list() IEvent_trigger_when_listContext + + // IsCreateeventtrigstmtContext differentiates from other interfaces. + IsCreateeventtrigstmtContext() +} + +type CreateeventtrigstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateeventtrigstmtContext() *CreateeventtrigstmtContext { + var p = new(CreateeventtrigstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createeventtrigstmt + return p +} + +func InitEmptyCreateeventtrigstmtContext(p *CreateeventtrigstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createeventtrigstmt +} + +func (*CreateeventtrigstmtContext) IsCreateeventtrigstmtContext() {} + +func NewCreateeventtrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateeventtrigstmtContext { + var p = new(CreateeventtrigstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createeventtrigstmt + + return p +} + +func (s *CreateeventtrigstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateeventtrigstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateeventtrigstmtContext) EVENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVENT, 0) +} + +func (s *CreateeventtrigstmtContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *CreateeventtrigstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateeventtrigstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *CreateeventtrigstmtContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *CreateeventtrigstmtContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *CreateeventtrigstmtContext) Function_or_procedure() IFunction_or_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_or_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_or_procedureContext) +} + +func (s *CreateeventtrigstmtContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *CreateeventtrigstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreateeventtrigstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreateeventtrigstmtContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *CreateeventtrigstmtContext) Event_trigger_when_list() IEvent_trigger_when_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_trigger_when_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEvent_trigger_when_listContext) +} + +func (s *CreateeventtrigstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateeventtrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateeventtrigstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateeventtrigstmt(s) + } +} + +func (s *CreateeventtrigstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateeventtrigstmt(s) + } +} + +func (s *CreateeventtrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateeventtrigstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createeventtrigstmt() (localctx ICreateeventtrigstmtContext) { + localctx = NewCreateeventtrigstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, RedshiftParserRULE_createeventtrigstmt) + p.SetState(5219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 348, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5193) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5194) + p.Match(RedshiftParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5195) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5196) + p.Name() + } + { + p.SetState(5197) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5198) + p.Collabel() + } + { + p.SetState(5199) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5200) + p.Function_or_procedure() + } + { + p.SetState(5201) + p.Func_name() + } + { + p.SetState(5202) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5203) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5205) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5206) + p.Match(RedshiftParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5207) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5208) + p.Name() + } + { + p.SetState(5209) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5210) + p.Collabel() + } + { + p.SetState(5211) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5212) + p.Event_trigger_when_list() + } + { + p.SetState(5213) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5214) + p.Function_or_procedure() + } + { + p.SetState(5215) + p.Func_name() + } + { + p.SetState(5216) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5217) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvent_trigger_when_listContext is an interface to support dynamic dispatch. +type IEvent_trigger_when_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllEvent_trigger_when_item() []IEvent_trigger_when_itemContext + Event_trigger_when_item(i int) IEvent_trigger_when_itemContext + AllAND() []antlr.TerminalNode + AND(i int) antlr.TerminalNode + + // IsEvent_trigger_when_listContext differentiates from other interfaces. + IsEvent_trigger_when_listContext() +} + +type Event_trigger_when_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEvent_trigger_when_listContext() *Event_trigger_when_listContext { + var p = new(Event_trigger_when_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event_trigger_when_list + return p +} + +func InitEmptyEvent_trigger_when_listContext(p *Event_trigger_when_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event_trigger_when_list +} + +func (*Event_trigger_when_listContext) IsEvent_trigger_when_listContext() {} + +func NewEvent_trigger_when_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_when_listContext { + var p = new(Event_trigger_when_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_event_trigger_when_list + + return p +} + +func (s *Event_trigger_when_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Event_trigger_when_listContext) AllEvent_trigger_when_item() []IEvent_trigger_when_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEvent_trigger_when_itemContext); ok { + len++ + } + } + + tst := make([]IEvent_trigger_when_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEvent_trigger_when_itemContext); ok { + tst[i] = t.(IEvent_trigger_when_itemContext) + i++ + } + } + + return tst +} + +func (s *Event_trigger_when_listContext) Event_trigger_when_item(i int) IEvent_trigger_when_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_trigger_when_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEvent_trigger_when_itemContext) +} + +func (s *Event_trigger_when_listContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserAND) +} + +func (s *Event_trigger_when_listContext) AND(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, i) +} + +func (s *Event_trigger_when_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Event_trigger_when_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Event_trigger_when_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEvent_trigger_when_list(s) + } +} + +func (s *Event_trigger_when_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEvent_trigger_when_list(s) + } +} + +func (s *Event_trigger_when_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEvent_trigger_when_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Event_trigger_when_list() (localctx IEvent_trigger_when_listContext) { + localctx = NewEvent_trigger_when_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, RedshiftParserRULE_event_trigger_when_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5221) + p.Event_trigger_when_item() + } + p.SetState(5226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserAND { + { + p.SetState(5222) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5223) + p.Event_trigger_when_item() + } + + p.SetState(5228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvent_trigger_when_itemContext is an interface to support dynamic dispatch. +type IEvent_trigger_when_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + IN_P() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Event_trigger_value_list() IEvent_trigger_value_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsEvent_trigger_when_itemContext differentiates from other interfaces. + IsEvent_trigger_when_itemContext() +} + +type Event_trigger_when_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEvent_trigger_when_itemContext() *Event_trigger_when_itemContext { + var p = new(Event_trigger_when_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event_trigger_when_item + return p +} + +func InitEmptyEvent_trigger_when_itemContext(p *Event_trigger_when_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event_trigger_when_item +} + +func (*Event_trigger_when_itemContext) IsEvent_trigger_when_itemContext() {} + +func NewEvent_trigger_when_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_when_itemContext { + var p = new(Event_trigger_when_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_event_trigger_when_item + + return p +} + +func (s *Event_trigger_when_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Event_trigger_when_itemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Event_trigger_when_itemContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Event_trigger_when_itemContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Event_trigger_when_itemContext) Event_trigger_value_list() IEvent_trigger_value_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvent_trigger_value_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEvent_trigger_value_listContext) +} + +func (s *Event_trigger_when_itemContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Event_trigger_when_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Event_trigger_when_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Event_trigger_when_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEvent_trigger_when_item(s) + } +} + +func (s *Event_trigger_when_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEvent_trigger_when_item(s) + } +} + +func (s *Event_trigger_when_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEvent_trigger_when_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Event_trigger_when_item() (localctx IEvent_trigger_when_itemContext) { + localctx = NewEvent_trigger_when_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, RedshiftParserRULE_event_trigger_when_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5229) + p.Colid() + } + { + p.SetState(5230) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5231) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5232) + p.Event_trigger_value_list() + } + { + p.SetState(5233) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvent_trigger_value_listContext is an interface to support dynamic dispatch. +type IEvent_trigger_value_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsEvent_trigger_value_listContext differentiates from other interfaces. + IsEvent_trigger_value_listContext() +} + +type Event_trigger_value_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEvent_trigger_value_listContext() *Event_trigger_value_listContext { + var p = new(Event_trigger_value_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event_trigger_value_list + return p +} + +func InitEmptyEvent_trigger_value_listContext(p *Event_trigger_value_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event_trigger_value_list +} + +func (*Event_trigger_value_listContext) IsEvent_trigger_value_listContext() {} + +func NewEvent_trigger_value_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Event_trigger_value_listContext { + var p = new(Event_trigger_value_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_event_trigger_value_list + + return p +} + +func (s *Event_trigger_value_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Event_trigger_value_listContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Event_trigger_value_listContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Event_trigger_value_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Event_trigger_value_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Event_trigger_value_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Event_trigger_value_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Event_trigger_value_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEvent_trigger_value_list(s) + } +} + +func (s *Event_trigger_value_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEvent_trigger_value_list(s) + } +} + +func (s *Event_trigger_value_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEvent_trigger_value_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Event_trigger_value_list() (localctx IEvent_trigger_value_listContext) { + localctx = NewEvent_trigger_value_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, RedshiftParserRULE_event_trigger_value_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5235) + p.Sconst() + } + p.SetState(5240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5236) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5237) + p.Sconst() + } + + p.SetState(5242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltereventtrigstmtContext is an interface to support dynamic dispatch. +type IAltereventtrigstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + EVENT() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Name() INameContext + Enable_trigger() IEnable_triggerContext + + // IsAltereventtrigstmtContext differentiates from other interfaces. + IsAltereventtrigstmtContext() +} + +type AltereventtrigstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltereventtrigstmtContext() *AltereventtrigstmtContext { + var p = new(AltereventtrigstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altereventtrigstmt + return p +} + +func InitEmptyAltereventtrigstmtContext(p *AltereventtrigstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altereventtrigstmt +} + +func (*AltereventtrigstmtContext) IsAltereventtrigstmtContext() {} + +func NewAltereventtrigstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltereventtrigstmtContext { + var p = new(AltereventtrigstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altereventtrigstmt + + return p +} + +func (s *AltereventtrigstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltereventtrigstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltereventtrigstmtContext) EVENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVENT, 0) +} + +func (s *AltereventtrigstmtContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *AltereventtrigstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AltereventtrigstmtContext) Enable_trigger() IEnable_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_triggerContext) +} + +func (s *AltereventtrigstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltereventtrigstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltereventtrigstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltereventtrigstmt(s) + } +} + +func (s *AltereventtrigstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltereventtrigstmt(s) + } +} + +func (s *AltereventtrigstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltereventtrigstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altereventtrigstmt() (localctx IAltereventtrigstmtContext) { + localctx = NewAltereventtrigstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, RedshiftParserRULE_altereventtrigstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5243) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5244) + p.Match(RedshiftParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5245) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5246) + p.Name() + } + { + p.SetState(5247) + p.Enable_trigger() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnable_triggerContext is an interface to support dynamic dispatch. +type IEnable_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE_P() antlr.TerminalNode + REPLICA() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + DISABLE_P() antlr.TerminalNode + + // IsEnable_triggerContext differentiates from other interfaces. + IsEnable_triggerContext() +} + +type Enable_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_triggerContext() *Enable_triggerContext { + var p = new(Enable_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_enable_trigger + return p +} + +func InitEmptyEnable_triggerContext(p *Enable_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_enable_trigger +} + +func (*Enable_triggerContext) IsEnable_triggerContext() {} + +func NewEnable_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_triggerContext { + var p = new(Enable_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_enable_trigger + + return p +} + +func (s *Enable_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_triggerContext) ENABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserENABLE_P, 0) +} + +func (s *Enable_triggerContext) REPLICA() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLICA, 0) +} + +func (s *Enable_triggerContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(RedshiftParserALWAYS, 0) +} + +func (s *Enable_triggerContext) DISABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISABLE_P, 0) +} + +func (s *Enable_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEnable_trigger(s) + } +} + +func (s *Enable_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEnable_trigger(s) + } +} + +func (s *Enable_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEnable_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Enable_trigger() (localctx IEnable_triggerContext) { + localctx = NewEnable_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, RedshiftParserRULE_enable_trigger) + p.SetState(5255) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 351, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5249) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5250) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5251) + p.Match(RedshiftParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5252) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5253) + p.Match(RedshiftParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5254) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateassertionstmtContext is an interface to support dynamic dispatch. +type ICreateassertionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ASSERTION() antlr.TerminalNode + Any_name() IAny_nameContext + CHECK() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + Constraintattributespec() IConstraintattributespecContext + + // IsCreateassertionstmtContext differentiates from other interfaces. + IsCreateassertionstmtContext() +} + +type CreateassertionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateassertionstmtContext() *CreateassertionstmtContext { + var p = new(CreateassertionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createassertionstmt + return p +} + +func InitEmptyCreateassertionstmtContext(p *CreateassertionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createassertionstmt +} + +func (*CreateassertionstmtContext) IsCreateassertionstmtContext() {} + +func NewCreateassertionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateassertionstmtContext { + var p = new(CreateassertionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createassertionstmt + + return p +} + +func (s *CreateassertionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateassertionstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateassertionstmtContext) ASSERTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSERTION, 0) +} + +func (s *CreateassertionstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *CreateassertionstmtContext) CHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECK, 0) +} + +func (s *CreateassertionstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreateassertionstmtContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *CreateassertionstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreateassertionstmtContext) Constraintattributespec() IConstraintattributespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraintattributespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraintattributespecContext) +} + +func (s *CreateassertionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateassertionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateassertionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateassertionstmt(s) + } +} + +func (s *CreateassertionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateassertionstmt(s) + } +} + +func (s *CreateassertionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateassertionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createassertionstmt() (localctx ICreateassertionstmtContext) { + localctx = NewCreateassertionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, RedshiftParserRULE_createassertionstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5257) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5258) + p.Match(RedshiftParserASSERTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5259) + p.Any_name() + } + { + p.SetState(5260) + p.Match(RedshiftParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5261) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5262) + p.A_expr() + } + { + p.SetState(5263) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5264) + p.Constraintattributespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefinestmtContext is an interface to support dynamic dispatch. +type IDefinestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + Func_name() IFunc_nameContext + Aggr_args() IAggr_argsContext + Definition() IDefinitionContext + Opt_or_replace() IOpt_or_replaceContext + Old_aggr_definition() IOld_aggr_definitionContext + OPERATOR() antlr.TerminalNode + Any_operator() IAny_operatorContext + TYPE_P() antlr.TerminalNode + AllAny_name() []IAny_nameContext + Any_name(i int) IAny_nameContext + AS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Opttablefuncelementlist() IOpttablefuncelementlistContext + ENUM_P() antlr.TerminalNode + Opt_enum_val_list() IOpt_enum_val_listContext + RANGE() antlr.TerminalNode + TEXT_P() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PARSER() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + COLLATION() antlr.TerminalNode + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + FROM() antlr.TerminalNode + + // IsDefinestmtContext differentiates from other interfaces. + IsDefinestmtContext() +} + +type DefinestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefinestmtContext() *DefinestmtContext { + var p = new(DefinestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_definestmt + return p +} + +func InitEmptyDefinestmtContext(p *DefinestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_definestmt +} + +func (*DefinestmtContext) IsDefinestmtContext() {} + +func NewDefinestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinestmtContext { + var p = new(DefinestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_definestmt + + return p +} + +func (s *DefinestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefinestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *DefinestmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *DefinestmtContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *DefinestmtContext) Aggr_args() IAggr_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggr_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggr_argsContext) +} + +func (s *DefinestmtContext) Definition() IDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefinitionContext) +} + +func (s *DefinestmtContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *DefinestmtContext) Old_aggr_definition() IOld_aggr_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOld_aggr_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOld_aggr_definitionContext) +} + +func (s *DefinestmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *DefinestmtContext) Any_operator() IAny_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_operatorContext) +} + +func (s *DefinestmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *DefinestmtContext) AllAny_name() []IAny_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAny_nameContext); ok { + len++ + } + } + + tst := make([]IAny_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAny_nameContext); ok { + tst[i] = t.(IAny_nameContext) + i++ + } + } + + return tst +} + +func (s *DefinestmtContext) Any_name(i int) IAny_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *DefinestmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *DefinestmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *DefinestmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *DefinestmtContext) Opttablefuncelementlist() IOpttablefuncelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttablefuncelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttablefuncelementlistContext) +} + +func (s *DefinestmtContext) ENUM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserENUM_P, 0) +} + +func (s *DefinestmtContext) Opt_enum_val_list() IOpt_enum_val_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_enum_val_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_enum_val_listContext) +} + +func (s *DefinestmtContext) RANGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRANGE, 0) +} + +func (s *DefinestmtContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *DefinestmtContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *DefinestmtContext) PARSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARSER, 0) +} + +func (s *DefinestmtContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDICTIONARY, 0) +} + +func (s *DefinestmtContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPLATE, 0) +} + +func (s *DefinestmtContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFIGURATION, 0) +} + +func (s *DefinestmtContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *DefinestmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *DefinestmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *DefinestmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *DefinestmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *DefinestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefinestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefinestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDefinestmt(s) + } +} + +func (s *DefinestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDefinestmt(s) + } +} + +func (s *DefinestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDefinestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Definestmt() (localctx IDefinestmtContext) { + localctx = NewDefinestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, RedshiftParserRULE_definestmt) + var _la int + + p.SetState(5380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 356, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5266) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(5267) + p.Opt_or_replace() + } + + } + { + p.SetState(5270) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5271) + p.Func_name() + } + { + p.SetState(5272) + p.Aggr_args() + } + { + p.SetState(5273) + p.Definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5275) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(5276) + p.Opt_or_replace() + } + + } + { + p.SetState(5279) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5280) + p.Func_name() + } + { + p.SetState(5281) + p.Old_aggr_definition() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5283) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5284) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5285) + p.Any_operator() + } + { + p.SetState(5286) + p.Definition() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5288) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5289) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5290) + p.Any_name() + } + { + p.SetState(5291) + p.Definition() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5293) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5294) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5295) + p.Any_name() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5296) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5297) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5298) + p.Any_name() + } + { + p.SetState(5299) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5300) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(5301) + p.Opttablefuncelementlist() + } + + } + { + p.SetState(5304) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5306) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5307) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5308) + p.Any_name() + } + { + p.SetState(5309) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5310) + p.Match(RedshiftParserENUM_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5311) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-862)) & ^0x3f) == 0 && ((int64(1)<<(_la-862))&67108885) != 0 { + { + p.SetState(5312) + p.Opt_enum_val_list() + } + + } + { + p.SetState(5315) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5317) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5318) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5319) + p.Any_name() + } + { + p.SetState(5320) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5321) + p.Match(RedshiftParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5322) + p.Definition() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5324) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5325) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5326) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5327) + p.Match(RedshiftParserPARSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5328) + p.Any_name() + } + { + p.SetState(5329) + p.Definition() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5331) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5332) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5333) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5334) + p.Match(RedshiftParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5335) + p.Any_name() + } + { + p.SetState(5336) + p.Definition() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5338) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5339) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5340) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5341) + p.Match(RedshiftParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5342) + p.Any_name() + } + { + p.SetState(5343) + p.Definition() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5345) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5346) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5347) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5348) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5349) + p.Any_name() + } + { + p.SetState(5350) + p.Definition() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5352) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5353) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5354) + p.Any_name() + } + { + p.SetState(5355) + p.Definition() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(5357) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5358) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5359) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5360) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5361) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5362) + p.Any_name() + } + { + p.SetState(5363) + p.Definition() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(5365) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5366) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5367) + p.Any_name() + } + { + p.SetState(5368) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5369) + p.Any_name() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(5371) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5372) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5373) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5374) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5375) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5376) + p.Any_name() + } + { + p.SetState(5377) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5378) + p.Any_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefinitionContext is an interface to support dynamic dispatch. +type IDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Def_list() IDef_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsDefinitionContext differentiates from other interfaces. + IsDefinitionContext() +} + +type DefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefinitionContext() *DefinitionContext { + var p = new(DefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_definition + return p +} + +func InitEmptyDefinitionContext(p *DefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_definition +} + +func (*DefinitionContext) IsDefinitionContext() {} + +func NewDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinitionContext { + var p = new(DefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_definition + + return p +} + +func (s *DefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefinitionContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *DefinitionContext) Def_list() IDef_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDef_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDef_listContext) +} + +func (s *DefinitionContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *DefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDefinition(s) + } +} + +func (s *DefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDefinition(s) + } +} + +func (s *DefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDefinition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Definition() (localctx IDefinitionContext) { + localctx = NewDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, RedshiftParserRULE_definition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5382) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5383) + p.Def_list() + } + { + p.SetState(5384) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDef_listContext is an interface to support dynamic dispatch. +type IDef_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDef_elem() []IDef_elemContext + Def_elem(i int) IDef_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDef_listContext differentiates from other interfaces. + IsDef_listContext() +} + +type Def_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDef_listContext() *Def_listContext { + var p = new(Def_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_def_list + return p +} + +func InitEmptyDef_listContext(p *Def_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_def_list +} + +func (*Def_listContext) IsDef_listContext() {} + +func NewDef_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_listContext { + var p = new(Def_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_def_list + + return p +} + +func (s *Def_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Def_listContext) AllDef_elem() []IDef_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDef_elemContext); ok { + len++ + } + } + + tst := make([]IDef_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDef_elemContext); ok { + tst[i] = t.(IDef_elemContext) + i++ + } + } + + return tst +} + +func (s *Def_listContext) Def_elem(i int) IDef_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDef_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDef_elemContext) +} + +func (s *Def_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Def_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Def_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Def_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDef_list(s) + } +} + +func (s *Def_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDef_list(s) + } +} + +func (s *Def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDef_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Def_list() (localctx IDef_listContext) { + localctx = NewDef_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, RedshiftParserRULE_def_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5386) + p.Def_elem() + } + p.SetState(5391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5387) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5388) + p.Def_elem() + } + + p.SetState(5393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDef_elemContext is an interface to support dynamic dispatch. +type IDef_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Collabel() ICollabelContext + EQUAL() antlr.TerminalNode + Def_arg() IDef_argContext + + // IsDef_elemContext differentiates from other interfaces. + IsDef_elemContext() +} + +type Def_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDef_elemContext() *Def_elemContext { + var p = new(Def_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_def_elem + return p +} + +func InitEmptyDef_elemContext(p *Def_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_def_elem +} + +func (*Def_elemContext) IsDef_elemContext() {} + +func NewDef_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_elemContext { + var p = new(Def_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_def_elem + + return p +} + +func (s *Def_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Def_elemContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Def_elemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Def_elemContext) Def_arg() IDef_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDef_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDef_argContext) +} + +func (s *Def_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Def_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Def_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDef_elem(s) + } +} + +func (s *Def_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDef_elem(s) + } +} + +func (s *Def_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDef_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Def_elem() (localctx IDef_elemContext) { + localctx = NewDef_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, RedshiftParserRULE_def_elem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5394) + p.Collabel() + } + p.SetState(5397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL { + { + p.SetState(5395) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5396) + p.Def_arg() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDef_argContext is an interface to support dynamic dispatch. +type IDef_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_type() IFunc_typeContext + Reserved_keyword() IReserved_keywordContext + Qual_all_op() IQual_all_opContext + Numericonly() INumericonlyContext + Sconst() ISconstContext + NONE() antlr.TerminalNode + + // IsDef_argContext differentiates from other interfaces. + IsDef_argContext() +} + +type Def_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDef_argContext() *Def_argContext { + var p = new(Def_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_def_arg + return p +} + +func InitEmptyDef_argContext(p *Def_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_def_arg +} + +func (*Def_argContext) IsDef_argContext() {} + +func NewDef_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Def_argContext { + var p = new(Def_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_def_arg + + return p +} + +func (s *Def_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Def_argContext) Func_type() IFunc_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_typeContext) +} + +func (s *Def_argContext) Reserved_keyword() IReserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReserved_keywordContext) +} + +func (s *Def_argContext) Qual_all_op() IQual_all_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQual_all_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQual_all_opContext) +} + +func (s *Def_argContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Def_argContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Def_argContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *Def_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Def_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Def_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDef_arg(s) + } +} + +func (s *Def_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDef_arg(s) + } +} + +func (s *Def_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDef_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Def_arg() (localctx IDef_argContext) { + localctx = NewDef_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, RedshiftParserRULE_def_arg) + p.SetState(5405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 359, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5399) + p.Func_type() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5400) + p.Reserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5401) + p.Qual_all_op() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5402) + p.Numericonly() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5403) + p.Sconst() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5404) + p.Match(RedshiftParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOld_aggr_definitionContext is an interface to support dynamic dispatch. +type IOld_aggr_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Old_aggr_list() IOld_aggr_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOld_aggr_definitionContext differentiates from other interfaces. + IsOld_aggr_definitionContext() +} + +type Old_aggr_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOld_aggr_definitionContext() *Old_aggr_definitionContext { + var p = new(Old_aggr_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_old_aggr_definition + return p +} + +func InitEmptyOld_aggr_definitionContext(p *Old_aggr_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_old_aggr_definition +} + +func (*Old_aggr_definitionContext) IsOld_aggr_definitionContext() {} + +func NewOld_aggr_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_definitionContext { + var p = new(Old_aggr_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_old_aggr_definition + + return p +} + +func (s *Old_aggr_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Old_aggr_definitionContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Old_aggr_definitionContext) Old_aggr_list() IOld_aggr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOld_aggr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOld_aggr_listContext) +} + +func (s *Old_aggr_definitionContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Old_aggr_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Old_aggr_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Old_aggr_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOld_aggr_definition(s) + } +} + +func (s *Old_aggr_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOld_aggr_definition(s) + } +} + +func (s *Old_aggr_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOld_aggr_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Old_aggr_definition() (localctx IOld_aggr_definitionContext) { + localctx = NewOld_aggr_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, RedshiftParserRULE_old_aggr_definition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5407) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5408) + p.Old_aggr_list() + } + { + p.SetState(5409) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOld_aggr_listContext is an interface to support dynamic dispatch. +type IOld_aggr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOld_aggr_elem() []IOld_aggr_elemContext + Old_aggr_elem(i int) IOld_aggr_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOld_aggr_listContext differentiates from other interfaces. + IsOld_aggr_listContext() +} + +type Old_aggr_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOld_aggr_listContext() *Old_aggr_listContext { + var p = new(Old_aggr_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_old_aggr_list + return p +} + +func InitEmptyOld_aggr_listContext(p *Old_aggr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_old_aggr_list +} + +func (*Old_aggr_listContext) IsOld_aggr_listContext() {} + +func NewOld_aggr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_listContext { + var p = new(Old_aggr_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_old_aggr_list + + return p +} + +func (s *Old_aggr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Old_aggr_listContext) AllOld_aggr_elem() []IOld_aggr_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOld_aggr_elemContext); ok { + len++ + } + } + + tst := make([]IOld_aggr_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOld_aggr_elemContext); ok { + tst[i] = t.(IOld_aggr_elemContext) + i++ + } + } + + return tst +} + +func (s *Old_aggr_listContext) Old_aggr_elem(i int) IOld_aggr_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOld_aggr_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOld_aggr_elemContext) +} + +func (s *Old_aggr_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Old_aggr_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Old_aggr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Old_aggr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Old_aggr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOld_aggr_list(s) + } +} + +func (s *Old_aggr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOld_aggr_list(s) + } +} + +func (s *Old_aggr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOld_aggr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Old_aggr_list() (localctx IOld_aggr_listContext) { + localctx = NewOld_aggr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, RedshiftParserRULE_old_aggr_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5411) + p.Old_aggr_elem() + } + p.SetState(5416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5412) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5413) + p.Old_aggr_elem() + } + + p.SetState(5418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOld_aggr_elemContext is an interface to support dynamic dispatch. +type IOld_aggr_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + EQUAL() antlr.TerminalNode + Def_arg() IDef_argContext + + // IsOld_aggr_elemContext differentiates from other interfaces. + IsOld_aggr_elemContext() +} + +type Old_aggr_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOld_aggr_elemContext() *Old_aggr_elemContext { + var p = new(Old_aggr_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_old_aggr_elem + return p +} + +func InitEmptyOld_aggr_elemContext(p *Old_aggr_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_old_aggr_elem +} + +func (*Old_aggr_elemContext) IsOld_aggr_elemContext() {} + +func NewOld_aggr_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_aggr_elemContext { + var p = new(Old_aggr_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_old_aggr_elem + + return p +} + +func (s *Old_aggr_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Old_aggr_elemContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Old_aggr_elemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Old_aggr_elemContext) Def_arg() IDef_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDef_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDef_argContext) +} + +func (s *Old_aggr_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Old_aggr_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Old_aggr_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOld_aggr_elem(s) + } +} + +func (s *Old_aggr_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOld_aggr_elem(s) + } +} + +func (s *Old_aggr_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOld_aggr_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Old_aggr_elem() (localctx IOld_aggr_elemContext) { + localctx = NewOld_aggr_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, RedshiftParserRULE_old_aggr_elem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5419) + p.Identifier() + } + { + p.SetState(5420) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5421) + p.Def_arg() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_enum_val_listContext is an interface to support dynamic dispatch. +type IOpt_enum_val_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Enum_val_list() IEnum_val_listContext + + // IsOpt_enum_val_listContext differentiates from other interfaces. + IsOpt_enum_val_listContext() +} + +type Opt_enum_val_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_enum_val_listContext() *Opt_enum_val_listContext { + var p = new(Opt_enum_val_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_enum_val_list + return p +} + +func InitEmptyOpt_enum_val_listContext(p *Opt_enum_val_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_enum_val_list +} + +func (*Opt_enum_val_listContext) IsOpt_enum_val_listContext() {} + +func NewOpt_enum_val_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_enum_val_listContext { + var p = new(Opt_enum_val_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_enum_val_list + + return p +} + +func (s *Opt_enum_val_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_enum_val_listContext) Enum_val_list() IEnum_val_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnum_val_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnum_val_listContext) +} + +func (s *Opt_enum_val_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_enum_val_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_enum_val_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_enum_val_list(s) + } +} + +func (s *Opt_enum_val_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_enum_val_list(s) + } +} + +func (s *Opt_enum_val_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_enum_val_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_enum_val_list() (localctx IOpt_enum_val_listContext) { + localctx = NewOpt_enum_val_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, RedshiftParserRULE_opt_enum_val_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5423) + p.Enum_val_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 +} + +// IEnum_val_listContext is an interface to support dynamic dispatch. +type IEnum_val_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsEnum_val_listContext differentiates from other interfaces. + IsEnum_val_listContext() +} + +type Enum_val_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnum_val_listContext() *Enum_val_listContext { + var p = new(Enum_val_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_enum_val_list + return p +} + +func InitEmptyEnum_val_listContext(p *Enum_val_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_enum_val_list +} + +func (*Enum_val_listContext) IsEnum_val_listContext() {} + +func NewEnum_val_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enum_val_listContext { + var p = new(Enum_val_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_enum_val_list + + return p +} + +func (s *Enum_val_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enum_val_listContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Enum_val_listContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Enum_val_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Enum_val_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Enum_val_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enum_val_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enum_val_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEnum_val_list(s) + } +} + +func (s *Enum_val_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEnum_val_list(s) + } +} + +func (s *Enum_val_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEnum_val_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Enum_val_list() (localctx IEnum_val_listContext) { + localctx = NewEnum_val_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, RedshiftParserRULE_enum_val_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5425) + p.Sconst() + } + p.SetState(5430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5426) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5427) + p.Sconst() + } + + p.SetState(5432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterenumstmtContext is an interface to support dynamic dispatch. +type IAlterenumstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + Any_name() IAny_nameContext + ADD_P() antlr.TerminalNode + VALUE_P() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + Opt_if_not_exists() IOpt_if_not_existsContext + BEFORE() antlr.TerminalNode + AFTER() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + + // IsAlterenumstmtContext differentiates from other interfaces. + IsAlterenumstmtContext() +} + +type AlterenumstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterenumstmtContext() *AlterenumstmtContext { + var p = new(AlterenumstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterenumstmt + return p +} + +func InitEmptyAlterenumstmtContext(p *AlterenumstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterenumstmt +} + +func (*AlterenumstmtContext) IsAlterenumstmtContext() {} + +func NewAlterenumstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterenumstmtContext { + var p = new(AlterenumstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterenumstmt + + return p +} + +func (s *AlterenumstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterenumstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterenumstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *AlterenumstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AlterenumstmtContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *AlterenumstmtContext) VALUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUE_P, 0) +} + +func (s *AlterenumstmtContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *AlterenumstmtContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *AlterenumstmtContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *AlterenumstmtContext) BEFORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEFORE, 0) +} + +func (s *AlterenumstmtContext) AFTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserAFTER, 0) +} + +func (s *AlterenumstmtContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *AlterenumstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AlterenumstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterenumstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterenumstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterenumstmt(s) + } +} + +func (s *AlterenumstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterenumstmt(s) + } +} + +func (s *AlterenumstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterenumstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterenumstmt() (localctx IAlterenumstmtContext) { + localctx = NewAlterenumstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, RedshiftParserRULE_alterenumstmt) + var _la int + + p.SetState(5476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 365, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5433) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5434) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5435) + p.Any_name() + } + { + p.SetState(5436) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5437) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIF_P { + { + p.SetState(5438) + p.Opt_if_not_exists() + } + + } + { + p.SetState(5441) + p.Sconst() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5443) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5444) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5445) + p.Any_name() + } + { + p.SetState(5446) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5447) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIF_P { + { + p.SetState(5448) + p.Opt_if_not_exists() + } + + } + { + p.SetState(5451) + p.Sconst() + } + { + p.SetState(5452) + p.Match(RedshiftParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5453) + p.Sconst() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5455) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5456) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5457) + p.Any_name() + } + { + p.SetState(5458) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5459) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIF_P { + { + p.SetState(5460) + p.Opt_if_not_exists() + } + + } + { + p.SetState(5463) + p.Sconst() + } + { + p.SetState(5464) + p.Match(RedshiftParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5465) + p.Sconst() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5467) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5468) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5469) + p.Any_name() + } + { + p.SetState(5470) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5471) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5472) + p.Sconst() + } + { + p.SetState(5473) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5474) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_if_not_existsContext is an interface to support dynamic dispatch. +type IOpt_if_not_existsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsOpt_if_not_existsContext differentiates from other interfaces. + IsOpt_if_not_existsContext() +} + +type Opt_if_not_existsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_if_not_existsContext() *Opt_if_not_existsContext { + var p = new(Opt_if_not_existsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_if_not_exists + return p +} + +func InitEmptyOpt_if_not_existsContext(p *Opt_if_not_existsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_if_not_exists +} + +func (*Opt_if_not_existsContext) IsOpt_if_not_existsContext() {} + +func NewOpt_if_not_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_not_existsContext { + var p = new(Opt_if_not_existsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_if_not_exists + + return p +} + +func (s *Opt_if_not_existsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_if_not_existsContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *Opt_if_not_existsContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Opt_if_not_existsContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *Opt_if_not_existsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_if_not_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_if_not_existsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_if_not_exists(s) + } +} + +func (s *Opt_if_not_existsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_if_not_exists(s) + } +} + +func (s *Opt_if_not_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_if_not_exists(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_if_not_exists() (localctx IOpt_if_not_existsContext) { + localctx = NewOpt_if_not_existsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, RedshiftParserRULE_opt_if_not_exists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5478) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5479) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5480) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateopclassstmtContext is an interface to support dynamic dispatch. +type ICreateopclassstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + CLASS() antlr.TerminalNode + Any_name() IAny_nameContext + FOR() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + Typename() ITypenameContext + USING() antlr.TerminalNode + Name() INameContext + AS() antlr.TerminalNode + Opclass_item_list() IOpclass_item_listContext + Opt_default() IOpt_defaultContext + Opt_opfamily() IOpt_opfamilyContext + + // IsCreateopclassstmtContext differentiates from other interfaces. + IsCreateopclassstmtContext() +} + +type CreateopclassstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateopclassstmtContext() *CreateopclassstmtContext { + var p = new(CreateopclassstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createopclassstmt + return p +} + +func InitEmptyCreateopclassstmtContext(p *CreateopclassstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createopclassstmt +} + +func (*CreateopclassstmtContext) IsCreateopclassstmtContext() {} + +func NewCreateopclassstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateopclassstmtContext { + var p = new(CreateopclassstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createopclassstmt + + return p +} + +func (s *CreateopclassstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateopclassstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateopclassstmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *CreateopclassstmtContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *CreateopclassstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *CreateopclassstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *CreateopclassstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *CreateopclassstmtContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *CreateopclassstmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *CreateopclassstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateopclassstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CreateopclassstmtContext) Opclass_item_list() IOpclass_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpclass_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpclass_item_listContext) +} + +func (s *CreateopclassstmtContext) Opt_default() IOpt_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_defaultContext) +} + +func (s *CreateopclassstmtContext) Opt_opfamily() IOpt_opfamilyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_opfamilyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_opfamilyContext) +} + +func (s *CreateopclassstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateopclassstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateopclassstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateopclassstmt(s) + } +} + +func (s *CreateopclassstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateopclassstmt(s) + } +} + +func (s *CreateopclassstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateopclassstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createopclassstmt() (localctx ICreateopclassstmtContext) { + localctx = NewCreateopclassstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, RedshiftParserRULE_createopclassstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5482) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5483) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5484) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5485) + p.Any_name() + } + p.SetState(5487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDEFAULT { + { + p.SetState(5486) + p.Opt_default() + } + + } + { + p.SetState(5489) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5490) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5491) + p.Typename() + } + { + p.SetState(5492) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5493) + p.Name() + } + p.SetState(5495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFAMILY { + { + p.SetState(5494) + p.Opt_opfamily() + } + + } + { + p.SetState(5497) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5498) + p.Opclass_item_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpclass_item_listContext is an interface to support dynamic dispatch. +type IOpclass_item_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOpclass_item() []IOpclass_itemContext + Opclass_item(i int) IOpclass_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOpclass_item_listContext differentiates from other interfaces. + IsOpclass_item_listContext() +} + +type Opclass_item_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpclass_item_listContext() *Opclass_item_listContext { + var p = new(Opclass_item_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_item_list + return p +} + +func InitEmptyOpclass_item_listContext(p *Opclass_item_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_item_list +} + +func (*Opclass_item_listContext) IsOpclass_item_listContext() {} + +func NewOpclass_item_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_item_listContext { + var p = new(Opclass_item_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opclass_item_list + + return p +} + +func (s *Opclass_item_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opclass_item_listContext) AllOpclass_item() []IOpclass_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpclass_itemContext); ok { + len++ + } + } + + tst := make([]IOpclass_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpclass_itemContext); ok { + tst[i] = t.(IOpclass_itemContext) + i++ + } + } + + return tst +} + +func (s *Opclass_item_listContext) Opclass_item(i int) IOpclass_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpclass_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpclass_itemContext) +} + +func (s *Opclass_item_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Opclass_item_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Opclass_item_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opclass_item_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opclass_item_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpclass_item_list(s) + } +} + +func (s *Opclass_item_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpclass_item_list(s) + } +} + +func (s *Opclass_item_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpclass_item_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opclass_item_list() (localctx IOpclass_item_listContext) { + localctx = NewOpclass_item_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, RedshiftParserRULE_opclass_item_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5500) + p.Opclass_item() + } + p.SetState(5505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5501) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5502) + p.Opclass_item() + } + + p.SetState(5507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpclass_itemContext is an interface to support dynamic dispatch. +type IOpclass_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPERATOR() antlr.TerminalNode + Iconst() IIconstContext + Any_operator() IAny_operatorContext + Opclass_purpose() IOpclass_purposeContext + Opt_recheck() IOpt_recheckContext + Operator_with_argtypes() IOperator_with_argtypesContext + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + OPEN_PAREN() antlr.TerminalNode + Type_list() IType_listContext + CLOSE_PAREN() antlr.TerminalNode + STORAGE() antlr.TerminalNode + Typename() ITypenameContext + + // IsOpclass_itemContext differentiates from other interfaces. + IsOpclass_itemContext() +} + +type Opclass_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpclass_itemContext() *Opclass_itemContext { + var p = new(Opclass_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_item + return p +} + +func InitEmptyOpclass_itemContext(p *Opclass_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_item +} + +func (*Opclass_itemContext) IsOpclass_itemContext() {} + +func NewOpclass_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_itemContext { + var p = new(Opclass_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opclass_item + + return p +} + +func (s *Opclass_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opclass_itemContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *Opclass_itemContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Opclass_itemContext) Any_operator() IAny_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_operatorContext) +} + +func (s *Opclass_itemContext) Opclass_purpose() IOpclass_purposeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpclass_purposeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpclass_purposeContext) +} + +func (s *Opclass_itemContext) Opt_recheck() IOpt_recheckContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_recheckContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_recheckContext) +} + +func (s *Opclass_itemContext) Operator_with_argtypes() IOperator_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypesContext) +} + +func (s *Opclass_itemContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Opclass_itemContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *Opclass_itemContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opclass_itemContext) Type_list() IType_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_listContext) +} + +func (s *Opclass_itemContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opclass_itemContext) STORAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTORAGE, 0) +} + +func (s *Opclass_itemContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Opclass_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opclass_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opclass_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpclass_item(s) + } +} + +func (s *Opclass_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpclass_item(s) + } +} + +func (s *Opclass_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpclass_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opclass_item() (localctx IOpclass_itemContext) { + localctx = NewOpclass_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, RedshiftParserRULE_opclass_item) + var _la int + + p.SetState(5539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 373, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5508) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5509) + p.Iconst() + } + { + p.SetState(5510) + p.Any_operator() + } + p.SetState(5512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(5511) + p.Opclass_purpose() + } + + } + p.SetState(5515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRECHECK { + { + p.SetState(5514) + p.Opt_recheck() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5517) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5518) + p.Iconst() + } + { + p.SetState(5519) + p.Operator_with_argtypes() + } + p.SetState(5521) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(5520) + p.Opclass_purpose() + } + + } + p.SetState(5524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRECHECK { + { + p.SetState(5523) + p.Opt_recheck() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5526) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5527) + p.Iconst() + } + { + p.SetState(5528) + p.Function_with_argtypes() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5530) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5531) + p.Iconst() + } + { + p.SetState(5532) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5533) + p.Type_list() + } + { + p.SetState(5534) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5535) + p.Function_with_argtypes() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5537) + p.Match(RedshiftParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5538) + p.Typename() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_defaultContext is an interface to support dynamic dispatch. +type IOpt_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + + // IsOpt_defaultContext differentiates from other interfaces. + IsOpt_defaultContext() +} + +type Opt_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_defaultContext() *Opt_defaultContext { + var p = new(Opt_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_default + return p +} + +func InitEmptyOpt_defaultContext(p *Opt_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_default +} + +func (*Opt_defaultContext) IsOpt_defaultContext() {} + +func NewOpt_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_defaultContext { + var p = new(Opt_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_default + + return p +} + +func (s *Opt_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_defaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Opt_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_default(s) + } +} + +func (s *Opt_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_default(s) + } +} + +func (s *Opt_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_default() (localctx IOpt_defaultContext) { + localctx = NewOpt_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, RedshiftParserRULE_opt_default) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5541) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_opfamilyContext is an interface to support dynamic dispatch. +type IOpt_opfamilyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FAMILY() antlr.TerminalNode + Any_name() IAny_nameContext + + // IsOpt_opfamilyContext differentiates from other interfaces. + IsOpt_opfamilyContext() +} + +type Opt_opfamilyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_opfamilyContext() *Opt_opfamilyContext { + var p = new(Opt_opfamilyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_opfamily + return p +} + +func InitEmptyOpt_opfamilyContext(p *Opt_opfamilyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_opfamily +} + +func (*Opt_opfamilyContext) IsOpt_opfamilyContext() {} + +func NewOpt_opfamilyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_opfamilyContext { + var p = new(Opt_opfamilyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_opfamily + + return p +} + +func (s *Opt_opfamilyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_opfamilyContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *Opt_opfamilyContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Opt_opfamilyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_opfamilyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_opfamilyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_opfamily(s) + } +} + +func (s *Opt_opfamilyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_opfamily(s) + } +} + +func (s *Opt_opfamilyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_opfamily(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_opfamily() (localctx IOpt_opfamilyContext) { + localctx = NewOpt_opfamilyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, RedshiftParserRULE_opt_opfamily) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5543) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5544) + p.Any_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpclass_purposeContext is an interface to support dynamic dispatch. +type IOpclass_purposeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + SEARCH() antlr.TerminalNode + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + Any_name() IAny_nameContext + + // IsOpclass_purposeContext differentiates from other interfaces. + IsOpclass_purposeContext() +} + +type Opclass_purposeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpclass_purposeContext() *Opclass_purposeContext { + var p = new(Opclass_purposeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_purpose + return p +} + +func InitEmptyOpclass_purposeContext(p *Opclass_purposeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_purpose +} + +func (*Opclass_purposeContext) IsOpclass_purposeContext() {} + +func NewOpclass_purposeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_purposeContext { + var p = new(Opclass_purposeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opclass_purpose + + return p +} + +func (s *Opclass_purposeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opclass_purposeContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Opclass_purposeContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *Opclass_purposeContext) ORDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserORDER, 0) +} + +func (s *Opclass_purposeContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Opclass_purposeContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Opclass_purposeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opclass_purposeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opclass_purposeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpclass_purpose(s) + } +} + +func (s *Opclass_purposeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpclass_purpose(s) + } +} + +func (s *Opclass_purposeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpclass_purpose(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opclass_purpose() (localctx IOpclass_purposeContext) { + localctx = NewOpclass_purposeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, RedshiftParserRULE_opclass_purpose) + p.SetState(5552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 374, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5546) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5547) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5548) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5549) + p.Match(RedshiftParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5550) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5551) + p.Any_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_recheckContext is an interface to support dynamic dispatch. +type IOpt_recheckContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECHECK() antlr.TerminalNode + + // IsOpt_recheckContext differentiates from other interfaces. + IsOpt_recheckContext() +} + +type Opt_recheckContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_recheckContext() *Opt_recheckContext { + var p = new(Opt_recheckContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_recheck + return p +} + +func InitEmptyOpt_recheckContext(p *Opt_recheckContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_recheck +} + +func (*Opt_recheckContext) IsOpt_recheckContext() {} + +func NewOpt_recheckContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_recheckContext { + var p = new(Opt_recheckContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_recheck + + return p +} + +func (s *Opt_recheckContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_recheckContext) RECHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserRECHECK, 0) +} + +func (s *Opt_recheckContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_recheckContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_recheckContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_recheck(s) + } +} + +func (s *Opt_recheckContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_recheck(s) + } +} + +func (s *Opt_recheckContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_recheck(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_recheck() (localctx IOpt_recheckContext) { + localctx = NewOpt_recheckContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, RedshiftParserRULE_opt_recheck) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5554) + p.Match(RedshiftParserRECHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateopfamilystmtContext is an interface to support dynamic dispatch. +type ICreateopfamilystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + FAMILY() antlr.TerminalNode + Any_name() IAny_nameContext + USING() antlr.TerminalNode + Name() INameContext + + // IsCreateopfamilystmtContext differentiates from other interfaces. + IsCreateopfamilystmtContext() +} + +type CreateopfamilystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateopfamilystmtContext() *CreateopfamilystmtContext { + var p = new(CreateopfamilystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createopfamilystmt + return p +} + +func InitEmptyCreateopfamilystmtContext(p *CreateopfamilystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createopfamilystmt +} + +func (*CreateopfamilystmtContext) IsCreateopfamilystmtContext() {} + +func NewCreateopfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateopfamilystmtContext { + var p = new(CreateopfamilystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createopfamilystmt + + return p +} + +func (s *CreateopfamilystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateopfamilystmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateopfamilystmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *CreateopfamilystmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *CreateopfamilystmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *CreateopfamilystmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *CreateopfamilystmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreateopfamilystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateopfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateopfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateopfamilystmt(s) + } +} + +func (s *CreateopfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateopfamilystmt(s) + } +} + +func (s *CreateopfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateopfamilystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createopfamilystmt() (localctx ICreateopfamilystmtContext) { + localctx = NewCreateopfamilystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, RedshiftParserRULE_createopfamilystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5556) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5557) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5558) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5559) + p.Any_name() + } + { + p.SetState(5560) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5561) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlteropfamilystmtContext is an interface to support dynamic dispatch. +type IAlteropfamilystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + FAMILY() antlr.TerminalNode + Any_name() IAny_nameContext + USING() antlr.TerminalNode + Name() INameContext + ADD_P() antlr.TerminalNode + Opclass_item_list() IOpclass_item_listContext + DROP() antlr.TerminalNode + Opclass_drop_list() IOpclass_drop_listContext + + // IsAlteropfamilystmtContext differentiates from other interfaces. + IsAlteropfamilystmtContext() +} + +type AlteropfamilystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlteropfamilystmtContext() *AlteropfamilystmtContext { + var p = new(AlteropfamilystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteropfamilystmt + return p +} + +func InitEmptyAlteropfamilystmtContext(p *AlteropfamilystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteropfamilystmt +} + +func (*AlteropfamilystmtContext) IsAlteropfamilystmtContext() {} + +func NewAlteropfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteropfamilystmtContext { + var p = new(AlteropfamilystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteropfamilystmt + + return p +} + +func (s *AlteropfamilystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteropfamilystmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlteropfamilystmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *AlteropfamilystmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *AlteropfamilystmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AlteropfamilystmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *AlteropfamilystmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlteropfamilystmtContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *AlteropfamilystmtContext) Opclass_item_list() IOpclass_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpclass_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpclass_item_listContext) +} + +func (s *AlteropfamilystmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *AlteropfamilystmtContext) Opclass_drop_list() IOpclass_drop_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpclass_drop_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpclass_drop_listContext) +} + +func (s *AlteropfamilystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteropfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteropfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteropfamilystmt(s) + } +} + +func (s *AlteropfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteropfamilystmt(s) + } +} + +func (s *AlteropfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteropfamilystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteropfamilystmt() (localctx IAlteropfamilystmtContext) { + localctx = NewAlteropfamilystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, RedshiftParserRULE_alteropfamilystmt) + p.SetState(5581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 375, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5563) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5564) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5565) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5566) + p.Any_name() + } + { + p.SetState(5567) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5568) + p.Name() + } + { + p.SetState(5569) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5570) + p.Opclass_item_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5572) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5573) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5574) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5575) + p.Any_name() + } + { + p.SetState(5576) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5577) + p.Name() + } + { + p.SetState(5578) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5579) + p.Opclass_drop_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpclass_drop_listContext is an interface to support dynamic dispatch. +type IOpclass_drop_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOpclass_drop() []IOpclass_dropContext + Opclass_drop(i int) IOpclass_dropContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOpclass_drop_listContext differentiates from other interfaces. + IsOpclass_drop_listContext() +} + +type Opclass_drop_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpclass_drop_listContext() *Opclass_drop_listContext { + var p = new(Opclass_drop_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_drop_list + return p +} + +func InitEmptyOpclass_drop_listContext(p *Opclass_drop_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_drop_list +} + +func (*Opclass_drop_listContext) IsOpclass_drop_listContext() {} + +func NewOpclass_drop_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_drop_listContext { + var p = new(Opclass_drop_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opclass_drop_list + + return p +} + +func (s *Opclass_drop_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opclass_drop_listContext) AllOpclass_drop() []IOpclass_dropContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpclass_dropContext); ok { + len++ + } + } + + tst := make([]IOpclass_dropContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpclass_dropContext); ok { + tst[i] = t.(IOpclass_dropContext) + i++ + } + } + + return tst +} + +func (s *Opclass_drop_listContext) Opclass_drop(i int) IOpclass_dropContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpclass_dropContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpclass_dropContext) +} + +func (s *Opclass_drop_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Opclass_drop_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Opclass_drop_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opclass_drop_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opclass_drop_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpclass_drop_list(s) + } +} + +func (s *Opclass_drop_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpclass_drop_list(s) + } +} + +func (s *Opclass_drop_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpclass_drop_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opclass_drop_list() (localctx IOpclass_drop_listContext) { + localctx = NewOpclass_drop_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, RedshiftParserRULE_opclass_drop_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5583) + p.Opclass_drop() + } + p.SetState(5588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5584) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5585) + p.Opclass_drop() + } + + p.SetState(5590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpclass_dropContext is an interface to support dynamic dispatch. +type IOpclass_dropContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPERATOR() antlr.TerminalNode + Iconst() IIconstContext + OPEN_PAREN() antlr.TerminalNode + Type_list() IType_listContext + CLOSE_PAREN() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + + // IsOpclass_dropContext differentiates from other interfaces. + IsOpclass_dropContext() +} + +type Opclass_dropContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpclass_dropContext() *Opclass_dropContext { + var p = new(Opclass_dropContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_drop + return p +} + +func InitEmptyOpclass_dropContext(p *Opclass_dropContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opclass_drop +} + +func (*Opclass_dropContext) IsOpclass_dropContext() {} + +func NewOpclass_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opclass_dropContext { + var p = new(Opclass_dropContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opclass_drop + + return p +} + +func (s *Opclass_dropContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opclass_dropContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *Opclass_dropContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Opclass_dropContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opclass_dropContext) Type_list() IType_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_listContext) +} + +func (s *Opclass_dropContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opclass_dropContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Opclass_dropContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opclass_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opclass_dropContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpclass_drop(s) + } +} + +func (s *Opclass_dropContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpclass_drop(s) + } +} + +func (s *Opclass_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpclass_drop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opclass_drop() (localctx IOpclass_dropContext) { + localctx = NewOpclass_dropContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, RedshiftParserRULE_opclass_drop) + p.SetState(5603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPERATOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5591) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5592) + p.Iconst() + } + { + p.SetState(5593) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5594) + p.Type_list() + } + { + p.SetState(5595) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFUNCTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5597) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5598) + p.Iconst() + } + { + p.SetState(5599) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5600) + p.Type_list() + } + { + p.SetState(5601) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropopclassstmtContext is an interface to support dynamic dispatch. +type IDropopclassstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + CLASS() antlr.TerminalNode + Any_name() IAny_nameContext + USING() antlr.TerminalNode + Name() INameContext + Opt_drop_behavior() IOpt_drop_behaviorContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDropopclassstmtContext differentiates from other interfaces. + IsDropopclassstmtContext() +} + +type DropopclassstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropopclassstmtContext() *DropopclassstmtContext { + var p = new(DropopclassstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropopclassstmt + return p +} + +func InitEmptyDropopclassstmtContext(p *DropopclassstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropopclassstmt +} + +func (*DropopclassstmtContext) IsDropopclassstmtContext() {} + +func NewDropopclassstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropopclassstmtContext { + var p = new(DropopclassstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropopclassstmt + + return p +} + +func (s *DropopclassstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropopclassstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropopclassstmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *DropopclassstmtContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *DropopclassstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *DropopclassstmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *DropopclassstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DropopclassstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DropopclassstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *DropopclassstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *DropopclassstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropopclassstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropopclassstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropopclassstmt(s) + } +} + +func (s *DropopclassstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropopclassstmt(s) + } +} + +func (s *DropopclassstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropopclassstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropopclassstmt() (localctx IDropopclassstmtContext) { + localctx = NewDropopclassstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, RedshiftParserRULE_dropopclassstmt) + var _la int + + p.SetState(5625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 380, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5605) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5606) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5607) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5608) + p.Any_name() + } + { + p.SetState(5609) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5610) + p.Name() + } + p.SetState(5612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5611) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5614) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5615) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5616) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5617) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5618) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5619) + p.Any_name() + } + { + p.SetState(5620) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5621) + p.Name() + } + p.SetState(5623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5622) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropopfamilystmtContext is an interface to support dynamic dispatch. +type IDropopfamilystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + FAMILY() antlr.TerminalNode + Any_name() IAny_nameContext + USING() antlr.TerminalNode + Name() INameContext + Opt_drop_behavior() IOpt_drop_behaviorContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDropopfamilystmtContext differentiates from other interfaces. + IsDropopfamilystmtContext() +} + +type DropopfamilystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropopfamilystmtContext() *DropopfamilystmtContext { + var p = new(DropopfamilystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropopfamilystmt + return p +} + +func InitEmptyDropopfamilystmtContext(p *DropopfamilystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropopfamilystmt +} + +func (*DropopfamilystmtContext) IsDropopfamilystmtContext() {} + +func NewDropopfamilystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropopfamilystmtContext { + var p = new(DropopfamilystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropopfamilystmt + + return p +} + +func (s *DropopfamilystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropopfamilystmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropopfamilystmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *DropopfamilystmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *DropopfamilystmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *DropopfamilystmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *DropopfamilystmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DropopfamilystmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DropopfamilystmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *DropopfamilystmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *DropopfamilystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropopfamilystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropopfamilystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropopfamilystmt(s) + } +} + +func (s *DropopfamilystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropopfamilystmt(s) + } +} + +func (s *DropopfamilystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropopfamilystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropopfamilystmt() (localctx IDropopfamilystmtContext) { + localctx = NewDropopfamilystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, RedshiftParserRULE_dropopfamilystmt) + var _la int + + p.SetState(5647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 383, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5627) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5628) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5629) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5630) + p.Any_name() + } + { + p.SetState(5631) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5632) + p.Name() + } + p.SetState(5634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5633) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5636) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5637) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5638) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5639) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5640) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5641) + p.Any_name() + } + { + p.SetState(5642) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5643) + p.Name() + } + p.SetState(5645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5644) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropownedstmtContext is an interface to support dynamic dispatch. +type IDropownedstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + OWNED() antlr.TerminalNode + BY() antlr.TerminalNode + Role_list() IRole_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsDropownedstmtContext differentiates from other interfaces. + IsDropownedstmtContext() +} + +type DropownedstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropownedstmtContext() *DropownedstmtContext { + var p = new(DropownedstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropownedstmt + return p +} + +func InitEmptyDropownedstmtContext(p *DropownedstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropownedstmt +} + +func (*DropownedstmtContext) IsDropownedstmtContext() {} + +func NewDropownedstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropownedstmtContext { + var p = new(DropownedstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropownedstmt + + return p +} + +func (s *DropownedstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropownedstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropownedstmtContext) OWNED() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNED, 0) +} + +func (s *DropownedstmtContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *DropownedstmtContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *DropownedstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DropownedstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropownedstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropownedstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropownedstmt(s) + } +} + +func (s *DropownedstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropownedstmt(s) + } +} + +func (s *DropownedstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropownedstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropownedstmt() (localctx IDropownedstmtContext) { + localctx = NewDropownedstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, RedshiftParserRULE_dropownedstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5649) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5650) + p.Match(RedshiftParserOWNED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5651) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5652) + p.Role_list() + } + p.SetState(5654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5653) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReassignownedstmtContext is an interface to support dynamic dispatch. +type IReassignownedstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REASSIGN() antlr.TerminalNode + OWNED() antlr.TerminalNode + BY() antlr.TerminalNode + Role_list() IRole_listContext + TO() antlr.TerminalNode + Rolespec() IRolespecContext + + // IsReassignownedstmtContext differentiates from other interfaces. + IsReassignownedstmtContext() +} + +type ReassignownedstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReassignownedstmtContext() *ReassignownedstmtContext { + var p = new(ReassignownedstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reassignownedstmt + return p +} + +func InitEmptyReassignownedstmtContext(p *ReassignownedstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reassignownedstmt +} + +func (*ReassignownedstmtContext) IsReassignownedstmtContext() {} + +func NewReassignownedstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReassignownedstmtContext { + var p = new(ReassignownedstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reassignownedstmt + + return p +} + +func (s *ReassignownedstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReassignownedstmtContext) REASSIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserREASSIGN, 0) +} + +func (s *ReassignownedstmtContext) OWNED() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNED, 0) +} + +func (s *ReassignownedstmtContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *ReassignownedstmtContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *ReassignownedstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *ReassignownedstmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *ReassignownedstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReassignownedstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReassignownedstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReassignownedstmt(s) + } +} + +func (s *ReassignownedstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReassignownedstmt(s) + } +} + +func (s *ReassignownedstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReassignownedstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reassignownedstmt() (localctx IReassignownedstmtContext) { + localctx = NewReassignownedstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, RedshiftParserRULE_reassignownedstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5656) + p.Match(RedshiftParserREASSIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5657) + p.Match(RedshiftParserOWNED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5658) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5659) + p.Role_list() + } + { + p.SetState(5660) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5661) + p.Rolespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropstmtContext is an interface to support dynamic dispatch. +type IDropstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + Object_type_any_name() IObject_type_any_nameContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Any_name_list() IAny_name_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + Drop_type_name() IDrop_type_nameContext + Name_list() IName_listContext + Object_type_name_on_any_name() IObject_type_name_on_any_nameContext + Name() INameContext + ON() antlr.TerminalNode + Any_name() IAny_nameContext + TYPE_P() antlr.TerminalNode + Type_name_list() IType_name_listContext + DOMAIN_P() antlr.TerminalNode + INDEX() antlr.TerminalNode + CONCURRENTLY() antlr.TerminalNode + + // IsDropstmtContext differentiates from other interfaces. + IsDropstmtContext() +} + +type DropstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropstmtContext() *DropstmtContext { + var p = new(DropstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropstmt + return p +} + +func InitEmptyDropstmtContext(p *DropstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropstmt +} + +func (*DropstmtContext) IsDropstmtContext() {} + +func NewDropstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropstmtContext { + var p = new(DropstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropstmt + + return p +} + +func (s *DropstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropstmtContext) Object_type_any_name() IObject_type_any_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_any_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_any_nameContext) +} + +func (s *DropstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *DropstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *DropstmtContext) Any_name_list() IAny_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_name_listContext) +} + +func (s *DropstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DropstmtContext) Drop_type_name() IDrop_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_type_nameContext) +} + +func (s *DropstmtContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *DropstmtContext) Object_type_name_on_any_name() IObject_type_name_on_any_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_name_on_any_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_name_on_any_nameContext) +} + +func (s *DropstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DropstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *DropstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *DropstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *DropstmtContext) Type_name_list() IType_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_name_listContext) +} + +func (s *DropstmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *DropstmtContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *DropstmtContext) CONCURRENTLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONCURRENTLY, 0) +} + +func (s *DropstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropstmt(s) + } +} + +func (s *DropstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropstmt(s) + } +} + +func (s *DropstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropstmt() (localctx IDropstmtContext) { + localctx = NewDropstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 554, RedshiftParserRULE_dropstmt) + var _la int + + p.SetState(5753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 397, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5663) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5664) + p.Object_type_any_name() + } + { + p.SetState(5665) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5666) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5667) + p.Any_name_list() + } + p.SetState(5669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5668) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5671) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5672) + p.Object_type_any_name() + } + { + p.SetState(5673) + p.Any_name_list() + } + p.SetState(5675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5674) + p.Opt_drop_behavior() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5677) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5678) + p.Drop_type_name() + } + { + p.SetState(5679) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5680) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5681) + p.Name_list() + } + p.SetState(5683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5682) + p.Opt_drop_behavior() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5685) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5686) + p.Drop_type_name() + } + { + p.SetState(5687) + p.Name_list() + } + p.SetState(5689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5688) + p.Opt_drop_behavior() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5691) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5692) + p.Object_type_name_on_any_name() + } + { + p.SetState(5693) + p.Name() + } + { + p.SetState(5694) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5695) + p.Any_name() + } + p.SetState(5697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5696) + p.Opt_drop_behavior() + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5699) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5700) + p.Object_type_name_on_any_name() + } + { + p.SetState(5701) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5702) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5703) + p.Name() + } + { + p.SetState(5704) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5705) + p.Any_name() + } + p.SetState(5707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5706) + p.Opt_drop_behavior() + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5709) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5710) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5711) + p.Type_name_list() + } + p.SetState(5713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5712) + p.Opt_drop_behavior() + } + + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5715) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5716) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5717) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5718) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5719) + p.Type_name_list() + } + p.SetState(5721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5720) + p.Opt_drop_behavior() + } + + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5723) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5724) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5725) + p.Type_name_list() + } + p.SetState(5727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5726) + p.Opt_drop_behavior() + } + + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5729) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5730) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5731) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5732) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5733) + p.Type_name_list() + } + p.SetState(5735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5734) + p.Opt_drop_behavior() + } + + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5737) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5738) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5739) + p.Match(RedshiftParserCONCURRENTLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5740) + p.Any_name_list() + } + p.SetState(5742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5741) + p.Opt_drop_behavior() + } + + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5744) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5745) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5746) + p.Match(RedshiftParserCONCURRENTLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5747) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5748) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5749) + p.Any_name_list() + } + p.SetState(5751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5750) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_type_any_nameContext is an interface to support dynamic dispatch. +type IObject_type_any_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + VIEW() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + INDEX() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + COLLATION() antlr.TerminalNode + CONVERSION_P() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + TEXT_P() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PARSER() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + + // IsObject_type_any_nameContext differentiates from other interfaces. + IsObject_type_any_nameContext() +} + +type Object_type_any_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_type_any_nameContext() *Object_type_any_nameContext { + var p = new(Object_type_any_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_object_type_any_name + return p +} + +func InitEmptyObject_type_any_nameContext(p *Object_type_any_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_object_type_any_name +} + +func (*Object_type_any_nameContext) IsObject_type_any_nameContext() {} + +func NewObject_type_any_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_any_nameContext { + var p = new(Object_type_any_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_object_type_any_name + + return p +} + +func (s *Object_type_any_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_any_nameContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Object_type_any_nameContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *Object_type_any_nameContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *Object_type_any_nameContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *Object_type_any_nameContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *Object_type_any_nameContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *Object_type_any_nameContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *Object_type_any_nameContext) CONVERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONVERSION_P, 0) +} + +func (s *Object_type_any_nameContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *Object_type_any_nameContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *Object_type_any_nameContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *Object_type_any_nameContext) PARSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARSER, 0) +} + +func (s *Object_type_any_nameContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDICTIONARY, 0) +} + +func (s *Object_type_any_nameContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPLATE, 0) +} + +func (s *Object_type_any_nameContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFIGURATION, 0) +} + +func (s *Object_type_any_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_any_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterObject_type_any_name(s) + } +} + +func (s *Object_type_any_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitObject_type_any_name(s) + } +} + +func (s *Object_type_any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitObject_type_any_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Object_type_any_name() (localctx IObject_type_any_nameContext) { + localctx = NewObject_type_any_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 556, RedshiftParserRULE_object_type_any_name) + p.SetState(5778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 398, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5755) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5756) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5757) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5758) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5759) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5760) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5761) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5762) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5763) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5764) + p.Match(RedshiftParserCONVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5765) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5766) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5767) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5768) + p.Match(RedshiftParserPARSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5769) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5770) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5771) + p.Match(RedshiftParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5772) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5773) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5774) + p.Match(RedshiftParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5775) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5776) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5777) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_type_nameContext is an interface to support dynamic dispatch. +type IObject_type_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Drop_type_name() IDrop_type_nameContext + SCHEMA() antlr.TerminalNode + DATABASE() antlr.TerminalNode + ROLE() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + + // IsObject_type_nameContext differentiates from other interfaces. + IsObject_type_nameContext() +} + +type Object_type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_type_nameContext() *Object_type_nameContext { + var p = new(Object_type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_object_type_name + return p +} + +func InitEmptyObject_type_nameContext(p *Object_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_object_type_name +} + +func (*Object_type_nameContext) IsObject_type_nameContext() {} + +func NewObject_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_nameContext { + var p = new(Object_type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_object_type_name + + return p +} + +func (s *Object_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_nameContext) Drop_type_name() IDrop_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_type_nameContext) +} + +func (s *Object_type_nameContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Object_type_nameContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Object_type_nameContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Object_type_nameContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSCRIPTION, 0) +} + +func (s *Object_type_nameContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *Object_type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterObject_type_name(s) + } +} + +func (s *Object_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitObject_type_name(s) + } +} + +func (s *Object_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitObject_type_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Object_type_name() (localctx IObject_type_nameContext) { + localctx = NewObject_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 558, RedshiftParserRULE_object_type_name) + p.SetState(5786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserFOREIGN, RedshiftParserACCESS, RedshiftParserEVENT, RedshiftParserEXTENSION, RedshiftParserLANGUAGE, RedshiftParserPROCEDURAL, RedshiftParserSERVER, RedshiftParserPUBLICATION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5780) + p.Drop_type_name() + } + + case RedshiftParserSCHEMA: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5781) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDATABASE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5782) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserROLE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5783) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSUBSCRIPTION: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5784) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserTABLESPACE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5785) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_type_nameContext is an interface to support dynamic dispatch. +type IDrop_type_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACCESS() antlr.TerminalNode + METHOD() antlr.TerminalNode + EVENT() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + DATA_P() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + Opt_procedural() IOpt_proceduralContext + PUBLICATION() antlr.TerminalNode + SERVER() antlr.TerminalNode + + // IsDrop_type_nameContext differentiates from other interfaces. + IsDrop_type_nameContext() +} + +type Drop_type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_type_nameContext() *Drop_type_nameContext { + var p = new(Drop_type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_drop_type_name + return p +} + +func InitEmptyDrop_type_nameContext(p *Drop_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_drop_type_name +} + +func (*Drop_type_nameContext) IsDrop_type_nameContext() {} + +func NewDrop_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_type_nameContext { + var p = new(Drop_type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_drop_type_name + + return p +} + +func (s *Drop_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_type_nameContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *Drop_type_nameContext) METHOD() antlr.TerminalNode { + return s.GetToken(RedshiftParserMETHOD, 0) +} + +func (s *Drop_type_nameContext) EVENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVENT, 0) +} + +func (s *Drop_type_nameContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *Drop_type_nameContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *Drop_type_nameContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *Drop_type_nameContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *Drop_type_nameContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *Drop_type_nameContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *Drop_type_nameContext) Opt_procedural() IOpt_proceduralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_proceduralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_proceduralContext) +} + +func (s *Drop_type_nameContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *Drop_type_nameContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *Drop_type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDrop_type_name(s) + } +} + +func (s *Drop_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDrop_type_name(s) + } +} + +func (s *Drop_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDrop_type_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Drop_type_name() (localctx IDrop_type_nameContext) { + localctx = NewDrop_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 560, RedshiftParserRULE_drop_type_name) + var _la int + + p.SetState(5802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserACCESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5788) + p.Match(RedshiftParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5789) + p.Match(RedshiftParserMETHOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEVENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5790) + p.Match(RedshiftParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5791) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEXTENSION: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5792) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFOREIGN: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5793) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5794) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5795) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserLANGUAGE, RedshiftParserPROCEDURAL: + p.EnterOuterAlt(localctx, 5) + p.SetState(5797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROCEDURAL { + { + p.SetState(5796) + p.Opt_procedural() + } + + } + { + p.SetState(5799) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserPUBLICATION: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5800) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSERVER: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5801) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_type_name_on_any_nameContext is an interface to support dynamic dispatch. +type IObject_type_name_on_any_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + POLICY() antlr.TerminalNode + RULE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + + // IsObject_type_name_on_any_nameContext differentiates from other interfaces. + IsObject_type_name_on_any_nameContext() +} + +type Object_type_name_on_any_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_type_name_on_any_nameContext() *Object_type_name_on_any_nameContext { + var p = new(Object_type_name_on_any_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_object_type_name_on_any_name + return p +} + +func InitEmptyObject_type_name_on_any_nameContext(p *Object_type_name_on_any_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_object_type_name_on_any_name +} + +func (*Object_type_name_on_any_nameContext) IsObject_type_name_on_any_nameContext() {} + +func NewObject_type_name_on_any_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_name_on_any_nameContext { + var p = new(Object_type_name_on_any_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_object_type_name_on_any_name + + return p +} + +func (s *Object_type_name_on_any_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_name_on_any_nameContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *Object_type_name_on_any_nameContext) RULE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRULE, 0) +} + +func (s *Object_type_name_on_any_nameContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *Object_type_name_on_any_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_name_on_any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_name_on_any_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterObject_type_name_on_any_name(s) + } +} + +func (s *Object_type_name_on_any_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitObject_type_name_on_any_name(s) + } +} + +func (s *Object_type_name_on_any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitObject_type_name_on_any_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Object_type_name_on_any_name() (localctx IObject_type_name_on_any_nameContext) { + localctx = NewObject_type_name_on_any_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 562, RedshiftParserRULE_object_type_name_on_any_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5804) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserRULE || _la == RedshiftParserTRIGGER || _la == RedshiftParserPOLICY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAny_name_listContext is an interface to support dynamic dispatch. +type IAny_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAny_name() []IAny_nameContext + Any_name(i int) IAny_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAny_name_listContext differentiates from other interfaces. + IsAny_name_listContext() +} + +type Any_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAny_name_listContext() *Any_name_listContext { + var p = new(Any_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_name_list + return p +} + +func InitEmptyAny_name_listContext(p *Any_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_name_list +} + +func (*Any_name_listContext) IsAny_name_listContext() {} + +func NewAny_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_name_listContext { + var p = new(Any_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_any_name_list + + return p +} + +func (s *Any_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Any_name_listContext) AllAny_name() []IAny_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAny_nameContext); ok { + len++ + } + } + + tst := make([]IAny_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAny_nameContext); ok { + tst[i] = t.(IAny_nameContext) + i++ + } + } + + return tst +} + +func (s *Any_name_listContext) Any_name(i int) IAny_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Any_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Any_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Any_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Any_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Any_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAny_name_list(s) + } +} + +func (s *Any_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAny_name_list(s) + } +} + +func (s *Any_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAny_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Any_name_list() (localctx IAny_name_listContext) { + localctx = NewAny_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 564, RedshiftParserRULE_any_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5806) + p.Any_name() + } + p.SetState(5811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5807) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5808) + p.Any_name() + } + + p.SetState(5813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAny_nameContext is an interface to support dynamic dispatch. +type IAny_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Attrs() IAttrsContext + + // IsAny_nameContext differentiates from other interfaces. + IsAny_nameContext() +} + +type Any_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAny_nameContext() *Any_nameContext { + var p = new(Any_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_name + return p +} + +func InitEmptyAny_nameContext(p *Any_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_name +} + +func (*Any_nameContext) IsAny_nameContext() {} + +func NewAny_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_nameContext { + var p = new(Any_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_any_name + + return p +} + +func (s *Any_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Any_nameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Any_nameContext) Attrs() IAttrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttrsContext) +} + +func (s *Any_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Any_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Any_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAny_name(s) + } +} + +func (s *Any_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAny_name(s) + } +} + +func (s *Any_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAny_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Any_name() (localctx IAny_nameContext) { + localctx = NewAny_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 566, RedshiftParserRULE_any_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5814) + p.Colid() + } + p.SetState(5816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDOT { + { + p.SetState(5815) + p.Attrs() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttrsContext is an interface to support dynamic dispatch. +type IAttrsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllAttr_name() []IAttr_nameContext + Attr_name(i int) IAttr_nameContext + + // IsAttrsContext differentiates from other interfaces. + IsAttrsContext() +} + +type AttrsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttrsContext() *AttrsContext { + var p = new(AttrsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attrs + return p +} + +func InitEmptyAttrsContext(p *AttrsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attrs +} + +func (*AttrsContext) IsAttrsContext() {} + +func NewAttrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttrsContext { + var p = new(AttrsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attrs + + return p +} + +func (s *AttrsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AttrsContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserDOT) +} + +func (s *AttrsContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, i) +} + +func (s *AttrsContext) AllAttr_name() []IAttr_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttr_nameContext); ok { + len++ + } + } + + tst := make([]IAttr_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttr_nameContext); ok { + tst[i] = t.(IAttr_nameContext) + i++ + } + } + + return tst +} + +func (s *AttrsContext) Attr_name(i int) IAttr_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttr_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttr_nameContext) +} + +func (s *AttrsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AttrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AttrsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttrs(s) + } +} + +func (s *AttrsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttrs(s) + } +} + +func (s *AttrsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttrs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attrs() (localctx IAttrsContext) { + localctx = NewAttrsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 568, RedshiftParserRULE_attrs) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5820) + 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(5818) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5819) + p.Attr_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5822) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 404, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_name_listContext is an interface to support dynamic dispatch. +type IType_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsType_name_listContext differentiates from other interfaces. + IsType_name_listContext() +} + +type Type_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_name_listContext() *Type_name_listContext { + var p = new(Type_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_name_list + return p +} + +func InitEmptyType_name_listContext(p *Type_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_name_list +} + +func (*Type_name_listContext) IsType_name_listContext() {} + +func NewType_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_name_listContext { + var p = new(Type_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_type_name_list + + return p +} + +func (s *Type_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_name_listContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *Type_name_listContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Type_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Type_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Type_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterType_name_list(s) + } +} + +func (s *Type_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitType_name_list(s) + } +} + +func (s *Type_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitType_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Type_name_list() (localctx IType_name_listContext) { + localctx = NewType_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 570, RedshiftParserRULE_type_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5824) + p.Typename() + } + p.SetState(5829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(5825) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5826) + p.Typename() + } + + p.SetState(5831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncatestmtContext is an interface to support dynamic dispatch. +type ITruncatestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + Relation_expr_list() IRelation_expr_listContext + Opt_table() IOpt_tableContext + Opt_restart_seqs() IOpt_restart_seqsContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsTruncatestmtContext differentiates from other interfaces. + IsTruncatestmtContext() +} + +type TruncatestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncatestmtContext() *TruncatestmtContext { + var p = new(TruncatestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_truncatestmt + return p +} + +func InitEmptyTruncatestmtContext(p *TruncatestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_truncatestmt +} + +func (*TruncatestmtContext) IsTruncatestmtContext() {} + +func NewTruncatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TruncatestmtContext { + var p = new(TruncatestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_truncatestmt + + return p +} + +func (s *TruncatestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *TruncatestmtContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNCATE, 0) +} + +func (s *TruncatestmtContext) Relation_expr_list() IRelation_expr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_expr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_expr_listContext) +} + +func (s *TruncatestmtContext) Opt_table() IOpt_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_tableContext) +} + +func (s *TruncatestmtContext) Opt_restart_seqs() IOpt_restart_seqsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_restart_seqsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_restart_seqsContext) +} + +func (s *TruncatestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *TruncatestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TruncatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TruncatestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTruncatestmt(s) + } +} + +func (s *TruncatestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTruncatestmt(s) + } +} + +func (s *TruncatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTruncatestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Truncatestmt() (localctx ITruncatestmtContext) { + localctx = NewTruncatestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 572, RedshiftParserRULE_truncatestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5832) + p.Match(RedshiftParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5834) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 406, p.GetParserRuleContext()) == 1 { + { + p.SetState(5833) + p.Opt_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5836) + p.Relation_expr_list() + } + p.SetState(5838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONTINUE_P || _la == RedshiftParserRESTART { + { + p.SetState(5837) + p.Opt_restart_seqs() + } + + } + p.SetState(5841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(5840) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_restart_seqsContext is an interface to support dynamic dispatch. +type IOpt_restart_seqsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTINUE_P() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + RESTART() antlr.TerminalNode + + // IsOpt_restart_seqsContext differentiates from other interfaces. + IsOpt_restart_seqsContext() +} + +type Opt_restart_seqsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_restart_seqsContext() *Opt_restart_seqsContext { + var p = new(Opt_restart_seqsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_restart_seqs + return p +} + +func InitEmptyOpt_restart_seqsContext(p *Opt_restart_seqsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_restart_seqs +} + +func (*Opt_restart_seqsContext) IsOpt_restart_seqsContext() {} + +func NewOpt_restart_seqsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_restart_seqsContext { + var p = new(Opt_restart_seqsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_restart_seqs + + return p +} + +func (s *Opt_restart_seqsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_restart_seqsContext) CONTINUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONTINUE_P, 0) +} + +func (s *Opt_restart_seqsContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *Opt_restart_seqsContext) RESTART() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTART, 0) +} + +func (s *Opt_restart_seqsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_restart_seqsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_restart_seqsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_restart_seqs(s) + } +} + +func (s *Opt_restart_seqsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_restart_seqs(s) + } +} + +func (s *Opt_restart_seqsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_restart_seqs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_restart_seqs() (localctx IOpt_restart_seqsContext) { + localctx = NewOpt_restart_seqsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 574, RedshiftParserRULE_opt_restart_seqs) + p.SetState(5847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCONTINUE_P: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5843) + p.Match(RedshiftParserCONTINUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5844) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserRESTART: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5845) + p.Match(RedshiftParserRESTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5846) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommentstmtContext is an interface to support dynamic dispatch. +type ICommentstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + Object_type_any_name() IObject_type_any_nameContext + Any_name() IAny_nameContext + IS() antlr.TerminalNode + Comment_text() IComment_textContext + COLUMN() antlr.TerminalNode + Object_type_name() IObject_type_nameContext + Name() INameContext + TYPE_P() antlr.TerminalNode + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + DOMAIN_P() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + Aggregate_with_argtypes() IAggregate_with_argtypesContext + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + OPERATOR() antlr.TerminalNode + Operator_with_argtypes() IOperator_with_argtypesContext + CONSTRAINT() antlr.TerminalNode + Object_type_name_on_any_name() IObject_type_name_on_any_nameContext + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + FOR() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + CLASS() antlr.TerminalNode + USING() antlr.TerminalNode + FAMILY() antlr.TerminalNode + LARGE_P() antlr.TerminalNode + OBJECT_P() antlr.TerminalNode + Numericonly() INumericonlyContext + CAST() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + AS() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + + // IsCommentstmtContext differentiates from other interfaces. + IsCommentstmtContext() +} + +type CommentstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommentstmtContext() *CommentstmtContext { + var p = new(CommentstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_commentstmt + return p +} + +func InitEmptyCommentstmtContext(p *CommentstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_commentstmt +} + +func (*CommentstmtContext) IsCommentstmtContext() {} + +func NewCommentstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommentstmtContext { + var p = new(CommentstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_commentstmt + + return p +} + +func (s *CommentstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CommentstmtContext) COMMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMENT, 0) +} + +func (s *CommentstmtContext) AllON() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserON) +} + +func (s *CommentstmtContext) ON(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserON, i) +} + +func (s *CommentstmtContext) Object_type_any_name() IObject_type_any_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_any_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_any_nameContext) +} + +func (s *CommentstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *CommentstmtContext) IS() antlr.TerminalNode { + return s.GetToken(RedshiftParserIS, 0) +} + +func (s *CommentstmtContext) Comment_text() IComment_textContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_textContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_textContext) +} + +func (s *CommentstmtContext) COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMN, 0) +} + +func (s *CommentstmtContext) Object_type_name() IObject_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_nameContext) +} + +func (s *CommentstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CommentstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *CommentstmtContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *CommentstmtContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *CommentstmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *CommentstmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *CommentstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypesContext) +} + +func (s *CommentstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *CommentstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *CommentstmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *CommentstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypesContext) +} + +func (s *CommentstmtContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *CommentstmtContext) Object_type_name_on_any_name() IObject_type_name_on_any_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_name_on_any_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_name_on_any_nameContext) +} + +func (s *CommentstmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *CommentstmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *CommentstmtContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSFORM, 0) +} + +func (s *CommentstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *CommentstmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *CommentstmtContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *CommentstmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *CommentstmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *CommentstmtContext) LARGE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLARGE_P, 0) +} + +func (s *CommentstmtContext) OBJECT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOBJECT_P, 0) +} + +func (s *CommentstmtContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *CommentstmtContext) CAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCAST, 0) +} + +func (s *CommentstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CommentstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CommentstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CommentstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommentstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CommentstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCommentstmt(s) + } +} + +func (s *CommentstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCommentstmt(s) + } +} + +func (s *CommentstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCommentstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Commentstmt() (localctx ICommentstmtContext) { + localctx = NewCommentstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 576, RedshiftParserRULE_commentstmt) + p.SetState(5996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 410, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5849) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5850) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5851) + p.Object_type_any_name() + } + { + p.SetState(5852) + p.Any_name() + } + { + p.SetState(5853) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5854) + p.Comment_text() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5856) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5857) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5858) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5859) + p.Any_name() + } + { + p.SetState(5860) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5861) + p.Comment_text() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5863) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5864) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5865) + p.Object_type_name() + } + { + p.SetState(5866) + p.Name() + } + { + p.SetState(5867) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5868) + p.Comment_text() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5870) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5871) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5872) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5873) + p.Typename() + } + { + p.SetState(5874) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5875) + p.Comment_text() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5877) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5878) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5879) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5880) + p.Typename() + } + { + p.SetState(5881) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5882) + p.Comment_text() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5884) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5885) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5886) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5887) + p.Aggregate_with_argtypes() + } + { + p.SetState(5888) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5889) + p.Comment_text() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5891) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5892) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5893) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5894) + p.Function_with_argtypes() + } + { + p.SetState(5895) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5896) + p.Comment_text() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5898) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5899) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5900) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5901) + p.Operator_with_argtypes() + } + { + p.SetState(5902) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5903) + p.Comment_text() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5905) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5906) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5907) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5908) + p.Name() + } + { + p.SetState(5909) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5910) + p.Any_name() + } + { + p.SetState(5911) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5912) + p.Comment_text() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5914) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5915) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5916) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5917) + p.Name() + } + { + p.SetState(5918) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5919) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5920) + p.Any_name() + } + { + p.SetState(5921) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5922) + p.Comment_text() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5924) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5925) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5926) + p.Object_type_name_on_any_name() + } + { + p.SetState(5927) + p.Name() + } + { + p.SetState(5928) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5929) + p.Any_name() + } + { + p.SetState(5930) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5931) + p.Comment_text() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5933) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5934) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5935) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5936) + p.Function_with_argtypes() + } + { + p.SetState(5937) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5938) + p.Comment_text() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5940) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5941) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5942) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5943) + p.Function_with_argtypes() + } + { + p.SetState(5944) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5945) + p.Comment_text() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(5947) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5948) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5949) + p.Match(RedshiftParserTRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5950) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5951) + p.Typename() + } + { + p.SetState(5952) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5953) + p.Name() + } + { + p.SetState(5954) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5955) + p.Comment_text() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(5957) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5958) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5959) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5960) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5961) + p.Any_name() + } + { + p.SetState(5962) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5963) + p.Name() + } + { + p.SetState(5964) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5965) + p.Comment_text() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(5967) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5968) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5969) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5970) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5971) + p.Any_name() + } + { + p.SetState(5972) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5973) + p.Name() + } + { + p.SetState(5974) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5975) + p.Comment_text() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(5977) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5978) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5979) + p.Match(RedshiftParserLARGE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5980) + p.Match(RedshiftParserOBJECT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5981) + p.Numericonly() + } + { + p.SetState(5982) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5983) + p.Comment_text() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(5985) + p.Match(RedshiftParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5986) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5987) + p.Match(RedshiftParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5988) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5989) + p.Typename() + } + { + p.SetState(5990) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5991) + p.Typename() + } + { + p.SetState(5992) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5993) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5994) + p.Comment_text() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComment_textContext is an interface to support dynamic dispatch. +type IComment_textContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + NULL_P() antlr.TerminalNode + + // IsComment_textContext differentiates from other interfaces. + IsComment_textContext() +} + +type Comment_textContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_textContext() *Comment_textContext { + var p = new(Comment_textContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_comment_text + return p +} + +func InitEmptyComment_textContext(p *Comment_textContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_comment_text +} + +func (*Comment_textContext) IsComment_textContext() {} + +func NewComment_textContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_textContext { + var p = new(Comment_textContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_comment_text + + return p +} + +func (s *Comment_textContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_textContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Comment_textContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Comment_textContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_textContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_textContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterComment_text(s) + } +} + +func (s *Comment_textContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitComment_text(s) + } +} + +func (s *Comment_textContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitComment_text(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Comment_text() (localctx IComment_textContext) { + localctx = NewComment_textContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 578, RedshiftParserRULE_comment_text) + p.SetState(6000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5998) + p.Sconst() + } + + case RedshiftParserNULL_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5999) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISeclabelstmtContext is an interface to support dynamic dispatch. +type ISeclabelstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SECURITY() antlr.TerminalNode + LABEL() antlr.TerminalNode + ON() antlr.TerminalNode + Object_type_any_name() IObject_type_any_nameContext + Any_name() IAny_nameContext + IS() antlr.TerminalNode + Security_label() ISecurity_labelContext + Opt_provider() IOpt_providerContext + COLUMN() antlr.TerminalNode + Object_type_name() IObject_type_nameContext + Name() INameContext + TYPE_P() antlr.TerminalNode + Typename() ITypenameContext + DOMAIN_P() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + Aggregate_with_argtypes() IAggregate_with_argtypesContext + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + LARGE_P() antlr.TerminalNode + OBJECT_P() antlr.TerminalNode + Numericonly() INumericonlyContext + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + + // IsSeclabelstmtContext differentiates from other interfaces. + IsSeclabelstmtContext() +} + +type SeclabelstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeclabelstmtContext() *SeclabelstmtContext { + var p = new(SeclabelstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_seclabelstmt + return p +} + +func InitEmptySeclabelstmtContext(p *SeclabelstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_seclabelstmt +} + +func (*SeclabelstmtContext) IsSeclabelstmtContext() {} + +func NewSeclabelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SeclabelstmtContext { + var p = new(SeclabelstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_seclabelstmt + + return p +} + +func (s *SeclabelstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *SeclabelstmtContext) SECURITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECURITY, 0) +} + +func (s *SeclabelstmtContext) LABEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLABEL, 0) +} + +func (s *SeclabelstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *SeclabelstmtContext) Object_type_any_name() IObject_type_any_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_any_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_any_nameContext) +} + +func (s *SeclabelstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *SeclabelstmtContext) IS() antlr.TerminalNode { + return s.GetToken(RedshiftParserIS, 0) +} + +func (s *SeclabelstmtContext) Security_label() ISecurity_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecurity_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecurity_labelContext) +} + +func (s *SeclabelstmtContext) Opt_provider() IOpt_providerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_providerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_providerContext) +} + +func (s *SeclabelstmtContext) COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMN, 0) +} + +func (s *SeclabelstmtContext) Object_type_name() IObject_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_nameContext) +} + +func (s *SeclabelstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *SeclabelstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *SeclabelstmtContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *SeclabelstmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *SeclabelstmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *SeclabelstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypesContext) +} + +func (s *SeclabelstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *SeclabelstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *SeclabelstmtContext) LARGE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLARGE_P, 0) +} + +func (s *SeclabelstmtContext) OBJECT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOBJECT_P, 0) +} + +func (s *SeclabelstmtContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *SeclabelstmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *SeclabelstmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *SeclabelstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SeclabelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SeclabelstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSeclabelstmt(s) + } +} + +func (s *SeclabelstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSeclabelstmt(s) + } +} + +func (s *SeclabelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSeclabelstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Seclabelstmt() (localctx ISeclabelstmtContext) { + localctx = NewSeclabelstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 580, RedshiftParserRULE_seclabelstmt) + var _la int + + p.SetState(6113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 422, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6002) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6003) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6004) + p.Opt_provider() + } + + } + { + p.SetState(6007) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6008) + p.Object_type_any_name() + } + { + p.SetState(6009) + p.Any_name() + } + { + p.SetState(6010) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6011) + p.Security_label() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6013) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6014) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6015) + p.Opt_provider() + } + + } + { + p.SetState(6018) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6019) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6020) + p.Any_name() + } + { + p.SetState(6021) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6022) + p.Security_label() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6024) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6025) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6026) + p.Opt_provider() + } + + } + { + p.SetState(6029) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6030) + p.Object_type_name() + } + { + p.SetState(6031) + p.Name() + } + { + p.SetState(6032) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6033) + p.Security_label() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6035) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6036) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6037) + p.Opt_provider() + } + + } + { + p.SetState(6040) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6041) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6042) + p.Typename() + } + { + p.SetState(6043) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6044) + p.Security_label() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6046) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6047) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6048) + p.Opt_provider() + } + + } + { + p.SetState(6051) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6052) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6053) + p.Typename() + } + { + p.SetState(6054) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6055) + p.Security_label() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6057) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6058) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6059) + p.Opt_provider() + } + + } + { + p.SetState(6062) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6063) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6064) + p.Aggregate_with_argtypes() + } + { + p.SetState(6065) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6066) + p.Security_label() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6068) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6069) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6070) + p.Opt_provider() + } + + } + { + p.SetState(6073) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6074) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6075) + p.Function_with_argtypes() + } + { + p.SetState(6076) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6077) + p.Security_label() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6079) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6080) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6081) + p.Opt_provider() + } + + } + { + p.SetState(6084) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6085) + p.Match(RedshiftParserLARGE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6086) + p.Match(RedshiftParserOBJECT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6087) + p.Numericonly() + } + { + p.SetState(6088) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6089) + p.Security_label() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6091) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6092) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6093) + p.Opt_provider() + } + + } + { + p.SetState(6096) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6097) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6098) + p.Function_with_argtypes() + } + { + p.SetState(6099) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6100) + p.Security_label() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6102) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6103) + p.Match(RedshiftParserLABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(6104) + p.Opt_provider() + } + + } + { + p.SetState(6107) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6108) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6109) + p.Function_with_argtypes() + } + { + p.SetState(6110) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6111) + p.Security_label() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_providerContext is an interface to support dynamic dispatch. +type IOpt_providerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Nonreservedword_or_sconst() INonreservedword_or_sconstContext + + // IsOpt_providerContext differentiates from other interfaces. + IsOpt_providerContext() +} + +type Opt_providerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_providerContext() *Opt_providerContext { + var p = new(Opt_providerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_provider + return p +} + +func InitEmptyOpt_providerContext(p *Opt_providerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_provider +} + +func (*Opt_providerContext) IsOpt_providerContext() {} + +func NewOpt_providerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_providerContext { + var p = new(Opt_providerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_provider + + return p +} + +func (s *Opt_providerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_providerContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Opt_providerContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedword_or_sconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedword_or_sconstContext) +} + +func (s *Opt_providerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_providerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_providerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_provider(s) + } +} + +func (s *Opt_providerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_provider(s) + } +} + +func (s *Opt_providerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_provider(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_provider() (localctx IOpt_providerContext) { + localctx = NewOpt_providerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 582, RedshiftParserRULE_opt_provider) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6115) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6116) + p.Nonreservedword_or_sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISecurity_labelContext is an interface to support dynamic dispatch. +type ISecurity_labelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + NULL_P() antlr.TerminalNode + + // IsSecurity_labelContext differentiates from other interfaces. + IsSecurity_labelContext() +} + +type Security_labelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecurity_labelContext() *Security_labelContext { + var p = new(Security_labelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_security_label + return p +} + +func InitEmptySecurity_labelContext(p *Security_labelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_security_label +} + +func (*Security_labelContext) IsSecurity_labelContext() {} + +func NewSecurity_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_labelContext { + var p = new(Security_labelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_security_label + + return p +} + +func (s *Security_labelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Security_labelContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Security_labelContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Security_labelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Security_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Security_labelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSecurity_label(s) + } +} + +func (s *Security_labelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSecurity_label(s) + } +} + +func (s *Security_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSecurity_label(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Security_label() (localctx ISecurity_labelContext) { + localctx = NewSecurity_labelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 584, RedshiftParserRULE_security_label) + p.SetState(6120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6118) + p.Sconst() + } + + case RedshiftParserNULL_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6119) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFetchstmtContext is an interface to support dynamic dispatch. +type IFetchstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FETCH() antlr.TerminalNode + Fetch_args() IFetch_argsContext + + // IsFetchstmtContext differentiates from other interfaces. + IsFetchstmtContext() +} + +type FetchstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFetchstmtContext() *FetchstmtContext { + var p = new(FetchstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fetchstmt + return p +} + +func InitEmptyFetchstmtContext(p *FetchstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fetchstmt +} + +func (*FetchstmtContext) IsFetchstmtContext() {} + +func NewFetchstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FetchstmtContext { + var p = new(FetchstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fetchstmt + + return p +} + +func (s *FetchstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *FetchstmtContext) FETCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFETCH, 0) +} + +func (s *FetchstmtContext) Fetch_args() IFetch_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFetch_argsContext) +} + +func (s *FetchstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FetchstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FetchstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFetchstmt(s) + } +} + +func (s *FetchstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFetchstmt(s) + } +} + +func (s *FetchstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFetchstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fetchstmt() (localctx IFetchstmtContext) { + localctx = NewFetchstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 586, RedshiftParserRULE_fetchstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6122) + p.Match(RedshiftParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6123) + p.Fetch_args() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFetch_argsContext is an interface to support dynamic dispatch. +type IFetch_argsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEXT() antlr.TerminalNode + FROM() antlr.TerminalNode + Cursor_name() ICursor_nameContext + ALL() antlr.TerminalNode + FORWARD() antlr.TerminalNode + Signediconst() ISignediconstContext + + // IsFetch_argsContext differentiates from other interfaces. + IsFetch_argsContext() +} + +type Fetch_argsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFetch_argsContext() *Fetch_argsContext { + var p = new(Fetch_argsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fetch_args + return p +} + +func InitEmptyFetch_argsContext(p *Fetch_argsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fetch_args +} + +func (*Fetch_argsContext) IsFetch_argsContext() {} + +func NewFetch_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_argsContext { + var p = new(Fetch_argsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fetch_args + + return p +} + +func (s *Fetch_argsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fetch_argsContext) NEXT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEXT, 0) +} + +func (s *Fetch_argsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Fetch_argsContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Fetch_argsContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Fetch_argsContext) FORWARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORWARD, 0) +} + +func (s *Fetch_argsContext) Signediconst() ISignediconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignediconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignediconstContext) +} + +func (s *Fetch_argsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fetch_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fetch_argsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFetch_args(s) + } +} + +func (s *Fetch_argsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFetch_args(s) + } +} + +func (s *Fetch_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFetch_args(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fetch_args() (localctx IFetch_argsContext) { + localctx = NewFetch_argsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 588, RedshiftParserRULE_fetch_args) + p.SetState(6140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNEXT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6125) + p.Match(RedshiftParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6126) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6127) + p.Cursor_name() + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6128) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6129) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6130) + p.Cursor_name() + } + + case RedshiftParserFORWARD: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6131) + p.Match(RedshiftParserFORWARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserIntegral: + { + p.SetState(6132) + p.Signediconst() + } + + case RedshiftParserALL: + { + p.SetState(6133) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFROM: + + default: + } + { + p.SetState(6136) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6137) + p.Cursor_name() + } + + case RedshiftParserFROM: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6138) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6139) + p.Cursor_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 +} + +// IGrantstmtContext is an interface to support dynamic dispatch. +type IGrantstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Common_grant() ICommon_grantContext + Grant_column_level_permissions() IGrant_column_level_permissionsContext + Grant_assume_role_permissions() IGrant_assume_role_permissionsContext + Grant_spectrum_integration_permissions() IGrant_spectrum_integration_permissionsContext + Grant_datashare_permissions() IGrant_datashare_permissionsContext + Grant_scoped_permissions() IGrant_scoped_permissionsContext + Grant_machine_learning_permissions() IGrant_machine_learning_permissionsContext + Grant_role_permissions() IGrant_role_permissionsContext + Grant_explain_permissions_for_row_level_security_policy_filters() IGrant_explain_permissions_for_row_level_security_policy_filtersContext + Grant_permissions_for_rls_lookup_tables() IGrant_permissions_for_rls_lookup_tablesContext + + // IsGrantstmtContext differentiates from other interfaces. + IsGrantstmtContext() +} + +type GrantstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantstmtContext() *GrantstmtContext { + var p = new(GrantstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantstmt + return p +} + +func InitEmptyGrantstmtContext(p *GrantstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantstmt +} + +func (*GrantstmtContext) IsGrantstmtContext() {} + +func NewGrantstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantstmtContext { + var p = new(GrantstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantstmt + + return p +} + +func (s *GrantstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantstmtContext) Common_grant() ICommon_grantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_grantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommon_grantContext) +} + +func (s *GrantstmtContext) Grant_column_level_permissions() IGrant_column_level_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_column_level_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_column_level_permissionsContext) +} + +func (s *GrantstmtContext) Grant_assume_role_permissions() IGrant_assume_role_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_assume_role_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_assume_role_permissionsContext) +} + +func (s *GrantstmtContext) Grant_spectrum_integration_permissions() IGrant_spectrum_integration_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_spectrum_integration_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_spectrum_integration_permissionsContext) +} + +func (s *GrantstmtContext) Grant_datashare_permissions() IGrant_datashare_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_datashare_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_datashare_permissionsContext) +} + +func (s *GrantstmtContext) Grant_scoped_permissions() IGrant_scoped_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_scoped_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_scoped_permissionsContext) +} + +func (s *GrantstmtContext) Grant_machine_learning_permissions() IGrant_machine_learning_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_machine_learning_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_machine_learning_permissionsContext) +} + +func (s *GrantstmtContext) Grant_role_permissions() IGrant_role_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_role_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_role_permissionsContext) +} + +func (s *GrantstmtContext) Grant_explain_permissions_for_row_level_security_policy_filters() IGrant_explain_permissions_for_row_level_security_policy_filtersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_explain_permissions_for_row_level_security_policy_filtersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_explain_permissions_for_row_level_security_policy_filtersContext) +} + +func (s *GrantstmtContext) Grant_permissions_for_rls_lookup_tables() IGrant_permissions_for_rls_lookup_tablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_permissions_for_rls_lookup_tablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_permissions_for_rls_lookup_tablesContext) +} + +func (s *GrantstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantstmt(s) + } +} + +func (s *GrantstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantstmt(s) + } +} + +func (s *GrantstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantstmt() (localctx IGrantstmtContext) { + localctx = NewGrantstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 590, RedshiftParserRULE_grantstmt) + p.SetState(6152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 426, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6142) + p.Common_grant() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6143) + p.Grant_column_level_permissions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6144) + p.Grant_assume_role_permissions() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6145) + p.Grant_spectrum_integration_permissions() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6146) + p.Grant_datashare_permissions() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6147) + p.Grant_scoped_permissions() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6148) + p.Grant_machine_learning_permissions() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6149) + p.Grant_role_permissions() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6150) + p.Grant_explain_permissions_for_row_level_security_policy_filters() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6151) + p.Grant_permissions_for_rls_lookup_tables() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_permissions_for_rls_lookup_tablesContext is an interface to support dynamic dispatch. +type IGrant_permissions_for_rls_lookup_tablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + SELECT() antlr.TerminalNode + ON() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + TO() antlr.TerminalNode + RLS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Columnlist() IColumnlistContext + TABLE() antlr.TerminalNode + + // IsGrant_permissions_for_rls_lookup_tablesContext differentiates from other interfaces. + IsGrant_permissions_for_rls_lookup_tablesContext() +} + +type Grant_permissions_for_rls_lookup_tablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_permissions_for_rls_lookup_tablesContext() *Grant_permissions_for_rls_lookup_tablesContext { + var p = new(Grant_permissions_for_rls_lookup_tablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_permissions_for_rls_lookup_tables + return p +} + +func InitEmptyGrant_permissions_for_rls_lookup_tablesContext(p *Grant_permissions_for_rls_lookup_tablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_permissions_for_rls_lookup_tables +} + +func (*Grant_permissions_for_rls_lookup_tablesContext) IsGrant_permissions_for_rls_lookup_tablesContext() { +} + +func NewGrant_permissions_for_rls_lookup_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_permissions_for_rls_lookup_tablesContext { + var p = new(Grant_permissions_for_rls_lookup_tablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_permissions_for_rls_lookup_tables + + return p +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_permissions_for_rls_lookup_tablesContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_permissions_for_rls_lookup_tables(s) + } +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_permissions_for_rls_lookup_tables(s) + } +} + +func (s *Grant_permissions_for_rls_lookup_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_permissions_for_rls_lookup_tables(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_permissions_for_rls_lookup_tables() (localctx IGrant_permissions_for_rls_lookup_tablesContext) { + localctx = NewGrant_permissions_for_rls_lookup_tablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 592, RedshiftParserRULE_grant_permissions_for_rls_lookup_tables) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6154) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6155) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6156) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6158) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 427, p.GetParserRuleContext()) == 1 { + { + p.SetState(6157) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6160) + p.Qualified_name_list() + } + { + p.SetState(6161) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6162) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6163) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6164) + p.Columnlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_explain_permissions_for_row_level_security_policy_filtersContext is an interface to support dynamic dispatch. +type IGrant_explain_permissions_for_row_level_security_policy_filtersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + RLS() antlr.TerminalNode + TO() antlr.TerminalNode + ROLE() antlr.TerminalNode + Rolespec() IRolespecContext + EXPLAIN() antlr.TerminalNode + IGNORE() antlr.TerminalNode + + // IsGrant_explain_permissions_for_row_level_security_policy_filtersContext differentiates from other interfaces. + IsGrant_explain_permissions_for_row_level_security_policy_filtersContext() +} + +type Grant_explain_permissions_for_row_level_security_policy_filtersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_explain_permissions_for_row_level_security_policy_filtersContext() *Grant_explain_permissions_for_row_level_security_policy_filtersContext { + var p = new(Grant_explain_permissions_for_row_level_security_policy_filtersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_explain_permissions_for_row_level_security_policy_filters + return p +} + +func InitEmptyGrant_explain_permissions_for_row_level_security_policy_filtersContext(p *Grant_explain_permissions_for_row_level_security_policy_filtersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_explain_permissions_for_row_level_security_policy_filters +} + +func (*Grant_explain_permissions_for_row_level_security_policy_filtersContext) IsGrant_explain_permissions_for_row_level_security_policy_filtersContext() { +} + +func NewGrant_explain_permissions_for_row_level_security_policy_filtersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_explain_permissions_for_row_level_security_policy_filtersContext { + var p = new(Grant_explain_permissions_for_row_level_security_policy_filtersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_explain_permissions_for_row_level_security_policy_filters + + return p +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPLAIN, 0) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) IGNORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNORE, 0) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_explain_permissions_for_row_level_security_policy_filters(s) + } +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_explain_permissions_for_row_level_security_policy_filters(s) + } +} + +func (s *Grant_explain_permissions_for_row_level_security_policy_filtersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_explain_permissions_for_row_level_security_policy_filters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_explain_permissions_for_row_level_security_policy_filters() (localctx IGrant_explain_permissions_for_row_level_security_policy_filtersContext) { + localctx = NewGrant_explain_permissions_for_row_level_security_policy_filtersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 594, RedshiftParserRULE_grant_explain_permissions_for_row_level_security_policy_filters) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6166) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6167) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXPLAIN || _la == RedshiftParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6168) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6169) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6170) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6171) + p.Rolespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_machine_learning_permissionsContext is an interface to support dynamic dispatch. +type IGrant_machine_learning_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + CREATE() antlr.TerminalNode + MODEL() antlr.TerminalNode + TO() antlr.TerminalNode + Grantee_list() IGrantee_listContext + Function_privilege_list() IFunction_privilege_listContext + ON() antlr.TerminalNode + Columnlist() IColumnlistContext + + // IsGrant_machine_learning_permissionsContext differentiates from other interfaces. + IsGrant_machine_learning_permissionsContext() +} + +type Grant_machine_learning_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_machine_learning_permissionsContext() *Grant_machine_learning_permissionsContext { + var p = new(Grant_machine_learning_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_machine_learning_permissions + return p +} + +func InitEmptyGrant_machine_learning_permissionsContext(p *Grant_machine_learning_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_machine_learning_permissions +} + +func (*Grant_machine_learning_permissionsContext) IsGrant_machine_learning_permissionsContext() {} + +func NewGrant_machine_learning_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_machine_learning_permissionsContext { + var p = new(Grant_machine_learning_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_machine_learning_permissions + + return p +} + +func (s *Grant_machine_learning_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_machine_learning_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_machine_learning_permissionsContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *Grant_machine_learning_permissionsContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *Grant_machine_learning_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_machine_learning_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Grant_machine_learning_permissionsContext) Function_privilege_list() IFunction_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_privilege_listContext) +} + +func (s *Grant_machine_learning_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Grant_machine_learning_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_machine_learning_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_machine_learning_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_machine_learning_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_machine_learning_permissions(s) + } +} + +func (s *Grant_machine_learning_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_machine_learning_permissions(s) + } +} + +func (s *Grant_machine_learning_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_machine_learning_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_machine_learning_permissions() (localctx IGrant_machine_learning_permissionsContext) { + localctx = NewGrant_machine_learning_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 596, RedshiftParserRULE_grant_machine_learning_permissions) + p.SetState(6186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 428, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6173) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6174) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6175) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6176) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6177) + p.Grantee_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6178) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6179) + p.Function_privilege_list() + } + { + p.SetState(6180) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6181) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6182) + p.Columnlist() + } + { + p.SetState(6183) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6184) + p.Grantee_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_role_permissionsContext is an interface to support dynamic dispatch. +type IGrant_role_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + AllROLE() []antlr.TerminalNode + ROLE(i int) antlr.TerminalNode + AllRolespec() []IRolespecContext + Rolespec(i int) IRolespecContext + TO() antlr.TerminalNode + Grant_role_permission_target_list() IGrant_role_permission_target_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + System_permissions() ISystem_permissionsContext + Role_list() IRole_listContext + + // IsGrant_role_permissionsContext differentiates from other interfaces. + IsGrant_role_permissionsContext() +} + +type Grant_role_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_role_permissionsContext() *Grant_role_permissionsContext { + var p = new(Grant_role_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_role_permissions + return p +} + +func InitEmptyGrant_role_permissionsContext(p *Grant_role_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_role_permissions +} + +func (*Grant_role_permissionsContext) IsGrant_role_permissionsContext() {} + +func NewGrant_role_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_role_permissionsContext { + var p = new(Grant_role_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_role_permissions + + return p +} + +func (s *Grant_role_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_role_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_role_permissionsContext) AllROLE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserROLE) +} + +func (s *Grant_role_permissionsContext) ROLE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, i) +} + +func (s *Grant_role_permissionsContext) AllRolespec() []IRolespecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRolespecContext); ok { + len++ + } + } + + tst := make([]IRolespecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRolespecContext); ok { + tst[i] = t.(IRolespecContext) + i++ + } + } + + return tst +} + +func (s *Grant_role_permissionsContext) Rolespec(i int) IRolespecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Grant_role_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_role_permissionsContext) Grant_role_permission_target_list() IGrant_role_permission_target_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_role_permission_target_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_role_permission_target_listContext) +} + +func (s *Grant_role_permissionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_role_permissionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_role_permissionsContext) System_permissions() ISystem_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_permissionsContext) +} + +func (s *Grant_role_permissionsContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *Grant_role_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_role_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_role_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_role_permissions(s) + } +} + +func (s *Grant_role_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_role_permissions(s) + } +} + +func (s *Grant_role_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_role_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_role_permissions() (localctx IGrant_role_permissionsContext) { + localctx = NewGrant_role_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 598, RedshiftParserRULE_grant_role_permissions) + var _la int + + p.SetState(6208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 430, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6188) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6189) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6190) + p.Rolespec() + } + p.SetState(6196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6191) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6192) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6193) + p.Rolespec() + } + + p.SetState(6198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6199) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6200) + p.Grant_role_permission_target_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6202) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6203) + p.System_permissions() + } + { + p.SetState(6204) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6205) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6206) + p.Role_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_role_permission_target_listContext is an interface to support dynamic dispatch. +type IGrant_role_permission_target_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGrant_role_permission_target_list_item() []IGrant_role_permission_target_list_itemContext + Grant_role_permission_target_list_item(i int) IGrant_role_permission_target_list_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrant_role_permission_target_listContext differentiates from other interfaces. + IsGrant_role_permission_target_listContext() +} + +type Grant_role_permission_target_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_role_permission_target_listContext() *Grant_role_permission_target_listContext { + var p = new(Grant_role_permission_target_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_role_permission_target_list + return p +} + +func InitEmptyGrant_role_permission_target_listContext(p *Grant_role_permission_target_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_role_permission_target_list +} + +func (*Grant_role_permission_target_listContext) IsGrant_role_permission_target_listContext() {} + +func NewGrant_role_permission_target_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_role_permission_target_listContext { + var p = new(Grant_role_permission_target_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_role_permission_target_list + + return p +} + +func (s *Grant_role_permission_target_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_role_permission_target_listContext) AllGrant_role_permission_target_list_item() []IGrant_role_permission_target_list_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrant_role_permission_target_list_itemContext); ok { + len++ + } + } + + tst := make([]IGrant_role_permission_target_list_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrant_role_permission_target_list_itemContext); ok { + tst[i] = t.(IGrant_role_permission_target_list_itemContext) + i++ + } + } + + return tst +} + +func (s *Grant_role_permission_target_listContext) Grant_role_permission_target_list_item(i int) IGrant_role_permission_target_list_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_role_permission_target_list_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrant_role_permission_target_list_itemContext) +} + +func (s *Grant_role_permission_target_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_role_permission_target_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_role_permission_target_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_role_permission_target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_role_permission_target_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_role_permission_target_list(s) + } +} + +func (s *Grant_role_permission_target_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_role_permission_target_list(s) + } +} + +func (s *Grant_role_permission_target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_role_permission_target_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_role_permission_target_list() (localctx IGrant_role_permission_target_listContext) { + localctx = NewGrant_role_permission_target_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 600, RedshiftParserRULE_grant_role_permission_target_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6210) + p.Grant_role_permission_target_list_item() + } + p.SetState(6215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6211) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6212) + p.Grant_role_permission_target_list_item() + } + + p.SetState(6217) + 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 +} + +// IGrant_role_permission_target_list_itemContext is an interface to support dynamic dispatch. +type IGrant_role_permission_target_list_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rolespec() IRolespecContext + Opt_with_admin_option() IOpt_with_admin_optionContext + ROLE() antlr.TerminalNode + + // IsGrant_role_permission_target_list_itemContext differentiates from other interfaces. + IsGrant_role_permission_target_list_itemContext() +} + +type Grant_role_permission_target_list_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_role_permission_target_list_itemContext() *Grant_role_permission_target_list_itemContext { + var p = new(Grant_role_permission_target_list_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_role_permission_target_list_item + return p +} + +func InitEmptyGrant_role_permission_target_list_itemContext(p *Grant_role_permission_target_list_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_role_permission_target_list_item +} + +func (*Grant_role_permission_target_list_itemContext) IsGrant_role_permission_target_list_itemContext() { +} + +func NewGrant_role_permission_target_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_role_permission_target_list_itemContext { + var p = new(Grant_role_permission_target_list_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_role_permission_target_list_item + + return p +} + +func (s *Grant_role_permission_target_list_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_role_permission_target_list_itemContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Grant_role_permission_target_list_itemContext) Opt_with_admin_option() IOpt_with_admin_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_admin_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_admin_optionContext) +} + +func (s *Grant_role_permission_target_list_itemContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Grant_role_permission_target_list_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_role_permission_target_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_role_permission_target_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_role_permission_target_list_item(s) + } +} + +func (s *Grant_role_permission_target_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_role_permission_target_list_item(s) + } +} + +func (s *Grant_role_permission_target_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_role_permission_target_list_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_role_permission_target_list_item() (localctx IGrant_role_permission_target_list_itemContext) { + localctx = NewGrant_role_permission_target_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 602, RedshiftParserRULE_grant_role_permission_target_list_item) + p.SetState(6224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 433, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6218) + p.Rolespec() + } + p.SetState(6220) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 432, p.GetParserRuleContext()) == 1 { + { + p.SetState(6219) + p.Opt_with_admin_option() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6222) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6223) + p.Rolespec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISystem_permissionsContext is an interface to support dynamic dispatch. +type ISystem_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSystem_permissions_item() []ISystem_permissions_itemContext + System_permissions_item(i int) ISystem_permissions_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsSystem_permissionsContext differentiates from other interfaces. + IsSystem_permissionsContext() +} + +type System_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_permissionsContext() *System_permissionsContext { + var p = new(System_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_system_permissions + return p +} + +func InitEmptySystem_permissionsContext(p *System_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_system_permissions +} + +func (*System_permissionsContext) IsSystem_permissionsContext() {} + +func NewSystem_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_permissionsContext { + var p = new(System_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_system_permissions + + return p +} + +func (s *System_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_permissionsContext) AllSystem_permissions_item() []ISystem_permissions_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_permissions_itemContext); ok { + len++ + } + } + + tst := make([]ISystem_permissions_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_permissions_itemContext); ok { + tst[i] = t.(ISystem_permissions_itemContext) + i++ + } + } + + return tst +} + +func (s *System_permissionsContext) System_permissions_item(i int) ISystem_permissions_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_permissions_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_permissions_itemContext) +} + +func (s *System_permissionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *System_permissionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *System_permissionsContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *System_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSystem_permissions(s) + } +} + +func (s *System_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSystem_permissions(s) + } +} + +func (s *System_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSystem_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) System_permissions() (localctx ISystem_permissionsContext) { + localctx = NewSystem_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 604, RedshiftParserRULE_system_permissions) + var _la int + + p.SetState(6235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserANALYZE, RedshiftParserCREATE, RedshiftParserACCESS, RedshiftParserALTER, RedshiftParserDROP, RedshiftParserEXPLAIN, RedshiftParserTRUNCATE, RedshiftParserVACUUM, RedshiftParserCANCEL, RedshiftParserIGNORE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6226) + p.System_permissions_item() + } + p.SetState(6231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6227) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6228) + p.System_permissions_item() + } + + p.SetState(6233) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6234) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_permissions_itemContext is an interface to support dynamic dispatch. +type ISystem_permissions_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USER() antlr.TerminalNode + CREATE() antlr.TerminalNode + DROP() antlr.TerminalNode + ALTER() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + ACCESS() antlr.TerminalNode + CATALOG() antlr.TerminalNode + SYSTEM_P() antlr.TerminalNode + TABLE() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + VIEW() antlr.TerminalNode + MODEL() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + ROLE() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + VACUUM() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + CANCEL() antlr.TerminalNode + RLS() antlr.TerminalNode + IGNORE() antlr.TerminalNode + EXPLAIN() antlr.TerminalNode + MASKING() antlr.TerminalNode + + // IsSystem_permissions_itemContext differentiates from other interfaces. + IsSystem_permissions_itemContext() +} + +type System_permissions_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_permissions_itemContext() *System_permissions_itemContext { + var p = new(System_permissions_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_system_permissions_item + return p +} + +func InitEmptySystem_permissions_itemContext(p *System_permissions_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_system_permissions_item +} + +func (*System_permissions_itemContext) IsSystem_permissions_itemContext() {} + +func NewSystem_permissions_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_permissions_itemContext { + var p = new(System_permissions_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_system_permissions_item + + return p +} + +func (s *System_permissions_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_permissions_itemContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *System_permissions_itemContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *System_permissions_itemContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *System_permissions_itemContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *System_permissions_itemContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *System_permissions_itemContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *System_permissions_itemContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIVILEGES, 0) +} + +func (s *System_permissions_itemContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *System_permissions_itemContext) CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG, 0) +} + +func (s *System_permissions_itemContext) SYSTEM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSTEM_P, 0) +} + +func (s *System_permissions_itemContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *System_permissions_itemContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *System_permissions_itemContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *System_permissions_itemContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *System_permissions_itemContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *System_permissions_itemContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *System_permissions_itemContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *System_permissions_itemContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *System_permissions_itemContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *System_permissions_itemContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIBRARY, 0) +} + +func (s *System_permissions_itemContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *System_permissions_itemContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNCATE, 0) +} + +func (s *System_permissions_itemContext) VACUUM() antlr.TerminalNode { + return s.GetToken(RedshiftParserVACUUM, 0) +} + +func (s *System_permissions_itemContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserANALYZE, 0) +} + +func (s *System_permissions_itemContext) CANCEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCANCEL, 0) +} + +func (s *System_permissions_itemContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *System_permissions_itemContext) IGNORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNORE, 0) +} + +func (s *System_permissions_itemContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPLAIN, 0) +} + +func (s *System_permissions_itemContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *System_permissions_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_permissions_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_permissions_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSystem_permissions_item(s) + } +} + +func (s *System_permissions_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSystem_permissions_item(s) + } +} + +func (s *System_permissions_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSystem_permissions_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) System_permissions_item() (localctx ISystem_permissions_itemContext) { + localctx = NewSystem_permissions_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 606, RedshiftParserRULE_system_permissions_item) + var _la int + + p.SetState(6293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6237) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserALTER || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6238) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6239) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6240) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6241) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6242) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6243) + p.Match(RedshiftParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6244) + p.Match(RedshiftParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCATALOG: + { + p.SetState(6245) + p.Match(RedshiftParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSYSTEM_P: + { + p.SetState(6246) + p.Match(RedshiftParserSYSTEM_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6247) + p.Match(RedshiftParserTABLE) + 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.EnterOuterAlt(localctx, 5) + { + p.SetState(6250) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserALTER || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6251) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6252) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6253) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6254) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserFUNCTION: + { + p.SetState(6255) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEXTERNAL: + { + p.SetState(6256) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6257) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6260) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6261) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + p.SetState(6266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCREATE: + { + p.SetState(6262) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6263) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6264) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDROP: + { + p.SetState(6265) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6268) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + p.SetState(6273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCREATE: + { + p.SetState(6269) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6270) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6271) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDROP: + { + p.SetState(6272) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6275) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6276) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6277) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6278) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserALTER || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6279) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(6280) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6281) + p.Match(RedshiftParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(6282) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6283) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(6284) + p.Match(RedshiftParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6285) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(6286) + p.Match(RedshiftParserVACUUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(6287) + p.Match(RedshiftParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(6288) + p.Match(RedshiftParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(6289) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXPLAIN || _la == RedshiftParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6290) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(6291) + p.Match(RedshiftParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6292) + p.Match(RedshiftParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_with_admin_optionContext is an interface to support dynamic dispatch. +type IOpt_with_admin_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + ADMIN() antlr.TerminalNode + OPTION() antlr.TerminalNode + + // IsOpt_with_admin_optionContext differentiates from other interfaces. + IsOpt_with_admin_optionContext() +} + +type Opt_with_admin_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_with_admin_optionContext() *Opt_with_admin_optionContext { + var p = new(Opt_with_admin_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_admin_option + return p +} + +func InitEmptyOpt_with_admin_optionContext(p *Opt_with_admin_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_admin_option +} + +func (*Opt_with_admin_optionContext) IsOpt_with_admin_optionContext() {} + +func NewOpt_with_admin_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_admin_optionContext { + var p = new(Opt_with_admin_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_with_admin_option + + return p +} + +func (s *Opt_with_admin_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_with_admin_optionContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_with_admin_optionContext) ADMIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserADMIN, 0) +} + +func (s *Opt_with_admin_optionContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Opt_with_admin_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_with_admin_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_with_admin_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_with_admin_option(s) + } +} + +func (s *Opt_with_admin_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_with_admin_option(s) + } +} + +func (s *Opt_with_admin_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_with_admin_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_with_admin_option() (localctx IOpt_with_admin_optionContext) { + localctx = NewOpt_with_admin_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 608, RedshiftParserRULE_opt_with_admin_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6295) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6296) + p.Match(RedshiftParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6297) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_permissionsContext is an interface to support dynamic dispatch. +type IGrant_scoped_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Grant_scoped_schemas_permissions() IGrant_scoped_schemas_permissionsContext + Grant_scoped_tables_permissions() IGrant_scoped_tables_permissionsContext + Grant_scoped_functions_permissions() IGrant_scoped_functions_permissionsContext + Grant_scoped_procedures_permissions() IGrant_scoped_procedures_permissionsContext + Grant_scoped_languages_permissions() IGrant_scoped_languages_permissionsContext + Grant_scoped_copy_jobs_permissions() IGrant_scoped_copy_jobs_permissionsContext + + // IsGrant_scoped_permissionsContext differentiates from other interfaces. + IsGrant_scoped_permissionsContext() +} + +type Grant_scoped_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_scoped_permissionsContext() *Grant_scoped_permissionsContext { + var p = new(Grant_scoped_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_permissions + return p +} + +func InitEmptyGrant_scoped_permissionsContext(p *Grant_scoped_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_permissions +} + +func (*Grant_scoped_permissionsContext) IsGrant_scoped_permissionsContext() {} + +func NewGrant_scoped_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_scoped_permissionsContext { + var p = new(Grant_scoped_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_scoped_permissions + + return p +} + +func (s *Grant_scoped_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_scoped_permissionsContext) Grant_scoped_schemas_permissions() IGrant_scoped_schemas_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_scoped_schemas_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_scoped_schemas_permissionsContext) +} + +func (s *Grant_scoped_permissionsContext) Grant_scoped_tables_permissions() IGrant_scoped_tables_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_scoped_tables_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_scoped_tables_permissionsContext) +} + +func (s *Grant_scoped_permissionsContext) Grant_scoped_functions_permissions() IGrant_scoped_functions_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_scoped_functions_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_scoped_functions_permissionsContext) +} + +func (s *Grant_scoped_permissionsContext) Grant_scoped_procedures_permissions() IGrant_scoped_procedures_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_scoped_procedures_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_scoped_procedures_permissionsContext) +} + +func (s *Grant_scoped_permissionsContext) Grant_scoped_languages_permissions() IGrant_scoped_languages_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_scoped_languages_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_scoped_languages_permissionsContext) +} + +func (s *Grant_scoped_permissionsContext) Grant_scoped_copy_jobs_permissions() IGrant_scoped_copy_jobs_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_scoped_copy_jobs_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_scoped_copy_jobs_permissionsContext) +} + +func (s *Grant_scoped_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_scoped_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_scoped_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_scoped_permissions(s) + } +} + +func (s *Grant_scoped_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_scoped_permissions(s) + } +} + +func (s *Grant_scoped_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_scoped_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_scoped_permissions() (localctx IGrant_scoped_permissionsContext) { + localctx = NewGrant_scoped_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 610, RedshiftParserRULE_grant_scoped_permissions) + p.SetState(6305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 441, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6299) + p.Grant_scoped_schemas_permissions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6300) + p.Grant_scoped_tables_permissions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6301) + p.Grant_scoped_functions_permissions() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6302) + p.Grant_scoped_procedures_permissions() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6303) + p.Grant_scoped_languages_permissions() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6304) + p.Grant_scoped_copy_jobs_permissions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_schemas_permissionsContext is an interface to support dynamic dispatch. +type IGrant_scoped_schemas_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Schema_privilege_list() ISchema_privilege_listContext + FOR() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + IN_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Colid() IColidContext + TO() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + + // IsGrant_scoped_schemas_permissionsContext differentiates from other interfaces. + IsGrant_scoped_schemas_permissionsContext() +} + +type Grant_scoped_schemas_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_scoped_schemas_permissionsContext() *Grant_scoped_schemas_permissionsContext { + var p = new(Grant_scoped_schemas_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_schemas_permissions + return p +} + +func InitEmptyGrant_scoped_schemas_permissionsContext(p *Grant_scoped_schemas_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_schemas_permissions +} + +func (*Grant_scoped_schemas_permissionsContext) IsGrant_scoped_schemas_permissionsContext() {} + +func NewGrant_scoped_schemas_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_scoped_schemas_permissionsContext { + var p = new(Grant_scoped_schemas_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_scoped_schemas_permissions + + return p +} + +func (s *Grant_scoped_schemas_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_scoped_schemas_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_scoped_schemas_permissionsContext) Schema_privilege_list() ISchema_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilege_listContext) +} + +func (s *Grant_scoped_schemas_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Grant_scoped_schemas_permissionsContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMAS, 0) +} + +func (s *Grant_scoped_schemas_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_scoped_schemas_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_scoped_schemas_permissionsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_scoped_schemas_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_scoped_schemas_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Grant_scoped_schemas_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_scoped_schemas_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_scoped_schemas_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_scoped_schemas_permissions(s) + } +} + +func (s *Grant_scoped_schemas_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_scoped_schemas_permissions(s) + } +} + +func (s *Grant_scoped_schemas_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_scoped_schemas_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_scoped_schemas_permissions() (localctx IGrant_scoped_schemas_permissionsContext) { + localctx = NewGrant_scoped_schemas_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 612, RedshiftParserRULE_grant_scoped_schemas_permissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6307) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6308) + p.Schema_privilege_list() + } + { + p.SetState(6309) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6310) + p.Match(RedshiftParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6311) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6312) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6313) + p.Colid() + } + { + p.SetState(6314) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6315) + p.Grantee_list_without_public() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_tables_permissionsContext is an interface to support dynamic dispatch. +type IGrant_scoped_tables_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Table_privilege_list() ITable_privilege_listContext + FOR() antlr.TerminalNode + TABLES() antlr.TerminalNode + IN_P() antlr.TerminalNode + TO() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsGrant_scoped_tables_permissionsContext differentiates from other interfaces. + IsGrant_scoped_tables_permissionsContext() +} + +type Grant_scoped_tables_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_scoped_tables_permissionsContext() *Grant_scoped_tables_permissionsContext { + var p = new(Grant_scoped_tables_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_tables_permissions + return p +} + +func InitEmptyGrant_scoped_tables_permissionsContext(p *Grant_scoped_tables_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_tables_permissions +} + +func (*Grant_scoped_tables_permissionsContext) IsGrant_scoped_tables_permissionsContext() {} + +func NewGrant_scoped_tables_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_scoped_tables_permissionsContext { + var p = new(Grant_scoped_tables_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_scoped_tables_permissions + + return p +} + +func (s *Grant_scoped_tables_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_scoped_tables_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_scoped_tables_permissionsContext) Table_privilege_list() ITable_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_privilege_listContext) +} + +func (s *Grant_scoped_tables_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Grant_scoped_tables_permissionsContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *Grant_scoped_tables_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_scoped_tables_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_scoped_tables_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Grant_scoped_tables_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_scoped_tables_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Grant_scoped_tables_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_scoped_tables_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_scoped_tables_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_scoped_tables_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_scoped_tables_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_scoped_tables_permissions(s) + } +} + +func (s *Grant_scoped_tables_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_scoped_tables_permissions(s) + } +} + +func (s *Grant_scoped_tables_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_scoped_tables_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_scoped_tables_permissions() (localctx IGrant_scoped_tables_permissionsContext) { + localctx = NewGrant_scoped_tables_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 614, RedshiftParserRULE_grant_scoped_tables_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6317) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6318) + p.Table_privilege_list() + } + { + p.SetState(6319) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6320) + p.Match(RedshiftParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6321) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(6322) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6323) + p.Colid() + } + p.SetState(6326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(6324) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6325) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(6328) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6329) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6332) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6333) + p.Grantee_list_without_public() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_functions_permissionsContext is an interface to support dynamic dispatch. +type IGrant_scoped_functions_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Function_privilege_list() IFunction_privilege_listContext + FOR() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + IN_P() antlr.TerminalNode + TO() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsGrant_scoped_functions_permissionsContext differentiates from other interfaces. + IsGrant_scoped_functions_permissionsContext() +} + +type Grant_scoped_functions_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_scoped_functions_permissionsContext() *Grant_scoped_functions_permissionsContext { + var p = new(Grant_scoped_functions_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_functions_permissions + return p +} + +func InitEmptyGrant_scoped_functions_permissionsContext(p *Grant_scoped_functions_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_functions_permissions +} + +func (*Grant_scoped_functions_permissionsContext) IsGrant_scoped_functions_permissionsContext() {} + +func NewGrant_scoped_functions_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_scoped_functions_permissionsContext { + var p = new(Grant_scoped_functions_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_scoped_functions_permissions + + return p +} + +func (s *Grant_scoped_functions_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_scoped_functions_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_scoped_functions_permissionsContext) Function_privilege_list() IFunction_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_privilege_listContext) +} + +func (s *Grant_scoped_functions_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Grant_scoped_functions_permissionsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTIONS, 0) +} + +func (s *Grant_scoped_functions_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_scoped_functions_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_scoped_functions_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Grant_scoped_functions_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_scoped_functions_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Grant_scoped_functions_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_scoped_functions_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_scoped_functions_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_scoped_functions_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_scoped_functions_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_scoped_functions_permissions(s) + } +} + +func (s *Grant_scoped_functions_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_scoped_functions_permissions(s) + } +} + +func (s *Grant_scoped_functions_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_scoped_functions_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_scoped_functions_permissions() (localctx IGrant_scoped_functions_permissionsContext) { + localctx = NewGrant_scoped_functions_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 616, RedshiftParserRULE_grant_scoped_functions_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6335) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6336) + p.Function_privilege_list() + } + { + p.SetState(6337) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6338) + p.Match(RedshiftParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6339) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(6340) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6341) + p.Colid() + } + p.SetState(6344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(6342) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6343) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(6346) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6347) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6350) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6351) + p.Grantee_list_without_public() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_procedures_permissionsContext is an interface to support dynamic dispatch. +type IGrant_scoped_procedures_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Procedure_privilege_list() IProcedure_privilege_listContext + FOR() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + IN_P() antlr.TerminalNode + TO() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsGrant_scoped_procedures_permissionsContext differentiates from other interfaces. + IsGrant_scoped_procedures_permissionsContext() +} + +type Grant_scoped_procedures_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_scoped_procedures_permissionsContext() *Grant_scoped_procedures_permissionsContext { + var p = new(Grant_scoped_procedures_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_procedures_permissions + return p +} + +func InitEmptyGrant_scoped_procedures_permissionsContext(p *Grant_scoped_procedures_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_procedures_permissions +} + +func (*Grant_scoped_procedures_permissionsContext) IsGrant_scoped_procedures_permissionsContext() {} + +func NewGrant_scoped_procedures_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_scoped_procedures_permissionsContext { + var p = new(Grant_scoped_procedures_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_scoped_procedures_permissions + + return p +} + +func (s *Grant_scoped_procedures_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_scoped_procedures_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_scoped_procedures_permissionsContext) Procedure_privilege_list() IProcedure_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_privilege_listContext) +} + +func (s *Grant_scoped_procedures_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Grant_scoped_procedures_permissionsContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURES, 0) +} + +func (s *Grant_scoped_procedures_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_scoped_procedures_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_scoped_procedures_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Grant_scoped_procedures_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_scoped_procedures_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Grant_scoped_procedures_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_scoped_procedures_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_scoped_procedures_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_scoped_procedures_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_scoped_procedures_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_scoped_procedures_permissions(s) + } +} + +func (s *Grant_scoped_procedures_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_scoped_procedures_permissions(s) + } +} + +func (s *Grant_scoped_procedures_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_scoped_procedures_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_scoped_procedures_permissions() (localctx IGrant_scoped_procedures_permissionsContext) { + localctx = NewGrant_scoped_procedures_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 618, RedshiftParserRULE_grant_scoped_procedures_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6353) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6354) + p.Procedure_privilege_list() + } + { + p.SetState(6355) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6356) + p.Match(RedshiftParserPROCEDURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6357) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(6358) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6359) + p.Colid() + } + p.SetState(6362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(6360) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6361) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(6364) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6365) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6368) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6369) + p.Grantee_list_without_public() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_languages_permissionsContext is an interface to support dynamic dispatch. +type IGrant_scoped_languages_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Language_privilege_list() ILanguage_privilege_listContext + FOR() antlr.TerminalNode + LANGUAGES() antlr.TerminalNode + IN_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Colid() IColidContext + TO() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + + // IsGrant_scoped_languages_permissionsContext differentiates from other interfaces. + IsGrant_scoped_languages_permissionsContext() +} + +type Grant_scoped_languages_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_scoped_languages_permissionsContext() *Grant_scoped_languages_permissionsContext { + var p = new(Grant_scoped_languages_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_languages_permissions + return p +} + +func InitEmptyGrant_scoped_languages_permissionsContext(p *Grant_scoped_languages_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_languages_permissions +} + +func (*Grant_scoped_languages_permissionsContext) IsGrant_scoped_languages_permissionsContext() {} + +func NewGrant_scoped_languages_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_scoped_languages_permissionsContext { + var p = new(Grant_scoped_languages_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_scoped_languages_permissions + + return p +} + +func (s *Grant_scoped_languages_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_scoped_languages_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_scoped_languages_permissionsContext) Language_privilege_list() ILanguage_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguage_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguage_privilege_listContext) +} + +func (s *Grant_scoped_languages_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Grant_scoped_languages_permissionsContext) LANGUAGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGES, 0) +} + +func (s *Grant_scoped_languages_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_scoped_languages_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_scoped_languages_permissionsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_scoped_languages_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_scoped_languages_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Grant_scoped_languages_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_scoped_languages_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_scoped_languages_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_scoped_languages_permissions(s) + } +} + +func (s *Grant_scoped_languages_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_scoped_languages_permissions(s) + } +} + +func (s *Grant_scoped_languages_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_scoped_languages_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_scoped_languages_permissions() (localctx IGrant_scoped_languages_permissionsContext) { + localctx = NewGrant_scoped_languages_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 620, RedshiftParserRULE_grant_scoped_languages_permissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6371) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6372) + p.Language_privilege_list() + } + { + p.SetState(6373) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6374) + p.Match(RedshiftParserLANGUAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6375) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6376) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6377) + p.Colid() + } + { + p.SetState(6378) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6379) + p.Grantee_list_without_public() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_copy_jobs_permissionsContext is an interface to support dynamic dispatch. +type IGrant_scoped_copy_jobs_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Copy_job_privilege_list() ICopy_job_privilege_listContext + FOR() antlr.TerminalNode + COPY() antlr.TerminalNode + JOBS() antlr.TerminalNode + IN_P() antlr.TerminalNode + TO() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsGrant_scoped_copy_jobs_permissionsContext differentiates from other interfaces. + IsGrant_scoped_copy_jobs_permissionsContext() +} + +type Grant_scoped_copy_jobs_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_scoped_copy_jobs_permissionsContext() *Grant_scoped_copy_jobs_permissionsContext { + var p = new(Grant_scoped_copy_jobs_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_copy_jobs_permissions + return p +} + +func InitEmptyGrant_scoped_copy_jobs_permissionsContext(p *Grant_scoped_copy_jobs_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_scoped_copy_jobs_permissions +} + +func (*Grant_scoped_copy_jobs_permissionsContext) IsGrant_scoped_copy_jobs_permissionsContext() {} + +func NewGrant_scoped_copy_jobs_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_scoped_copy_jobs_permissionsContext { + var p = new(Grant_scoped_copy_jobs_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_scoped_copy_jobs_permissions + + return p +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_scoped_copy_jobs_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) Copy_job_privilege_list() ICopy_job_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_privilege_listContext) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) COPY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOPY, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) JOBS() antlr.TerminalNode { + return s.GetToken(RedshiftParserJOBS, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_scoped_copy_jobs_permissions(s) + } +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_scoped_copy_jobs_permissions(s) + } +} + +func (s *Grant_scoped_copy_jobs_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_scoped_copy_jobs_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_scoped_copy_jobs_permissions() (localctx IGrant_scoped_copy_jobs_permissionsContext) { + localctx = NewGrant_scoped_copy_jobs_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 622, RedshiftParserRULE_grant_scoped_copy_jobs_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6381) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6382) + p.Copy_job_privilege_list() + } + { + p.SetState(6383) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6384) + p.Match(RedshiftParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6385) + p.Match(RedshiftParserJOBS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6386) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(6387) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6388) + p.Colid() + } + p.SetState(6391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(6389) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6390) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(6393) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6394) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6397) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6398) + p.Grantee_list_without_public() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_list_without_publicContext is an interface to support dynamic dispatch. +type IGrantee_list_without_publicContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGrantee_without_public() []IGrantee_without_publicContext + Grantee_without_public(i int) IGrantee_without_publicContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrantee_list_without_publicContext differentiates from other interfaces. + IsGrantee_list_without_publicContext() +} + +type Grantee_list_without_publicContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantee_list_without_publicContext() *Grantee_list_without_publicContext { + var p = new(Grantee_list_without_publicContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee_list_without_public + return p +} + +func InitEmptyGrantee_list_without_publicContext(p *Grantee_list_without_publicContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee_list_without_public +} + +func (*Grantee_list_without_publicContext) IsGrantee_list_without_publicContext() {} + +func NewGrantee_list_without_publicContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_list_without_publicContext { + var p = new(Grantee_list_without_publicContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantee_list_without_public + + return p +} + +func (s *Grantee_list_without_publicContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grantee_list_without_publicContext) AllGrantee_without_public() []IGrantee_without_publicContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrantee_without_publicContext); ok { + len++ + } + } + + tst := make([]IGrantee_without_publicContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrantee_without_publicContext); ok { + tst[i] = t.(IGrantee_without_publicContext) + i++ + } + } + + return tst +} + +func (s *Grantee_list_without_publicContext) Grantee_without_public(i int) IGrantee_without_publicContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_without_publicContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_without_publicContext) +} + +func (s *Grantee_list_without_publicContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grantee_list_without_publicContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grantee_list_without_publicContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grantee_list_without_publicContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grantee_list_without_publicContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantee_list_without_public(s) + } +} + +func (s *Grantee_list_without_publicContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantee_list_without_public(s) + } +} + +func (s *Grantee_list_without_publicContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantee_list_without_public(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantee_list_without_public() (localctx IGrantee_list_without_publicContext) { + localctx = NewGrantee_list_without_publicContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 624, RedshiftParserRULE_grantee_list_without_public) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6400) + p.Grantee_without_public() + } + p.SetState(6405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6401) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6402) + p.Grantee_without_public() + } + + p.SetState(6407) + 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 +} + +// IGrantee_without_publicContext is an interface to support dynamic dispatch. +type IGrantee_without_publicContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rolespec() IRolespecContext + Opt_with_grant_option() IOpt_with_grant_optionContext + ROLE() antlr.TerminalNode + + // IsGrantee_without_publicContext differentiates from other interfaces. + IsGrantee_without_publicContext() +} + +type Grantee_without_publicContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantee_without_publicContext() *Grantee_without_publicContext { + var p = new(Grantee_without_publicContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee_without_public + return p +} + +func InitEmptyGrantee_without_publicContext(p *Grantee_without_publicContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee_without_public +} + +func (*Grantee_without_publicContext) IsGrantee_without_publicContext() {} + +func NewGrantee_without_publicContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_without_publicContext { + var p = new(Grantee_without_publicContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantee_without_public + + return p +} + +func (s *Grantee_without_publicContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grantee_without_publicContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Grantee_without_publicContext) Opt_with_grant_option() IOpt_with_grant_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_grant_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_grant_optionContext) +} + +func (s *Grantee_without_publicContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Grantee_without_publicContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grantee_without_publicContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grantee_without_publicContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantee_without_public(s) + } +} + +func (s *Grantee_without_publicContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantee_without_public(s) + } +} + +func (s *Grantee_without_publicContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantee_without_public(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantee_without_public() (localctx IGrantee_without_publicContext) { + localctx = NewGrantee_without_publicContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 626, RedshiftParserRULE_grantee_without_public) + p.SetState(6414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 452, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6408) + p.Rolespec() + } + p.SetState(6410) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 451, p.GetParserRuleContext()) == 1 { + { + p.SetState(6409) + p.Opt_with_grant_option() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6412) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6413) + p.Rolespec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_datashare_permissionsContext is an interface to support dynamic dispatch. +type IGrant_datashare_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + ON() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + Colid() IColidContext + TO() antlr.TerminalNode + Grantee_list() IGrantee_listContext + ALTER() antlr.TerminalNode + SHARE() antlr.TerminalNode + USAGE() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + Sconst() ISconstContext + ACCOUNT() antlr.TerminalNode + VIA() antlr.TerminalNode + DATA_P() antlr.TerminalNode + CATALOG() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Columnlist() IColumnlistContext + SCHEMA() antlr.TerminalNode + + // IsGrant_datashare_permissionsContext differentiates from other interfaces. + IsGrant_datashare_permissionsContext() +} + +type Grant_datashare_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_datashare_permissionsContext() *Grant_datashare_permissionsContext { + var p = new(Grant_datashare_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_datashare_permissions + return p +} + +func InitEmptyGrant_datashare_permissionsContext(p *Grant_datashare_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_datashare_permissions +} + +func (*Grant_datashare_permissionsContext) IsGrant_datashare_permissionsContext() {} + +func NewGrant_datashare_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_datashare_permissionsContext { + var p = new(Grant_datashare_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_datashare_permissions + + return p +} + +func (s *Grant_datashare_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_datashare_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_datashare_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Grant_datashare_permissionsContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *Grant_datashare_permissionsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_datashare_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_datashare_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Grant_datashare_permissionsContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Grant_datashare_permissionsContext) SHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHARE, 0) +} + +func (s *Grant_datashare_permissionsContext) USAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSAGE, 0) +} + +func (s *Grant_datashare_permissionsContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMESPACE, 0) +} + +func (s *Grant_datashare_permissionsContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Grant_datashare_permissionsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCOUNT, 0) +} + +func (s *Grant_datashare_permissionsContext) VIA() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIA, 0) +} + +func (s *Grant_datashare_permissionsContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *Grant_datashare_permissionsContext) CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG, 0) +} + +func (s *Grant_datashare_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_datashare_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_datashare_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_datashare_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_datashare_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_datashare_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_datashare_permissions(s) + } +} + +func (s *Grant_datashare_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_datashare_permissions(s) + } +} + +func (s *Grant_datashare_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_datashare_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_datashare_permissions() (localctx IGrant_datashare_permissionsContext) { + localctx = NewGrant_datashare_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 628, RedshiftParserRULE_grant_datashare_permissions) + var _la int + + p.SetState(6453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6416) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6417) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALTER || _la == RedshiftParserSHARE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6418) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6419) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6420) + p.Colid() + } + { + p.SetState(6421) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6422) + p.Grantee_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6424) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6425) + p.Match(RedshiftParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6426) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6427) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6428) + p.Colid() + } + { + p.SetState(6429) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNAMESPACE: + { + p.SetState(6430) + p.Match(RedshiftParserNAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6431) + p.Sconst() + } + + case RedshiftParserACCOUNT: + { + p.SetState(6432) + p.Match(RedshiftParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6433) + p.Sconst() + } + p.SetState(6437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVIA { + { + p.SetState(6434) + p.Match(RedshiftParserVIA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6435) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6436) + p.Match(RedshiftParserCATALOG) + 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(6441) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6442) + p.Match(RedshiftParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6443) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDATABASE: + { + p.SetState(6444) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6445) + p.Columnlist() + } + + case RedshiftParserSCHEMA: + { + p.SetState(6446) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6447) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6450) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6451) + p.Grantee_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_spectrum_integration_permissionsContext is an interface to support dynamic dispatch. +type IGrant_spectrum_integration_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Grant_spectrum_integration_extenral_column_permissions() IGrant_spectrum_integration_extenral_column_permissionsContext + Grant_spectrum_integration_external_table_permissions() IGrant_spectrum_integration_external_table_permissionsContext + Grant_spectrum_integration_external_schema_permissions() IGrant_spectrum_integration_external_schema_permissionsContext + + // IsGrant_spectrum_integration_permissionsContext differentiates from other interfaces. + IsGrant_spectrum_integration_permissionsContext() +} + +type Grant_spectrum_integration_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_spectrum_integration_permissionsContext() *Grant_spectrum_integration_permissionsContext { + var p = new(Grant_spectrum_integration_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_permissions + return p +} + +func InitEmptyGrant_spectrum_integration_permissionsContext(p *Grant_spectrum_integration_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_permissions +} + +func (*Grant_spectrum_integration_permissionsContext) IsGrant_spectrum_integration_permissionsContext() { +} + +func NewGrant_spectrum_integration_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_spectrum_integration_permissionsContext { + var p = new(Grant_spectrum_integration_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_permissions + + return p +} + +func (s *Grant_spectrum_integration_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_spectrum_integration_permissionsContext) Grant_spectrum_integration_extenral_column_permissions() IGrant_spectrum_integration_extenral_column_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_spectrum_integration_extenral_column_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_spectrum_integration_extenral_column_permissionsContext) +} + +func (s *Grant_spectrum_integration_permissionsContext) Grant_spectrum_integration_external_table_permissions() IGrant_spectrum_integration_external_table_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_spectrum_integration_external_table_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_spectrum_integration_external_table_permissionsContext) +} + +func (s *Grant_spectrum_integration_permissionsContext) Grant_spectrum_integration_external_schema_permissions() IGrant_spectrum_integration_external_schema_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_spectrum_integration_external_schema_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_spectrum_integration_external_schema_permissionsContext) +} + +func (s *Grant_spectrum_integration_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_spectrum_integration_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_spectrum_integration_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_spectrum_integration_permissions(s) + } +} + +func (s *Grant_spectrum_integration_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_spectrum_integration_permissions(s) + } +} + +func (s *Grant_spectrum_integration_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_spectrum_integration_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_spectrum_integration_permissions() (localctx IGrant_spectrum_integration_permissionsContext) { + localctx = NewGrant_spectrum_integration_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 630, RedshiftParserRULE_grant_spectrum_integration_permissions) + p.SetState(6458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 457, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6455) + p.Grant_spectrum_integration_extenral_column_permissions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6456) + p.Grant_spectrum_integration_external_table_permissions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6457) + p.Grant_spectrum_integration_external_schema_permissions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_spectrum_integration_external_schema_permissionsContext is an interface to support dynamic dispatch. +type IGrant_spectrum_integration_external_schema_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Spectrum_integration_external_schema_permission_list() ISpectrum_integration_external_schema_permission_listContext + ON() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Columnlist() IColumnlistContext + TO() antlr.TerminalNode + Iamrolelist_or_public() IIamrolelist_or_publicContext + Opt_with_grant_option() IOpt_with_grant_optionContext + + // IsGrant_spectrum_integration_external_schema_permissionsContext differentiates from other interfaces. + IsGrant_spectrum_integration_external_schema_permissionsContext() +} + +type Grant_spectrum_integration_external_schema_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_spectrum_integration_external_schema_permissionsContext() *Grant_spectrum_integration_external_schema_permissionsContext { + var p = new(Grant_spectrum_integration_external_schema_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_external_schema_permissions + return p +} + +func InitEmptyGrant_spectrum_integration_external_schema_permissionsContext(p *Grant_spectrum_integration_external_schema_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_external_schema_permissions +} + +func (*Grant_spectrum_integration_external_schema_permissionsContext) IsGrant_spectrum_integration_external_schema_permissionsContext() { +} + +func NewGrant_spectrum_integration_external_schema_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_spectrum_integration_external_schema_permissionsContext { + var p = new(Grant_spectrum_integration_external_schema_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_external_schema_permissions + + return p +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) Spectrum_integration_external_schema_permission_list() ISpectrum_integration_external_schema_permission_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpectrum_integration_external_schema_permission_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpectrum_integration_external_schema_permission_listContext) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) Iamrolelist_or_public() IIamrolelist_or_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolelist_or_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolelist_or_publicContext) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) Opt_with_grant_option() IOpt_with_grant_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_grant_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_grant_optionContext) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_spectrum_integration_external_schema_permissions(s) + } +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_spectrum_integration_external_schema_permissions(s) + } +} + +func (s *Grant_spectrum_integration_external_schema_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_spectrum_integration_external_schema_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_spectrum_integration_external_schema_permissions() (localctx IGrant_spectrum_integration_external_schema_permissionsContext) { + localctx = NewGrant_spectrum_integration_external_schema_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 632, RedshiftParserRULE_grant_spectrum_integration_external_schema_permissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6460) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6461) + p.Spectrum_integration_external_schema_permission_list() + } + { + p.SetState(6462) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6463) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6464) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6465) + p.Columnlist() + } + { + p.SetState(6466) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6467) + p.Iamrolelist_or_public() + } + p.SetState(6469) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 458, p.GetParserRuleContext()) == 1 { + { + p.SetState(6468) + p.Opt_with_grant_option() + } + + } 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 +} + +// ISpectrum_integration_external_schema_permission_listContext is an interface to support dynamic dispatch. +type ISpectrum_integration_external_schema_permission_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSpectrum_integration_external_schema_permission() []ISpectrum_integration_external_schema_permissionContext + Spectrum_integration_external_schema_permission(i int) ISpectrum_integration_external_schema_permissionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsSpectrum_integration_external_schema_permission_listContext differentiates from other interfaces. + IsSpectrum_integration_external_schema_permission_listContext() +} + +type Spectrum_integration_external_schema_permission_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpectrum_integration_external_schema_permission_listContext() *Spectrum_integration_external_schema_permission_listContext { + var p = new(Spectrum_integration_external_schema_permission_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_schema_permission_list + return p +} + +func InitEmptySpectrum_integration_external_schema_permission_listContext(p *Spectrum_integration_external_schema_permission_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_schema_permission_list +} + +func (*Spectrum_integration_external_schema_permission_listContext) IsSpectrum_integration_external_schema_permission_listContext() { +} + +func NewSpectrum_integration_external_schema_permission_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spectrum_integration_external_schema_permission_listContext { + var p = new(Spectrum_integration_external_schema_permission_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_schema_permission_list + + return p +} + +func (s *Spectrum_integration_external_schema_permission_listContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Spectrum_integration_external_schema_permission_listContext) AllSpectrum_integration_external_schema_permission() []ISpectrum_integration_external_schema_permissionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISpectrum_integration_external_schema_permissionContext); ok { + len++ + } + } + + tst := make([]ISpectrum_integration_external_schema_permissionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISpectrum_integration_external_schema_permissionContext); ok { + tst[i] = t.(ISpectrum_integration_external_schema_permissionContext) + i++ + } + } + + return tst +} + +func (s *Spectrum_integration_external_schema_permission_listContext) Spectrum_integration_external_schema_permission(i int) ISpectrum_integration_external_schema_permissionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpectrum_integration_external_schema_permissionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISpectrum_integration_external_schema_permissionContext) +} + +func (s *Spectrum_integration_external_schema_permission_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Spectrum_integration_external_schema_permission_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Spectrum_integration_external_schema_permission_listContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Spectrum_integration_external_schema_permission_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spectrum_integration_external_schema_permission_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spectrum_integration_external_schema_permission_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSpectrum_integration_external_schema_permission_list(s) + } +} + +func (s *Spectrum_integration_external_schema_permission_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSpectrum_integration_external_schema_permission_list(s) + } +} + +func (s *Spectrum_integration_external_schema_permission_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSpectrum_integration_external_schema_permission_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Spectrum_integration_external_schema_permission_list() (localctx ISpectrum_integration_external_schema_permission_listContext) { + localctx = NewSpectrum_integration_external_schema_permission_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 634, RedshiftParserRULE_spectrum_integration_external_schema_permission_list) + var _la int + + p.SetState(6480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCREATE, RedshiftParserALTER, RedshiftParserDROP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6471) + p.Spectrum_integration_external_schema_permission() + } + p.SetState(6476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6472) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6473) + p.Spectrum_integration_external_schema_permission() + } + + p.SetState(6478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6479) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpectrum_integration_external_schema_permissionContext is an interface to support dynamic dispatch. +type ISpectrum_integration_external_schema_permissionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsSpectrum_integration_external_schema_permissionContext differentiates from other interfaces. + IsSpectrum_integration_external_schema_permissionContext() +} + +type Spectrum_integration_external_schema_permissionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpectrum_integration_external_schema_permissionContext() *Spectrum_integration_external_schema_permissionContext { + var p = new(Spectrum_integration_external_schema_permissionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_schema_permission + return p +} + +func InitEmptySpectrum_integration_external_schema_permissionContext(p *Spectrum_integration_external_schema_permissionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_schema_permission +} + +func (*Spectrum_integration_external_schema_permissionContext) IsSpectrum_integration_external_schema_permissionContext() { +} + +func NewSpectrum_integration_external_schema_permissionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spectrum_integration_external_schema_permissionContext { + var p = new(Spectrum_integration_external_schema_permissionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_schema_permission + + return p +} + +func (s *Spectrum_integration_external_schema_permissionContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Spectrum_integration_external_schema_permissionContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *Spectrum_integration_external_schema_permissionContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Spectrum_integration_external_schema_permissionContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Spectrum_integration_external_schema_permissionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spectrum_integration_external_schema_permissionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spectrum_integration_external_schema_permissionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSpectrum_integration_external_schema_permission(s) + } +} + +func (s *Spectrum_integration_external_schema_permissionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSpectrum_integration_external_schema_permission(s) + } +} + +func (s *Spectrum_integration_external_schema_permissionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSpectrum_integration_external_schema_permission(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Spectrum_integration_external_schema_permission() (localctx ISpectrum_integration_external_schema_permissionContext) { + localctx = NewSpectrum_integration_external_schema_permissionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 636, RedshiftParserRULE_spectrum_integration_external_schema_permission) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6482) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserALTER || _la == RedshiftParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_spectrum_integration_external_table_permissionsContext is an interface to support dynamic dispatch. +type IGrant_spectrum_integration_external_table_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Spectrum_integration_external_table_permission_list() ISpectrum_integration_external_table_permission_listContext + ON() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + TO() antlr.TerminalNode + Iamrolelist_or_public() IIamrolelist_or_publicContext + Opt_with_grant_option() IOpt_with_grant_optionContext + + // IsGrant_spectrum_integration_external_table_permissionsContext differentiates from other interfaces. + IsGrant_spectrum_integration_external_table_permissionsContext() +} + +type Grant_spectrum_integration_external_table_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_spectrum_integration_external_table_permissionsContext() *Grant_spectrum_integration_external_table_permissionsContext { + var p = new(Grant_spectrum_integration_external_table_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_external_table_permissions + return p +} + +func InitEmptyGrant_spectrum_integration_external_table_permissionsContext(p *Grant_spectrum_integration_external_table_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_external_table_permissions +} + +func (*Grant_spectrum_integration_external_table_permissionsContext) IsGrant_spectrum_integration_external_table_permissionsContext() { +} + +func NewGrant_spectrum_integration_external_table_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_spectrum_integration_external_table_permissionsContext { + var p = new(Grant_spectrum_integration_external_table_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_external_table_permissions + + return p +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) Spectrum_integration_external_table_permission_list() ISpectrum_integration_external_table_permission_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpectrum_integration_external_table_permission_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpectrum_integration_external_table_permission_listContext) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) Iamrolelist_or_public() IIamrolelist_or_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolelist_or_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolelist_or_publicContext) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) Opt_with_grant_option() IOpt_with_grant_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_grant_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_grant_optionContext) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_spectrum_integration_external_table_permissions(s) + } +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_spectrum_integration_external_table_permissions(s) + } +} + +func (s *Grant_spectrum_integration_external_table_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_spectrum_integration_external_table_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_spectrum_integration_external_table_permissions() (localctx IGrant_spectrum_integration_external_table_permissionsContext) { + localctx = NewGrant_spectrum_integration_external_table_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 638, RedshiftParserRULE_grant_spectrum_integration_external_table_permissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6484) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6485) + p.Spectrum_integration_external_table_permission_list() + } + { + p.SetState(6486) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6487) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6488) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6489) + p.Qualified_name_list() + } + { + p.SetState(6490) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6491) + p.Iamrolelist_or_public() + } + p.SetState(6493) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 461, p.GetParserRuleContext()) == 1 { + { + p.SetState(6492) + p.Opt_with_grant_option() + } + + } 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 +} + +// ISpectrum_integration_external_table_permissionContext is an interface to support dynamic dispatch. +type ISpectrum_integration_external_table_permissionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + ALTER() antlr.TerminalNode + DROP() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + INSERT() antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsSpectrum_integration_external_table_permissionContext differentiates from other interfaces. + IsSpectrum_integration_external_table_permissionContext() +} + +type Spectrum_integration_external_table_permissionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpectrum_integration_external_table_permissionContext() *Spectrum_integration_external_table_permissionContext { + var p = new(Spectrum_integration_external_table_permissionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_table_permission + return p +} + +func InitEmptySpectrum_integration_external_table_permissionContext(p *Spectrum_integration_external_table_permissionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_table_permission +} + +func (*Spectrum_integration_external_table_permissionContext) IsSpectrum_integration_external_table_permissionContext() { +} + +func NewSpectrum_integration_external_table_permissionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spectrum_integration_external_table_permissionContext { + var p = new(Spectrum_integration_external_table_permissionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_table_permission + + return p +} + +func (s *Spectrum_integration_external_table_permissionContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Spectrum_integration_external_table_permissionContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Spectrum_integration_external_table_permissionContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Spectrum_integration_external_table_permissionContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Spectrum_integration_external_table_permissionContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *Spectrum_integration_external_table_permissionContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *Spectrum_integration_external_table_permissionContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Spectrum_integration_external_table_permissionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spectrum_integration_external_table_permissionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spectrum_integration_external_table_permissionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSpectrum_integration_external_table_permission(s) + } +} + +func (s *Spectrum_integration_external_table_permissionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSpectrum_integration_external_table_permission(s) + } +} + +func (s *Spectrum_integration_external_table_permissionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSpectrum_integration_external_table_permission(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Spectrum_integration_external_table_permission() (localctx ISpectrum_integration_external_table_permissionContext) { + localctx = NewSpectrum_integration_external_table_permissionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 640, RedshiftParserRULE_spectrum_integration_external_table_permission) + p.SetState(6501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSELECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6495) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6496) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDROP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6497) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDELETE_P: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6498) + p.Match(RedshiftParserDELETE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserINSERT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6499) + p.Match(RedshiftParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6500) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISpectrum_integration_external_table_permission_listContext is an interface to support dynamic dispatch. +type ISpectrum_integration_external_table_permission_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSpectrum_integration_external_table_permission() []ISpectrum_integration_external_table_permissionContext + Spectrum_integration_external_table_permission(i int) ISpectrum_integration_external_table_permissionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSpectrum_integration_external_table_permission_listContext differentiates from other interfaces. + IsSpectrum_integration_external_table_permission_listContext() +} + +type Spectrum_integration_external_table_permission_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpectrum_integration_external_table_permission_listContext() *Spectrum_integration_external_table_permission_listContext { + var p = new(Spectrum_integration_external_table_permission_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_table_permission_list + return p +} + +func InitEmptySpectrum_integration_external_table_permission_listContext(p *Spectrum_integration_external_table_permission_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_table_permission_list +} + +func (*Spectrum_integration_external_table_permission_listContext) IsSpectrum_integration_external_table_permission_listContext() { +} + +func NewSpectrum_integration_external_table_permission_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spectrum_integration_external_table_permission_listContext { + var p = new(Spectrum_integration_external_table_permission_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_spectrum_integration_external_table_permission_list + + return p +} + +func (s *Spectrum_integration_external_table_permission_listContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Spectrum_integration_external_table_permission_listContext) AllSpectrum_integration_external_table_permission() []ISpectrum_integration_external_table_permissionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISpectrum_integration_external_table_permissionContext); ok { + len++ + } + } + + tst := make([]ISpectrum_integration_external_table_permissionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISpectrum_integration_external_table_permissionContext); ok { + tst[i] = t.(ISpectrum_integration_external_table_permissionContext) + i++ + } + } + + return tst +} + +func (s *Spectrum_integration_external_table_permission_listContext) Spectrum_integration_external_table_permission(i int) ISpectrum_integration_external_table_permissionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpectrum_integration_external_table_permissionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISpectrum_integration_external_table_permissionContext) +} + +func (s *Spectrum_integration_external_table_permission_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Spectrum_integration_external_table_permission_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Spectrum_integration_external_table_permission_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spectrum_integration_external_table_permission_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spectrum_integration_external_table_permission_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSpectrum_integration_external_table_permission_list(s) + } +} + +func (s *Spectrum_integration_external_table_permission_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSpectrum_integration_external_table_permission_list(s) + } +} + +func (s *Spectrum_integration_external_table_permission_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSpectrum_integration_external_table_permission_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Spectrum_integration_external_table_permission_list() (localctx ISpectrum_integration_external_table_permission_listContext) { + localctx = NewSpectrum_integration_external_table_permission_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 642, RedshiftParserRULE_spectrum_integration_external_table_permission_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6503) + p.Spectrum_integration_external_table_permission() + } + p.SetState(6508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6504) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6505) + p.Spectrum_integration_external_table_permission() + } + + p.SetState(6510) + 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 +} + +// IGrant_spectrum_integration_extenral_column_permissionsContext is an interface to support dynamic dispatch. +type IGrant_spectrum_integration_extenral_column_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + ON() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + TO() antlr.TerminalNode + Iamrolelist_or_public() IIamrolelist_or_publicContext + SELECT() antlr.TerminalNode + All_privileges() IAll_privilegesContext + Opt_with_grant_option() IOpt_with_grant_optionContext + + // IsGrant_spectrum_integration_extenral_column_permissionsContext differentiates from other interfaces. + IsGrant_spectrum_integration_extenral_column_permissionsContext() +} + +type Grant_spectrum_integration_extenral_column_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_spectrum_integration_extenral_column_permissionsContext() *Grant_spectrum_integration_extenral_column_permissionsContext { + var p = new(Grant_spectrum_integration_extenral_column_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_extenral_column_permissions + return p +} + +func InitEmptyGrant_spectrum_integration_extenral_column_permissionsContext(p *Grant_spectrum_integration_extenral_column_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_extenral_column_permissions +} + +func (*Grant_spectrum_integration_extenral_column_permissionsContext) IsGrant_spectrum_integration_extenral_column_permissionsContext() { +} + +func NewGrant_spectrum_integration_extenral_column_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_spectrum_integration_extenral_column_permissionsContext { + var p = new(Grant_spectrum_integration_extenral_column_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_spectrum_integration_extenral_column_permissions + + return p +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) Iamrolelist_or_public() IIamrolelist_or_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolelist_or_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolelist_or_publicContext) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) Opt_with_grant_option() IOpt_with_grant_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_grant_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_grant_optionContext) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_spectrum_integration_extenral_column_permissions(s) + } +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_spectrum_integration_extenral_column_permissions(s) + } +} + +func (s *Grant_spectrum_integration_extenral_column_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_spectrum_integration_extenral_column_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_spectrum_integration_extenral_column_permissions() (localctx IGrant_spectrum_integration_extenral_column_permissionsContext) { + localctx = NewGrant_spectrum_integration_extenral_column_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 644, RedshiftParserRULE_grant_spectrum_integration_extenral_column_permissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6511) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSELECT: + { + p.SetState(6512) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALL: + { + p.SetState(6513) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6516) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6517) + p.Columnlist() + } + { + p.SetState(6518) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6519) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6520) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6521) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6522) + p.Qualified_name() + } + { + p.SetState(6523) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6524) + p.Iamrolelist_or_public() + } + p.SetState(6526) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 465, p.GetParserRuleContext()) == 1 { + { + p.SetState(6525) + p.Opt_with_grant_option() + } + + } 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 +} + +// IIamrolelist_or_publicContext is an interface to support dynamic dispatch. +type IIamrolelist_or_publicContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Iamrolelist() IIamrolelistContext + PUBLIC() antlr.TerminalNode + + // IsIamrolelist_or_publicContext differentiates from other interfaces. + IsIamrolelist_or_publicContext() +} + +type Iamrolelist_or_publicContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIamrolelist_or_publicContext() *Iamrolelist_or_publicContext { + var p = new(Iamrolelist_or_publicContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolelist_or_public + return p +} + +func InitEmptyIamrolelist_or_publicContext(p *Iamrolelist_or_publicContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolelist_or_public +} + +func (*Iamrolelist_or_publicContext) IsIamrolelist_or_publicContext() {} + +func NewIamrolelist_or_publicContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Iamrolelist_or_publicContext { + var p = new(Iamrolelist_or_publicContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_iamrolelist_or_public + + return p +} + +func (s *Iamrolelist_or_publicContext) GetParser() antlr.Parser { return s.parser } + +func (s *Iamrolelist_or_publicContext) Iamrolelist() IIamrolelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolelistContext) +} + +func (s *Iamrolelist_or_publicContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLIC, 0) +} + +func (s *Iamrolelist_or_publicContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Iamrolelist_or_publicContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Iamrolelist_or_publicContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIamrolelist_or_public(s) + } +} + +func (s *Iamrolelist_or_publicContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIamrolelist_or_public(s) + } +} + +func (s *Iamrolelist_or_publicContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIamrolelist_or_public(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Iamrolelist_or_public() (localctx IIamrolelist_or_publicContext) { + localctx = NewIamrolelist_or_publicContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 646, RedshiftParserRULE_iamrolelist_or_public) + p.SetState(6530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIAM_ROLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6528) + p.Iamrolelist() + } + + case RedshiftParserPUBLIC: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6529) + p.Match(RedshiftParserPUBLIC) + 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 +} + +// IIamrolelistContext is an interface to support dynamic dispatch. +type IIamrolelistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIAM_ROLE() []antlr.TerminalNode + IAM_ROLE(i int) antlr.TerminalNode + AllIamrolevalue() []IIamrolevalueContext + Iamrolevalue(i int) IIamrolevalueContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIamrolelistContext differentiates from other interfaces. + IsIamrolelistContext() +} + +type IamrolelistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIamrolelistContext() *IamrolelistContext { + var p = new(IamrolelistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolelist + return p +} + +func InitEmptyIamrolelistContext(p *IamrolelistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolelist +} + +func (*IamrolelistContext) IsIamrolelistContext() {} + +func NewIamrolelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IamrolelistContext { + var p = new(IamrolelistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_iamrolelist + + return p +} + +func (s *IamrolelistContext) GetParser() antlr.Parser { return s.parser } + +func (s *IamrolelistContext) AllIAM_ROLE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserIAM_ROLE) +} + +func (s *IamrolelistContext) IAM_ROLE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, i) +} + +func (s *IamrolelistContext) AllIamrolevalue() []IIamrolevalueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIamrolevalueContext); ok { + len++ + } + } + + tst := make([]IIamrolevalueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIamrolevalueContext); ok { + tst[i] = t.(IIamrolevalueContext) + i++ + } + } + + return tst +} + +func (s *IamrolelistContext) Iamrolevalue(i int) IIamrolevalueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *IamrolelistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *IamrolelistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *IamrolelistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IamrolelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IamrolelistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIamrolelist(s) + } +} + +func (s *IamrolelistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIamrolelist(s) + } +} + +func (s *IamrolelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIamrolelist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Iamrolelist() (localctx IIamrolelistContext) { + localctx = NewIamrolelistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 648, RedshiftParserRULE_iamrolelist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6532) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6533) + p.Iamrolevalue() + } + p.SetState(6539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6534) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6535) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6536) + p.Iamrolevalue() + } + + p.SetState(6541) + 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 +} + +// IGrant_assume_role_permissionsContext is an interface to support dynamic dispatch. +type IGrant_assume_role_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + ASSUMEROLE() antlr.TerminalNode + Grant_assume_role_target() IGrant_assume_role_targetContext + TO() antlr.TerminalNode + Grantee_list() IGrantee_listContext + FOR() antlr.TerminalNode + Grant_assume_role_for_list() IGrant_assume_role_for_listContext + + // IsGrant_assume_role_permissionsContext differentiates from other interfaces. + IsGrant_assume_role_permissionsContext() +} + +type Grant_assume_role_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_assume_role_permissionsContext() *Grant_assume_role_permissionsContext { + var p = new(Grant_assume_role_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_permissions + return p +} + +func InitEmptyGrant_assume_role_permissionsContext(p *Grant_assume_role_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_permissions +} + +func (*Grant_assume_role_permissionsContext) IsGrant_assume_role_permissionsContext() {} + +func NewGrant_assume_role_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_assume_role_permissionsContext { + var p = new(Grant_assume_role_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_assume_role_permissions + + return p +} + +func (s *Grant_assume_role_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_assume_role_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_assume_role_permissionsContext) ASSUMEROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSUMEROLE, 0) +} + +func (s *Grant_assume_role_permissionsContext) Grant_assume_role_target() IGrant_assume_role_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_assume_role_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_assume_role_targetContext) +} + +func (s *Grant_assume_role_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_assume_role_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Grant_assume_role_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Grant_assume_role_permissionsContext) Grant_assume_role_for_list() IGrant_assume_role_for_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_assume_role_for_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_assume_role_for_listContext) +} + +func (s *Grant_assume_role_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_assume_role_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_assume_role_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_assume_role_permissions(s) + } +} + +func (s *Grant_assume_role_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_assume_role_permissions(s) + } +} + +func (s *Grant_assume_role_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_assume_role_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_assume_role_permissions() (localctx IGrant_assume_role_permissionsContext) { + localctx = NewGrant_assume_role_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 650, RedshiftParserRULE_grant_assume_role_permissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6542) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6543) + p.Match(RedshiftParserASSUMEROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6544) + p.Grant_assume_role_target() + } + { + p.SetState(6545) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6546) + p.Grantee_list() + } + { + p.SetState(6547) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6548) + p.Grant_assume_role_for_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 +} + +// IGrant_assume_role_for_listContext is an interface to support dynamic dispatch. +type IGrant_assume_role_for_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGrant_assume_role_for_item() []IGrant_assume_role_for_itemContext + Grant_assume_role_for_item(i int) IGrant_assume_role_for_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrant_assume_role_for_listContext differentiates from other interfaces. + IsGrant_assume_role_for_listContext() +} + +type Grant_assume_role_for_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_assume_role_for_listContext() *Grant_assume_role_for_listContext { + var p = new(Grant_assume_role_for_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_for_list + return p +} + +func InitEmptyGrant_assume_role_for_listContext(p *Grant_assume_role_for_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_for_list +} + +func (*Grant_assume_role_for_listContext) IsGrant_assume_role_for_listContext() {} + +func NewGrant_assume_role_for_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_assume_role_for_listContext { + var p = new(Grant_assume_role_for_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_assume_role_for_list + + return p +} + +func (s *Grant_assume_role_for_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_assume_role_for_listContext) AllGrant_assume_role_for_item() []IGrant_assume_role_for_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrant_assume_role_for_itemContext); ok { + len++ + } + } + + tst := make([]IGrant_assume_role_for_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrant_assume_role_for_itemContext); ok { + tst[i] = t.(IGrant_assume_role_for_itemContext) + i++ + } + } + + return tst +} + +func (s *Grant_assume_role_for_listContext) Grant_assume_role_for_item(i int) IGrant_assume_role_for_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_assume_role_for_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrant_assume_role_for_itemContext) +} + +func (s *Grant_assume_role_for_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_assume_role_for_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_assume_role_for_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_assume_role_for_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_assume_role_for_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_assume_role_for_list(s) + } +} + +func (s *Grant_assume_role_for_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_assume_role_for_list(s) + } +} + +func (s *Grant_assume_role_for_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_assume_role_for_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_assume_role_for_list() (localctx IGrant_assume_role_for_listContext) { + localctx = NewGrant_assume_role_for_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 652, RedshiftParserRULE_grant_assume_role_for_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6550) + p.Grant_assume_role_for_item() + } + p.SetState(6555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6551) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6552) + p.Grant_assume_role_for_item() + } + + p.SetState(6557) + 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 +} + +// IGrant_assume_role_for_itemContext is an interface to support dynamic dispatch. +type IGrant_assume_role_for_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + COPY() antlr.TerminalNode + UNLOAD() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + CREATE() antlr.TerminalNode + MODEL() antlr.TerminalNode + + // IsGrant_assume_role_for_itemContext differentiates from other interfaces. + IsGrant_assume_role_for_itemContext() +} + +type Grant_assume_role_for_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_assume_role_for_itemContext() *Grant_assume_role_for_itemContext { + var p = new(Grant_assume_role_for_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_for_item + return p +} + +func InitEmptyGrant_assume_role_for_itemContext(p *Grant_assume_role_for_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_for_item +} + +func (*Grant_assume_role_for_itemContext) IsGrant_assume_role_for_itemContext() {} + +func NewGrant_assume_role_for_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_assume_role_for_itemContext { + var p = new(Grant_assume_role_for_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_assume_role_for_item + + return p +} + +func (s *Grant_assume_role_for_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_assume_role_for_itemContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Grant_assume_role_for_itemContext) COPY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOPY, 0) +} + +func (s *Grant_assume_role_for_itemContext) UNLOAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLOAD, 0) +} + +func (s *Grant_assume_role_for_itemContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Grant_assume_role_for_itemContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Grant_assume_role_for_itemContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *Grant_assume_role_for_itemContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *Grant_assume_role_for_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_assume_role_for_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_assume_role_for_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_assume_role_for_item(s) + } +} + +func (s *Grant_assume_role_for_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_assume_role_for_item(s) + } +} + +func (s *Grant_assume_role_for_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_assume_role_for_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_assume_role_for_item() (localctx IGrant_assume_role_for_itemContext) { + localctx = NewGrant_assume_role_for_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 654, RedshiftParserRULE_grant_assume_role_for_item) + p.SetState(6565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6558) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCOPY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6559) + p.Match(RedshiftParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUNLOAD: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6560) + p.Match(RedshiftParserUNLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEXTERNAL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6561) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6562) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCREATE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6563) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6564) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_assume_role_targetContext is an interface to support dynamic dispatch. +type IGrant_assume_role_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DEFAULT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsGrant_assume_role_targetContext differentiates from other interfaces. + IsGrant_assume_role_targetContext() +} + +type Grant_assume_role_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_assume_role_targetContext() *Grant_assume_role_targetContext { + var p = new(Grant_assume_role_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_target + return p +} + +func InitEmptyGrant_assume_role_targetContext(p *Grant_assume_role_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_assume_role_target +} + +func (*Grant_assume_role_targetContext) IsGrant_assume_role_targetContext() {} + +func NewGrant_assume_role_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_assume_role_targetContext { + var p = new(Grant_assume_role_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_assume_role_target + + return p +} + +func (s *Grant_assume_role_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_assume_role_targetContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Grant_assume_role_targetContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Grant_assume_role_targetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_assume_role_targetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_assume_role_targetContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Grant_assume_role_targetContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Grant_assume_role_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_assume_role_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_assume_role_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_assume_role_target(s) + } +} + +func (s *Grant_assume_role_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_assume_role_target(s) + } +} + +func (s *Grant_assume_role_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_assume_role_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_assume_role_target() (localctx IGrant_assume_role_targetContext) { + localctx = NewGrant_assume_role_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 656, RedshiftParserRULE_grant_assume_role_target) + var _la int + + p.SetState(6577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6567) + p.Sconst() + } + p.SetState(6572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6568) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6569) + p.Sconst() + } + + p.SetState(6574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6575) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6576) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_column_level_permissionsContext is an interface to support dynamic dispatch. +type IGrant_column_level_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Column_privilege_list() IColumn_privilege_listContext + ON() antlr.TerminalNode + Column_privilege_target() IColumn_privilege_targetContext + TO() antlr.TerminalNode + Grantee_list() IGrantee_listContext + + // IsGrant_column_level_permissionsContext differentiates from other interfaces. + IsGrant_column_level_permissionsContext() +} + +type Grant_column_level_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_column_level_permissionsContext() *Grant_column_level_permissionsContext { + var p = new(Grant_column_level_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_column_level_permissions + return p +} + +func InitEmptyGrant_column_level_permissionsContext(p *Grant_column_level_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_column_level_permissions +} + +func (*Grant_column_level_permissionsContext) IsGrant_column_level_permissionsContext() {} + +func NewGrant_column_level_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_column_level_permissionsContext { + var p = new(Grant_column_level_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_column_level_permissions + + return p +} + +func (s *Grant_column_level_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_column_level_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Grant_column_level_permissionsContext) Column_privilege_list() IColumn_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_privilege_listContext) +} + +func (s *Grant_column_level_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Grant_column_level_permissionsContext) Column_privilege_target() IColumn_privilege_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_privilege_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_privilege_targetContext) +} + +func (s *Grant_column_level_permissionsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Grant_column_level_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Grant_column_level_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_column_level_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_column_level_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_column_level_permissions(s) + } +} + +func (s *Grant_column_level_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_column_level_permissions(s) + } +} + +func (s *Grant_column_level_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_column_level_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_column_level_permissions() (localctx IGrant_column_level_permissionsContext) { + localctx = NewGrant_column_level_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 658, RedshiftParserRULE_grant_column_level_permissions) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6579) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6580) + p.Column_privilege_list() + } + { + p.SetState(6581) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6582) + p.Column_privilege_target() + } + { + p.SetState(6583) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6584) + p.Grantee_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 +} + +// IColumn_privilege_targetContext is an interface to support dynamic dispatch. +type IColumn_privilege_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name_list() IQualified_name_listContext + TABLE() antlr.TerminalNode + + // IsColumn_privilege_targetContext differentiates from other interfaces. + IsColumn_privilege_targetContext() +} + +type Column_privilege_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_privilege_targetContext() *Column_privilege_targetContext { + var p = new(Column_privilege_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_privilege_target + return p +} + +func InitEmptyColumn_privilege_targetContext(p *Column_privilege_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_privilege_target +} + +func (*Column_privilege_targetContext) IsColumn_privilege_targetContext() {} + +func NewColumn_privilege_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_privilege_targetContext { + var p = new(Column_privilege_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_column_privilege_target + + return p +} + +func (s *Column_privilege_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_privilege_targetContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Column_privilege_targetContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Column_privilege_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_privilege_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_privilege_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumn_privilege_target(s) + } +} + +func (s *Column_privilege_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumn_privilege_target(s) + } +} + +func (s *Column_privilege_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumn_privilege_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Column_privilege_target() (localctx IColumn_privilege_targetContext) { + localctx = NewColumn_privilege_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 660, RedshiftParserRULE_column_privilege_target) + p.EnterOuterAlt(localctx, 1) + p.SetState(6587) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 472, p.GetParserRuleContext()) == 1 { + { + p.SetState(6586) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6589) + p.Qualified_name_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_privilege_listContext is an interface to support dynamic dispatch. +type IColumn_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_select_update_privilege() []IColumn_select_update_privilegeContext + Column_select_update_privilege(i int) IColumn_select_update_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllColumn_all_privilege() []IColumn_all_privilegeContext + Column_all_privilege(i int) IColumn_all_privilegeContext + + // IsColumn_privilege_listContext differentiates from other interfaces. + IsColumn_privilege_listContext() +} + +type Column_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_privilege_listContext() *Column_privilege_listContext { + var p = new(Column_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_privilege_list + return p +} + +func InitEmptyColumn_privilege_listContext(p *Column_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_privilege_list +} + +func (*Column_privilege_listContext) IsColumn_privilege_listContext() {} + +func NewColumn_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_privilege_listContext { + var p = new(Column_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_column_privilege_list + + return p +} + +func (s *Column_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_privilege_listContext) AllColumn_select_update_privilege() []IColumn_select_update_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_select_update_privilegeContext); ok { + len++ + } + } + + tst := make([]IColumn_select_update_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_select_update_privilegeContext); ok { + tst[i] = t.(IColumn_select_update_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Column_privilege_listContext) Column_select_update_privilege(i int) IColumn_select_update_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_select_update_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_select_update_privilegeContext) +} + +func (s *Column_privilege_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Column_privilege_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Column_privilege_listContext) AllColumn_all_privilege() []IColumn_all_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_all_privilegeContext); ok { + len++ + } + } + + tst := make([]IColumn_all_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_all_privilegeContext); ok { + tst[i] = t.(IColumn_all_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Column_privilege_listContext) Column_all_privilege(i int) IColumn_all_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_all_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_all_privilegeContext) +} + +func (s *Column_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumn_privilege_list(s) + } +} + +func (s *Column_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumn_privilege_list(s) + } +} + +func (s *Column_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumn_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Column_privilege_list() (localctx IColumn_privilege_listContext) { + localctx = NewColumn_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 662, RedshiftParserRULE_column_privilege_list) + var _la int + + p.SetState(6607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSELECT, RedshiftParserUPDATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6591) + p.Column_select_update_privilege() + } + p.SetState(6596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6592) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6593) + p.Column_select_update_privilege() + } + + p.SetState(6598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6599) + p.Column_all_privilege() + } + p.SetState(6604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6600) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6601) + p.Column_all_privilege() + } + + p.SetState(6606) + 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 +} + +// IColumn_all_privilegeContext is an interface to support dynamic dispatch. +type IColumn_all_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + Columnlist() IColumnlistContext + + // IsColumn_all_privilegeContext differentiates from other interfaces. + IsColumn_all_privilegeContext() +} + +type Column_all_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_all_privilegeContext() *Column_all_privilegeContext { + var p = new(Column_all_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_all_privilege + return p +} + +func InitEmptyColumn_all_privilegeContext(p *Column_all_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_all_privilege +} + +func (*Column_all_privilegeContext) IsColumn_all_privilegeContext() {} + +func NewColumn_all_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_all_privilegeContext { + var p = new(Column_all_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_column_all_privilege + + return p +} + +func (s *Column_all_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_all_privilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Column_all_privilegeContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Column_all_privilegeContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Column_all_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIVILEGES, 0) +} + +func (s *Column_all_privilegeContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Column_all_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_all_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_all_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumn_all_privilege(s) + } +} + +func (s *Column_all_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumn_all_privilege(s) + } +} + +func (s *Column_all_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumn_all_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Column_all_privilege() (localctx IColumn_all_privilegeContext) { + localctx = NewColumn_all_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 664, RedshiftParserRULE_column_all_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6609) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPRIVILEGES { + { + p.SetState(6610) + p.Match(RedshiftParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6613) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(6614) + p.Columnlist() + } + + } + { + p.SetState(6617) + p.Match(RedshiftParserCLOSE_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_select_update_privilegeContext is an interface to support dynamic dispatch. +type IColumn_select_update_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + Columnlist() IColumnlistContext + + // IsColumn_select_update_privilegeContext differentiates from other interfaces. + IsColumn_select_update_privilegeContext() +} + +type Column_select_update_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_select_update_privilegeContext() *Column_select_update_privilegeContext { + var p = new(Column_select_update_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_select_update_privilege + return p +} + +func InitEmptyColumn_select_update_privilegeContext(p *Column_select_update_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_column_select_update_privilege +} + +func (*Column_select_update_privilegeContext) IsColumn_select_update_privilegeContext() {} + +func NewColumn_select_update_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_select_update_privilegeContext { + var p = new(Column_select_update_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_column_select_update_privilege + + return p +} + +func (s *Column_select_update_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_select_update_privilegeContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Column_select_update_privilegeContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Column_select_update_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Column_select_update_privilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Column_select_update_privilegeContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Column_select_update_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_select_update_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_select_update_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumn_select_update_privilege(s) + } +} + +func (s *Column_select_update_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumn_select_update_privilege(s) + } +} + +func (s *Column_select_update_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumn_select_update_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Column_select_update_privilege() (localctx IColumn_select_update_privilegeContext) { + localctx = NewColumn_select_update_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 666, RedshiftParserRULE_column_select_update_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6619) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserSELECT || _la == RedshiftParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6620) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(6621) + p.Columnlist() + } + + } + { + p.SetState(6624) + p.Match(RedshiftParserCLOSE_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 +} + +// ICommon_grantContext is an interface to support dynamic dispatch. +type ICommon_grantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Table_privilege_list() ITable_privilege_listContext + ON() antlr.TerminalNode + Grant_table_target() IGrant_table_targetContext + TO() antlr.TerminalNode + Grantee_list() IGrantee_listContext + Database_privilege_list() IDatabase_privilege_listContext + Grant_database_target() IGrant_database_targetContext + Schema_privilege_list() ISchema_privilege_listContext + Grant_schema_target() IGrant_schema_targetContext + Function_privilege_list() IFunction_privilege_listContext + Grant_function_target() IGrant_function_targetContext + Procedure_privilege_list() IProcedure_privilege_listContext + Grant_procedure_target() IGrant_procedure_targetContext + Language_privilege_list() ILanguage_privilege_listContext + Grant_language_target() IGrant_language_targetContext + Copy_job_privilege_list() ICopy_job_privilege_listContext + Copy_job_target() ICopy_job_targetContext + + // IsCommon_grantContext differentiates from other interfaces. + IsCommon_grantContext() +} + +type Common_grantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommon_grantContext() *Common_grantContext { + var p = new(Common_grantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_grant + return p +} + +func InitEmptyCommon_grantContext(p *Common_grantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_grant +} + +func (*Common_grantContext) IsCommon_grantContext() {} + +func NewCommon_grantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_grantContext { + var p = new(Common_grantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_common_grant + + return p +} + +func (s *Common_grantContext) GetParser() antlr.Parser { return s.parser } + +func (s *Common_grantContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Common_grantContext) Table_privilege_list() ITable_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_privilege_listContext) +} + +func (s *Common_grantContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Common_grantContext) Grant_table_target() IGrant_table_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_table_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_table_targetContext) +} + +func (s *Common_grantContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Common_grantContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Common_grantContext) Database_privilege_list() IDatabase_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_privilege_listContext) +} + +func (s *Common_grantContext) Grant_database_target() IGrant_database_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_database_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_database_targetContext) +} + +func (s *Common_grantContext) Schema_privilege_list() ISchema_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilege_listContext) +} + +func (s *Common_grantContext) Grant_schema_target() IGrant_schema_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_schema_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_schema_targetContext) +} + +func (s *Common_grantContext) Function_privilege_list() IFunction_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_privilege_listContext) +} + +func (s *Common_grantContext) Grant_function_target() IGrant_function_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_function_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_function_targetContext) +} + +func (s *Common_grantContext) Procedure_privilege_list() IProcedure_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_privilege_listContext) +} + +func (s *Common_grantContext) Grant_procedure_target() IGrant_procedure_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_procedure_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_procedure_targetContext) +} + +func (s *Common_grantContext) Language_privilege_list() ILanguage_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguage_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguage_privilege_listContext) +} + +func (s *Common_grantContext) Grant_language_target() IGrant_language_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_language_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_language_targetContext) +} + +func (s *Common_grantContext) Copy_job_privilege_list() ICopy_job_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_privilege_listContext) +} + +func (s *Common_grantContext) Copy_job_target() ICopy_job_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_targetContext) +} + +func (s *Common_grantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Common_grantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Common_grantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCommon_grant(s) + } +} + +func (s *Common_grantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCommon_grant(s) + } +} + +func (s *Common_grantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCommon_grant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Common_grant() (localctx ICommon_grantContext) { + localctx = NewCommon_grantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 668, RedshiftParserRULE_common_grant) + p.SetState(6675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6626) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6627) + p.Table_privilege_list() + } + { + p.SetState(6628) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6629) + p.Grant_table_target() + } + { + p.SetState(6630) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6631) + p.Grantee_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6633) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6634) + p.Database_privilege_list() + } + { + p.SetState(6635) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6636) + p.Grant_database_target() + } + { + p.SetState(6637) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6638) + p.Grantee_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6640) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6641) + p.Schema_privilege_list() + } + { + p.SetState(6642) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6643) + p.Grant_schema_target() + } + { + p.SetState(6644) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6645) + p.Grantee_list() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6647) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6648) + p.Function_privilege_list() + } + { + p.SetState(6649) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6650) + p.Grant_function_target() + } + { + p.SetState(6651) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6652) + p.Grantee_list() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6654) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6655) + p.Procedure_privilege_list() + } + { + p.SetState(6656) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6657) + p.Grant_procedure_target() + } + { + p.SetState(6658) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6659) + p.Grantee_list() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6661) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6662) + p.Language_privilege_list() + } + { + p.SetState(6663) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6664) + p.Grant_language_target() + } + { + p.SetState(6665) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6666) + p.Grantee_list() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6668) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6669) + p.Copy_job_privilege_list() + } + { + p.SetState(6670) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6671) + p.Copy_job_target() + } + { + p.SetState(6672) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6673) + p.Grantee_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_job_privilege_listContext is an interface to support dynamic dispatch. +type ICopy_job_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCopy_job_privilege() []ICopy_job_privilegeContext + Copy_job_privilege(i int) ICopy_job_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsCopy_job_privilege_listContext differentiates from other interfaces. + IsCopy_job_privilege_listContext() +} + +type Copy_job_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_job_privilege_listContext() *Copy_job_privilege_listContext { + var p = new(Copy_job_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_privilege_list + return p +} + +func InitEmptyCopy_job_privilege_listContext(p *Copy_job_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_privilege_list +} + +func (*Copy_job_privilege_listContext) IsCopy_job_privilege_listContext() {} + +func NewCopy_job_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_job_privilege_listContext { + var p = new(Copy_job_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_job_privilege_list + + return p +} + +func (s *Copy_job_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_job_privilege_listContext) AllCopy_job_privilege() []ICopy_job_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICopy_job_privilegeContext); ok { + len++ + } + } + + tst := make([]ICopy_job_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICopy_job_privilegeContext); ok { + tst[i] = t.(ICopy_job_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Copy_job_privilege_listContext) Copy_job_privilege(i int) ICopy_job_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_privilegeContext) +} + +func (s *Copy_job_privilege_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Copy_job_privilege_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Copy_job_privilege_listContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Copy_job_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_job_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_job_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_job_privilege_list(s) + } +} + +func (s *Copy_job_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_job_privilege_list(s) + } +} + +func (s *Copy_job_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_job_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_job_privilege_list() (localctx ICopy_job_privilege_listContext) { + localctx = NewCopy_job_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 670, RedshiftParserRULE_copy_job_privilege_list) + var _la int + + p.SetState(6686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserALTER, RedshiftParserDROP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6677) + p.Copy_job_privilege() + } + p.SetState(6682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6678) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6679) + p.Copy_job_privilege() + } + + p.SetState(6684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6685) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_job_privilegeContext is an interface to support dynamic dispatch. +type ICopy_job_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsCopy_job_privilegeContext differentiates from other interfaces. + IsCopy_job_privilegeContext() +} + +type Copy_job_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_job_privilegeContext() *Copy_job_privilegeContext { + var p = new(Copy_job_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_privilege + return p +} + +func InitEmptyCopy_job_privilegeContext(p *Copy_job_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_privilege +} + +func (*Copy_job_privilegeContext) IsCopy_job_privilegeContext() {} + +func NewCopy_job_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_job_privilegeContext { + var p = new(Copy_job_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_job_privilege + + return p +} + +func (s *Copy_job_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_job_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Copy_job_privilegeContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Copy_job_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_job_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_job_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_job_privilege(s) + } +} + +func (s *Copy_job_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_job_privilege(s) + } +} + +func (s *Copy_job_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_job_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_job_privilege() (localctx ICopy_job_privilegeContext) { + localctx = NewCopy_job_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 672, RedshiftParserRULE_copy_job_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6688) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALTER || _la == RedshiftParserDROP) { + 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 +} + +// ICopy_job_targetContext is an interface to support dynamic dispatch. +type ICopy_job_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COPY() antlr.TerminalNode + JOB() antlr.TerminalNode + AllCopy_job_name() []ICopy_job_nameContext + Copy_job_name(i int) ICopy_job_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCopy_job_targetContext differentiates from other interfaces. + IsCopy_job_targetContext() +} + +type Copy_job_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_job_targetContext() *Copy_job_targetContext { + var p = new(Copy_job_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_target + return p +} + +func InitEmptyCopy_job_targetContext(p *Copy_job_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_target +} + +func (*Copy_job_targetContext) IsCopy_job_targetContext() {} + +func NewCopy_job_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_job_targetContext { + var p = new(Copy_job_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_job_target + + return p +} + +func (s *Copy_job_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_job_targetContext) COPY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOPY, 0) +} + +func (s *Copy_job_targetContext) JOB() antlr.TerminalNode { + return s.GetToken(RedshiftParserJOB, 0) +} + +func (s *Copy_job_targetContext) AllCopy_job_name() []ICopy_job_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICopy_job_nameContext); ok { + len++ + } + } + + tst := make([]ICopy_job_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICopy_job_nameContext); ok { + tst[i] = t.(ICopy_job_nameContext) + i++ + } + } + + return tst +} + +func (s *Copy_job_targetContext) Copy_job_name(i int) ICopy_job_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_nameContext) +} + +func (s *Copy_job_targetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Copy_job_targetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Copy_job_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_job_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_job_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_job_target(s) + } +} + +func (s *Copy_job_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_job_target(s) + } +} + +func (s *Copy_job_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_job_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_job_target() (localctx ICopy_job_targetContext) { + localctx = NewCopy_job_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 674, RedshiftParserRULE_copy_job_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6690) + p.Match(RedshiftParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6691) + p.Match(RedshiftParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6692) + p.Copy_job_name() + } + p.SetState(6697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6693) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6694) + p.Copy_job_name() + } + + p.SetState(6699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICopy_job_nameContext is an interface to support dynamic dispatch. +type ICopy_job_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + + // IsCopy_job_nameContext differentiates from other interfaces. + IsCopy_job_nameContext() +} + +type Copy_job_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_job_nameContext() *Copy_job_nameContext { + var p = new(Copy_job_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_name + return p +} + +func InitEmptyCopy_job_nameContext(p *Copy_job_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_copy_job_name +} + +func (*Copy_job_nameContext) IsCopy_job_nameContext() {} + +func NewCopy_job_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_job_nameContext { + var p = new(Copy_job_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_copy_job_name + + return p +} + +func (s *Copy_job_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_job_nameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Copy_job_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_job_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_job_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCopy_job_name(s) + } +} + +func (s *Copy_job_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCopy_job_name(s) + } +} + +func (s *Copy_job_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCopy_job_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Copy_job_name() (localctx ICopy_job_nameContext) { + localctx = NewCopy_job_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 676, RedshiftParserRULE_copy_job_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6700) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILanguage_privilege_listContext is an interface to support dynamic dispatch. +type ILanguage_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USAGE() antlr.TerminalNode + + // IsLanguage_privilege_listContext differentiates from other interfaces. + IsLanguage_privilege_listContext() +} + +type Language_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLanguage_privilege_listContext() *Language_privilege_listContext { + var p = new(Language_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_language_privilege_list + return p +} + +func InitEmptyLanguage_privilege_listContext(p *Language_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_language_privilege_list +} + +func (*Language_privilege_listContext) IsLanguage_privilege_listContext() {} + +func NewLanguage_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Language_privilege_listContext { + var p = new(Language_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_language_privilege_list + + return p +} + +func (s *Language_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Language_privilege_listContext) USAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSAGE, 0) +} + +func (s *Language_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Language_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Language_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLanguage_privilege_list(s) + } +} + +func (s *Language_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLanguage_privilege_list(s) + } +} + +func (s *Language_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLanguage_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Language_privilege_list() (localctx ILanguage_privilege_listContext) { + localctx = NewLanguage_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 678, RedshiftParserRULE_language_privilege_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6702) + p.Match(RedshiftParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_language_targetContext is an interface to support dynamic dispatch. +type IGrant_language_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LANGUAGE() antlr.TerminalNode + Columnlist() IColumnlistContext + + // IsGrant_language_targetContext differentiates from other interfaces. + IsGrant_language_targetContext() +} + +type Grant_language_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_language_targetContext() *Grant_language_targetContext { + var p = new(Grant_language_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_language_target + return p +} + +func InitEmptyGrant_language_targetContext(p *Grant_language_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_language_target +} + +func (*Grant_language_targetContext) IsGrant_language_targetContext() {} + +func NewGrant_language_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_language_targetContext { + var p = new(Grant_language_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_language_target + + return p +} + +func (s *Grant_language_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_language_targetContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *Grant_language_targetContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_language_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_language_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_language_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_language_target(s) + } +} + +func (s *Grant_language_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_language_target(s) + } +} + +func (s *Grant_language_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_language_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_language_target() (localctx IGrant_language_targetContext) { + localctx = NewGrant_language_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 680, RedshiftParserRULE_grant_language_target) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6704) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6705) + p.Columnlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_procedure_targetContext is an interface to support dynamic dispatch. +type IGrant_procedure_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + AllFunction_with_argtypes_list() []IFunction_with_argtypes_listContext + Function_with_argtypes_list(i int) IFunction_with_argtypes_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALL() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + IN_P() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Columnlist() IColumnlistContext + + // IsGrant_procedure_targetContext differentiates from other interfaces. + IsGrant_procedure_targetContext() +} + +type Grant_procedure_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_procedure_targetContext() *Grant_procedure_targetContext { + var p = new(Grant_procedure_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_procedure_target + return p +} + +func InitEmptyGrant_procedure_targetContext(p *Grant_procedure_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_procedure_target +} + +func (*Grant_procedure_targetContext) IsGrant_procedure_targetContext() {} + +func NewGrant_procedure_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_procedure_targetContext { + var p = new(Grant_procedure_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_procedure_target + + return p +} + +func (s *Grant_procedure_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_procedure_targetContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *Grant_procedure_targetContext) AllFunction_with_argtypes_list() []IFunction_with_argtypes_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { + len++ + } + } + + tst := make([]IFunction_with_argtypes_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_with_argtypes_listContext); ok { + tst[i] = t.(IFunction_with_argtypes_listContext) + i++ + } + } + + return tst +} + +func (s *Grant_procedure_targetContext) Function_with_argtypes_list(i int) IFunction_with_argtypes_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypes_listContext) +} + +func (s *Grant_procedure_targetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_procedure_targetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_procedure_targetContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Grant_procedure_targetContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURES, 0) +} + +func (s *Grant_procedure_targetContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_procedure_targetContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_procedure_targetContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_procedure_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_procedure_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_procedure_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_procedure_target(s) + } +} + +func (s *Grant_procedure_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_procedure_target(s) + } +} + +func (s *Grant_procedure_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_procedure_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_procedure_target() (localctx IGrant_procedure_targetContext) { + localctx = NewGrant_procedure_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 682, RedshiftParserRULE_grant_procedure_target) + var _la int + + p.SetState(6721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserPROCEDURE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6707) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6708) + p.Function_with_argtypes_list() + } + p.SetState(6713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6709) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6710) + p.Function_with_argtypes_list() + } + + p.SetState(6715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6716) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6717) + p.Match(RedshiftParserPROCEDURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6718) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6719) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6720) + p.Columnlist() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_privilege_listContext is an interface to support dynamic dispatch. +type IProcedure_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Procedure_privilege() IProcedure_privilegeContext + All_privileges() IAll_privilegesContext + + // IsProcedure_privilege_listContext differentiates from other interfaces. + IsProcedure_privilege_listContext() +} + +type Procedure_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_privilege_listContext() *Procedure_privilege_listContext { + var p = new(Procedure_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_procedure_privilege_list + return p +} + +func InitEmptyProcedure_privilege_listContext(p *Procedure_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_procedure_privilege_list +} + +func (*Procedure_privilege_listContext) IsProcedure_privilege_listContext() {} + +func NewProcedure_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_privilege_listContext { + var p = new(Procedure_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_procedure_privilege_list + + return p +} + +func (s *Procedure_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_privilege_listContext) Procedure_privilege() IProcedure_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_privilegeContext) +} + +func (s *Procedure_privilege_listContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Procedure_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProcedure_privilege_list(s) + } +} + +func (s *Procedure_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProcedure_privilege_list(s) + } +} + +func (s *Procedure_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProcedure_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Procedure_privilege_list() (localctx IProcedure_privilege_listContext) { + localctx = NewProcedure_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 684, RedshiftParserRULE_procedure_privilege_list) + p.SetState(6725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6723) + p.Procedure_privilege() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6724) + p.All_privileges() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_privilegeContext is an interface to support dynamic dispatch. +type IProcedure_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsProcedure_privilegeContext differentiates from other interfaces. + IsProcedure_privilegeContext() +} + +type Procedure_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_privilegeContext() *Procedure_privilegeContext { + var p = new(Procedure_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_procedure_privilege + return p +} + +func InitEmptyProcedure_privilegeContext(p *Procedure_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_procedure_privilege +} + +func (*Procedure_privilegeContext) IsProcedure_privilegeContext() {} + +func NewProcedure_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_privilegeContext { + var p = new(Procedure_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_procedure_privilege + + return p +} + +func (s *Procedure_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_privilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *Procedure_privilegeContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Procedure_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProcedure_privilege(s) + } +} + +func (s *Procedure_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProcedure_privilege(s) + } +} + +func (s *Procedure_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProcedure_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Procedure_privilege() (localctx IProcedure_privilegeContext) { + localctx = NewProcedure_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 686, RedshiftParserRULE_procedure_privilege) + p.SetState(6729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserEXECUTE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6727) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6728) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_privilege_listContext is an interface to support dynamic dispatch. +type IFunction_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Function_privilege() IFunction_privilegeContext + All_privileges() IAll_privilegesContext + + // IsFunction_privilege_listContext differentiates from other interfaces. + IsFunction_privilege_listContext() +} + +type Function_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_privilege_listContext() *Function_privilege_listContext { + var p = new(Function_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_privilege_list + return p +} + +func InitEmptyFunction_privilege_listContext(p *Function_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_privilege_list +} + +func (*Function_privilege_listContext) IsFunction_privilege_listContext() {} + +func NewFunction_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_privilege_listContext { + var p = new(Function_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_function_privilege_list + + return p +} + +func (s *Function_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_privilege_listContext) Function_privilege() IFunction_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_privilegeContext) +} + +func (s *Function_privilege_listContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Function_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunction_privilege_list(s) + } +} + +func (s *Function_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunction_privilege_list(s) + } +} + +func (s *Function_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunction_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Function_privilege_list() (localctx IFunction_privilege_listContext) { + localctx = NewFunction_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 688, RedshiftParserRULE_function_privilege_list) + p.SetState(6733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 487, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6731) + p.Function_privilege() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6732) + p.All_privileges() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_privilegeContext is an interface to support dynamic dispatch. +type IFunction_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsFunction_privilegeContext differentiates from other interfaces. + IsFunction_privilegeContext() +} + +type Function_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_privilegeContext() *Function_privilegeContext { + var p = new(Function_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_privilege + return p +} + +func InitEmptyFunction_privilegeContext(p *Function_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_privilege +} + +func (*Function_privilegeContext) IsFunction_privilegeContext() {} + +func NewFunction_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_privilegeContext { + var p = new(Function_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_function_privilege + + return p +} + +func (s *Function_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_privilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *Function_privilegeContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Function_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunction_privilege(s) + } +} + +func (s *Function_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunction_privilege(s) + } +} + +func (s *Function_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunction_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Function_privilege() (localctx IFunction_privilegeContext) { + localctx = NewFunction_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 690, RedshiftParserRULE_function_privilege) + p.SetState(6737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserEXECUTE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6735) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6736) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_function_targetContext is an interface to support dynamic dispatch. +type IGrant_function_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + AllFunction_with_argtypes_list() []IFunction_with_argtypes_listContext + Function_with_argtypes_list(i int) IFunction_with_argtypes_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALL() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + IN_P() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Columnlist() IColumnlistContext + + // IsGrant_function_targetContext differentiates from other interfaces. + IsGrant_function_targetContext() +} + +type Grant_function_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_function_targetContext() *Grant_function_targetContext { + var p = new(Grant_function_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_function_target + return p +} + +func InitEmptyGrant_function_targetContext(p *Grant_function_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_function_target +} + +func (*Grant_function_targetContext) IsGrant_function_targetContext() {} + +func NewGrant_function_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_function_targetContext { + var p = new(Grant_function_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_function_target + + return p +} + +func (s *Grant_function_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_function_targetContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Grant_function_targetContext) AllFunction_with_argtypes_list() []IFunction_with_argtypes_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { + len++ + } + } + + tst := make([]IFunction_with_argtypes_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_with_argtypes_listContext); ok { + tst[i] = t.(IFunction_with_argtypes_listContext) + i++ + } + } + + return tst +} + +func (s *Grant_function_targetContext) Function_with_argtypes_list(i int) IFunction_with_argtypes_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypes_listContext) +} + +func (s *Grant_function_targetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_function_targetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_function_targetContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Grant_function_targetContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTIONS, 0) +} + +func (s *Grant_function_targetContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Grant_function_targetContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_function_targetContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Grant_function_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_function_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_function_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_function_target(s) + } +} + +func (s *Grant_function_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_function_target(s) + } +} + +func (s *Grant_function_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_function_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_function_target() (localctx IGrant_function_targetContext) { + localctx = NewGrant_function_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 692, RedshiftParserRULE_grant_function_target) + var _la int + + p.SetState(6753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserFUNCTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6739) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6740) + p.Function_with_argtypes_list() + } + p.SetState(6745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6741) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6742) + p.Function_with_argtypes_list() + } + + p.SetState(6747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6748) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6749) + p.Match(RedshiftParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6750) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6751) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6752) + p.Columnlist() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_schema_targetContext is an interface to support dynamic dispatch. +type IGrant_schema_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrant_schema_targetContext differentiates from other interfaces. + IsGrant_schema_targetContext() +} + +type Grant_schema_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_schema_targetContext() *Grant_schema_targetContext { + var p = new(Grant_schema_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_schema_target + return p +} + +func InitEmptyGrant_schema_targetContext(p *Grant_schema_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_schema_target +} + +func (*Grant_schema_targetContext) IsGrant_schema_targetContext() {} + +func NewGrant_schema_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_schema_targetContext { + var p = new(Grant_schema_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_schema_target + + return p +} + +func (s *Grant_schema_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_schema_targetContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Grant_schema_targetContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Grant_schema_targetContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_schema_targetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_schema_targetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_schema_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_schema_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_schema_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_schema_target(s) + } +} + +func (s *Grant_schema_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_schema_target(s) + } +} + +func (s *Grant_schema_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_schema_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_schema_target() (localctx IGrant_schema_targetContext) { + localctx = NewGrant_schema_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 694, RedshiftParserRULE_grant_schema_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6755) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6756) + p.Colid() + } + p.SetState(6761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6757) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6758) + p.Colid() + } + + p.SetState(6763) + 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_schema_targetContext is an interface to support dynamic dispatch. +type IRevoke_schema_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRevoke_schema_targetContext differentiates from other interfaces. + IsRevoke_schema_targetContext() +} + +type Revoke_schema_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_schema_targetContext() *Revoke_schema_targetContext { + var p = new(Revoke_schema_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_schema_target + return p +} + +func InitEmptyRevoke_schema_targetContext(p *Revoke_schema_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_schema_target +} + +func (*Revoke_schema_targetContext) IsRevoke_schema_targetContext() {} + +func NewRevoke_schema_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_schema_targetContext { + var p = new(Revoke_schema_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_schema_target + + return p +} + +func (s *Revoke_schema_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_schema_targetContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Revoke_schema_targetContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Revoke_schema_targetContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_schema_targetContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *Revoke_schema_targetContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *Revoke_schema_targetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Revoke_schema_targetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Revoke_schema_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_schema_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_schema_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_schema_target(s) + } +} + +func (s *Revoke_schema_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_schema_target(s) + } +} + +func (s *Revoke_schema_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_schema_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_schema_target() (localctx IRevoke_schema_targetContext) { + localctx = NewRevoke_schema_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 696, RedshiftParserRULE_revoke_schema_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6764) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6767) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 492, p.GetParserRuleContext()) == 1 { + { + p.SetState(6765) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6766) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6769) + p.Colid() + } + p.SetState(6774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6770) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6771) + p.Colid() + } + + p.SetState(6776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_privilege_listContext is an interface to support dynamic dispatch. +type ISchema_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSchema_privilege() []ISchema_privilegeContext + Schema_privilege(i int) ISchema_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsSchema_privilege_listContext differentiates from other interfaces. + IsSchema_privilege_listContext() +} + +type Schema_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_privilege_listContext() *Schema_privilege_listContext { + var p = new(Schema_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_schema_privilege_list + return p +} + +func InitEmptySchema_privilege_listContext(p *Schema_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_schema_privilege_list +} + +func (*Schema_privilege_listContext) IsSchema_privilege_listContext() {} + +func NewSchema_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_privilege_listContext { + var p = new(Schema_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_schema_privilege_list + + return p +} + +func (s *Schema_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_privilege_listContext) AllSchema_privilege() []ISchema_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_privilegeContext); ok { + len++ + } + } + + tst := make([]ISchema_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_privilegeContext); ok { + tst[i] = t.(ISchema_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Schema_privilege_listContext) Schema_privilege(i int) ISchema_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilegeContext) +} + +func (s *Schema_privilege_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Schema_privilege_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Schema_privilege_listContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Schema_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSchema_privilege_list(s) + } +} + +func (s *Schema_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSchema_privilege_list(s) + } +} + +func (s *Schema_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSchema_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Schema_privilege_list() (localctx ISchema_privilege_listContext) { + localctx = NewSchema_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 698, RedshiftParserRULE_schema_privilege_list) + var _la int + + p.SetState(6786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCREATE, RedshiftParserALTER, RedshiftParserDROP, RedshiftParserUSAGE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6777) + p.Schema_privilege() + } + p.SetState(6782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6778) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6779) + p.Schema_privilege() + } + + p.SetState(6784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6785) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_privilegeContext is an interface to support dynamic dispatch. +type ISchema_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + USAGE() antlr.TerminalNode + ALTER() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsSchema_privilegeContext differentiates from other interfaces. + IsSchema_privilegeContext() +} + +type Schema_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_privilegeContext() *Schema_privilegeContext { + var p = new(Schema_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_schema_privilege + return p +} + +func InitEmptySchema_privilegeContext(p *Schema_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_schema_privilege +} + +func (*Schema_privilegeContext) IsSchema_privilegeContext() {} + +func NewSchema_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_privilegeContext { + var p = new(Schema_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_schema_privilege + + return p +} + +func (s *Schema_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_privilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *Schema_privilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSAGE, 0) +} + +func (s *Schema_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Schema_privilegeContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Schema_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSchema_privilege(s) + } +} + +func (s *Schema_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSchema_privilege(s) + } +} + +func (s *Schema_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSchema_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Schema_privilege() (localctx ISchema_privilegeContext) { + localctx = NewSchema_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 700, RedshiftParserRULE_schema_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6788) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserALTER || _la == RedshiftParserDROP || _la == RedshiftParserUSAGE) { + 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_privilege_listContext is an interface to support dynamic dispatch. +type IDatabase_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDatabase_privilege() []IDatabase_privilegeContext + Database_privilege(i int) IDatabase_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsDatabase_privilege_listContext differentiates from other interfaces. + IsDatabase_privilege_listContext() +} + +type Database_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_privilege_listContext() *Database_privilege_listContext { + var p = new(Database_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_database_privilege_list + return p +} + +func InitEmptyDatabase_privilege_listContext(p *Database_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_database_privilege_list +} + +func (*Database_privilege_listContext) IsDatabase_privilege_listContext() {} + +func NewDatabase_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_privilege_listContext { + var p = new(Database_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_database_privilege_list + + return p +} + +func (s *Database_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_privilege_listContext) AllDatabase_privilege() []IDatabase_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_privilegeContext); ok { + len++ + } + } + + tst := make([]IDatabase_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_privilegeContext); ok { + tst[i] = t.(IDatabase_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Database_privilege_listContext) Database_privilege(i int) IDatabase_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_privilegeContext) +} + +func (s *Database_privilege_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Database_privilege_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Database_privilege_listContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Database_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatabase_privilege_list(s) + } +} + +func (s *Database_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatabase_privilege_list(s) + } +} + +func (s *Database_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatabase_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Database_privilege_list() (localctx IDatabase_privilege_listContext) { + localctx = NewDatabase_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 702, RedshiftParserRULE_database_privilege_list) + var _la int + + p.SetState(6799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCREATE, RedshiftParserALTER, RedshiftParserTEMP, RedshiftParserTEMPORARY, RedshiftParserUSAGE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6790) + p.Database_privilege() + } + p.SetState(6795) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6791) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6792) + p.Database_privilege() + } + + p.SetState(6797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6798) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_privilegeContext is an interface to support dynamic dispatch. +type IDatabase_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + USAGE() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TEMP() antlr.TerminalNode + ALTER() antlr.TerminalNode + + // IsDatabase_privilegeContext differentiates from other interfaces. + IsDatabase_privilegeContext() +} + +type Database_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_privilegeContext() *Database_privilegeContext { + var p = new(Database_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_database_privilege + return p +} + +func InitEmptyDatabase_privilegeContext(p *Database_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_database_privilege +} + +func (*Database_privilegeContext) IsDatabase_privilegeContext() {} + +func NewDatabase_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_privilegeContext { + var p = new(Database_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_database_privilege + + return p +} + +func (s *Database_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_privilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *Database_privilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSAGE, 0) +} + +func (s *Database_privilegeContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPORARY, 0) +} + +func (s *Database_privilegeContext) TEMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMP, 0) +} + +func (s *Database_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Database_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatabase_privilege(s) + } +} + +func (s *Database_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatabase_privilege(s) + } +} + +func (s *Database_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatabase_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Database_privilege() (localctx IDatabase_privilegeContext) { + localctx = NewDatabase_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 704, RedshiftParserRULE_database_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6801) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCREATE || _la == RedshiftParserALTER || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY || _la == RedshiftParserUSAGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_database_targetContext is an interface to support dynamic dispatch. +type IGrant_database_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATABASE() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrant_database_targetContext differentiates from other interfaces. + IsGrant_database_targetContext() +} + +type Grant_database_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_database_targetContext() *Grant_database_targetContext { + var p = new(Grant_database_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_database_target + return p +} + +func InitEmptyGrant_database_targetContext(p *Grant_database_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_database_target +} + +func (*Grant_database_targetContext) IsGrant_database_targetContext() {} + +func NewGrant_database_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_database_targetContext { + var p = new(Grant_database_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_database_target + + return p +} + +func (s *Grant_database_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_database_targetContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Grant_database_targetContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Grant_database_targetContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Grant_database_targetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grant_database_targetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grant_database_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_database_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_database_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_database_target(s) + } +} + +func (s *Grant_database_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_database_target(s) + } +} + +func (s *Grant_database_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_database_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_database_target() (localctx IGrant_database_targetContext) { + localctx = NewGrant_database_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 706, RedshiftParserRULE_grant_database_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6803) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6804) + p.Colid() + } + p.SetState(6809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6805) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6806) + p.Colid() + } + + p.SetState(6811) + 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 +} + +// IGrant_table_targetContext is an interface to support dynamic dispatch. +type IGrant_table_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name_list() IQualified_name_listContext + TABLE() antlr.TerminalNode + All_tables_in_schema_list() IAll_tables_in_schema_listContext + + // IsGrant_table_targetContext differentiates from other interfaces. + IsGrant_table_targetContext() +} + +type Grant_table_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_table_targetContext() *Grant_table_targetContext { + var p = new(Grant_table_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_table_target + return p +} + +func InitEmptyGrant_table_targetContext(p *Grant_table_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grant_table_target +} + +func (*Grant_table_targetContext) IsGrant_table_targetContext() {} + +func NewGrant_table_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_table_targetContext { + var p = new(Grant_table_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grant_table_target + + return p +} + +func (s *Grant_table_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_table_targetContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Grant_table_targetContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Grant_table_targetContext) All_tables_in_schema_list() IAll_tables_in_schema_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_tables_in_schema_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_tables_in_schema_listContext) +} + +func (s *Grant_table_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_table_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_table_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrant_table_target(s) + } +} + +func (s *Grant_table_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrant_table_target(s) + } +} + +func (s *Grant_table_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrant_table_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grant_table_target() (localctx IGrant_table_targetContext) { + localctx = NewGrant_table_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 708, RedshiftParserRULE_grant_table_target) + p.SetState(6817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + p.SetState(6813) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 499, p.GetParserRuleContext()) == 1 { + { + p.SetState(6812) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6815) + p.Qualified_name_list() + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6816) + p.All_tables_in_schema_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 +} + +// IRevoke_table_targetContext is an interface to support dynamic dispatch. +type IRevoke_table_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name_list() IQualified_name_listContext + TABLE() antlr.TerminalNode + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + All_tables_in_schema_list() IAll_tables_in_schema_listContext + + // IsRevoke_table_targetContext differentiates from other interfaces. + IsRevoke_table_targetContext() +} + +type Revoke_table_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_table_targetContext() *Revoke_table_targetContext { + var p = new(Revoke_table_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_table_target + return p +} + +func InitEmptyRevoke_table_targetContext(p *Revoke_table_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_table_target +} + +func (*Revoke_table_targetContext) IsRevoke_table_targetContext() {} + +func NewRevoke_table_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_table_targetContext { + var p = new(Revoke_table_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_table_target + + return p +} + +func (s *Revoke_table_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_table_targetContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Revoke_table_targetContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Revoke_table_targetContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *Revoke_table_targetContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *Revoke_table_targetContext) All_tables_in_schema_list() IAll_tables_in_schema_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_tables_in_schema_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_tables_in_schema_listContext) +} + +func (s *Revoke_table_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_table_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_table_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_table_target(s) + } +} + +func (s *Revoke_table_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_table_target(s) + } +} + +func (s *Revoke_table_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_table_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_table_target() (localctx IRevoke_table_targetContext) { + localctx = NewRevoke_table_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 710, RedshiftParserRULE_revoke_table_target) + p.SetState(6828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + p.SetState(6820) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 501, p.GetParserRuleContext()) == 1 { + { + p.SetState(6819) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6824) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 502, p.GetParserRuleContext()) == 1 { + { + p.SetState(6822) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6823) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6826) + p.Qualified_name_list() + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6827) + p.All_tables_in_schema_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 +} + +// IAll_tables_in_schema_listContext is an interface to support dynamic dispatch. +type IAll_tables_in_schema_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + TABLES() antlr.TerminalNode + IN_P() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + + // IsAll_tables_in_schema_listContext differentiates from other interfaces. + IsAll_tables_in_schema_listContext() +} + +type All_tables_in_schema_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_tables_in_schema_listContext() *All_tables_in_schema_listContext { + var p = new(All_tables_in_schema_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_tables_in_schema_list + return p +} + +func InitEmptyAll_tables_in_schema_listContext(p *All_tables_in_schema_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_tables_in_schema_list +} + +func (*All_tables_in_schema_listContext) IsAll_tables_in_schema_listContext() {} + +func NewAll_tables_in_schema_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_tables_in_schema_listContext { + var p = new(All_tables_in_schema_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_all_tables_in_schema_list + + return p +} + +func (s *All_tables_in_schema_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_tables_in_schema_listContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *All_tables_in_schema_listContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *All_tables_in_schema_listContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *All_tables_in_schema_listContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *All_tables_in_schema_listContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *All_tables_in_schema_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_tables_in_schema_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_tables_in_schema_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAll_tables_in_schema_list(s) + } +} + +func (s *All_tables_in_schema_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAll_tables_in_schema_list(s) + } +} + +func (s *All_tables_in_schema_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAll_tables_in_schema_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) All_tables_in_schema_list() (localctx IAll_tables_in_schema_listContext) { + localctx = NewAll_tables_in_schema_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 712, RedshiftParserRULE_all_tables_in_schema_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6830) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6831) + p.Match(RedshiftParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6832) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6833) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6834) + p.Qualified_name_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAll_privilegesContext is an interface to support dynamic dispatch. +type IAll_privilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + + // IsAll_privilegesContext differentiates from other interfaces. + IsAll_privilegesContext() +} + +type All_privilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_privilegesContext() *All_privilegesContext { + var p = new(All_privilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_privileges + return p +} + +func InitEmptyAll_privilegesContext(p *All_privilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_privileges +} + +func (*All_privilegesContext) IsAll_privilegesContext() {} + +func NewAll_privilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_privilegesContext { + var p = new(All_privilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_all_privileges + + return p +} + +func (s *All_privilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_privilegesContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *All_privilegesContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIVILEGES, 0) +} + +func (s *All_privilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_privilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_privilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAll_privileges(s) + } +} + +func (s *All_privilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAll_privileges(s) + } +} + +func (s *All_privilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAll_privileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) All_privileges() (localctx IAll_privilegesContext) { + localctx = NewAll_privilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 714, RedshiftParserRULE_all_privileges) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6836) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPRIVILEGES { + { + p.SetState(6837) + p.Match(RedshiftParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantee_listContext is an interface to support dynamic dispatch. +type IGrantee_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGrantee() []IGranteeContext + Grantee(i int) IGranteeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrantee_listContext differentiates from other interfaces. + IsGrantee_listContext() +} + +type Grantee_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantee_listContext() *Grantee_listContext { + var p = new(Grantee_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee_list + return p +} + +func InitEmptyGrantee_listContext(p *Grantee_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee_list +} + +func (*Grantee_listContext) IsGrantee_listContext() {} + +func NewGrantee_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_listContext { + var p = new(Grantee_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantee_list + + return p +} + +func (s *Grantee_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grantee_listContext) AllGrantee() []IGranteeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGranteeContext); ok { + len++ + } + } + + tst := make([]IGranteeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGranteeContext); ok { + tst[i] = t.(IGranteeContext) + i++ + } + } + + return tst +} + +func (s *Grantee_listContext) Grantee(i int) IGranteeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGranteeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGranteeContext) +} + +func (s *Grantee_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Grantee_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Grantee_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grantee_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grantee_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantee_list(s) + } +} + +func (s *Grantee_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantee_list(s) + } +} + +func (s *Grantee_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantee_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantee_list() (localctx IGrantee_listContext) { + localctx = NewGrantee_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 716, RedshiftParserRULE_grantee_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6840) + p.Grantee() + } + p.SetState(6845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6841) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6842) + p.Grantee() + } + + p.SetState(6847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGranteeContext is an interface to support dynamic dispatch. +type IGranteeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rolespec() IRolespecContext + Opt_with_grant_option() IOpt_with_grant_optionContext + GROUP_P() antlr.TerminalNode + ROLE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + + // IsGranteeContext differentiates from other interfaces. + IsGranteeContext() +} + +type GranteeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGranteeContext() *GranteeContext { + var p = new(GranteeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee + return p +} + +func InitEmptyGranteeContext(p *GranteeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantee +} + +func (*GranteeContext) IsGranteeContext() {} + +func NewGranteeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GranteeContext { + var p = new(GranteeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantee + + return p +} + +func (s *GranteeContext) GetParser() antlr.Parser { return s.parser } + +func (s *GranteeContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *GranteeContext) Opt_with_grant_option() IOpt_with_grant_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_grant_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_grant_optionContext) +} + +func (s *GranteeContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *GranteeContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *GranteeContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLIC, 0) +} + +func (s *GranteeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GranteeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GranteeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantee(s) + } +} + +func (s *GranteeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantee(s) + } +} + +func (s *GranteeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantee(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantee() (localctx IGranteeContext) { + localctx = NewGranteeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 718, RedshiftParserRULE_grantee) + p.SetState(6857) + 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(6848) + p.Rolespec() + } + p.SetState(6850) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 506, p.GetParserRuleContext()) == 1 { + { + p.SetState(6849) + p.Opt_with_grant_option() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6852) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6853) + p.Rolespec() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6854) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6855) + p.Rolespec() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6856) + p.Match(RedshiftParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_with_grant_optionContext is an interface to support dynamic dispatch. +type IOpt_with_grant_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + GRANT() antlr.TerminalNode + OPTION() antlr.TerminalNode + + // IsOpt_with_grant_optionContext differentiates from other interfaces. + IsOpt_with_grant_optionContext() +} + +type Opt_with_grant_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_with_grant_optionContext() *Opt_with_grant_optionContext { + var p = new(Opt_with_grant_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_grant_option + return p +} + +func InitEmptyOpt_with_grant_optionContext(p *Opt_with_grant_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_grant_option +} + +func (*Opt_with_grant_optionContext) IsOpt_with_grant_optionContext() {} + +func NewOpt_with_grant_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_grant_optionContext { + var p = new(Opt_with_grant_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_with_grant_option + + return p +} + +func (s *Opt_with_grant_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_with_grant_optionContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_with_grant_optionContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Opt_with_grant_optionContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Opt_with_grant_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_with_grant_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_with_grant_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_with_grant_option(s) + } +} + +func (s *Opt_with_grant_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_with_grant_option(s) + } +} + +func (s *Opt_with_grant_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_with_grant_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_with_grant_option() (localctx IOpt_with_grant_optionContext) { + localctx = NewOpt_with_grant_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 720, RedshiftParserRULE_opt_with_grant_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6859) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6860) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6861) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_privilegeContext is an interface to support dynamic dispatch. +type ITable_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + DROP() antlr.TerminalNode + ALTER() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + + // IsTable_privilegeContext differentiates from other interfaces. + IsTable_privilegeContext() +} + +type Table_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_privilegeContext() *Table_privilegeContext { + var p = new(Table_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_privilege + return p +} + +func InitEmptyTable_privilegeContext(p *Table_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_privilege +} + +func (*Table_privilegeContext) IsTable_privilegeContext() {} + +func NewTable_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_privilegeContext { + var p = new(Table_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_privilege + + return p +} + +func (s *Table_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Table_privilegeContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *Table_privilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Table_privilegeContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *Table_privilegeContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Table_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Table_privilegeContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNCATE, 0) +} + +func (s *Table_privilegeContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCES, 0) +} + +func (s *Table_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_privilege(s) + } +} + +func (s *Table_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_privilege(s) + } +} + +func (s *Table_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_privilege() (localctx ITable_privilegeContext) { + localctx = NewTable_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 722, RedshiftParserRULE_table_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6863) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-87)) & ^0x3f) == 0 && ((int64(1)<<(_la-87))&9007199254740997) != 0) || ((int64((_la-186)) & ^0x3f) == 0 && ((int64(1)<<(_la-186))&1125899906843137) != 0) || _la == RedshiftParserTRUNCATE || _la == RedshiftParserUPDATE) { + 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_privilege_listContext is an interface to support dynamic dispatch. +type ITable_privilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTable_privilege() []ITable_privilegeContext + Table_privilege(i int) ITable_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + All_privileges() IAll_privilegesContext + + // IsTable_privilege_listContext differentiates from other interfaces. + IsTable_privilege_listContext() +} + +type Table_privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_privilege_listContext() *Table_privilege_listContext { + var p = new(Table_privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_privilege_list + return p +} + +func InitEmptyTable_privilege_listContext(p *Table_privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_privilege_list +} + +func (*Table_privilege_listContext) IsTable_privilege_listContext() {} + +func NewTable_privilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_privilege_listContext { + var p = new(Table_privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_privilege_list + + return p +} + +func (s *Table_privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_privilege_listContext) AllTable_privilege() []ITable_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_privilegeContext); ok { + len++ + } + } + + tst := make([]ITable_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_privilegeContext); ok { + tst[i] = t.(ITable_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Table_privilege_listContext) Table_privilege(i int) ITable_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_privilegeContext) +} + +func (s *Table_privilege_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Table_privilege_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Table_privilege_listContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Table_privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_privilege_list(s) + } +} + +func (s *Table_privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_privilege_list(s) + } +} + +func (s *Table_privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_privilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_privilege_list() (localctx ITable_privilege_listContext) { + localctx = NewTable_privilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 724, RedshiftParserRULE_table_privilege_list) + var _la int + + p.SetState(6874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserREFERENCES, RedshiftParserSELECT, RedshiftParserALTER, RedshiftParserDELETE_P, RedshiftParserDROP, RedshiftParserINSERT, RedshiftParserTRUNCATE, RedshiftParserUPDATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6865) + p.Table_privilege() + } + p.SetState(6870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6866) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6867) + p.Table_privilege() + } + + p.SetState(6872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6873) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevokestmtContext is an interface to support dynamic dispatch. +type IRevokestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Common_revoke() ICommon_revokeContext + Revoke_column_level_permissions() IRevoke_column_level_permissionsContext + Revoke_assume_role_permissions() IRevoke_assume_role_permissionsContext + Revoke_spectrum_integration_permissions() IRevoke_spectrum_integration_permissionsContext + Revoke_datashare_permissions() IRevoke_datashare_permissionsContext + Revoke_scoped_permissions() IRevoke_scoped_permissionsContext + Revoke_machine_learning_permissions() IRevoke_machine_learning_permissionsContext + Revoke_role_permissions() IRevoke_role_permissionsContext + Revoke_explain_permissions_for_row_level_security_policy_filters() IRevoke_explain_permissions_for_row_level_security_policy_filtersContext + Revoke_permissions_for_rls_lookup_tables() IRevoke_permissions_for_rls_lookup_tablesContext + + // IsRevokestmtContext differentiates from other interfaces. + IsRevokestmtContext() +} + +type RevokestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevokestmtContext() *RevokestmtContext { + var p = new(RevokestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revokestmt + return p +} + +func InitEmptyRevokestmtContext(p *RevokestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revokestmt +} + +func (*RevokestmtContext) IsRevokestmtContext() {} + +func NewRevokestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokestmtContext { + var p = new(RevokestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revokestmt + + return p +} + +func (s *RevokestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RevokestmtContext) Common_revoke() ICommon_revokeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_revokeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommon_revokeContext) +} + +func (s *RevokestmtContext) Revoke_column_level_permissions() IRevoke_column_level_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_column_level_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_column_level_permissionsContext) +} + +func (s *RevokestmtContext) Revoke_assume_role_permissions() IRevoke_assume_role_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_assume_role_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_assume_role_permissionsContext) +} + +func (s *RevokestmtContext) Revoke_spectrum_integration_permissions() IRevoke_spectrum_integration_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_spectrum_integration_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_spectrum_integration_permissionsContext) +} + +func (s *RevokestmtContext) Revoke_datashare_permissions() IRevoke_datashare_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_datashare_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_datashare_permissionsContext) +} + +func (s *RevokestmtContext) Revoke_scoped_permissions() IRevoke_scoped_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_scoped_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_scoped_permissionsContext) +} + +func (s *RevokestmtContext) Revoke_machine_learning_permissions() IRevoke_machine_learning_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_machine_learning_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_machine_learning_permissionsContext) +} + +func (s *RevokestmtContext) Revoke_role_permissions() IRevoke_role_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_role_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_role_permissionsContext) +} + +func (s *RevokestmtContext) Revoke_explain_permissions_for_row_level_security_policy_filters() IRevoke_explain_permissions_for_row_level_security_policy_filtersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_explain_permissions_for_row_level_security_policy_filtersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_explain_permissions_for_row_level_security_policy_filtersContext) +} + +func (s *RevokestmtContext) Revoke_permissions_for_rls_lookup_tables() IRevoke_permissions_for_rls_lookup_tablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_permissions_for_rls_lookup_tablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_permissions_for_rls_lookup_tablesContext) +} + +func (s *RevokestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RevokestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevokestmt(s) + } +} + +func (s *RevokestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevokestmt(s) + } +} + +func (s *RevokestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevokestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revokestmt() (localctx IRevokestmtContext) { + localctx = NewRevokestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 726, RedshiftParserRULE_revokestmt) + p.SetState(6886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 510, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6876) + p.Common_revoke() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6877) + p.Revoke_column_level_permissions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6878) + p.Revoke_assume_role_permissions() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6879) + p.Revoke_spectrum_integration_permissions() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6880) + p.Revoke_datashare_permissions() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6881) + p.Revoke_scoped_permissions() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6882) + p.Revoke_machine_learning_permissions() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6883) + p.Revoke_role_permissions() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6884) + p.Revoke_explain_permissions_for_row_level_security_policy_filters() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6885) + p.Revoke_permissions_for_rls_lookup_tables() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_permissions_for_rls_lookup_tablesContext is an interface to support dynamic dispatch. +type IRevoke_permissions_for_rls_lookup_tablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + SELECT() antlr.TerminalNode + ON() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + FROM() antlr.TerminalNode + RLS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Columnlist() IColumnlistContext + TABLE() antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_permissions_for_rls_lookup_tablesContext differentiates from other interfaces. + IsRevoke_permissions_for_rls_lookup_tablesContext() +} + +type Revoke_permissions_for_rls_lookup_tablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_permissions_for_rls_lookup_tablesContext() *Revoke_permissions_for_rls_lookup_tablesContext { + var p = new(Revoke_permissions_for_rls_lookup_tablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_permissions_for_rls_lookup_tables + return p +} + +func InitEmptyRevoke_permissions_for_rls_lookup_tablesContext(p *Revoke_permissions_for_rls_lookup_tablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_permissions_for_rls_lookup_tables +} + +func (*Revoke_permissions_for_rls_lookup_tablesContext) IsRevoke_permissions_for_rls_lookup_tablesContext() { +} + +func NewRevoke_permissions_for_rls_lookup_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_permissions_for_rls_lookup_tablesContext { + var p = new(Revoke_permissions_for_rls_lookup_tablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_permissions_for_rls_lookup_tables + + return p +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_permissions_for_rls_lookup_tables(s) + } +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_permissions_for_rls_lookup_tables(s) + } +} + +func (s *Revoke_permissions_for_rls_lookup_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_permissions_for_rls_lookup_tables(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_permissions_for_rls_lookup_tables() (localctx IRevoke_permissions_for_rls_lookup_tablesContext) { + localctx = NewRevoke_permissions_for_rls_lookup_tablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 728, RedshiftParserRULE_revoke_permissions_for_rls_lookup_tables) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6888) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6889) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6890) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6892) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 511, p.GetParserRuleContext()) == 1 { + { + p.SetState(6891) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6894) + p.Qualified_name_list() + } + { + p.SetState(6895) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6896) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6897) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6898) + p.Columnlist() + } + p.SetState(6900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6899) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_explain_permissions_for_row_level_security_policy_filtersContext is an interface to support dynamic dispatch. +type IRevoke_explain_permissions_for_row_level_security_policy_filtersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + RLS() antlr.TerminalNode + FROM() antlr.TerminalNode + ROLE() antlr.TerminalNode + Rolespec() IRolespecContext + EXPLAIN() antlr.TerminalNode + IGNORE() antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_explain_permissions_for_row_level_security_policy_filtersContext differentiates from other interfaces. + IsRevoke_explain_permissions_for_row_level_security_policy_filtersContext() +} + +type Revoke_explain_permissions_for_row_level_security_policy_filtersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_explain_permissions_for_row_level_security_policy_filtersContext() *Revoke_explain_permissions_for_row_level_security_policy_filtersContext { + var p = new(Revoke_explain_permissions_for_row_level_security_policy_filtersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_explain_permissions_for_row_level_security_policy_filters + return p +} + +func InitEmptyRevoke_explain_permissions_for_row_level_security_policy_filtersContext(p *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_explain_permissions_for_row_level_security_policy_filters +} + +func (*Revoke_explain_permissions_for_row_level_security_policy_filtersContext) IsRevoke_explain_permissions_for_row_level_security_policy_filtersContext() { +} + +func NewRevoke_explain_permissions_for_row_level_security_policy_filtersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_explain_permissions_for_row_level_security_policy_filtersContext { + var p = new(Revoke_explain_permissions_for_row_level_security_policy_filtersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_explain_permissions_for_row_level_security_policy_filters + + return p +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPLAIN, 0) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) IGNORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNORE, 0) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_explain_permissions_for_row_level_security_policy_filters(s) + } +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_explain_permissions_for_row_level_security_policy_filters(s) + } +} + +func (s *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_explain_permissions_for_row_level_security_policy_filters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_explain_permissions_for_row_level_security_policy_filters() (localctx IRevoke_explain_permissions_for_row_level_security_policy_filtersContext) { + localctx = NewRevoke_explain_permissions_for_row_level_security_policy_filtersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 730, RedshiftParserRULE_revoke_explain_permissions_for_row_level_security_policy_filters) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6902) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6903) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXPLAIN || _la == RedshiftParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6904) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6905) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6906) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6907) + p.Rolespec() + } + p.SetState(6909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6908) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_machine_learning_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_machine_learning_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + CREATE() antlr.TerminalNode + MODEL() antlr.TerminalNode + FROM() antlr.TerminalNode + Grantee_list() IGrantee_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + Function_privilege_list() IFunction_privilege_listContext + ON() antlr.TerminalNode + Columnlist() IColumnlistContext + + // IsRevoke_machine_learning_permissionsContext differentiates from other interfaces. + IsRevoke_machine_learning_permissionsContext() +} + +type Revoke_machine_learning_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_machine_learning_permissionsContext() *Revoke_machine_learning_permissionsContext { + var p = new(Revoke_machine_learning_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_machine_learning_permissions + return p +} + +func InitEmptyRevoke_machine_learning_permissionsContext(p *Revoke_machine_learning_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_machine_learning_permissions +} + +func (*Revoke_machine_learning_permissionsContext) IsRevoke_machine_learning_permissionsContext() {} + +func NewRevoke_machine_learning_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_machine_learning_permissionsContext { + var p = new(Revoke_machine_learning_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_machine_learning_permissions + + return p +} + +func (s *Revoke_machine_learning_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_machine_learning_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_machine_learning_permissionsContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *Revoke_machine_learning_permissionsContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *Revoke_machine_learning_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_machine_learning_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Revoke_machine_learning_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_machine_learning_permissionsContext) Function_privilege_list() IFunction_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_privilege_listContext) +} + +func (s *Revoke_machine_learning_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Revoke_machine_learning_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Revoke_machine_learning_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_machine_learning_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_machine_learning_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_machine_learning_permissions(s) + } +} + +func (s *Revoke_machine_learning_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_machine_learning_permissions(s) + } +} + +func (s *Revoke_machine_learning_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_machine_learning_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_machine_learning_permissions() (localctx IRevoke_machine_learning_permissionsContext) { + localctx = NewRevoke_machine_learning_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 732, RedshiftParserRULE_revoke_machine_learning_permissions) + var _la int + + p.SetState(6929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 516, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6911) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6912) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6913) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6914) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6915) + p.Grantee_list() + } + p.SetState(6917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6916) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6919) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6920) + p.Function_privilege_list() + } + { + p.SetState(6921) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6922) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6923) + p.Columnlist() + } + { + p.SetState(6924) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6925) + p.Grantee_list() + } + p.SetState(6927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6926) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_role_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_role_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + AllROLE() []antlr.TerminalNode + ROLE(i int) antlr.TerminalNode + AllRolespec() []IRolespecContext + Rolespec(i int) IRolespecContext + FROM() antlr.TerminalNode + Grant_role_permission_target_list() IGrant_role_permission_target_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + System_permissions() ISystem_permissionsContext + Role_list() IRole_listContext + ADMIN() antlr.TerminalNode + OPTION() antlr.TerminalNode + FOR() antlr.TerminalNode + + // IsRevoke_role_permissionsContext differentiates from other interfaces. + IsRevoke_role_permissionsContext() +} + +type Revoke_role_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_role_permissionsContext() *Revoke_role_permissionsContext { + var p = new(Revoke_role_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_role_permissions + return p +} + +func InitEmptyRevoke_role_permissionsContext(p *Revoke_role_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_role_permissions +} + +func (*Revoke_role_permissionsContext) IsRevoke_role_permissionsContext() {} + +func NewRevoke_role_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_role_permissionsContext { + var p = new(Revoke_role_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_role_permissions + + return p +} + +func (s *Revoke_role_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_role_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_role_permissionsContext) AllROLE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserROLE) +} + +func (s *Revoke_role_permissionsContext) ROLE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, i) +} + +func (s *Revoke_role_permissionsContext) AllRolespec() []IRolespecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRolespecContext); ok { + len++ + } + } + + tst := make([]IRolespecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRolespecContext); ok { + tst[i] = t.(IRolespecContext) + i++ + } + } + + return tst +} + +func (s *Revoke_role_permissionsContext) Rolespec(i int) IRolespecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Revoke_role_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_role_permissionsContext) Grant_role_permission_target_list() IGrant_role_permission_target_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_role_permission_target_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_role_permission_target_listContext) +} + +func (s *Revoke_role_permissionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Revoke_role_permissionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Revoke_role_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_role_permissionsContext) System_permissions() ISystem_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_permissionsContext) +} + +func (s *Revoke_role_permissionsContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *Revoke_role_permissionsContext) ADMIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserADMIN, 0) +} + +func (s *Revoke_role_permissionsContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Revoke_role_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_role_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_role_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_role_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_role_permissions(s) + } +} + +func (s *Revoke_role_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_role_permissions(s) + } +} + +func (s *Revoke_role_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_role_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_role_permissions() (localctx IRevoke_role_permissionsContext) { + localctx = NewRevoke_role_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 734, RedshiftParserRULE_revoke_role_permissions) + var _la int + + p.SetState(6974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 522, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6931) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6932) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6933) + p.Rolespec() + } + p.SetState(6939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6934) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6935) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6936) + p.Rolespec() + } + + p.SetState(6941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6942) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6943) + p.Grant_role_permission_target_list() + } + p.SetState(6945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6944) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6947) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6948) + p.System_permissions() + } + { + p.SetState(6949) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6950) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6951) + p.Role_list() + } + p.SetState(6953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6952) + p.Opt_drop_behavior() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6955) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6956) + p.Match(RedshiftParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6957) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6958) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6959) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6960) + p.Rolespec() + } + p.SetState(6966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(6961) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6962) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6963) + p.Rolespec() + } + + p.SetState(6968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6969) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6970) + p.Grant_role_permission_target_list() + } + p.SetState(6972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6971) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_scoped_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_scoped_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Revoke_scoped_schemas_permissions() IRevoke_scoped_schemas_permissionsContext + Revoke_scoped_tables_permissions() IRevoke_scoped_tables_permissionsContext + Revoke_scoped_functions_permissions() IRevoke_scoped_functions_permissionsContext + Revoke_scoped_procedures_permissions() IRevoke_scoped_procedures_permissionsContext + Revoke_scoped_languages_permissions() IRevoke_scoped_languages_permissionsContext + Revoke_scoped_copy_jobs_permissions() IRevoke_scoped_copy_jobs_permissionsContext + + // IsRevoke_scoped_permissionsContext differentiates from other interfaces. + IsRevoke_scoped_permissionsContext() +} + +type Revoke_scoped_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_scoped_permissionsContext() *Revoke_scoped_permissionsContext { + var p = new(Revoke_scoped_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_permissions + return p +} + +func InitEmptyRevoke_scoped_permissionsContext(p *Revoke_scoped_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_permissions +} + +func (*Revoke_scoped_permissionsContext) IsRevoke_scoped_permissionsContext() {} + +func NewRevoke_scoped_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_scoped_permissionsContext { + var p = new(Revoke_scoped_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_scoped_permissions + + return p +} + +func (s *Revoke_scoped_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_scoped_permissionsContext) Revoke_scoped_schemas_permissions() IRevoke_scoped_schemas_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_scoped_schemas_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_scoped_schemas_permissionsContext) +} + +func (s *Revoke_scoped_permissionsContext) Revoke_scoped_tables_permissions() IRevoke_scoped_tables_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_scoped_tables_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_scoped_tables_permissionsContext) +} + +func (s *Revoke_scoped_permissionsContext) Revoke_scoped_functions_permissions() IRevoke_scoped_functions_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_scoped_functions_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_scoped_functions_permissionsContext) +} + +func (s *Revoke_scoped_permissionsContext) Revoke_scoped_procedures_permissions() IRevoke_scoped_procedures_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_scoped_procedures_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_scoped_procedures_permissionsContext) +} + +func (s *Revoke_scoped_permissionsContext) Revoke_scoped_languages_permissions() IRevoke_scoped_languages_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_scoped_languages_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_scoped_languages_permissionsContext) +} + +func (s *Revoke_scoped_permissionsContext) Revoke_scoped_copy_jobs_permissions() IRevoke_scoped_copy_jobs_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_scoped_copy_jobs_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_scoped_copy_jobs_permissionsContext) +} + +func (s *Revoke_scoped_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_scoped_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_scoped_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_scoped_permissions(s) + } +} + +func (s *Revoke_scoped_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_scoped_permissions(s) + } +} + +func (s *Revoke_scoped_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_scoped_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_scoped_permissions() (localctx IRevoke_scoped_permissionsContext) { + localctx = NewRevoke_scoped_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 736, RedshiftParserRULE_revoke_scoped_permissions) + p.SetState(6982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 523, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6976) + p.Revoke_scoped_schemas_permissions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6977) + p.Revoke_scoped_tables_permissions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6978) + p.Revoke_scoped_functions_permissions() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6979) + p.Revoke_scoped_procedures_permissions() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6980) + p.Revoke_scoped_languages_permissions() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6981) + p.Revoke_scoped_copy_jobs_permissions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_scoped_schemas_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_scoped_schemas_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Schema_privilege_list() ISchema_privilege_listContext + FOR() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + IN_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Colid() IColidContext + FROM() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_scoped_schemas_permissionsContext differentiates from other interfaces. + IsRevoke_scoped_schemas_permissionsContext() +} + +type Revoke_scoped_schemas_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_scoped_schemas_permissionsContext() *Revoke_scoped_schemas_permissionsContext { + var p = new(Revoke_scoped_schemas_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_schemas_permissions + return p +} + +func InitEmptyRevoke_scoped_schemas_permissionsContext(p *Revoke_scoped_schemas_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_schemas_permissions +} + +func (*Revoke_scoped_schemas_permissionsContext) IsRevoke_scoped_schemas_permissionsContext() {} + +func NewRevoke_scoped_schemas_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_scoped_schemas_permissionsContext { + var p = new(Revoke_scoped_schemas_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_scoped_schemas_permissions + + return p +} + +func (s *Revoke_scoped_schemas_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_scoped_schemas_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_scoped_schemas_permissionsContext) Schema_privilege_list() ISchema_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilege_listContext) +} + +func (s *Revoke_scoped_schemas_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_scoped_schemas_permissionsContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMAS, 0) +} + +func (s *Revoke_scoped_schemas_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Revoke_scoped_schemas_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Revoke_scoped_schemas_permissionsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_scoped_schemas_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_scoped_schemas_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Revoke_scoped_schemas_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_scoped_schemas_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_scoped_schemas_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_scoped_schemas_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_scoped_schemas_permissions(s) + } +} + +func (s *Revoke_scoped_schemas_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_scoped_schemas_permissions(s) + } +} + +func (s *Revoke_scoped_schemas_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_scoped_schemas_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_scoped_schemas_permissions() (localctx IRevoke_scoped_schemas_permissionsContext) { + localctx = NewRevoke_scoped_schemas_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 738, RedshiftParserRULE_revoke_scoped_schemas_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6984) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6985) + p.Schema_privilege_list() + } + { + p.SetState(6986) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6987) + p.Match(RedshiftParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6988) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6989) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6990) + p.Colid() + } + { + p.SetState(6991) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6992) + p.Grantee_list_without_public() + } + p.SetState(6994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(6993) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_scoped_tables_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_scoped_tables_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Table_privilege_list() ITable_privilege_listContext + FOR() antlr.TerminalNode + TABLES() antlr.TerminalNode + IN_P() antlr.TerminalNode + FROM() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + Opt_drop_behavior() IOpt_drop_behaviorContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsRevoke_scoped_tables_permissionsContext differentiates from other interfaces. + IsRevoke_scoped_tables_permissionsContext() +} + +type Revoke_scoped_tables_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_scoped_tables_permissionsContext() *Revoke_scoped_tables_permissionsContext { + var p = new(Revoke_scoped_tables_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_tables_permissions + return p +} + +func InitEmptyRevoke_scoped_tables_permissionsContext(p *Revoke_scoped_tables_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_tables_permissions +} + +func (*Revoke_scoped_tables_permissionsContext) IsRevoke_scoped_tables_permissionsContext() {} + +func NewRevoke_scoped_tables_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_scoped_tables_permissionsContext { + var p = new(Revoke_scoped_tables_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_scoped_tables_permissions + + return p +} + +func (s *Revoke_scoped_tables_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_scoped_tables_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_scoped_tables_permissionsContext) Table_privilege_list() ITable_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_privilege_listContext) +} + +func (s *Revoke_scoped_tables_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_scoped_tables_permissionsContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *Revoke_scoped_tables_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Revoke_scoped_tables_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_scoped_tables_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Revoke_scoped_tables_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_scoped_tables_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Revoke_scoped_tables_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Revoke_scoped_tables_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_scoped_tables_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Revoke_scoped_tables_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_scoped_tables_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_scoped_tables_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_scoped_tables_permissions(s) + } +} + +func (s *Revoke_scoped_tables_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_scoped_tables_permissions(s) + } +} + +func (s *Revoke_scoped_tables_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_scoped_tables_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_scoped_tables_permissions() (localctx IRevoke_scoped_tables_permissionsContext) { + localctx = NewRevoke_scoped_tables_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 740, RedshiftParserRULE_revoke_scoped_tables_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6996) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6997) + p.Table_privilege_list() + } + { + p.SetState(6998) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6999) + p.Match(RedshiftParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7000) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(7001) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7002) + p.Colid() + } + p.SetState(7005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(7003) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7004) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(7007) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7008) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7011) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7012) + p.Grantee_list_without_public() + } + p.SetState(7014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7013) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_scoped_functions_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_scoped_functions_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Function_privilege_list() IFunction_privilege_listContext + FOR() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + IN_P() antlr.TerminalNode + FROM() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + Opt_drop_behavior() IOpt_drop_behaviorContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsRevoke_scoped_functions_permissionsContext differentiates from other interfaces. + IsRevoke_scoped_functions_permissionsContext() +} + +type Revoke_scoped_functions_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_scoped_functions_permissionsContext() *Revoke_scoped_functions_permissionsContext { + var p = new(Revoke_scoped_functions_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_functions_permissions + return p +} + +func InitEmptyRevoke_scoped_functions_permissionsContext(p *Revoke_scoped_functions_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_functions_permissions +} + +func (*Revoke_scoped_functions_permissionsContext) IsRevoke_scoped_functions_permissionsContext() {} + +func NewRevoke_scoped_functions_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_scoped_functions_permissionsContext { + var p = new(Revoke_scoped_functions_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_scoped_functions_permissions + + return p +} + +func (s *Revoke_scoped_functions_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_scoped_functions_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_scoped_functions_permissionsContext) Function_privilege_list() IFunction_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_privilege_listContext) +} + +func (s *Revoke_scoped_functions_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_scoped_functions_permissionsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTIONS, 0) +} + +func (s *Revoke_scoped_functions_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Revoke_scoped_functions_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_scoped_functions_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Revoke_scoped_functions_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_scoped_functions_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Revoke_scoped_functions_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Revoke_scoped_functions_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_scoped_functions_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Revoke_scoped_functions_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_scoped_functions_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_scoped_functions_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_scoped_functions_permissions(s) + } +} + +func (s *Revoke_scoped_functions_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_scoped_functions_permissions(s) + } +} + +func (s *Revoke_scoped_functions_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_scoped_functions_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_scoped_functions_permissions() (localctx IRevoke_scoped_functions_permissionsContext) { + localctx = NewRevoke_scoped_functions_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 742, RedshiftParserRULE_revoke_scoped_functions_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7016) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7017) + p.Function_privilege_list() + } + { + p.SetState(7018) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7019) + p.Match(RedshiftParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7020) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(7021) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7022) + p.Colid() + } + p.SetState(7025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(7023) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7024) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(7027) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7028) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7031) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7032) + p.Grantee_list_without_public() + } + p.SetState(7034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7033) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_scoped_procedures_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_scoped_procedures_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Procedure_privilege_list() IProcedure_privilege_listContext + FOR() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + IN_P() antlr.TerminalNode + FROM() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + Opt_drop_behavior() IOpt_drop_behaviorContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsRevoke_scoped_procedures_permissionsContext differentiates from other interfaces. + IsRevoke_scoped_procedures_permissionsContext() +} + +type Revoke_scoped_procedures_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_scoped_procedures_permissionsContext() *Revoke_scoped_procedures_permissionsContext { + var p = new(Revoke_scoped_procedures_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_procedures_permissions + return p +} + +func InitEmptyRevoke_scoped_procedures_permissionsContext(p *Revoke_scoped_procedures_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_procedures_permissions +} + +func (*Revoke_scoped_procedures_permissionsContext) IsRevoke_scoped_procedures_permissionsContext() {} + +func NewRevoke_scoped_procedures_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_scoped_procedures_permissionsContext { + var p = new(Revoke_scoped_procedures_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_scoped_procedures_permissions + + return p +} + +func (s *Revoke_scoped_procedures_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_scoped_procedures_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_scoped_procedures_permissionsContext) Procedure_privilege_list() IProcedure_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_privilege_listContext) +} + +func (s *Revoke_scoped_procedures_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_scoped_procedures_permissionsContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURES, 0) +} + +func (s *Revoke_scoped_procedures_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Revoke_scoped_procedures_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_scoped_procedures_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Revoke_scoped_procedures_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_scoped_procedures_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Revoke_scoped_procedures_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Revoke_scoped_procedures_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_scoped_procedures_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Revoke_scoped_procedures_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_scoped_procedures_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_scoped_procedures_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_scoped_procedures_permissions(s) + } +} + +func (s *Revoke_scoped_procedures_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_scoped_procedures_permissions(s) + } +} + +func (s *Revoke_scoped_procedures_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_scoped_procedures_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_scoped_procedures_permissions() (localctx IRevoke_scoped_procedures_permissionsContext) { + localctx = NewRevoke_scoped_procedures_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 744, RedshiftParserRULE_revoke_scoped_procedures_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7036) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7037) + p.Procedure_privilege_list() + } + { + p.SetState(7038) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7039) + p.Match(RedshiftParserPROCEDURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7040) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(7041) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7042) + p.Colid() + } + p.SetState(7045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(7043) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7044) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(7047) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7048) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7051) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7052) + p.Grantee_list_without_public() + } + p.SetState(7054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7053) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_scoped_languages_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_scoped_languages_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Language_privilege_list() ILanguage_privilege_listContext + FOR() antlr.TerminalNode + LANGUAGES() antlr.TerminalNode + IN_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Colid() IColidContext + FROM() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_scoped_languages_permissionsContext differentiates from other interfaces. + IsRevoke_scoped_languages_permissionsContext() +} + +type Revoke_scoped_languages_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_scoped_languages_permissionsContext() *Revoke_scoped_languages_permissionsContext { + var p = new(Revoke_scoped_languages_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_languages_permissions + return p +} + +func InitEmptyRevoke_scoped_languages_permissionsContext(p *Revoke_scoped_languages_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_languages_permissions +} + +func (*Revoke_scoped_languages_permissionsContext) IsRevoke_scoped_languages_permissionsContext() {} + +func NewRevoke_scoped_languages_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_scoped_languages_permissionsContext { + var p = new(Revoke_scoped_languages_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_scoped_languages_permissions + + return p +} + +func (s *Revoke_scoped_languages_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_scoped_languages_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_scoped_languages_permissionsContext) Language_privilege_list() ILanguage_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguage_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguage_privilege_listContext) +} + +func (s *Revoke_scoped_languages_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_scoped_languages_permissionsContext) LANGUAGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGES, 0) +} + +func (s *Revoke_scoped_languages_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Revoke_scoped_languages_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Revoke_scoped_languages_permissionsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_scoped_languages_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_scoped_languages_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Revoke_scoped_languages_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_scoped_languages_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_scoped_languages_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_scoped_languages_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_scoped_languages_permissions(s) + } +} + +func (s *Revoke_scoped_languages_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_scoped_languages_permissions(s) + } +} + +func (s *Revoke_scoped_languages_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_scoped_languages_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_scoped_languages_permissions() (localctx IRevoke_scoped_languages_permissionsContext) { + localctx = NewRevoke_scoped_languages_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 746, RedshiftParserRULE_revoke_scoped_languages_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7056) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7057) + p.Language_privilege_list() + } + { + p.SetState(7058) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7059) + p.Match(RedshiftParserLANGUAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7060) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7061) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7062) + p.Colid() + } + { + p.SetState(7063) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7064) + p.Grantee_list_without_public() + } + p.SetState(7066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7065) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_scoped_copy_jobs_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_scoped_copy_jobs_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Copy_job_privilege_list() ICopy_job_privilege_listContext + FOR() antlr.TerminalNode + COPY() antlr.TerminalNode + JOBS() antlr.TerminalNode + IN_P() antlr.TerminalNode + FROM() antlr.TerminalNode + Grantee_list_without_public() IGrantee_list_without_publicContext + Opt_drop_behavior() IOpt_drop_behaviorContext + SCHEMA() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DATABASE() antlr.TerminalNode + + // IsRevoke_scoped_copy_jobs_permissionsContext differentiates from other interfaces. + IsRevoke_scoped_copy_jobs_permissionsContext() +} + +type Revoke_scoped_copy_jobs_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_scoped_copy_jobs_permissionsContext() *Revoke_scoped_copy_jobs_permissionsContext { + var p = new(Revoke_scoped_copy_jobs_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_copy_jobs_permissions + return p +} + +func InitEmptyRevoke_scoped_copy_jobs_permissionsContext(p *Revoke_scoped_copy_jobs_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_scoped_copy_jobs_permissions +} + +func (*Revoke_scoped_copy_jobs_permissionsContext) IsRevoke_scoped_copy_jobs_permissionsContext() {} + +func NewRevoke_scoped_copy_jobs_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_scoped_copy_jobs_permissionsContext { + var p = new(Revoke_scoped_copy_jobs_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_scoped_copy_jobs_permissions + + return p +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_scoped_copy_jobs_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) Copy_job_privilege_list() ICopy_job_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_privilege_listContext) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) COPY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOPY, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) JOBS() antlr.TerminalNode { + return s.GetToken(RedshiftParserJOBS, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) Grantee_list_without_public() IGrantee_list_without_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_list_without_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_list_without_publicContext) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_scoped_copy_jobs_permissions(s) + } +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_scoped_copy_jobs_permissions(s) + } +} + +func (s *Revoke_scoped_copy_jobs_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_scoped_copy_jobs_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_scoped_copy_jobs_permissions() (localctx IRevoke_scoped_copy_jobs_permissionsContext) { + localctx = NewRevoke_scoped_copy_jobs_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 748, RedshiftParserRULE_revoke_scoped_copy_jobs_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7068) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7069) + p.Copy_job_privilege_list() + } + { + p.SetState(7070) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7071) + p.Match(RedshiftParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7072) + p.Match(RedshiftParserJOBS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7073) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSCHEMA: + { + p.SetState(7074) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7075) + p.Colid() + } + p.SetState(7078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDATABASE { + { + p.SetState(7076) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7077) + p.Colid() + } + + } + + case RedshiftParserDATABASE: + { + p.SetState(7080) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7081) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7084) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7085) + p.Grantee_list_without_public() + } + p.SetState(7087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7086) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_datashare_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_datashare_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + ON() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + Colid() IColidContext + FROM() antlr.TerminalNode + Grantee_list() IGrantee_listContext + ALTER() antlr.TerminalNode + SHARE() antlr.TerminalNode + GRANT() antlr.TerminalNode + OPTION() antlr.TerminalNode + FOR() antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + USAGE() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + Sconst() ISconstContext + ACCOUNT() antlr.TerminalNode + VIA() antlr.TerminalNode + DATA_CATALOG() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Columnlist() IColumnlistContext + SCHEMA() antlr.TerminalNode + + // IsRevoke_datashare_permissionsContext differentiates from other interfaces. + IsRevoke_datashare_permissionsContext() +} + +type Revoke_datashare_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_datashare_permissionsContext() *Revoke_datashare_permissionsContext { + var p = new(Revoke_datashare_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_datashare_permissions + return p +} + +func InitEmptyRevoke_datashare_permissionsContext(p *Revoke_datashare_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_datashare_permissions +} + +func (*Revoke_datashare_permissionsContext) IsRevoke_datashare_permissionsContext() {} + +func NewRevoke_datashare_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_datashare_permissionsContext { + var p = new(Revoke_datashare_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_datashare_permissions + + return p +} + +func (s *Revoke_datashare_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_datashare_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_datashare_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Revoke_datashare_permissionsContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *Revoke_datashare_permissionsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Revoke_datashare_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_datashare_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Revoke_datashare_permissionsContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Revoke_datashare_permissionsContext) SHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHARE, 0) +} + +func (s *Revoke_datashare_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Revoke_datashare_permissionsContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Revoke_datashare_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_datashare_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_datashare_permissionsContext) USAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSAGE, 0) +} + +func (s *Revoke_datashare_permissionsContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMESPACE, 0) +} + +func (s *Revoke_datashare_permissionsContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Revoke_datashare_permissionsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCOUNT, 0) +} + +func (s *Revoke_datashare_permissionsContext) VIA() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIA, 0) +} + +func (s *Revoke_datashare_permissionsContext) DATA_CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_CATALOG, 0) +} + +func (s *Revoke_datashare_permissionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Revoke_datashare_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Revoke_datashare_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Revoke_datashare_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_datashare_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_datashare_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_datashare_permissions(s) + } +} + +func (s *Revoke_datashare_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_datashare_permissions(s) + } +} + +func (s *Revoke_datashare_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_datashare_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_datashare_permissions() (localctx IRevoke_datashare_permissionsContext) { + localctx = NewRevoke_datashare_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 750, RedshiftParserRULE_revoke_datashare_permissions) + var _la int + + p.SetState(7147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 547, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7089) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7090) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7091) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7092) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7095) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALTER || _la == RedshiftParserSHARE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7096) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7097) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7098) + p.Colid() + } + { + p.SetState(7099) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7100) + p.Grantee_list() + } + p.SetState(7102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7101) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7104) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7105) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7106) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7107) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7110) + p.Match(RedshiftParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7111) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7112) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7113) + p.Colid() + } + { + p.SetState(7114) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNAMESPACE: + { + p.SetState(7115) + p.Match(RedshiftParserNAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7116) + p.Sconst() + } + + case RedshiftParserACCOUNT: + { + p.SetState(7117) + p.Match(RedshiftParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7118) + p.Sconst() + } + p.SetState(7121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVIA { + { + p.SetState(7119) + p.Match(RedshiftParserVIA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7120) + p.Match(RedshiftParserDATA_CATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7125) + p.Opt_drop_behavior() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7128) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7129) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7130) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7131) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7134) + p.Match(RedshiftParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7135) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDATABASE: + { + p.SetState(7136) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7137) + p.Columnlist() + } + + case RedshiftParserSCHEMA: + { + p.SetState(7138) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7139) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7142) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7143) + p.Grantee_list() + } + p.SetState(7145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7144) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_spectrum_integration_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_spectrum_integration_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Revoke_spectrum_integration_extenral_column_permissions() IRevoke_spectrum_integration_extenral_column_permissionsContext + Revoke_spectrum_integration_external_table_permissions() IRevoke_spectrum_integration_external_table_permissionsContext + Revoke_spectrum_integration_external_schema_permissions() IRevoke_spectrum_integration_external_schema_permissionsContext + + // IsRevoke_spectrum_integration_permissionsContext differentiates from other interfaces. + IsRevoke_spectrum_integration_permissionsContext() +} + +type Revoke_spectrum_integration_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_spectrum_integration_permissionsContext() *Revoke_spectrum_integration_permissionsContext { + var p = new(Revoke_spectrum_integration_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_permissions + return p +} + +func InitEmptyRevoke_spectrum_integration_permissionsContext(p *Revoke_spectrum_integration_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_permissions +} + +func (*Revoke_spectrum_integration_permissionsContext) IsRevoke_spectrum_integration_permissionsContext() { +} + +func NewRevoke_spectrum_integration_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_spectrum_integration_permissionsContext { + var p = new(Revoke_spectrum_integration_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_permissions + + return p +} + +func (s *Revoke_spectrum_integration_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_spectrum_integration_permissionsContext) Revoke_spectrum_integration_extenral_column_permissions() IRevoke_spectrum_integration_extenral_column_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_spectrum_integration_extenral_column_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_spectrum_integration_extenral_column_permissionsContext) +} + +func (s *Revoke_spectrum_integration_permissionsContext) Revoke_spectrum_integration_external_table_permissions() IRevoke_spectrum_integration_external_table_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_spectrum_integration_external_table_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_spectrum_integration_external_table_permissionsContext) +} + +func (s *Revoke_spectrum_integration_permissionsContext) Revoke_spectrum_integration_external_schema_permissions() IRevoke_spectrum_integration_external_schema_permissionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_spectrum_integration_external_schema_permissionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_spectrum_integration_external_schema_permissionsContext) +} + +func (s *Revoke_spectrum_integration_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_spectrum_integration_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_spectrum_integration_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_spectrum_integration_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_spectrum_integration_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_spectrum_integration_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_spectrum_integration_permissions() (localctx IRevoke_spectrum_integration_permissionsContext) { + localctx = NewRevoke_spectrum_integration_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 752, RedshiftParserRULE_revoke_spectrum_integration_permissions) + p.SetState(7152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 548, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7149) + p.Revoke_spectrum_integration_extenral_column_permissions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7150) + p.Revoke_spectrum_integration_external_table_permissions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7151) + p.Revoke_spectrum_integration_external_schema_permissions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_spectrum_integration_external_schema_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_spectrum_integration_external_schema_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Spectrum_integration_external_schema_permission_list() ISpectrum_integration_external_schema_permission_listContext + ON() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Columnlist() IColumnlistContext + FROM() antlr.TerminalNode + Iamrolelist() IIamrolelistContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_spectrum_integration_external_schema_permissionsContext differentiates from other interfaces. + IsRevoke_spectrum_integration_external_schema_permissionsContext() +} + +type Revoke_spectrum_integration_external_schema_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_spectrum_integration_external_schema_permissionsContext() *Revoke_spectrum_integration_external_schema_permissionsContext { + var p = new(Revoke_spectrum_integration_external_schema_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_external_schema_permissions + return p +} + +func InitEmptyRevoke_spectrum_integration_external_schema_permissionsContext(p *Revoke_spectrum_integration_external_schema_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_external_schema_permissions +} + +func (*Revoke_spectrum_integration_external_schema_permissionsContext) IsRevoke_spectrum_integration_external_schema_permissionsContext() { +} + +func NewRevoke_spectrum_integration_external_schema_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_spectrum_integration_external_schema_permissionsContext { + var p = new(Revoke_spectrum_integration_external_schema_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_external_schema_permissions + + return p +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) Spectrum_integration_external_schema_permission_list() ISpectrum_integration_external_schema_permission_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpectrum_integration_external_schema_permission_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpectrum_integration_external_schema_permission_listContext) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) Iamrolelist() IIamrolelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolelistContext) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_spectrum_integration_external_schema_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_spectrum_integration_external_schema_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_external_schema_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_spectrum_integration_external_schema_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_spectrum_integration_external_schema_permissions() (localctx IRevoke_spectrum_integration_external_schema_permissionsContext) { + localctx = NewRevoke_spectrum_integration_external_schema_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 754, RedshiftParserRULE_revoke_spectrum_integration_external_schema_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7154) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7155) + p.Spectrum_integration_external_schema_permission_list() + } + { + p.SetState(7156) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7157) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7158) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7159) + p.Columnlist() + } + { + p.SetState(7160) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7161) + p.Iamrolelist() + } + p.SetState(7163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7162) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_spectrum_integration_external_table_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_spectrum_integration_external_table_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Spectrum_integration_external_table_permission_list() ISpectrum_integration_external_table_permission_listContext + ON() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + FROM() antlr.TerminalNode + Iamrolelist_or_public() IIamrolelist_or_publicContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_spectrum_integration_external_table_permissionsContext differentiates from other interfaces. + IsRevoke_spectrum_integration_external_table_permissionsContext() +} + +type Revoke_spectrum_integration_external_table_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_spectrum_integration_external_table_permissionsContext() *Revoke_spectrum_integration_external_table_permissionsContext { + var p = new(Revoke_spectrum_integration_external_table_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_external_table_permissions + return p +} + +func InitEmptyRevoke_spectrum_integration_external_table_permissionsContext(p *Revoke_spectrum_integration_external_table_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_external_table_permissions +} + +func (*Revoke_spectrum_integration_external_table_permissionsContext) IsRevoke_spectrum_integration_external_table_permissionsContext() { +} + +func NewRevoke_spectrum_integration_external_table_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_spectrum_integration_external_table_permissionsContext { + var p = new(Revoke_spectrum_integration_external_table_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_external_table_permissions + + return p +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) Spectrum_integration_external_table_permission_list() ISpectrum_integration_external_table_permission_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpectrum_integration_external_table_permission_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpectrum_integration_external_table_permission_listContext) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) Iamrolelist_or_public() IIamrolelist_or_publicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolelist_or_publicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolelist_or_publicContext) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_spectrum_integration_external_table_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_spectrum_integration_external_table_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_external_table_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_spectrum_integration_external_table_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_spectrum_integration_external_table_permissions() (localctx IRevoke_spectrum_integration_external_table_permissionsContext) { + localctx = NewRevoke_spectrum_integration_external_table_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 756, RedshiftParserRULE_revoke_spectrum_integration_external_table_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7165) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7166) + p.Spectrum_integration_external_table_permission_list() + } + { + p.SetState(7167) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7168) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7169) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7170) + p.Qualified_name_list() + } + { + p.SetState(7171) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7172) + p.Iamrolelist_or_public() + } + p.SetState(7174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7173) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_spectrum_integration_extenral_column_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_spectrum_integration_extenral_column_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + ON() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + FROM() antlr.TerminalNode + Iamrolelist() IIamrolelistContext + SELECT() antlr.TerminalNode + All_privileges() IAll_privilegesContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_spectrum_integration_extenral_column_permissionsContext differentiates from other interfaces. + IsRevoke_spectrum_integration_extenral_column_permissionsContext() +} + +type Revoke_spectrum_integration_extenral_column_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_spectrum_integration_extenral_column_permissionsContext() *Revoke_spectrum_integration_extenral_column_permissionsContext { + var p = new(Revoke_spectrum_integration_extenral_column_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_extenral_column_permissions + return p +} + +func InitEmptyRevoke_spectrum_integration_extenral_column_permissionsContext(p *Revoke_spectrum_integration_extenral_column_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_extenral_column_permissions +} + +func (*Revoke_spectrum_integration_extenral_column_permissionsContext) IsRevoke_spectrum_integration_extenral_column_permissionsContext() { +} + +func NewRevoke_spectrum_integration_extenral_column_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_spectrum_integration_extenral_column_permissionsContext { + var p = new(Revoke_spectrum_integration_extenral_column_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_spectrum_integration_extenral_column_permissions + + return p +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) Iamrolelist() IIamrolelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolelistContext) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) All_privileges() IAll_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_privilegesContext) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_spectrum_integration_extenral_column_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_spectrum_integration_extenral_column_permissions(s) + } +} + +func (s *Revoke_spectrum_integration_extenral_column_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_spectrum_integration_extenral_column_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_spectrum_integration_extenral_column_permissions() (localctx IRevoke_spectrum_integration_extenral_column_permissionsContext) { + localctx = NewRevoke_spectrum_integration_extenral_column_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 758, RedshiftParserRULE_revoke_spectrum_integration_extenral_column_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7176) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSELECT: + { + p.SetState(7177) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALL: + { + p.SetState(7178) + p.All_privileges() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7181) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7182) + p.Columnlist() + } + { + p.SetState(7183) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7184) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7185) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7186) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7187) + p.Qualified_name() + } + { + p.SetState(7188) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7189) + p.Iamrolelist() + } + p.SetState(7191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7190) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_assume_role_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_assume_role_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + ASSUMEROLE() antlr.TerminalNode + Grant_assume_role_target() IGrant_assume_role_targetContext + FROM() antlr.TerminalNode + Grantee_list() IGrantee_listContext + FOR() antlr.TerminalNode + Grant_assume_role_for_list() IGrant_assume_role_for_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRevoke_assume_role_permissionsContext differentiates from other interfaces. + IsRevoke_assume_role_permissionsContext() +} + +type Revoke_assume_role_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_assume_role_permissionsContext() *Revoke_assume_role_permissionsContext { + var p = new(Revoke_assume_role_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_assume_role_permissions + return p +} + +func InitEmptyRevoke_assume_role_permissionsContext(p *Revoke_assume_role_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_assume_role_permissions +} + +func (*Revoke_assume_role_permissionsContext) IsRevoke_assume_role_permissionsContext() {} + +func NewRevoke_assume_role_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_assume_role_permissionsContext { + var p = new(Revoke_assume_role_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_assume_role_permissions + + return p +} + +func (s *Revoke_assume_role_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_assume_role_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_assume_role_permissionsContext) ASSUMEROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSUMEROLE, 0) +} + +func (s *Revoke_assume_role_permissionsContext) Grant_assume_role_target() IGrant_assume_role_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_assume_role_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_assume_role_targetContext) +} + +func (s *Revoke_assume_role_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_assume_role_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Revoke_assume_role_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_assume_role_permissionsContext) Grant_assume_role_for_list() IGrant_assume_role_for_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_assume_role_for_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_assume_role_for_listContext) +} + +func (s *Revoke_assume_role_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_assume_role_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_assume_role_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_assume_role_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_assume_role_permissions(s) + } +} + +func (s *Revoke_assume_role_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_assume_role_permissions(s) + } +} + +func (s *Revoke_assume_role_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_assume_role_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_assume_role_permissions() (localctx IRevoke_assume_role_permissionsContext) { + localctx = NewRevoke_assume_role_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 760, RedshiftParserRULE_revoke_assume_role_permissions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7193) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7194) + p.Match(RedshiftParserASSUMEROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7195) + p.Grant_assume_role_target() + } + { + p.SetState(7196) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7197) + p.Grantee_list() + } + { + p.SetState(7198) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7199) + p.Grant_assume_role_for_list() + } + p.SetState(7201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7200) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_column_level_permissionsContext is an interface to support dynamic dispatch. +type IRevoke_column_level_permissionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Column_privilege_list() IColumn_privilege_listContext + ON() antlr.TerminalNode + Column_privilege_target() IColumn_privilege_targetContext + FROM() antlr.TerminalNode + Grantee_list() IGrantee_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + GRANT() antlr.TerminalNode + OPTION() antlr.TerminalNode + FOR() antlr.TerminalNode + + // IsRevoke_column_level_permissionsContext differentiates from other interfaces. + IsRevoke_column_level_permissionsContext() +} + +type Revoke_column_level_permissionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_column_level_permissionsContext() *Revoke_column_level_permissionsContext { + var p = new(Revoke_column_level_permissionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_column_level_permissions + return p +} + +func InitEmptyRevoke_column_level_permissionsContext(p *Revoke_column_level_permissionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revoke_column_level_permissions +} + +func (*Revoke_column_level_permissionsContext) IsRevoke_column_level_permissionsContext() {} + +func NewRevoke_column_level_permissionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_column_level_permissionsContext { + var p = new(Revoke_column_level_permissionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revoke_column_level_permissions + + return p +} + +func (s *Revoke_column_level_permissionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_column_level_permissionsContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Revoke_column_level_permissionsContext) Column_privilege_list() IColumn_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_privilege_listContext) +} + +func (s *Revoke_column_level_permissionsContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Revoke_column_level_permissionsContext) Column_privilege_target() IColumn_privilege_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_privilege_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_privilege_targetContext) +} + +func (s *Revoke_column_level_permissionsContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Revoke_column_level_permissionsContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Revoke_column_level_permissionsContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Revoke_column_level_permissionsContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Revoke_column_level_permissionsContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Revoke_column_level_permissionsContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Revoke_column_level_permissionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_column_level_permissionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_column_level_permissionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevoke_column_level_permissions(s) + } +} + +func (s *Revoke_column_level_permissionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevoke_column_level_permissions(s) + } +} + +func (s *Revoke_column_level_permissionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevoke_column_level_permissions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revoke_column_level_permissions() (localctx IRevoke_column_level_permissionsContext) { + localctx = NewRevoke_column_level_permissionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 762, RedshiftParserRULE_revoke_column_level_permissions) + var _la int + + p.SetState(7224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 556, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7203) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7204) + p.Column_privilege_list() + } + { + p.SetState(7205) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7206) + p.Column_privilege_target() + } + { + p.SetState(7207) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7208) + p.Grantee_list() + } + p.SetState(7210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7209) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7212) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7213) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7214) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7215) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7216) + p.Column_privilege_list() + } + { + p.SetState(7217) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7218) + p.Column_privilege_target() + } + { + p.SetState(7219) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7220) + p.Grantee_list() + } + p.SetState(7222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7221) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommon_revokeContext is an interface to support dynamic dispatch. +type ICommon_revokeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Table_privilege_list() ITable_privilege_listContext + ON() antlr.TerminalNode + Revoke_table_target() IRevoke_table_targetContext + FROM() antlr.TerminalNode + Grantee_list() IGrantee_listContext + GRANT() antlr.TerminalNode + OPTION() antlr.TerminalNode + FOR() antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + Database_privilege_list() IDatabase_privilege_listContext + Grant_database_target() IGrant_database_targetContext + Schema_privilege_list() ISchema_privilege_listContext + Revoke_schema_target() IRevoke_schema_targetContext + Function_privilege_list() IFunction_privilege_listContext + Grant_function_target() IGrant_function_targetContext + Procedure_privilege_list() IProcedure_privilege_listContext + Grant_procedure_target() IGrant_procedure_targetContext + Language_privilege_list() ILanguage_privilege_listContext + Grant_language_target() IGrant_language_targetContext + Copy_job_privilege_list() ICopy_job_privilege_listContext + Copy_job_target() ICopy_job_targetContext + + // IsCommon_revokeContext differentiates from other interfaces. + IsCommon_revokeContext() +} + +type Common_revokeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommon_revokeContext() *Common_revokeContext { + var p = new(Common_revokeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_revoke + return p +} + +func InitEmptyCommon_revokeContext(p *Common_revokeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_revoke +} + +func (*Common_revokeContext) IsCommon_revokeContext() {} + +func NewCommon_revokeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_revokeContext { + var p = new(Common_revokeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_common_revoke + + return p +} + +func (s *Common_revokeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Common_revokeContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Common_revokeContext) Table_privilege_list() ITable_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_privilege_listContext) +} + +func (s *Common_revokeContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Common_revokeContext) Revoke_table_target() IRevoke_table_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_table_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_table_targetContext) +} + +func (s *Common_revokeContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Common_revokeContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *Common_revokeContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Common_revokeContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Common_revokeContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Common_revokeContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *Common_revokeContext) Database_privilege_list() IDatabase_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_privilege_listContext) +} + +func (s *Common_revokeContext) Grant_database_target() IGrant_database_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_database_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_database_targetContext) +} + +func (s *Common_revokeContext) Schema_privilege_list() ISchema_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilege_listContext) +} + +func (s *Common_revokeContext) Revoke_schema_target() IRevoke_schema_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_schema_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_schema_targetContext) +} + +func (s *Common_revokeContext) Function_privilege_list() IFunction_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_privilege_listContext) +} + +func (s *Common_revokeContext) Grant_function_target() IGrant_function_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_function_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_function_targetContext) +} + +func (s *Common_revokeContext) Procedure_privilege_list() IProcedure_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_privilege_listContext) +} + +func (s *Common_revokeContext) Grant_procedure_target() IGrant_procedure_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_procedure_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_procedure_targetContext) +} + +func (s *Common_revokeContext) Language_privilege_list() ILanguage_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguage_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguage_privilege_listContext) +} + +func (s *Common_revokeContext) Grant_language_target() IGrant_language_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_language_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_language_targetContext) +} + +func (s *Common_revokeContext) Copy_job_privilege_list() ICopy_job_privilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_privilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_privilege_listContext) +} + +func (s *Common_revokeContext) Copy_job_target() ICopy_job_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_job_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_job_targetContext) +} + +func (s *Common_revokeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Common_revokeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Common_revokeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCommon_revoke(s) + } +} + +func (s *Common_revokeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCommon_revoke(s) + } +} + +func (s *Common_revokeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCommon_revoke(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Common_revoke() (localctx ICommon_revokeContext) { + localctx = NewCommon_revokeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 764, RedshiftParserRULE_common_revoke) + var _la int + + p.SetState(7324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 571, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7226) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7227) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7228) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7229) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7232) + p.Table_privilege_list() + } + { + p.SetState(7233) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7234) + p.Revoke_table_target() + } + { + p.SetState(7235) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7236) + p.Grantee_list() + } + p.SetState(7238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7237) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7240) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7241) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7242) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7243) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7246) + p.Database_privilege_list() + } + { + p.SetState(7247) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7248) + p.Grant_database_target() + } + { + p.SetState(7249) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7250) + p.Grantee_list() + } + p.SetState(7252) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7251) + p.Opt_drop_behavior() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7254) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7255) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7256) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7257) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7260) + p.Schema_privilege_list() + } + { + p.SetState(7261) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7262) + p.Revoke_schema_target() + } + { + p.SetState(7263) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7264) + p.Grantee_list() + } + p.SetState(7266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7265) + p.Opt_drop_behavior() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7268) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7269) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7270) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7271) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7274) + p.Function_privilege_list() + } + { + p.SetState(7275) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7276) + p.Grant_function_target() + } + { + p.SetState(7277) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7278) + p.Grantee_list() + } + p.SetState(7280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7279) + p.Opt_drop_behavior() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7282) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7283) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7284) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7285) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7288) + p.Procedure_privilege_list() + } + { + p.SetState(7289) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7290) + p.Grant_procedure_target() + } + { + p.SetState(7291) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7292) + p.Grantee_list() + } + p.SetState(7294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7293) + p.Opt_drop_behavior() + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7296) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7297) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7298) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7299) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7302) + p.Language_privilege_list() + } + { + p.SetState(7303) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7304) + p.Grant_language_target() + } + { + p.SetState(7305) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7306) + p.Grantee_list() + } + p.SetState(7308) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7307) + p.Opt_drop_behavior() + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7310) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANT { + { + p.SetState(7311) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7312) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7313) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7316) + p.Copy_job_privilege_list() + } + { + p.SetState(7317) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7318) + p.Copy_job_target() + } + { + p.SetState(7319) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7320) + p.Grantee_list() + } + p.SetState(7322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7321) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegesContext is an interface to support dynamic dispatch. +type IPrivilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Privilege_list() IPrivilege_listContext + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsPrivilegesContext differentiates from other interfaces. + IsPrivilegesContext() +} + +type PrivilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegesContext() *PrivilegesContext { + var p = new(PrivilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privileges + return p +} + +func InitEmptyPrivilegesContext(p *PrivilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privileges +} + +func (*PrivilegesContext) IsPrivilegesContext() {} + +func NewPrivilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegesContext { + var p = new(PrivilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_privileges + + return p +} + +func (s *PrivilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegesContext) Privilege_list() IPrivilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_listContext) +} + +func (s *PrivilegesContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *PrivilegesContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIVILEGES, 0) +} + +func (s *PrivilegesContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *PrivilegesContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *PrivilegesContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *PrivilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPrivileges(s) + } +} + +func (s *PrivilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPrivileges(s) + } +} + +func (s *PrivilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPrivileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Privileges() (localctx IPrivilegesContext) { + localctx = NewPrivilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 766, RedshiftParserRULE_privileges) + p.SetState(7341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 572, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7326) + p.Privilege_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7327) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7328) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7329) + p.Match(RedshiftParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7330) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7331) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7332) + p.Columnlist() + } + { + p.SetState(7333) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7335) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7336) + p.Match(RedshiftParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7337) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7338) + p.Columnlist() + } + { + p.SetState(7339) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilege_listContext is an interface to support dynamic dispatch. +type IPrivilege_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPrivilege() []IPrivilegeContext + Privilege(i int) IPrivilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrivilege_listContext differentiates from other interfaces. + IsPrivilege_listContext() +} + +type Privilege_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilege_listContext() *Privilege_listContext { + var p = new(Privilege_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privilege_list + return p +} + +func InitEmptyPrivilege_listContext(p *Privilege_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privilege_list +} + +func (*Privilege_listContext) IsPrivilege_listContext() {} + +func NewPrivilege_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_listContext { + var p = new(Privilege_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_privilege_list + + return p +} + +func (s *Privilege_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Privilege_listContext) AllPrivilege() []IPrivilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrivilegeContext); ok { + len++ + } + } + + tst := make([]IPrivilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrivilegeContext); ok { + tst[i] = t.(IPrivilegeContext) + i++ + } + } + + return tst +} + +func (s *Privilege_listContext) Privilege(i int) IPrivilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegeContext) +} + +func (s *Privilege_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Privilege_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Privilege_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Privilege_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Privilege_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPrivilege_list(s) + } +} + +func (s *Privilege_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPrivilege_list(s) + } +} + +func (s *Privilege_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPrivilege_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Privilege_list() (localctx IPrivilege_listContext) { + localctx = NewPrivilege_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 768, RedshiftParserRULE_privilege_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7343) + p.Privilege() + } + p.SetState(7348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7344) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7345) + p.Privilege() + } + + p.SetState(7350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilegeContext is an interface to support dynamic dispatch. +type IPrivilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + Opt_column_list() IOpt_column_listContext + REFERENCES() antlr.TerminalNode + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + SYSTEM_P() antlr.TerminalNode + Colid() IColidContext + + // IsPrivilegeContext differentiates from other interfaces. + IsPrivilegeContext() +} + +type PrivilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilegeContext() *PrivilegeContext { + var p = new(PrivilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privilege + return p +} + +func InitEmptyPrivilegeContext(p *PrivilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privilege +} + +func (*PrivilegeContext) IsPrivilegeContext() {} + +func NewPrivilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PrivilegeContext { + var p = new(PrivilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_privilege + + return p +} + +func (s *PrivilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *PrivilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *PrivilegeContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *PrivilegeContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCES, 0) +} + +func (s *PrivilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *PrivilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *PrivilegeContext) SYSTEM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSTEM_P, 0) +} + +func (s *PrivilegeContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *PrivilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PrivilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PrivilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPrivilege(s) + } +} + +func (s *PrivilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPrivilege(s) + } +} + +func (s *PrivilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPrivilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Privilege() (localctx IPrivilegeContext) { + localctx = NewPrivilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 770, RedshiftParserRULE_privilege) + var _la int + + p.SetState(7369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 578, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7351) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(7352) + p.Opt_column_list() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7355) + p.Match(RedshiftParserREFERENCES) + 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 == RedshiftParserOPEN_PAREN { + { + p.SetState(7356) + p.Opt_column_list() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7359) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(7360) + p.Opt_column_list() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7363) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7364) + p.Match(RedshiftParserSYSTEM_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7365) + p.Colid() + } + p.SetState(7367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(7366) + p.Opt_column_list() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrivilege_targetContext is an interface to support dynamic dispatch. +type IPrivilege_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name_list() IQualified_name_listContext + TABLE() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + DATA_P() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + Name_list() IName_listContext + SERVER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes_list() IFunction_with_argtypes_listContext + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + DOMAIN_P() antlr.TerminalNode + Any_name_list() IAny_name_listContext + LANGUAGE() antlr.TerminalNode + LARGE_P() antlr.TerminalNode + OBJECT_P() antlr.TerminalNode + Numericonly_list() INumericonly_listContext + PARAMETER() antlr.TerminalNode + Parameter_name_list() IParameter_name_listContext + SCHEMA() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + ALL() antlr.TerminalNode + TABLES() antlr.TerminalNode + IN_P() antlr.TerminalNode + SEQUENCES() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + ROUTINES() antlr.TerminalNode + + // IsPrivilege_targetContext differentiates from other interfaces. + IsPrivilege_targetContext() +} + +type Privilege_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilege_targetContext() *Privilege_targetContext { + var p = new(Privilege_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privilege_target + return p +} + +func InitEmptyPrivilege_targetContext(p *Privilege_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_privilege_target +} + +func (*Privilege_targetContext) IsPrivilege_targetContext() {} + +func NewPrivilege_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_targetContext { + var p = new(Privilege_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_privilege_target + + return p +} + +func (s *Privilege_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Privilege_targetContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Privilege_targetContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Privilege_targetContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *Privilege_targetContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *Privilege_targetContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *Privilege_targetContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *Privilege_targetContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *Privilege_targetContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *Privilege_targetContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Privilege_targetContext) Function_with_argtypes_list() IFunction_with_argtypes_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypes_listContext) +} + +func (s *Privilege_targetContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *Privilege_targetContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *Privilege_targetContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Privilege_targetContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *Privilege_targetContext) Any_name_list() IAny_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_name_listContext) +} + +func (s *Privilege_targetContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *Privilege_targetContext) LARGE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLARGE_P, 0) +} + +func (s *Privilege_targetContext) OBJECT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOBJECT_P, 0) +} + +func (s *Privilege_targetContext) Numericonly_list() INumericonly_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonly_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonly_listContext) +} + +func (s *Privilege_targetContext) PARAMETER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAMETER, 0) +} + +func (s *Privilege_targetContext) Parameter_name_list() IParameter_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_name_listContext) +} + +func (s *Privilege_targetContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Privilege_targetContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *Privilege_targetContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Privilege_targetContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Privilege_targetContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *Privilege_targetContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Privilege_targetContext) SEQUENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCES, 0) +} + +func (s *Privilege_targetContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTIONS, 0) +} + +func (s *Privilege_targetContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURES, 0) +} + +func (s *Privilege_targetContext) ROUTINES() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINES, 0) +} + +func (s *Privilege_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Privilege_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Privilege_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPrivilege_target(s) + } +} + +func (s *Privilege_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPrivilege_target(s) + } +} + +func (s *Privilege_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPrivilege_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Privilege_target() (localctx IPrivilege_targetContext) { + localctx = NewPrivilege_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 772, RedshiftParserRULE_privilege_target) + p.SetState(7431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 579, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7371) + p.Qualified_name_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7372) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7373) + p.Qualified_name_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7374) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7375) + p.Qualified_name_list() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7376) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7377) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7378) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7379) + p.Name_list() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7380) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7381) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7382) + p.Name_list() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7383) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7384) + p.Function_with_argtypes_list() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7385) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7386) + p.Function_with_argtypes_list() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7387) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7388) + p.Function_with_argtypes_list() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7389) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7390) + p.Name_list() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7391) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7392) + p.Any_name_list() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(7393) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7394) + p.Name_list() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(7395) + p.Match(RedshiftParserLARGE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7396) + p.Match(RedshiftParserOBJECT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7397) + p.Numericonly_list() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(7398) + p.Match(RedshiftParserPARAMETER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7399) + p.Parameter_name_list() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(7400) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7401) + p.Name_list() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(7402) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7403) + p.Name_list() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(7404) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7405) + p.Any_name_list() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(7406) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7407) + p.Match(RedshiftParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7408) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7409) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7410) + p.Name_list() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(7411) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7412) + p.Match(RedshiftParserSEQUENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7413) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7414) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7415) + p.Name_list() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(7416) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7417) + p.Match(RedshiftParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7418) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7419) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7420) + p.Name_list() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(7421) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7422) + p.Match(RedshiftParserPROCEDURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7423) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7424) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7425) + p.Name_list() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(7426) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7427) + p.Match(RedshiftParserROUTINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7428) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7429) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7430) + p.Name_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameter_name_listContext is an interface to support dynamic dispatch. +type IParameter_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllParameter_name() []IParameter_nameContext + Parameter_name(i int) IParameter_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsParameter_name_listContext differentiates from other interfaces. + IsParameter_name_listContext() +} + +type Parameter_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_name_listContext() *Parameter_name_listContext { + var p = new(Parameter_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_parameter_name_list + return p +} + +func InitEmptyParameter_name_listContext(p *Parameter_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_parameter_name_list +} + +func (*Parameter_name_listContext) IsParameter_name_listContext() {} + +func NewParameter_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_name_listContext { + var p = new(Parameter_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_parameter_name_list + + return p +} + +func (s *Parameter_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_name_listContext) 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 *Parameter_name_listContext) 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 *Parameter_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Parameter_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Parameter_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterParameter_name_list(s) + } +} + +func (s *Parameter_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitParameter_name_list(s) + } +} + +func (s *Parameter_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitParameter_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Parameter_name_list() (localctx IParameter_name_listContext) { + localctx = NewParameter_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 774, RedshiftParserRULE_parameter_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7433) + p.Parameter_name() + } + p.SetState(7438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7434) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7435) + p.Parameter_name() + } + + p.SetState(7440) + 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 +} + +// IParameter_nameContext is an interface to support dynamic dispatch. +type IParameter_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColid() []IColidContext + Colid(i int) IColidContext + DOT() antlr.TerminalNode + + // 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 = RedshiftParserRULE_parameter_name + return p +} + +func InitEmptyParameter_nameContext(p *Parameter_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_parameter_name + + return p +} + +func (s *Parameter_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_nameContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Parameter_nameContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Parameter_nameContext) DOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, 0) +} + +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.(RedshiftParserListener); ok { + listenerT.EnterParameter_name(s) + } +} + +func (s *Parameter_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitParameter_name(s) + } +} + +func (s *Parameter_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitParameter_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Parameter_name() (localctx IParameter_nameContext) { + localctx = NewParameter_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 776, RedshiftParserRULE_parameter_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7441) + p.Colid() + } + p.SetState(7444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDOT { + { + p.SetState(7442) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7443) + p.Colid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_grant_grant_optionContext is an interface to support dynamic dispatch. +type IOpt_grant_grant_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + GRANT() antlr.TerminalNode + OPTION() antlr.TerminalNode + + // IsOpt_grant_grant_optionContext differentiates from other interfaces. + IsOpt_grant_grant_optionContext() +} + +type Opt_grant_grant_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_grant_grant_optionContext() *Opt_grant_grant_optionContext { + var p = new(Opt_grant_grant_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_grant_grant_option + return p +} + +func InitEmptyOpt_grant_grant_optionContext(p *Opt_grant_grant_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_grant_grant_option +} + +func (*Opt_grant_grant_optionContext) IsOpt_grant_grant_optionContext() {} + +func NewOpt_grant_grant_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_grant_grant_optionContext { + var p = new(Opt_grant_grant_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_grant_grant_option + + return p +} + +func (s *Opt_grant_grant_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_grant_grant_optionContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_grant_grant_optionContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Opt_grant_grant_optionContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Opt_grant_grant_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_grant_grant_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_grant_grant_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_grant_grant_option(s) + } +} + +func (s *Opt_grant_grant_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_grant_grant_option(s) + } +} + +func (s *Opt_grant_grant_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_grant_grant_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_grant_grant_option() (localctx IOpt_grant_grant_optionContext) { + localctx = NewOpt_grant_grant_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 778, RedshiftParserRULE_opt_grant_grant_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7446) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7447) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7448) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantrolestmtContext is an interface to support dynamic dispatch. +type IGrantrolestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Privilege_list() IPrivilege_listContext + TO() antlr.TerminalNode + Role_list() IRole_listContext + Opt_grant_admin_option() IOpt_grant_admin_optionContext + Opt_granted_by() IOpt_granted_byContext + + // IsGrantrolestmtContext differentiates from other interfaces. + IsGrantrolestmtContext() +} + +type GrantrolestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantrolestmtContext() *GrantrolestmtContext { + var p = new(GrantrolestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantrolestmt + return p +} + +func InitEmptyGrantrolestmtContext(p *GrantrolestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantrolestmt +} + +func (*GrantrolestmtContext) IsGrantrolestmtContext() {} + +func NewGrantrolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantrolestmtContext { + var p = new(GrantrolestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantrolestmt + + return p +} + +func (s *GrantrolestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantrolestmtContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *GrantrolestmtContext) Privilege_list() IPrivilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_listContext) +} + +func (s *GrantrolestmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *GrantrolestmtContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *GrantrolestmtContext) Opt_grant_admin_option() IOpt_grant_admin_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_grant_admin_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_grant_admin_optionContext) +} + +func (s *GrantrolestmtContext) Opt_granted_by() IOpt_granted_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_granted_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_granted_byContext) +} + +func (s *GrantrolestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantrolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantrolestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantrolestmt(s) + } +} + +func (s *GrantrolestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantrolestmt(s) + } +} + +func (s *GrantrolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantrolestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantrolestmt() (localctx IGrantrolestmtContext) { + localctx = NewGrantrolestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 780, RedshiftParserRULE_grantrolestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7450) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7451) + p.Privilege_list() + } + { + p.SetState(7452) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7453) + p.Role_list() + } + p.SetState(7455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(7454) + p.Opt_grant_admin_option() + } + + } + p.SetState(7458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANTED { + { + p.SetState(7457) + p.Opt_granted_by() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevokerolestmtContext is an interface to support dynamic dispatch. +type IRevokerolestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Privilege_list() IPrivilege_listContext + FROM() antlr.TerminalNode + Role_list() IRole_listContext + Opt_granted_by() IOpt_granted_byContext + Opt_drop_behavior() IOpt_drop_behaviorContext + ADMIN() antlr.TerminalNode + OPTION() antlr.TerminalNode + FOR() antlr.TerminalNode + + // IsRevokerolestmtContext differentiates from other interfaces. + IsRevokerolestmtContext() +} + +type RevokerolestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevokerolestmtContext() *RevokerolestmtContext { + var p = new(RevokerolestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revokerolestmt + return p +} + +func InitEmptyRevokerolestmtContext(p *RevokerolestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_revokerolestmt +} + +func (*RevokerolestmtContext) IsRevokerolestmtContext() {} + +func NewRevokerolestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RevokerolestmtContext { + var p = new(RevokerolestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_revokerolestmt + + return p +} + +func (s *RevokerolestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RevokerolestmtContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *RevokerolestmtContext) Privilege_list() IPrivilege_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_listContext) +} + +func (s *RevokerolestmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *RevokerolestmtContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *RevokerolestmtContext) Opt_granted_by() IOpt_granted_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_granted_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_granted_byContext) +} + +func (s *RevokerolestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *RevokerolestmtContext) ADMIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserADMIN, 0) +} + +func (s *RevokerolestmtContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *RevokerolestmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *RevokerolestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RevokerolestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RevokerolestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRevokerolestmt(s) + } +} + +func (s *RevokerolestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRevokerolestmt(s) + } +} + +func (s *RevokerolestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRevokerolestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Revokerolestmt() (localctx IRevokerolestmtContext) { + localctx = NewRevokerolestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 782, RedshiftParserRULE_revokerolestmt) + var _la int + + p.SetState(7483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7460) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7461) + p.Privilege_list() + } + { + p.SetState(7462) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7463) + p.Role_list() + } + p.SetState(7465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANTED { + { + p.SetState(7464) + p.Opt_granted_by() + } + + } + p.SetState(7468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7467) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7470) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7471) + p.Match(RedshiftParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7472) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7473) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7474) + p.Privilege_list() + } + { + p.SetState(7475) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7476) + p.Role_list() + } + p.SetState(7478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGRANTED { + { + p.SetState(7477) + p.Opt_granted_by() + } + + } + p.SetState(7481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7480) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_grant_admin_optionContext is an interface to support dynamic dispatch. +type IOpt_grant_admin_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + ADMIN() antlr.TerminalNode + OPTION() antlr.TerminalNode + + // IsOpt_grant_admin_optionContext differentiates from other interfaces. + IsOpt_grant_admin_optionContext() +} + +type Opt_grant_admin_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_grant_admin_optionContext() *Opt_grant_admin_optionContext { + var p = new(Opt_grant_admin_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_grant_admin_option + return p +} + +func InitEmptyOpt_grant_admin_optionContext(p *Opt_grant_admin_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_grant_admin_option +} + +func (*Opt_grant_admin_optionContext) IsOpt_grant_admin_optionContext() {} + +func NewOpt_grant_admin_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_grant_admin_optionContext { + var p = new(Opt_grant_admin_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_grant_admin_option + + return p +} + +func (s *Opt_grant_admin_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_grant_admin_optionContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_grant_admin_optionContext) ADMIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserADMIN, 0) +} + +func (s *Opt_grant_admin_optionContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Opt_grant_admin_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_grant_admin_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_grant_admin_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_grant_admin_option(s) + } +} + +func (s *Opt_grant_admin_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_grant_admin_option(s) + } +} + +func (s *Opt_grant_admin_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_grant_admin_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_grant_admin_option() (localctx IOpt_grant_admin_optionContext) { + localctx = NewOpt_grant_admin_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 784, RedshiftParserRULE_opt_grant_admin_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7485) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7486) + p.Match(RedshiftParserADMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7487) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_granted_byContext is an interface to support dynamic dispatch. +type IOpt_granted_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANTED() antlr.TerminalNode + BY() antlr.TerminalNode + Rolespec() IRolespecContext + + // IsOpt_granted_byContext differentiates from other interfaces. + IsOpt_granted_byContext() +} + +type Opt_granted_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_granted_byContext() *Opt_granted_byContext { + var p = new(Opt_granted_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_granted_by + return p +} + +func InitEmptyOpt_granted_byContext(p *Opt_granted_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_granted_by +} + +func (*Opt_granted_byContext) IsOpt_granted_byContext() {} + +func NewOpt_granted_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_granted_byContext { + var p = new(Opt_granted_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_granted_by + + return p +} + +func (s *Opt_granted_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_granted_byContext) GRANTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANTED, 0) +} + +func (s *Opt_granted_byContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Opt_granted_byContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Opt_granted_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_granted_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_granted_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_granted_by(s) + } +} + +func (s *Opt_granted_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_granted_by(s) + } +} + +func (s *Opt_granted_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_granted_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_granted_by() (localctx IOpt_granted_byContext) { + localctx = NewOpt_granted_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 786, RedshiftParserRULE_opt_granted_by) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7489) + p.Match(RedshiftParserGRANTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7490) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7491) + p.Rolespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterdefaultprivilegesstmtContext is an interface to support dynamic dispatch. +type IAlterdefaultprivilegesstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + Defacloptionlist() IDefacloptionlistContext + Defaclaction() IDefaclactionContext + + // IsAlterdefaultprivilegesstmtContext differentiates from other interfaces. + IsAlterdefaultprivilegesstmtContext() +} + +type AlterdefaultprivilegesstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdefaultprivilegesstmtContext() *AlterdefaultprivilegesstmtContext { + var p = new(AlterdefaultprivilegesstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdefaultprivilegesstmt + return p +} + +func InitEmptyAlterdefaultprivilegesstmtContext(p *AlterdefaultprivilegesstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdefaultprivilegesstmt +} + +func (*AlterdefaultprivilegesstmtContext) IsAlterdefaultprivilegesstmtContext() {} + +func NewAlterdefaultprivilegesstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdefaultprivilegesstmtContext { + var p = new(AlterdefaultprivilegesstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdefaultprivilegesstmt + + return p +} + +func (s *AlterdefaultprivilegesstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterdefaultprivilegesstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterdefaultprivilegesstmtContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *AlterdefaultprivilegesstmtContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIVILEGES, 0) +} + +func (s *AlterdefaultprivilegesstmtContext) Defacloptionlist() IDefacloptionlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefacloptionlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefacloptionlistContext) +} + +func (s *AlterdefaultprivilegesstmtContext) Defaclaction() IDefaclactionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefaclactionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefaclactionContext) +} + +func (s *AlterdefaultprivilegesstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterdefaultprivilegesstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterdefaultprivilegesstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdefaultprivilegesstmt(s) + } +} + +func (s *AlterdefaultprivilegesstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdefaultprivilegesstmt(s) + } +} + +func (s *AlterdefaultprivilegesstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdefaultprivilegesstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdefaultprivilegesstmt() (localctx IAlterdefaultprivilegesstmtContext) { + localctx = NewAlterdefaultprivilegesstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 788, RedshiftParserRULE_alterdefaultprivilegesstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7493) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7494) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7495) + p.Match(RedshiftParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7496) + p.Defacloptionlist() + } + { + p.SetState(7497) + p.Defaclaction() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefacloptionlistContext is an interface to support dynamic dispatch. +type IDefacloptionlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDefacloption() []IDefacloptionContext + Defacloption(i int) IDefacloptionContext + + // IsDefacloptionlistContext differentiates from other interfaces. + IsDefacloptionlistContext() +} + +type DefacloptionlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefacloptionlistContext() *DefacloptionlistContext { + var p = new(DefacloptionlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defacloptionlist + return p +} + +func InitEmptyDefacloptionlistContext(p *DefacloptionlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defacloptionlist +} + +func (*DefacloptionlistContext) IsDefacloptionlistContext() {} + +func NewDefacloptionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefacloptionlistContext { + var p = new(DefacloptionlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_defacloptionlist + + return p +} + +func (s *DefacloptionlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefacloptionlistContext) AllDefacloption() []IDefacloptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDefacloptionContext); ok { + len++ + } + } + + tst := make([]IDefacloptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDefacloptionContext); ok { + tst[i] = t.(IDefacloptionContext) + i++ + } + } + + return tst +} + +func (s *DefacloptionlistContext) Defacloption(i int) IDefacloptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefacloptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDefacloptionContext) +} + +func (s *DefacloptionlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefacloptionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefacloptionlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDefacloptionlist(s) + } +} + +func (s *DefacloptionlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDefacloptionlist(s) + } +} + +func (s *DefacloptionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDefacloptionlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Defacloptionlist() (localctx IDefacloptionlistContext) { + localctx = NewDefacloptionlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 790, RedshiftParserRULE_defacloptionlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserFOR || _la == RedshiftParserIN_P { + { + p.SetState(7499) + p.Defacloption() + } + + p.SetState(7504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefacloptionContext is an interface to support dynamic dispatch. +type IDefacloptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN_P() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Name_list() IName_listContext + FOR() antlr.TerminalNode + ROLE() antlr.TerminalNode + Role_list() IRole_listContext + USER() antlr.TerminalNode + + // IsDefacloptionContext differentiates from other interfaces. + IsDefacloptionContext() +} + +type DefacloptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefacloptionContext() *DefacloptionContext { + var p = new(DefacloptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defacloption + return p +} + +func InitEmptyDefacloptionContext(p *DefacloptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defacloption +} + +func (*DefacloptionContext) IsDefacloptionContext() {} + +func NewDefacloptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefacloptionContext { + var p = new(DefacloptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_defacloption + + return p +} + +func (s *DefacloptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefacloptionContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *DefacloptionContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *DefacloptionContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *DefacloptionContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *DefacloptionContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *DefacloptionContext) Role_list() IRole_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_listContext) +} + +func (s *DefacloptionContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *DefacloptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefacloptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefacloptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDefacloption(s) + } +} + +func (s *DefacloptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDefacloption(s) + } +} + +func (s *DefacloptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDefacloption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Defacloption() (localctx IDefacloptionContext) { + localctx = NewDefacloptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 792, RedshiftParserRULE_defacloption) + p.SetState(7514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 590, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7505) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7506) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7507) + p.Name_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7508) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7509) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7510) + p.Role_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7511) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7512) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7513) + p.Role_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefaclactionContext is an interface to support dynamic dispatch. +type IDefaclactionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Privileges() IPrivilegesContext + ON() antlr.TerminalNode + Defacl_privilege_target() IDefacl_privilege_targetContext + TO() antlr.TerminalNode + Grantee_list() IGrantee_listContext + Opt_grant_grant_option() IOpt_grant_grant_optionContext + REVOKE() antlr.TerminalNode + FROM() antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + OPTION() antlr.TerminalNode + FOR() antlr.TerminalNode + + // IsDefaclactionContext differentiates from other interfaces. + IsDefaclactionContext() +} + +type DefaclactionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefaclactionContext() *DefaclactionContext { + var p = new(DefaclactionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defaclaction + return p +} + +func InitEmptyDefaclactionContext(p *DefaclactionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defaclaction +} + +func (*DefaclactionContext) IsDefaclactionContext() {} + +func NewDefaclactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefaclactionContext { + var p = new(DefaclactionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_defaclaction + + return p +} + +func (s *DefaclactionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefaclactionContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *DefaclactionContext) Privileges() IPrivilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilegesContext) +} + +func (s *DefaclactionContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *DefaclactionContext) Defacl_privilege_target() IDefacl_privilege_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefacl_privilege_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefacl_privilege_targetContext) +} + +func (s *DefaclactionContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *DefaclactionContext) Grantee_list() IGrantee_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_listContext) +} + +func (s *DefaclactionContext) Opt_grant_grant_option() IOpt_grant_grant_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_grant_grant_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_grant_grant_optionContext) +} + +func (s *DefaclactionContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *DefaclactionContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *DefaclactionContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DefaclactionContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *DefaclactionContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *DefaclactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefaclactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefaclactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDefaclaction(s) + } +} + +func (s *DefaclactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDefaclaction(s) + } +} + +func (s *DefaclactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDefaclaction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Defaclaction() (localctx IDefaclactionContext) { + localctx = NewDefaclactionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 794, RedshiftParserRULE_defaclaction) + var _la int + + p.SetState(7546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 594, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7516) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7517) + p.Privileges() + } + { + p.SetState(7518) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7519) + p.Defacl_privilege_target() + } + { + p.SetState(7520) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7521) + p.Grantee_list() + } + p.SetState(7523) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 591, p.GetParserRuleContext()) == 1 { + { + p.SetState(7522) + p.Opt_grant_grant_option() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7525) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7526) + p.Privileges() + } + { + p.SetState(7527) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7528) + p.Defacl_privilege_target() + } + { + p.SetState(7529) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7530) + p.Grantee_list() + } + p.SetState(7532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7531) + p.Opt_drop_behavior() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7534) + p.Match(RedshiftParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7535) + p.Match(RedshiftParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7536) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7537) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7538) + p.Privileges() + } + { + p.SetState(7539) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7540) + p.Defacl_privilege_target() + } + { + p.SetState(7541) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7542) + p.Grantee_list() + } + p.SetState(7544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(7543) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefacl_privilege_targetContext is an interface to support dynamic dispatch. +type IDefacl_privilege_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLES() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + ROUTINES() antlr.TerminalNode + SEQUENCES() antlr.TerminalNode + TYPES_P() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + + // IsDefacl_privilege_targetContext differentiates from other interfaces. + IsDefacl_privilege_targetContext() +} + +type Defacl_privilege_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefacl_privilege_targetContext() *Defacl_privilege_targetContext { + var p = new(Defacl_privilege_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defacl_privilege_target + return p +} + +func InitEmptyDefacl_privilege_targetContext(p *Defacl_privilege_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_defacl_privilege_target +} + +func (*Defacl_privilege_targetContext) IsDefacl_privilege_targetContext() {} + +func NewDefacl_privilege_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Defacl_privilege_targetContext { + var p = new(Defacl_privilege_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_defacl_privilege_target + + return p +} + +func (s *Defacl_privilege_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Defacl_privilege_targetContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *Defacl_privilege_targetContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTIONS, 0) +} + +func (s *Defacl_privilege_targetContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURES, 0) +} + +func (s *Defacl_privilege_targetContext) ROUTINES() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINES, 0) +} + +func (s *Defacl_privilege_targetContext) SEQUENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCES, 0) +} + +func (s *Defacl_privilege_targetContext) TYPES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPES_P, 0) +} + +func (s *Defacl_privilege_targetContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMAS, 0) +} + +func (s *Defacl_privilege_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Defacl_privilege_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Defacl_privilege_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDefacl_privilege_target(s) + } +} + +func (s *Defacl_privilege_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDefacl_privilege_target(s) + } +} + +func (s *Defacl_privilege_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDefacl_privilege_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Defacl_privilege_target() (localctx IDefacl_privilege_targetContext) { + localctx = NewDefacl_privilege_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 796, RedshiftParserRULE_defacl_privilege_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7548) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFUNCTIONS || ((int64((_la-327)) & ^0x3f) == 0 && ((int64(1)<<(_la-327))&4297064449) != 0) || ((int64((_la-654)) & ^0x3f) == 0 && ((int64(1)<<(_la-654))&7) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndexstmtContext is an interface to support dynamic dispatch. +type IIndexstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + INDEX() antlr.TerminalNode + ON() antlr.TerminalNode + Relation_expr() IRelation_exprContext + OPEN_PAREN() antlr.TerminalNode + Index_params() IIndex_paramsContext + CLOSE_PAREN() antlr.TerminalNode + Opt_unique() IOpt_uniqueContext + Opt_concurrently() IOpt_concurrentlyContext + Name() INameContext + Access_method_clause() IAccess_method_clauseContext + Opt_include() IOpt_includeContext + Opt_unique_null_treatment() IOpt_unique_null_treatmentContext + Opt_reloptions() IOpt_reloptionsContext + Opttablespace() IOpttablespaceContext + Where_clause() IWhere_clauseContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsIndexstmtContext differentiates from other interfaces. + IsIndexstmtContext() +} + +type IndexstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexstmtContext() *IndexstmtContext { + var p = new(IndexstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_indexstmt + return p +} + +func InitEmptyIndexstmtContext(p *IndexstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_indexstmt +} + +func (*IndexstmtContext) IsIndexstmtContext() {} + +func NewIndexstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndexstmtContext { + var p = new(IndexstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_indexstmt + + return p +} + +func (s *IndexstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndexstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *IndexstmtContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *IndexstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *IndexstmtContext) Relation_expr() IRelation_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *IndexstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *IndexstmtContext) Index_params() IIndex_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_paramsContext) +} + +func (s *IndexstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *IndexstmtContext) Opt_unique() IOpt_uniqueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_uniqueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_uniqueContext) +} + +func (s *IndexstmtContext) Opt_concurrently() IOpt_concurrentlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_concurrentlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_concurrentlyContext) +} + +func (s *IndexstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *IndexstmtContext) Access_method_clause() IAccess_method_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccess_method_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccess_method_clauseContext) +} + +func (s *IndexstmtContext) Opt_include() IOpt_includeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_includeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_includeContext) +} + +func (s *IndexstmtContext) Opt_unique_null_treatment() IOpt_unique_null_treatmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_unique_null_treatmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_unique_null_treatmentContext) +} + +func (s *IndexstmtContext) Opt_reloptions() IOpt_reloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_reloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_reloptionsContext) +} + +func (s *IndexstmtContext) Opttablespace() IOpttablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttablespaceContext) +} + +func (s *IndexstmtContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *IndexstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *IndexstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *IndexstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *IndexstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndexstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndexstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndexstmt(s) + } +} + +func (s *IndexstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndexstmt(s) + } +} + +func (s *IndexstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndexstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Indexstmt() (localctx IIndexstmtContext) { + localctx = NewIndexstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 798, RedshiftParserRULE_indexstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7550) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUNIQUE { + { + p.SetState(7551) + p.Opt_unique() + } + + } + { + p.SetState(7554) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONCURRENTLY { + { + p.SetState(7555) + p.Opt_concurrently() + } + + } + p.SetState(7564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + p.SetState(7561) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) == 1 { + { + p.SetState(7558) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7559) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7560) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7563) + p.Name() + } + + } + { + p.SetState(7566) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7567) + p.Relation_expr() + } + p.SetState(7569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(7568) + p.Access_method_clause() + } + + } + { + p.SetState(7571) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7572) + p.Index_params() + } + { + p.SetState(7573) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINCLUDE { + { + p.SetState(7574) + p.Opt_include() + } + + } + p.SetState(7578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNULLS_P { + { + p.SetState(7577) + p.Opt_unique_null_treatment() + } + + } + p.SetState(7581) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 1 { + { + p.SetState(7580) + p.Opt_reloptions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTABLESPACE { + { + p.SetState(7583) + p.Opttablespace() + } + + } + p.SetState(7587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(7586) + 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 +} + +// IOpt_uniqueContext is an interface to support dynamic dispatch. +type IOpt_uniqueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNIQUE() antlr.TerminalNode + + // IsOpt_uniqueContext differentiates from other interfaces. + IsOpt_uniqueContext() +} + +type Opt_uniqueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_uniqueContext() *Opt_uniqueContext { + var p = new(Opt_uniqueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_unique + return p +} + +func InitEmptyOpt_uniqueContext(p *Opt_uniqueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_unique +} + +func (*Opt_uniqueContext) IsOpt_uniqueContext() {} + +func NewOpt_uniqueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_uniqueContext { + var p = new(Opt_uniqueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_unique + + return p +} + +func (s *Opt_uniqueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_uniqueContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIQUE, 0) +} + +func (s *Opt_uniqueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_uniqueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_uniqueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_unique(s) + } +} + +func (s *Opt_uniqueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_unique(s) + } +} + +func (s *Opt_uniqueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_unique(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_unique() (localctx IOpt_uniqueContext) { + localctx = NewOpt_uniqueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 800, RedshiftParserRULE_opt_unique) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7589) + p.Match(RedshiftParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_concurrentlyContext is an interface to support dynamic dispatch. +type IOpt_concurrentlyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONCURRENTLY() antlr.TerminalNode + + // IsOpt_concurrentlyContext differentiates from other interfaces. + IsOpt_concurrentlyContext() +} + +type Opt_concurrentlyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_concurrentlyContext() *Opt_concurrentlyContext { + var p = new(Opt_concurrentlyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_concurrently + return p +} + +func InitEmptyOpt_concurrentlyContext(p *Opt_concurrentlyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_concurrently +} + +func (*Opt_concurrentlyContext) IsOpt_concurrentlyContext() {} + +func NewOpt_concurrentlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_concurrentlyContext { + var p = new(Opt_concurrentlyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_concurrently + + return p +} + +func (s *Opt_concurrentlyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_concurrentlyContext) CONCURRENTLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONCURRENTLY, 0) +} + +func (s *Opt_concurrentlyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_concurrentlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_concurrentlyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_concurrently(s) + } +} + +func (s *Opt_concurrentlyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_concurrently(s) + } +} + +func (s *Opt_concurrentlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_concurrently(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_concurrently() (localctx IOpt_concurrentlyContext) { + localctx = NewOpt_concurrentlyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 802, RedshiftParserRULE_opt_concurrently) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7591) + p.Match(RedshiftParserCONCURRENTLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_index_nameContext is an interface to support dynamic dispatch. +type IOpt_index_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsOpt_index_nameContext differentiates from other interfaces. + IsOpt_index_nameContext() +} + +type Opt_index_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_index_nameContext() *Opt_index_nameContext { + var p = new(Opt_index_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_index_name + return p +} + +func InitEmptyOpt_index_nameContext(p *Opt_index_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_index_name +} + +func (*Opt_index_nameContext) IsOpt_index_nameContext() {} + +func NewOpt_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_index_nameContext { + var p = new(Opt_index_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_index_name + + return p +} + +func (s *Opt_index_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_index_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Opt_index_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_index_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_index_name(s) + } +} + +func (s *Opt_index_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_index_name(s) + } +} + +func (s *Opt_index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_index_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_index_name() (localctx IOpt_index_nameContext) { + localctx = NewOpt_index_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 804, RedshiftParserRULE_opt_index_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7593) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAccess_method_clauseContext is an interface to support dynamic dispatch. +type IAccess_method_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Name() INameContext + + // IsAccess_method_clauseContext differentiates from other interfaces. + IsAccess_method_clauseContext() +} + +type Access_method_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccess_method_clauseContext() *Access_method_clauseContext { + var p = new(Access_method_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_access_method_clause + return p +} + +func InitEmptyAccess_method_clauseContext(p *Access_method_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_access_method_clause +} + +func (*Access_method_clauseContext) IsAccess_method_clauseContext() {} + +func NewAccess_method_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Access_method_clauseContext { + var p = new(Access_method_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_access_method_clause + + return p +} + +func (s *Access_method_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Access_method_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Access_method_clauseContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Access_method_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Access_method_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Access_method_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAccess_method_clause(s) + } +} + +func (s *Access_method_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAccess_method_clause(s) + } +} + +func (s *Access_method_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAccess_method_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Access_method_clause() (localctx IAccess_method_clauseContext) { + localctx = NewAccess_method_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 806, RedshiftParserRULE_access_method_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7595) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7596) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_paramsContext is an interface to support dynamic dispatch. +type IIndex_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIndex_elem() []IIndex_elemContext + Index_elem(i int) IIndex_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIndex_paramsContext differentiates from other interfaces. + IsIndex_paramsContext() +} + +type Index_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_paramsContext() *Index_paramsContext { + var p = new(Index_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_params + return p +} + +func InitEmptyIndex_paramsContext(p *Index_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_params +} + +func (*Index_paramsContext) IsIndex_paramsContext() {} + +func NewIndex_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_paramsContext { + var p = new(Index_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_index_params + + return p +} + +func (s *Index_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_paramsContext) AllIndex_elem() []IIndex_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_elemContext); ok { + len++ + } + } + + tst := make([]IIndex_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_elemContext); ok { + tst[i] = t.(IIndex_elemContext) + i++ + } + } + + return tst +} + +func (s *Index_paramsContext) Index_elem(i int) IIndex_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_elemContext) +} + +func (s *Index_paramsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Index_paramsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Index_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndex_params(s) + } +} + +func (s *Index_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndex_params(s) + } +} + +func (s *Index_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndex_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Index_params() (localctx IIndex_paramsContext) { + localctx = NewIndex_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 808, RedshiftParserRULE_index_params) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7598) + p.Index_elem() + } + p.SetState(7603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7599) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7600) + p.Index_elem() + } + + p.SetState(7605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_elem_optionsContext is an interface to support dynamic dispatch. +type IIndex_elem_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_collate() IOpt_collateContext + Opt_class() IOpt_classContext + Opt_asc_desc() IOpt_asc_descContext + Opt_nulls_order() IOpt_nulls_orderContext + Any_name() IAny_nameContext + Reloptions() IReloptionsContext + + // IsIndex_elem_optionsContext differentiates from other interfaces. + IsIndex_elem_optionsContext() +} + +type Index_elem_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_elem_optionsContext() *Index_elem_optionsContext { + var p = new(Index_elem_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_elem_options + return p +} + +func InitEmptyIndex_elem_optionsContext(p *Index_elem_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_elem_options +} + +func (*Index_elem_optionsContext) IsIndex_elem_optionsContext() {} + +func NewIndex_elem_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_elem_optionsContext { + var p = new(Index_elem_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_index_elem_options + + return p +} + +func (s *Index_elem_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_elem_optionsContext) Opt_collate() IOpt_collateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_collateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_collateContext) +} + +func (s *Index_elem_optionsContext) Opt_class() IOpt_classContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_classContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_classContext) +} + +func (s *Index_elem_optionsContext) Opt_asc_desc() IOpt_asc_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_asc_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_asc_descContext) +} + +func (s *Index_elem_optionsContext) Opt_nulls_order() IOpt_nulls_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_nulls_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_nulls_orderContext) +} + +func (s *Index_elem_optionsContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Index_elem_optionsContext) Reloptions() IReloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReloptionsContext) +} + +func (s *Index_elem_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_elem_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_elem_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndex_elem_options(s) + } +} + +func (s *Index_elem_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndex_elem_options(s) + } +} + +func (s *Index_elem_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndex_elem_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Index_elem_options() (localctx IIndex_elem_optionsContext) { + localctx = NewIndex_elem_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 810, RedshiftParserRULE_index_elem_options) + var _la int + + p.SetState(7629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 613, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(7607) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 606, p.GetParserRuleContext()) == 1 { + { + p.SetState(7606) + p.Opt_collate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7610) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 607, p.GetParserRuleContext()) == 1 { + { + p.SetState(7609) + p.Opt_class() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserASC || _la == RedshiftParserDESC { + { + p.SetState(7612) + p.Opt_asc_desc() + } + + } + p.SetState(7616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNULLS_P { + { + p.SetState(7615) + p.Opt_nulls_order() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(7619) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 610, p.GetParserRuleContext()) == 1 { + { + p.SetState(7618) + p.Opt_collate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7621) + p.Any_name() + } + { + p.SetState(7622) + p.Reloptions() + } + p.SetState(7624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserASC || _la == RedshiftParserDESC { + { + p.SetState(7623) + p.Opt_asc_desc() + } + + } + p.SetState(7627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNULLS_P { + { + p.SetState(7626) + p.Opt_nulls_order() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_elemContext is an interface to support dynamic dispatch. +type IIndex_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Index_elem_options() IIndex_elem_optionsContext + Func_expr_windowless() IFunc_expr_windowlessContext + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsIndex_elemContext differentiates from other interfaces. + IsIndex_elemContext() +} + +type Index_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_elemContext() *Index_elemContext { + var p = new(Index_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_elem + return p +} + +func InitEmptyIndex_elemContext(p *Index_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_elem +} + +func (*Index_elemContext) IsIndex_elemContext() {} + +func NewIndex_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_elemContext { + var p = new(Index_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_index_elem + + return p +} + +func (s *Index_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_elemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Index_elemContext) Index_elem_options() IIndex_elem_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_elem_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_elem_optionsContext) +} + +func (s *Index_elemContext) Func_expr_windowless() IFunc_expr_windowlessContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_expr_windowlessContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_expr_windowlessContext) +} + +func (s *Index_elemContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Index_elemContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Index_elemContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Index_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndex_elem(s) + } +} + +func (s *Index_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndex_elem(s) + } +} + +func (s *Index_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndex_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Index_elem() (localctx IIndex_elemContext) { + localctx = NewIndex_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 812, RedshiftParserRULE_index_elem) + p.SetState(7642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 614, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7631) + p.Colid() + } + { + p.SetState(7632) + p.Index_elem_options() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7634) + p.Func_expr_windowless() + } + { + p.SetState(7635) + p.Index_elem_options() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7637) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7638) + p.A_expr() + } + { + p.SetState(7639) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7640) + p.Index_elem_options() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_includeContext is an interface to support dynamic dispatch. +type IOpt_includeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCLUDE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Index_including_params() IIndex_including_paramsContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_includeContext differentiates from other interfaces. + IsOpt_includeContext() +} + +type Opt_includeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_includeContext() *Opt_includeContext { + var p = new(Opt_includeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_include + return p +} + +func InitEmptyOpt_includeContext(p *Opt_includeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_include +} + +func (*Opt_includeContext) IsOpt_includeContext() {} + +func NewOpt_includeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_includeContext { + var p = new(Opt_includeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_include + + return p +} + +func (s *Opt_includeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_includeContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDE, 0) +} + +func (s *Opt_includeContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_includeContext) Index_including_params() IIndex_including_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_including_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_including_paramsContext) +} + +func (s *Opt_includeContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_includeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_includeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_includeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_include(s) + } +} + +func (s *Opt_includeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_include(s) + } +} + +func (s *Opt_includeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_include(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_include() (localctx IOpt_includeContext) { + localctx = NewOpt_includeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 814, RedshiftParserRULE_opt_include) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7644) + p.Match(RedshiftParserINCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7645) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7646) + p.Index_including_params() + } + { + p.SetState(7647) + p.Match(RedshiftParserCLOSE_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 +} + +// IIndex_including_paramsContext is an interface to support dynamic dispatch. +type IIndex_including_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIndex_elem() []IIndex_elemContext + Index_elem(i int) IIndex_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIndex_including_paramsContext differentiates from other interfaces. + IsIndex_including_paramsContext() +} + +type Index_including_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_including_paramsContext() *Index_including_paramsContext { + var p = new(Index_including_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_including_params + return p +} + +func InitEmptyIndex_including_paramsContext(p *Index_including_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_index_including_params +} + +func (*Index_including_paramsContext) IsIndex_including_paramsContext() {} + +func NewIndex_including_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_including_paramsContext { + var p = new(Index_including_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_index_including_params + + return p +} + +func (s *Index_including_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_including_paramsContext) AllIndex_elem() []IIndex_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_elemContext); ok { + len++ + } + } + + tst := make([]IIndex_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_elemContext); ok { + tst[i] = t.(IIndex_elemContext) + i++ + } + } + + return tst +} + +func (s *Index_including_paramsContext) Index_elem(i int) IIndex_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_elemContext) +} + +func (s *Index_including_paramsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Index_including_paramsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Index_including_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_including_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_including_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndex_including_params(s) + } +} + +func (s *Index_including_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndex_including_params(s) + } +} + +func (s *Index_including_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndex_including_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Index_including_params() (localctx IIndex_including_paramsContext) { + localctx = NewIndex_including_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 816, RedshiftParserRULE_index_including_params) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7649) + p.Index_elem() + } + p.SetState(7654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7650) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7651) + p.Index_elem() + } + + p.SetState(7656) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_collateContext is an interface to support dynamic dispatch. +type IOpt_collateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLLATE() antlr.TerminalNode + Any_name() IAny_nameContext + + // IsOpt_collateContext differentiates from other interfaces. + IsOpt_collateContext() +} + +type Opt_collateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_collateContext() *Opt_collateContext { + var p = new(Opt_collateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_collate + return p +} + +func InitEmptyOpt_collateContext(p *Opt_collateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_collate +} + +func (*Opt_collateContext) IsOpt_collateContext() {} + +func NewOpt_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_collateContext { + var p = new(Opt_collateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_collate + + return p +} + +func (s *Opt_collateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_collateContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Opt_collateContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Opt_collateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_collateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_collate(s) + } +} + +func (s *Opt_collateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_collate(s) + } +} + +func (s *Opt_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_collate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_collate() (localctx IOpt_collateContext) { + localctx = NewOpt_collateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 818, RedshiftParserRULE_opt_collate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7657) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7658) + p.Any_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_classContext is an interface to support dynamic dispatch. +type IOpt_classContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Any_name() IAny_nameContext + + // IsOpt_classContext differentiates from other interfaces. + IsOpt_classContext() +} + +type Opt_classContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_classContext() *Opt_classContext { + var p = new(Opt_classContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_class + return p +} + +func InitEmptyOpt_classContext(p *Opt_classContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_class +} + +func (*Opt_classContext) IsOpt_classContext() {} + +func NewOpt_classContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_classContext { + var p = new(Opt_classContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_class + + return p +} + +func (s *Opt_classContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_classContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Opt_classContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_classContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_classContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_class(s) + } +} + +func (s *Opt_classContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_class(s) + } +} + +func (s *Opt_classContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_class(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_class() (localctx IOpt_classContext) { + localctx = NewOpt_classContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 820, RedshiftParserRULE_opt_class) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7660) + p.Any_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_asc_descContext is an interface to support dynamic dispatch. +type IOpt_asc_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsOpt_asc_descContext differentiates from other interfaces. + IsOpt_asc_descContext() +} + +type Opt_asc_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_asc_descContext() *Opt_asc_descContext { + var p = new(Opt_asc_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_asc_desc + return p +} + +func InitEmptyOpt_asc_descContext(p *Opt_asc_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_asc_desc +} + +func (*Opt_asc_descContext) IsOpt_asc_descContext() {} + +func NewOpt_asc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_asc_descContext { + var p = new(Opt_asc_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_asc_desc + + return p +} + +func (s *Opt_asc_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_asc_descContext) ASC() antlr.TerminalNode { + return s.GetToken(RedshiftParserASC, 0) +} + +func (s *Opt_asc_descContext) DESC() antlr.TerminalNode { + return s.GetToken(RedshiftParserDESC, 0) +} + +func (s *Opt_asc_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_asc_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_asc_desc(s) + } +} + +func (s *Opt_asc_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_asc_desc(s) + } +} + +func (s *Opt_asc_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_asc_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_asc_desc() (localctx IOpt_asc_descContext) { + localctx = NewOpt_asc_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 822, RedshiftParserRULE_opt_asc_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7662) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserASC || _la == RedshiftParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_nulls_orderContext is an interface to support dynamic dispatch. +type IOpt_nulls_orderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULLS_P() antlr.TerminalNode + FIRST_P() antlr.TerminalNode + LAST_P() antlr.TerminalNode + + // IsOpt_nulls_orderContext differentiates from other interfaces. + IsOpt_nulls_orderContext() +} + +type Opt_nulls_orderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_nulls_orderContext() *Opt_nulls_orderContext { + var p = new(Opt_nulls_orderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nulls_order + return p +} + +func InitEmptyOpt_nulls_orderContext(p *Opt_nulls_orderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nulls_order +} + +func (*Opt_nulls_orderContext) IsOpt_nulls_orderContext() {} + +func NewOpt_nulls_orderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nulls_orderContext { + var p = new(Opt_nulls_orderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_nulls_order + + return p +} + +func (s *Opt_nulls_orderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_nulls_orderContext) NULLS_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULLS_P, 0) +} + +func (s *Opt_nulls_orderContext) FIRST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIRST_P, 0) +} + +func (s *Opt_nulls_orderContext) LAST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLAST_P, 0) +} + +func (s *Opt_nulls_orderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_nulls_orderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_nulls_orderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_nulls_order(s) + } +} + +func (s *Opt_nulls_orderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_nulls_order(s) + } +} + +func (s *Opt_nulls_orderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_nulls_order(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_nulls_order() (localctx IOpt_nulls_orderContext) { + localctx = NewOpt_nulls_orderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 824, RedshiftParserRULE_opt_nulls_order) + p.SetState(7668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 616, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7664) + p.Match(RedshiftParserNULLS_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7665) + p.Match(RedshiftParserFIRST_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7666) + p.Match(RedshiftParserNULLS_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7667) + p.Match(RedshiftParserLAST_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatefunctionstmtContext is an interface to support dynamic dispatch. +type ICreatefunctionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Func_name() IFunc_nameContext + Func_py_args_or_sql_args() IFunc_py_args_or_sql_argsContext + Createfunc_opt_list() ICreatefunc_opt_listContext + VOLATILE() antlr.TerminalNode + STABLE() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + Opt_or_replace() IOpt_or_replaceContext + RETURNS() antlr.TerminalNode + Func_return() IFunc_returnContext + TABLE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Table_func_column_list() ITable_func_column_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsCreatefunctionstmtContext differentiates from other interfaces. + IsCreatefunctionstmtContext() +} + +type CreatefunctionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatefunctionstmtContext() *CreatefunctionstmtContext { + var p = new(CreatefunctionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfunctionstmt + return p +} + +func InitEmptyCreatefunctionstmtContext(p *CreatefunctionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfunctionstmt +} + +func (*CreatefunctionstmtContext) IsCreatefunctionstmtContext() {} + +func NewCreatefunctionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatefunctionstmtContext { + var p = new(CreatefunctionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createfunctionstmt + + return p +} + +func (s *CreatefunctionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatefunctionstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatefunctionstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *CreatefunctionstmtContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *CreatefunctionstmtContext) Func_py_args_or_sql_args() IFunc_py_args_or_sql_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_py_args_or_sql_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_py_args_or_sql_argsContext) +} + +func (s *CreatefunctionstmtContext) Createfunc_opt_list() ICreatefunc_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatefunc_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatefunc_opt_listContext) +} + +func (s *CreatefunctionstmtContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVOLATILE, 0) +} + +func (s *CreatefunctionstmtContext) STABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTABLE, 0) +} + +func (s *CreatefunctionstmtContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMUTABLE, 0) +} + +func (s *CreatefunctionstmtContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *CreatefunctionstmtContext) RETURNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNS, 0) +} + +func (s *CreatefunctionstmtContext) Func_return() IFunc_returnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_returnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_returnContext) +} + +func (s *CreatefunctionstmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *CreatefunctionstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreatefunctionstmtContext) Table_func_column_list() ITable_func_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_func_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_func_column_listContext) +} + +func (s *CreatefunctionstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreatefunctionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatefunctionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatefunctionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatefunctionstmt(s) + } +} + +func (s *CreatefunctionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatefunctionstmt(s) + } +} + +func (s *CreatefunctionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatefunctionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createfunctionstmt() (localctx ICreatefunctionstmtContext) { + localctx = NewCreatefunctionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 826, RedshiftParserRULE_createfunctionstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7670) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(7671) + p.Opt_or_replace() + } + + } + { + p.SetState(7674) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7675) + p.Func_name() + } + { + p.SetState(7676) + p.Func_py_args_or_sql_args() + } + p.SetState(7686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRETURNS { + { + p.SetState(7677) + p.Match(RedshiftParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7678) + p.Func_return() + } + + case 2: + { + p.SetState(7679) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7680) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7681) + p.Table_func_column_list() + } + { + p.SetState(7682) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + { + p.SetState(7688) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserIMMUTABLE || _la == RedshiftParserSTABLE || _la == RedshiftParserVOLATILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7689) + p.Createfunc_opt_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateprocedurestmtContext is an interface to support dynamic dispatch. +type ICreateprocedurestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Func_name() IFunc_nameContext + Func_args() IFunc_argsContext + Createfunc_opt_list() ICreatefunc_opt_listContext + Opt_or_replace() IOpt_or_replaceContext + RETURNS() antlr.TerminalNode + Opt_nonatomic() IOpt_nonatomicContext + Func_return() IFunc_returnContext + TABLE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Table_func_column_list() ITable_func_column_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsCreateprocedurestmtContext differentiates from other interfaces. + IsCreateprocedurestmtContext() +} + +type CreateprocedurestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateprocedurestmtContext() *CreateprocedurestmtContext { + var p = new(CreateprocedurestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createprocedurestmt + return p +} + +func InitEmptyCreateprocedurestmtContext(p *CreateprocedurestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createprocedurestmt +} + +func (*CreateprocedurestmtContext) IsCreateprocedurestmtContext() {} + +func NewCreateprocedurestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateprocedurestmtContext { + var p = new(CreateprocedurestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createprocedurestmt + + return p +} + +func (s *CreateprocedurestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateprocedurestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateprocedurestmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *CreateprocedurestmtContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *CreateprocedurestmtContext) Func_args() IFunc_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argsContext) +} + +func (s *CreateprocedurestmtContext) Createfunc_opt_list() ICreatefunc_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatefunc_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatefunc_opt_listContext) +} + +func (s *CreateprocedurestmtContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *CreateprocedurestmtContext) RETURNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNS, 0) +} + +func (s *CreateprocedurestmtContext) Opt_nonatomic() IOpt_nonatomicContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_nonatomicContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_nonatomicContext) +} + +func (s *CreateprocedurestmtContext) Func_return() IFunc_returnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_returnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_returnContext) +} + +func (s *CreateprocedurestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *CreateprocedurestmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreateprocedurestmtContext) Table_func_column_list() ITable_func_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_func_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_func_column_listContext) +} + +func (s *CreateprocedurestmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreateprocedurestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateprocedurestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateprocedurestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateprocedurestmt(s) + } +} + +func (s *CreateprocedurestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateprocedurestmt(s) + } +} + +func (s *CreateprocedurestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateprocedurestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createprocedurestmt() (localctx ICreateprocedurestmtContext) { + localctx = NewCreateprocedurestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 828, RedshiftParserRULE_createprocedurestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7691) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(7692) + p.Opt_or_replace() + } + + } + { + p.SetState(7695) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7696) + p.Func_name() + } + { + p.SetState(7697) + p.Func_args() + } + p.SetState(7707) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) == 1 { + { + p.SetState(7698) + p.Match(RedshiftParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7699) + p.Func_return() + } + + case 2: + { + p.SetState(7700) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7701) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7702) + p.Table_func_column_list() + } + { + p.SetState(7703) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNONATOMIC { + { + p.SetState(7709) + p.Opt_nonatomic() + } + + } + { + p.SetState(7712) + p.Createfunc_opt_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_nonatomicContext is an interface to support dynamic dispatch. +type IOpt_nonatomicContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NONATOMIC() antlr.TerminalNode + + // IsOpt_nonatomicContext differentiates from other interfaces. + IsOpt_nonatomicContext() +} + +type Opt_nonatomicContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_nonatomicContext() *Opt_nonatomicContext { + var p = new(Opt_nonatomicContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nonatomic + return p +} + +func InitEmptyOpt_nonatomicContext(p *Opt_nonatomicContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nonatomic +} + +func (*Opt_nonatomicContext) IsOpt_nonatomicContext() {} + +func NewOpt_nonatomicContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nonatomicContext { + var p = new(Opt_nonatomicContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_nonatomic + + return p +} + +func (s *Opt_nonatomicContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_nonatomicContext) NONATOMIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONATOMIC, 0) +} + +func (s *Opt_nonatomicContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_nonatomicContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_nonatomicContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_nonatomic(s) + } +} + +func (s *Opt_nonatomicContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_nonatomic(s) + } +} + +func (s *Opt_nonatomicContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_nonatomic(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_nonatomic() (localctx IOpt_nonatomicContext) { + localctx = NewOpt_nonatomicContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 830, RedshiftParserRULE_opt_nonatomic) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7714) + p.Match(RedshiftParserNONATOMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_or_replaceContext is an interface to support dynamic dispatch. +type IOpt_or_replaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsOpt_or_replaceContext differentiates from other interfaces. + IsOpt_or_replaceContext() +} + +type Opt_or_replaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_or_replaceContext() *Opt_or_replaceContext { + var p = new(Opt_or_replaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_or_replace + return p +} + +func InitEmptyOpt_or_replaceContext(p *Opt_or_replaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_or_replace +} + +func (*Opt_or_replaceContext) IsOpt_or_replaceContext() {} + +func NewOpt_or_replaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_or_replaceContext { + var p = new(Opt_or_replaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_or_replace + + return p +} + +func (s *Opt_or_replaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_or_replaceContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *Opt_or_replaceContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *Opt_or_replaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_or_replaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_or_replaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_or_replace(s) + } +} + +func (s *Opt_or_replaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_or_replace(s) + } +} + +func (s *Opt_or_replaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_or_replace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_or_replace() (localctx IOpt_or_replaceContext) { + localctx = NewOpt_or_replaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 832, RedshiftParserRULE_opt_or_replace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7716) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7717) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_py_args_or_sql_argsContext is an interface to support dynamic dispatch. +type IFunc_py_args_or_sql_argsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Func_py_args_or_sql_args_list() IFunc_py_args_or_sql_args_listContext + + // IsFunc_py_args_or_sql_argsContext differentiates from other interfaces. + IsFunc_py_args_or_sql_argsContext() +} + +type Func_py_args_or_sql_argsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_py_args_or_sql_argsContext() *Func_py_args_or_sql_argsContext { + var p = new(Func_py_args_or_sql_argsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_py_args_or_sql_args + return p +} + +func InitEmptyFunc_py_args_or_sql_argsContext(p *Func_py_args_or_sql_argsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_py_args_or_sql_args +} + +func (*Func_py_args_or_sql_argsContext) IsFunc_py_args_or_sql_argsContext() {} + +func NewFunc_py_args_or_sql_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_py_args_or_sql_argsContext { + var p = new(Func_py_args_or_sql_argsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_py_args_or_sql_args + + return p +} + +func (s *Func_py_args_or_sql_argsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_py_args_or_sql_argsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Func_py_args_or_sql_argsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Func_py_args_or_sql_argsContext) Func_py_args_or_sql_args_list() IFunc_py_args_or_sql_args_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_py_args_or_sql_args_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_py_args_or_sql_args_listContext) +} + +func (s *Func_py_args_or_sql_argsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_py_args_or_sql_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_py_args_or_sql_argsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_py_args_or_sql_args(s) + } +} + +func (s *Func_py_args_or_sql_argsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_py_args_or_sql_args(s) + } +} + +func (s *Func_py_args_or_sql_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_py_args_or_sql_args(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_py_args_or_sql_args() (localctx IFunc_py_args_or_sql_argsContext) { + localctx = NewFunc_py_args_or_sql_argsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 834, RedshiftParserRULE_func_py_args_or_sql_args) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7719) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-107)) & ^0x3f) == 0 && ((int64(1)<<(_la-107))&-5) != 0) || ((int64((_la-171)) & ^0x3f) == 0 && ((int64(1)<<(_la-171))&-129) != 0) || ((int64((_la-235)) & ^0x3f) == 0 && ((int64(1)<<(_la-235))&-4503599632089089) != 0) || ((int64((_la-299)) & ^0x3f) == 0 && ((int64(1)<<(_la-299))&-1) != 0) || ((int64((_la-363)) & ^0x3f) == 0 && ((int64(1)<<(_la-363))&-1237319681) != 0) || ((int64((_la-427)) & ^0x3f) == 0 && ((int64(1)<<(_la-427))&-1) != 0) || ((int64((_la-491)) & ^0x3f) == 0 && ((int64(1)<<(_la-491))&-1) != 0) || ((int64((_la-555)) & ^0x3f) == 0 && ((int64(1)<<(_la-555))&72057594037927935) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372036854759423) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(7720) + p.Func_py_args_or_sql_args_list() + } + + } + { + p.SetState(7723) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_py_args_or_sql_args_listContext is an interface to support dynamic dispatch. +type IFunc_py_args_or_sql_args_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllParam_name() []IParam_nameContext + Param_name(i int) IParam_nameContext + AllFunc_type() []IFunc_typeContext + Func_type(i int) IFunc_typeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_py_args_or_sql_args_listContext differentiates from other interfaces. + IsFunc_py_args_or_sql_args_listContext() +} + +type Func_py_args_or_sql_args_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_py_args_or_sql_args_listContext() *Func_py_args_or_sql_args_listContext { + var p = new(Func_py_args_or_sql_args_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_py_args_or_sql_args_list + return p +} + +func InitEmptyFunc_py_args_or_sql_args_listContext(p *Func_py_args_or_sql_args_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_py_args_or_sql_args_list +} + +func (*Func_py_args_or_sql_args_listContext) IsFunc_py_args_or_sql_args_listContext() {} + +func NewFunc_py_args_or_sql_args_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_py_args_or_sql_args_listContext { + var p = new(Func_py_args_or_sql_args_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_py_args_or_sql_args_list + + return p +} + +func (s *Func_py_args_or_sql_args_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_py_args_or_sql_args_listContext) AllParam_name() []IParam_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParam_nameContext); ok { + len++ + } + } + + tst := make([]IParam_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParam_nameContext); ok { + tst[i] = t.(IParam_nameContext) + i++ + } + } + + return tst +} + +func (s *Func_py_args_or_sql_args_listContext) Param_name(i int) IParam_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParam_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParam_nameContext) +} + +func (s *Func_py_args_or_sql_args_listContext) AllFunc_type() []IFunc_typeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_typeContext); ok { + len++ + } + } + + tst := make([]IFunc_typeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_typeContext); ok { + tst[i] = t.(IFunc_typeContext) + i++ + } + } + + return tst +} + +func (s *Func_py_args_or_sql_args_listContext) Func_type(i int) IFunc_typeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_typeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_typeContext) +} + +func (s *Func_py_args_or_sql_args_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Func_py_args_or_sql_args_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Func_py_args_or_sql_args_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_py_args_or_sql_args_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_py_args_or_sql_args_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_py_args_or_sql_args_list(s) + } +} + +func (s *Func_py_args_or_sql_args_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_py_args_or_sql_args_list(s) + } +} + +func (s *Func_py_args_or_sql_args_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_py_args_or_sql_args_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_py_args_or_sql_args_list() (localctx IFunc_py_args_or_sql_args_listContext) { + localctx = NewFunc_py_args_or_sql_args_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 836, RedshiftParserRULE_func_py_args_or_sql_args_list) + var _la int + + p.SetState(7744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 627, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7725) + p.Param_name() + } + { + p.SetState(7726) + p.Func_type() + } + p.SetState(7733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7727) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7728) + p.Param_name() + } + { + p.SetState(7729) + p.Func_type() + } + + p.SetState(7735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7736) + p.Func_type() + } + p.SetState(7741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7737) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7738) + p.Func_type() + } + + p.SetState(7743) + 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 +} + +// IFunc_argsContext is an interface to support dynamic dispatch. +type IFunc_argsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Func_args_list() IFunc_args_listContext + + // IsFunc_argsContext differentiates from other interfaces. + IsFunc_argsContext() +} + +type Func_argsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_argsContext() *Func_argsContext { + var p = new(Func_argsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args + return p +} + +func InitEmptyFunc_argsContext(p *Func_argsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args +} + +func (*Func_argsContext) IsFunc_argsContext() {} + +func NewFunc_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_argsContext { + var p = new(Func_argsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_args + + return p +} + +func (s *Func_argsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_argsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Func_argsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Func_argsContext) Func_args_list() IFunc_args_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_args_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_args_listContext) +} + +func (s *Func_argsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_argsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_args(s) + } +} + +func (s *Func_argsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_args(s) + } +} + +func (s *Func_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_args(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_args() (localctx IFunc_argsContext) { + localctx = NewFunc_argsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 838, RedshiftParserRULE_func_args) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7746) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999107252296709) != 0) || ((int64((_la-107)) & ^0x3f) == 0 && ((int64(1)<<(_la-107))&-5) != 0) || ((int64((_la-171)) & ^0x3f) == 0 && ((int64(1)<<(_la-171))&-129) != 0) || ((int64((_la-235)) & ^0x3f) == 0 && ((int64(1)<<(_la-235))&-4503599632089089) != 0) || ((int64((_la-299)) & ^0x3f) == 0 && ((int64(1)<<(_la-299))&-1) != 0) || ((int64((_la-363)) & ^0x3f) == 0 && ((int64(1)<<(_la-363))&-1237319681) != 0) || ((int64((_la-427)) & ^0x3f) == 0 && ((int64(1)<<(_la-427))&-1) != 0) || ((int64((_la-491)) & ^0x3f) == 0 && ((int64(1)<<(_la-491))&-1) != 0) || ((int64((_la-555)) & ^0x3f) == 0 && ((int64(1)<<(_la-555))&72057594037927935) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372036854759423) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(7747) + p.Func_args_list() + } + + } + { + p.SetState(7750) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_args_listContext is an interface to support dynamic dispatch. +type IFunc_args_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFunc_arg() []IFunc_argContext + Func_arg(i int) IFunc_argContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_args_listContext differentiates from other interfaces. + IsFunc_args_listContext() +} + +type Func_args_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_args_listContext() *Func_args_listContext { + var p = new(Func_args_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args_list + return p +} + +func InitEmptyFunc_args_listContext(p *Func_args_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args_list +} + +func (*Func_args_listContext) IsFunc_args_listContext() {} + +func NewFunc_args_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_listContext { + var p = new(Func_args_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_args_list + + return p +} + +func (s *Func_args_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_args_listContext) AllFunc_arg() []IFunc_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_argContext); ok { + len++ + } + } + + tst := make([]IFunc_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_argContext); ok { + tst[i] = t.(IFunc_argContext) + i++ + } + } + + return tst +} + +func (s *Func_args_listContext) Func_arg(i int) IFunc_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argContext) +} + +func (s *Func_args_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Func_args_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Func_args_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_args_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_args_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_args_list(s) + } +} + +func (s *Func_args_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_args_list(s) + } +} + +func (s *Func_args_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_args_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_args_list() (localctx IFunc_args_listContext) { + localctx = NewFunc_args_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 840, RedshiftParserRULE_func_args_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7752) + p.Func_arg() + } + p.SetState(7757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7753) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7754) + p.Func_arg() + } + + p.SetState(7759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_with_argtypes_listContext is an interface to support dynamic dispatch. +type IFunction_with_argtypes_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFunction_with_argtypes() []IFunction_with_argtypesContext + Function_with_argtypes(i int) IFunction_with_argtypesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_with_argtypes_listContext differentiates from other interfaces. + IsFunction_with_argtypes_listContext() +} + +type Function_with_argtypes_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_with_argtypes_listContext() *Function_with_argtypes_listContext { + var p = new(Function_with_argtypes_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_with_argtypes_list + return p +} + +func InitEmptyFunction_with_argtypes_listContext(p *Function_with_argtypes_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_with_argtypes_list +} + +func (*Function_with_argtypes_listContext) IsFunction_with_argtypes_listContext() {} + +func NewFunction_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_with_argtypes_listContext { + var p = new(Function_with_argtypes_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_function_with_argtypes_list + + return p +} + +func (s *Function_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_with_argtypes_listContext) AllFunction_with_argtypes() []IFunction_with_argtypesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + len++ + } + } + + tst := make([]IFunction_with_argtypesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_with_argtypesContext); ok { + tst[i] = t.(IFunction_with_argtypesContext) + i++ + } + } + + return tst +} + +func (s *Function_with_argtypes_listContext) Function_with_argtypes(i int) IFunction_with_argtypesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *Function_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Function_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Function_with_argtypes_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunction_with_argtypes_list(s) + } +} + +func (s *Function_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunction_with_argtypes_list(s) + } +} + +func (s *Function_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunction_with_argtypes_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Function_with_argtypes_list() (localctx IFunction_with_argtypes_listContext) { + localctx = NewFunction_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 842, RedshiftParserRULE_function_with_argtypes_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7760) + p.Function_with_argtypes() + } + p.SetState(7765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7761) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7762) + p.Function_with_argtypes() + } + + } + p.SetState(7767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunction_with_argtypesContext is an interface to support dynamic dispatch. +type IFunction_with_argtypesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_name() IFunc_nameContext + Func_args() IFunc_argsContext + Type_func_name_keyword() IType_func_name_keywordContext + Colid() IColidContext + Indirection() IIndirectionContext + + // IsFunction_with_argtypesContext differentiates from other interfaces. + IsFunction_with_argtypesContext() +} + +type Function_with_argtypesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_with_argtypesContext() *Function_with_argtypesContext { + var p = new(Function_with_argtypesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_with_argtypes + return p +} + +func InitEmptyFunction_with_argtypesContext(p *Function_with_argtypesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_function_with_argtypes +} + +func (*Function_with_argtypesContext) IsFunction_with_argtypesContext() {} + +func NewFunction_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_with_argtypesContext { + var p = new(Function_with_argtypesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_function_with_argtypes + + return p +} + +func (s *Function_with_argtypesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_with_argtypesContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *Function_with_argtypesContext) Func_args() IFunc_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argsContext) +} + +func (s *Function_with_argtypesContext) Type_func_name_keyword() IType_func_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_func_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_func_name_keywordContext) +} + +func (s *Function_with_argtypesContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Function_with_argtypesContext) Indirection() IIndirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndirectionContext) +} + +func (s *Function_with_argtypesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunction_with_argtypes(s) + } +} + +func (s *Function_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunction_with_argtypes(s) + } +} + +func (s *Function_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunction_with_argtypes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Function_with_argtypes() (localctx IFunction_with_argtypesContext) { + localctx = NewFunction_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 844, RedshiftParserRULE_function_with_argtypes) + var _la int + + p.SetState(7776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 632, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7768) + p.Func_name() + } + { + p.SetState(7769) + p.Func_args() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7771) + p.Type_func_name_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7772) + p.Colid() + } + p.SetState(7774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_BRACKET || _la == RedshiftParserDOT { + { + p.SetState(7773) + p.Indirection() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_args_with_defaultsContext is an interface to support dynamic dispatch. +type IFunc_args_with_defaultsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Func_args_with_defaults_list() IFunc_args_with_defaults_listContext + + // IsFunc_args_with_defaultsContext differentiates from other interfaces. + IsFunc_args_with_defaultsContext() +} + +type Func_args_with_defaultsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_args_with_defaultsContext() *Func_args_with_defaultsContext { + var p = new(Func_args_with_defaultsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args_with_defaults + return p +} + +func InitEmptyFunc_args_with_defaultsContext(p *Func_args_with_defaultsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args_with_defaults +} + +func (*Func_args_with_defaultsContext) IsFunc_args_with_defaultsContext() {} + +func NewFunc_args_with_defaultsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_with_defaultsContext { + var p = new(Func_args_with_defaultsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_args_with_defaults + + return p +} + +func (s *Func_args_with_defaultsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_args_with_defaultsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Func_args_with_defaultsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Func_args_with_defaultsContext) Func_args_with_defaults_list() IFunc_args_with_defaults_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_args_with_defaults_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_args_with_defaults_listContext) +} + +func (s *Func_args_with_defaultsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_args_with_defaultsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_args_with_defaultsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_args_with_defaults(s) + } +} + +func (s *Func_args_with_defaultsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_args_with_defaults(s) + } +} + +func (s *Func_args_with_defaultsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_args_with_defaults(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_args_with_defaults() (localctx IFunc_args_with_defaultsContext) { + localctx = NewFunc_args_with_defaultsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 846, RedshiftParserRULE_func_args_with_defaults) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7778) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999107252296709) != 0) || ((int64((_la-107)) & ^0x3f) == 0 && ((int64(1)<<(_la-107))&-5) != 0) || ((int64((_la-171)) & ^0x3f) == 0 && ((int64(1)<<(_la-171))&-129) != 0) || ((int64((_la-235)) & ^0x3f) == 0 && ((int64(1)<<(_la-235))&-4503599632089089) != 0) || ((int64((_la-299)) & ^0x3f) == 0 && ((int64(1)<<(_la-299))&-1) != 0) || ((int64((_la-363)) & ^0x3f) == 0 && ((int64(1)<<(_la-363))&-1237319681) != 0) || ((int64((_la-427)) & ^0x3f) == 0 && ((int64(1)<<(_la-427))&-1) != 0) || ((int64((_la-491)) & ^0x3f) == 0 && ((int64(1)<<(_la-491))&-1) != 0) || ((int64((_la-555)) & ^0x3f) == 0 && ((int64(1)<<(_la-555))&72057594037927935) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372036854759423) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(7779) + p.Func_args_with_defaults_list() + } + + } + { + p.SetState(7782) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_args_with_defaults_listContext is an interface to support dynamic dispatch. +type IFunc_args_with_defaults_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFunc_arg_with_default() []IFunc_arg_with_defaultContext + Func_arg_with_default(i int) IFunc_arg_with_defaultContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_args_with_defaults_listContext differentiates from other interfaces. + IsFunc_args_with_defaults_listContext() +} + +type Func_args_with_defaults_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_args_with_defaults_listContext() *Func_args_with_defaults_listContext { + var p = new(Func_args_with_defaults_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args_with_defaults_list + return p +} + +func InitEmptyFunc_args_with_defaults_listContext(p *Func_args_with_defaults_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_args_with_defaults_list +} + +func (*Func_args_with_defaults_listContext) IsFunc_args_with_defaults_listContext() {} + +func NewFunc_args_with_defaults_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_args_with_defaults_listContext { + var p = new(Func_args_with_defaults_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_args_with_defaults_list + + return p +} + +func (s *Func_args_with_defaults_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_args_with_defaults_listContext) AllFunc_arg_with_default() []IFunc_arg_with_defaultContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_arg_with_defaultContext); ok { + len++ + } + } + + tst := make([]IFunc_arg_with_defaultContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_arg_with_defaultContext); ok { + tst[i] = t.(IFunc_arg_with_defaultContext) + i++ + } + } + + return tst +} + +func (s *Func_args_with_defaults_listContext) Func_arg_with_default(i int) IFunc_arg_with_defaultContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_arg_with_defaultContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_arg_with_defaultContext) +} + +func (s *Func_args_with_defaults_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Func_args_with_defaults_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Func_args_with_defaults_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_args_with_defaults_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_args_with_defaults_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_args_with_defaults_list(s) + } +} + +func (s *Func_args_with_defaults_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_args_with_defaults_list(s) + } +} + +func (s *Func_args_with_defaults_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_args_with_defaults_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_args_with_defaults_list() (localctx IFunc_args_with_defaults_listContext) { + localctx = NewFunc_args_with_defaults_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 848, RedshiftParserRULE_func_args_with_defaults_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7784) + p.Func_arg_with_default() + } + p.SetState(7789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7785) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7786) + p.Func_arg_with_default() + } + + p.SetState(7791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_argContext is an interface to support dynamic dispatch. +type IFunc_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Arg_class() IArg_classContext + Func_type() IFunc_typeContext + Param_name() IParam_nameContext + + // IsFunc_argContext differentiates from other interfaces. + IsFunc_argContext() +} + +type Func_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_argContext() *Func_argContext { + var p = new(Func_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg + return p +} + +func InitEmptyFunc_argContext(p *Func_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg +} + +func (*Func_argContext) IsFunc_argContext() {} + +func NewFunc_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_argContext { + var p = new(Func_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_arg + + return p +} + +func (s *Func_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_argContext) Arg_class() IArg_classContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_classContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArg_classContext) +} + +func (s *Func_argContext) Func_type() IFunc_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_typeContext) +} + +func (s *Func_argContext) Param_name() IParam_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParam_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParam_nameContext) +} + +func (s *Func_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_arg(s) + } +} + +func (s *Func_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_arg(s) + } +} + +func (s *Func_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_arg() (localctx IFunc_argContext) { + localctx = NewFunc_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 850, RedshiftParserRULE_func_arg) + p.SetState(7805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 637, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7792) + p.Arg_class() + } + p.SetState(7794) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 635, p.GetParserRuleContext()) == 1 { + { + p.SetState(7793) + p.Param_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7796) + p.Func_type() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7798) + p.Param_name() + } + p.SetState(7800) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 636, p.GetParserRuleContext()) == 1 { + { + p.SetState(7799) + p.Arg_class() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7802) + p.Func_type() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7804) + p.Func_type() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArg_classContext is an interface to support dynamic dispatch. +type IArg_classContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN_P() antlr.TerminalNode + OUT_P() antlr.TerminalNode + INOUT() antlr.TerminalNode + + // IsArg_classContext differentiates from other interfaces. + IsArg_classContext() +} + +type Arg_classContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArg_classContext() *Arg_classContext { + var p = new(Arg_classContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_arg_class + return p +} + +func InitEmptyArg_classContext(p *Arg_classContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_arg_class +} + +func (*Arg_classContext) IsArg_classContext() {} + +func NewArg_classContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_classContext { + var p = new(Arg_classContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_arg_class + + return p +} + +func (s *Arg_classContext) GetParser() antlr.Parser { return s.parser } + +func (s *Arg_classContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Arg_classContext) OUT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOUT_P, 0) +} + +func (s *Arg_classContext) INOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINOUT, 0) +} + +func (s *Arg_classContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Arg_classContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Arg_classContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterArg_class(s) + } +} + +func (s *Arg_classContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitArg_class(s) + } +} + +func (s *Arg_classContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitArg_class(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Arg_class() (localctx IArg_classContext) { + localctx = NewArg_classContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 852, RedshiftParserRULE_arg_class) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7807) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserIN_P || _la == RedshiftParserINOUT || _la == RedshiftParserOUT_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParam_nameContext is an interface to support dynamic dispatch. +type IParam_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Type_function_name() IType_function_nameContext + Builtin_function_name() IBuiltin_function_nameContext + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + + // IsParam_nameContext differentiates from other interfaces. + IsParam_nameContext() +} + +type Param_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParam_nameContext() *Param_nameContext { + var p = new(Param_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_param_name + return p +} + +func InitEmptyParam_nameContext(p *Param_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_param_name +} + +func (*Param_nameContext) IsParam_nameContext() {} + +func NewParam_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Param_nameContext { + var p = new(Param_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_param_name + + return p +} + +func (s *Param_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Param_nameContext) Type_function_name() IType_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_nameContext) +} + +func (s *Param_nameContext) Builtin_function_name() IBuiltin_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuiltin_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuiltin_function_nameContext) +} + +func (s *Param_nameContext) LEFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEFT, 0) +} + +func (s *Param_nameContext) RIGHT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRIGHT, 0) +} + +func (s *Param_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Param_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Param_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterParam_name(s) + } +} + +func (s *Param_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitParam_name(s) + } +} + +func (s *Param_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitParam_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Param_name() (localctx IParam_nameContext) { + localctx = NewParam_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 854, RedshiftParserRULE_param_name) + p.SetState(7813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserPARAMETER, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserCOLUMNS, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7809) + p.Type_function_name() + } + + case RedshiftParserCURRENT_USER, RedshiftParserREPLACE, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserREVERSE, RedshiftParserLOG, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7810) + p.Builtin_function_name() + } + + case RedshiftParserLEFT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7811) + p.Match(RedshiftParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserRIGHT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7812) + p.Match(RedshiftParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_returnContext is an interface to support dynamic dispatch. +type IFunc_returnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_type() IFunc_typeContext + + // IsFunc_returnContext differentiates from other interfaces. + IsFunc_returnContext() +} + +type Func_returnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_returnContext() *Func_returnContext { + var p = new(Func_returnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_return + return p +} + +func InitEmptyFunc_returnContext(p *Func_returnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_return +} + +func (*Func_returnContext) IsFunc_returnContext() {} + +func NewFunc_returnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_returnContext { + var p = new(Func_returnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_return + + return p +} + +func (s *Func_returnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_returnContext) Func_type() IFunc_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_typeContext) +} + +func (s *Func_returnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_returnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_returnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_return(s) + } +} + +func (s *Func_returnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_return(s) + } +} + +func (s *Func_returnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_return(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_return() (localctx IFunc_returnContext) { + localctx = NewFunc_returnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 856, RedshiftParserRULE_func_return) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7815) + p.Func_type() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_typeContext is an interface to support dynamic dispatch. +type IFunc_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Typename() ITypenameContext + Attrs() IAttrsContext + PERCENT() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + Builtin_function_name() IBuiltin_function_nameContext + Type_function_name() IType_function_nameContext + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + SETOF() antlr.TerminalNode + + // IsFunc_typeContext differentiates from other interfaces. + IsFunc_typeContext() +} + +type Func_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_typeContext() *Func_typeContext { + var p = new(Func_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_type + return p +} + +func InitEmptyFunc_typeContext(p *Func_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_type +} + +func (*Func_typeContext) IsFunc_typeContext() {} + +func NewFunc_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_typeContext { + var p = new(Func_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_type + + return p +} + +func (s *Func_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_typeContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Func_typeContext) Attrs() IAttrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttrsContext) +} + +func (s *Func_typeContext) PERCENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENT, 0) +} + +func (s *Func_typeContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Func_typeContext) Builtin_function_name() IBuiltin_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuiltin_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuiltin_function_nameContext) +} + +func (s *Func_typeContext) Type_function_name() IType_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_nameContext) +} + +func (s *Func_typeContext) LEFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEFT, 0) +} + +func (s *Func_typeContext) RIGHT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRIGHT, 0) +} + +func (s *Func_typeContext) SETOF() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETOF, 0) +} + +func (s *Func_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_type(s) + } +} + +func (s *Func_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_type(s) + } +} + +func (s *Func_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_type() (localctx IFunc_typeContext) { + localctx = NewFunc_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 858, RedshiftParserRULE_func_type) + var _la int + + p.SetState(7831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7817) + p.Typename() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(7819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSETOF { + { + p.SetState(7818) + p.Match(RedshiftParserSETOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCURRENT_USER, RedshiftParserREPLACE, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserREVERSE, RedshiftParserLOG, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER: + { + p.SetState(7821) + p.Builtin_function_name() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserPARAMETER, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserCOLUMNS, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(7822) + p.Type_function_name() + } + + case RedshiftParserLEFT: + { + p.SetState(7823) + p.Match(RedshiftParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserRIGHT: + { + p.SetState(7824) + p.Match(RedshiftParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7827) + p.Attrs() + } + { + p.SetState(7828) + p.Match(RedshiftParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7829) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_arg_with_defaultContext is an interface to support dynamic dispatch. +type IFunc_arg_with_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_arg() IFunc_argContext + A_expr() IA_exprContext + DEFAULT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + + // IsFunc_arg_with_defaultContext differentiates from other interfaces. + IsFunc_arg_with_defaultContext() +} + +type Func_arg_with_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_arg_with_defaultContext() *Func_arg_with_defaultContext { + var p = new(Func_arg_with_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg_with_default + return p +} + +func InitEmptyFunc_arg_with_defaultContext(p *Func_arg_with_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg_with_default +} + +func (*Func_arg_with_defaultContext) IsFunc_arg_with_defaultContext() {} + +func NewFunc_arg_with_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_with_defaultContext { + var p = new(Func_arg_with_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_arg_with_default + + return p +} + +func (s *Func_arg_with_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_arg_with_defaultContext) Func_arg() IFunc_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argContext) +} + +func (s *Func_arg_with_defaultContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Func_arg_with_defaultContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Func_arg_with_defaultContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Func_arg_with_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_arg_with_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_arg_with_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_arg_with_default(s) + } +} + +func (s *Func_arg_with_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_arg_with_default(s) + } +} + +func (s *Func_arg_with_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_arg_with_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_arg_with_default() (localctx IFunc_arg_with_defaultContext) { + localctx = NewFunc_arg_with_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 860, RedshiftParserRULE_func_arg_with_default) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7833) + p.Func_arg() + } + p.SetState(7836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL || _la == RedshiftParserDEFAULT { + { + p.SetState(7834) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEQUAL || _la == RedshiftParserDEFAULT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7835) + p.A_expr() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggr_argContext is an interface to support dynamic dispatch. +type IAggr_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_arg() IFunc_argContext + + // IsAggr_argContext differentiates from other interfaces. + IsAggr_argContext() +} + +type Aggr_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggr_argContext() *Aggr_argContext { + var p = new(Aggr_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggr_arg + return p +} + +func InitEmptyAggr_argContext(p *Aggr_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggr_arg +} + +func (*Aggr_argContext) IsAggr_argContext() {} + +func NewAggr_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_argContext { + var p = new(Aggr_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_aggr_arg + + return p +} + +func (s *Aggr_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggr_argContext) Func_arg() IFunc_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argContext) +} + +func (s *Aggr_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggr_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggr_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAggr_arg(s) + } +} + +func (s *Aggr_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAggr_arg(s) + } +} + +func (s *Aggr_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAggr_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Aggr_arg() (localctx IAggr_argContext) { + localctx = NewAggr_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 862, RedshiftParserRULE_aggr_arg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7838) + p.Func_arg() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggr_argsContext is an interface to support dynamic dispatch. +type IAggr_argsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + STAR() antlr.TerminalNode + AllAggr_args_list() []IAggr_args_listContext + Aggr_args_list(i int) IAggr_args_listContext + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + + // IsAggr_argsContext differentiates from other interfaces. + IsAggr_argsContext() +} + +type Aggr_argsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggr_argsContext() *Aggr_argsContext { + var p = new(Aggr_argsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggr_args + return p +} + +func InitEmptyAggr_argsContext(p *Aggr_argsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggr_args +} + +func (*Aggr_argsContext) IsAggr_argsContext() {} + +func NewAggr_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_argsContext { + var p = new(Aggr_argsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_aggr_args + + return p +} + +func (s *Aggr_argsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggr_argsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Aggr_argsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Aggr_argsContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *Aggr_argsContext) AllAggr_args_list() []IAggr_args_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAggr_args_listContext); ok { + len++ + } + } + + tst := make([]IAggr_args_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAggr_args_listContext); ok { + tst[i] = t.(IAggr_args_listContext) + i++ + } + } + + return tst +} + +func (s *Aggr_argsContext) Aggr_args_list(i int) IAggr_args_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggr_args_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAggr_args_listContext) +} + +func (s *Aggr_argsContext) ORDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserORDER, 0) +} + +func (s *Aggr_argsContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Aggr_argsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggr_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggr_argsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAggr_args(s) + } +} + +func (s *Aggr_argsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAggr_args(s) + } +} + +func (s *Aggr_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAggr_args(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Aggr_args() (localctx IAggr_argsContext) { + localctx = NewAggr_argsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 864, RedshiftParserRULE_aggr_args) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7840) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 643, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7841) + p.Match(RedshiftParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(7842) + p.Aggr_args_list() + } + + case 3: + { + p.SetState(7843) + p.Match(RedshiftParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7844) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7845) + p.Aggr_args_list() + } + + case 4: + { + p.SetState(7846) + p.Aggr_args_list() + } + { + p.SetState(7847) + p.Match(RedshiftParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7848) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7849) + p.Aggr_args_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(7853) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggr_args_listContext is an interface to support dynamic dispatch. +type IAggr_args_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAggr_arg() []IAggr_argContext + Aggr_arg(i int) IAggr_argContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAggr_args_listContext differentiates from other interfaces. + IsAggr_args_listContext() +} + +type Aggr_args_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggr_args_listContext() *Aggr_args_listContext { + var p = new(Aggr_args_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggr_args_list + return p +} + +func InitEmptyAggr_args_listContext(p *Aggr_args_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggr_args_list +} + +func (*Aggr_args_listContext) IsAggr_args_listContext() {} + +func NewAggr_args_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggr_args_listContext { + var p = new(Aggr_args_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_aggr_args_list + + return p +} + +func (s *Aggr_args_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggr_args_listContext) AllAggr_arg() []IAggr_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAggr_argContext); ok { + len++ + } + } + + tst := make([]IAggr_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAggr_argContext); ok { + tst[i] = t.(IAggr_argContext) + i++ + } + } + + return tst +} + +func (s *Aggr_args_listContext) Aggr_arg(i int) IAggr_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggr_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAggr_argContext) +} + +func (s *Aggr_args_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Aggr_args_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Aggr_args_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggr_args_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggr_args_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAggr_args_list(s) + } +} + +func (s *Aggr_args_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAggr_args_list(s) + } +} + +func (s *Aggr_args_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAggr_args_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Aggr_args_list() (localctx IAggr_args_listContext) { + localctx = NewAggr_args_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 866, RedshiftParserRULE_aggr_args_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7855) + p.Aggr_arg() + } + p.SetState(7860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7856) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7857) + p.Aggr_arg() + } + + p.SetState(7862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregate_with_argtypesContext is an interface to support dynamic dispatch. +type IAggregate_with_argtypesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_name() IFunc_nameContext + Aggr_args() IAggr_argsContext + + // IsAggregate_with_argtypesContext differentiates from other interfaces. + IsAggregate_with_argtypesContext() +} + +type Aggregate_with_argtypesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggregate_with_argtypesContext() *Aggregate_with_argtypesContext { + var p = new(Aggregate_with_argtypesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggregate_with_argtypes + return p +} + +func InitEmptyAggregate_with_argtypesContext(p *Aggregate_with_argtypesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggregate_with_argtypes +} + +func (*Aggregate_with_argtypesContext) IsAggregate_with_argtypesContext() {} + +func NewAggregate_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_with_argtypesContext { + var p = new(Aggregate_with_argtypesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_aggregate_with_argtypes + + return p +} + +func (s *Aggregate_with_argtypesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggregate_with_argtypesContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *Aggregate_with_argtypesContext) Aggr_args() IAggr_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggr_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggr_argsContext) +} + +func (s *Aggregate_with_argtypesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggregate_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggregate_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAggregate_with_argtypes(s) + } +} + +func (s *Aggregate_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAggregate_with_argtypes(s) + } +} + +func (s *Aggregate_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAggregate_with_argtypes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Aggregate_with_argtypes() (localctx IAggregate_with_argtypesContext) { + localctx = NewAggregate_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 868, RedshiftParserRULE_aggregate_with_argtypes) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7863) + p.Func_name() + } + { + p.SetState(7864) + p.Aggr_args() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregate_with_argtypes_listContext is an interface to support dynamic dispatch. +type IAggregate_with_argtypes_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAggregate_with_argtypes() []IAggregate_with_argtypesContext + Aggregate_with_argtypes(i int) IAggregate_with_argtypesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAggregate_with_argtypes_listContext differentiates from other interfaces. + IsAggregate_with_argtypes_listContext() +} + +type Aggregate_with_argtypes_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggregate_with_argtypes_listContext() *Aggregate_with_argtypes_listContext { + var p = new(Aggregate_with_argtypes_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggregate_with_argtypes_list + return p +} + +func InitEmptyAggregate_with_argtypes_listContext(p *Aggregate_with_argtypes_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aggregate_with_argtypes_list +} + +func (*Aggregate_with_argtypes_listContext) IsAggregate_with_argtypes_listContext() {} + +func NewAggregate_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_with_argtypes_listContext { + var p = new(Aggregate_with_argtypes_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_aggregate_with_argtypes_list + + return p +} + +func (s *Aggregate_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggregate_with_argtypes_listContext) AllAggregate_with_argtypes() []IAggregate_with_argtypesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + len++ + } + } + + tst := make([]IAggregate_with_argtypesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAggregate_with_argtypesContext); ok { + tst[i] = t.(IAggregate_with_argtypesContext) + i++ + } + } + + return tst +} + +func (s *Aggregate_with_argtypes_listContext) Aggregate_with_argtypes(i int) IAggregate_with_argtypesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypesContext) +} + +func (s *Aggregate_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Aggregate_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Aggregate_with_argtypes_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggregate_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggregate_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAggregate_with_argtypes_list(s) + } +} + +func (s *Aggregate_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAggregate_with_argtypes_list(s) + } +} + +func (s *Aggregate_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAggregate_with_argtypes_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Aggregate_with_argtypes_list() (localctx IAggregate_with_argtypes_listContext) { + localctx = NewAggregate_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 870, RedshiftParserRULE_aggregate_with_argtypes_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7866) + p.Aggregate_with_argtypes() + } + p.SetState(7871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7867) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7868) + p.Aggregate_with_argtypes() + } + + p.SetState(7873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatefunc_opt_listContext is an interface to support dynamic dispatch. +type ICreatefunc_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCreatefunc_opt_item() []ICreatefunc_opt_itemContext + Createfunc_opt_item(i int) ICreatefunc_opt_itemContext + + // IsCreatefunc_opt_listContext differentiates from other interfaces. + IsCreatefunc_opt_listContext() +} + +type Createfunc_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatefunc_opt_listContext() *Createfunc_opt_listContext { + var p = new(Createfunc_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfunc_opt_list + return p +} + +func InitEmptyCreatefunc_opt_listContext(p *Createfunc_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfunc_opt_list +} + +func (*Createfunc_opt_listContext) IsCreatefunc_opt_listContext() {} + +func NewCreatefunc_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createfunc_opt_listContext { + var p = new(Createfunc_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createfunc_opt_list + + return p +} + +func (s *Createfunc_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Createfunc_opt_listContext) AllCreatefunc_opt_item() []ICreatefunc_opt_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreatefunc_opt_itemContext); ok { + len++ + } + } + + tst := make([]ICreatefunc_opt_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreatefunc_opt_itemContext); ok { + tst[i] = t.(ICreatefunc_opt_itemContext) + i++ + } + } + + return tst +} + +func (s *Createfunc_opt_listContext) Createfunc_opt_item(i int) ICreatefunc_opt_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatefunc_opt_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreatefunc_opt_itemContext) +} + +func (s *Createfunc_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Createfunc_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Createfunc_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatefunc_opt_list(s) + } +} + +func (s *Createfunc_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatefunc_opt_list(s) + } +} + +func (s *Createfunc_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatefunc_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createfunc_opt_list() (localctx ICreatefunc_opt_listContext) { + localctx = NewCreatefunc_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 872, RedshiftParserRULE_createfunc_opt_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7875) + 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(7874) + p.Createfunc_opt_item() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(7877) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 646, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + p.ParseRoutineBody(localctx) + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommon_func_opt_itemContext is an interface to support dynamic dispatch. +type ICommon_func_opt_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALLED() antlr.TerminalNode + ON() antlr.TerminalNode + AllNULL_P() []antlr.TerminalNode + NULL_P(i int) antlr.TerminalNode + INPUT_P() antlr.TerminalNode + RETURNS() antlr.TerminalNode + STRICT_P() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + STABLE() antlr.TerminalNode + VOLATILE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + SECURITY() antlr.TerminalNode + DEFINER() antlr.TerminalNode + INVOKER() antlr.TerminalNode + LEAKPROOF() antlr.TerminalNode + NOT() antlr.TerminalNode + COST() antlr.TerminalNode + Numericonly() INumericonlyContext + ROWS() antlr.TerminalNode + SUPPORT() antlr.TerminalNode + Any_name() IAny_nameContext + Functionsetresetclause() IFunctionsetresetclauseContext + PARALLEL() antlr.TerminalNode + Colid() IColidContext + + // IsCommon_func_opt_itemContext differentiates from other interfaces. + IsCommon_func_opt_itemContext() +} + +type Common_func_opt_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommon_func_opt_itemContext() *Common_func_opt_itemContext { + var p = new(Common_func_opt_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_func_opt_item + return p +} + +func InitEmptyCommon_func_opt_itemContext(p *Common_func_opt_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_func_opt_item +} + +func (*Common_func_opt_itemContext) IsCommon_func_opt_itemContext() {} + +func NewCommon_func_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_func_opt_itemContext { + var p = new(Common_func_opt_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_common_func_opt_item + + return p +} + +func (s *Common_func_opt_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Common_func_opt_itemContext) CALLED() antlr.TerminalNode { + return s.GetToken(RedshiftParserCALLED, 0) +} + +func (s *Common_func_opt_itemContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Common_func_opt_itemContext) AllNULL_P() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserNULL_P) +} + +func (s *Common_func_opt_itemContext) NULL_P(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, i) +} + +func (s *Common_func_opt_itemContext) INPUT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINPUT_P, 0) +} + +func (s *Common_func_opt_itemContext) RETURNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNS, 0) +} + +func (s *Common_func_opt_itemContext) STRICT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRICT_P, 0) +} + +func (s *Common_func_opt_itemContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMUTABLE, 0) +} + +func (s *Common_func_opt_itemContext) STABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTABLE, 0) +} + +func (s *Common_func_opt_itemContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVOLATILE, 0) +} + +func (s *Common_func_opt_itemContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Common_func_opt_itemContext) SECURITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECURITY, 0) +} + +func (s *Common_func_opt_itemContext) DEFINER() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFINER, 0) +} + +func (s *Common_func_opt_itemContext) INVOKER() antlr.TerminalNode { + return s.GetToken(RedshiftParserINVOKER, 0) +} + +func (s *Common_func_opt_itemContext) LEAKPROOF() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEAKPROOF, 0) +} + +func (s *Common_func_opt_itemContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Common_func_opt_itemContext) COST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOST, 0) +} + +func (s *Common_func_opt_itemContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Common_func_opt_itemContext) ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWS, 0) +} + +func (s *Common_func_opt_itemContext) SUPPORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUPPORT, 0) +} + +func (s *Common_func_opt_itemContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Common_func_opt_itemContext) Functionsetresetclause() IFunctionsetresetclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunctionsetresetclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunctionsetresetclauseContext) +} + +func (s *Common_func_opt_itemContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARALLEL, 0) +} + +func (s *Common_func_opt_itemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Common_func_opt_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Common_func_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Common_func_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCommon_func_opt_item(s) + } +} + +func (s *Common_func_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCommon_func_opt_item(s) + } +} + +func (s *Common_func_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCommon_func_opt_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Common_func_opt_item() (localctx ICommon_func_opt_itemContext) { + localctx = NewCommon_func_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 874, RedshiftParserRULE_common_func_opt_item) + p.SetState(7916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 647, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7881) + p.Match(RedshiftParserCALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7882) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7883) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7884) + p.Match(RedshiftParserINPUT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7885) + p.Match(RedshiftParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7886) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7887) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7888) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7889) + p.Match(RedshiftParserINPUT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7890) + p.Match(RedshiftParserSTRICT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7891) + p.Match(RedshiftParserIMMUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7892) + p.Match(RedshiftParserSTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7893) + p.Match(RedshiftParserVOLATILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7894) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7895) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7896) + p.Match(RedshiftParserDEFINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7897) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7898) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7899) + p.Match(RedshiftParserINVOKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7900) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7901) + p.Match(RedshiftParserDEFINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7902) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7903) + p.Match(RedshiftParserINVOKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(7904) + p.Match(RedshiftParserLEAKPROOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(7905) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7906) + p.Match(RedshiftParserLEAKPROOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(7907) + p.Match(RedshiftParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7908) + p.Numericonly() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(7909) + p.Match(RedshiftParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7910) + p.Numericonly() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(7911) + p.Match(RedshiftParserSUPPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7912) + p.Any_name() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(7913) + p.Functionsetresetclause() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(7914) + p.Match(RedshiftParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7915) + p.Colid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatefunc_opt_itemContext is an interface to support dynamic dispatch. +type ICreatefunc_opt_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + Func_as() IFunc_asContext + BEGIN_P() antlr.TerminalNode + ATOMIC_P() antlr.TerminalNode + Stmtmulti() IStmtmultiContext + END_P() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + Nonreservedword_or_sconst() INonreservedword_or_sconstContext + TRANSFORM() antlr.TerminalNode + Transform_type_list() ITransform_type_listContext + WINDOW() antlr.TerminalNode + Common_func_opt_item() ICommon_func_opt_itemContext + + // IsCreatefunc_opt_itemContext differentiates from other interfaces. + IsCreatefunc_opt_itemContext() +} + +type Createfunc_opt_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatefunc_opt_itemContext() *Createfunc_opt_itemContext { + var p = new(Createfunc_opt_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfunc_opt_item + return p +} + +func InitEmptyCreatefunc_opt_itemContext(p *Createfunc_opt_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createfunc_opt_item +} + +func (*Createfunc_opt_itemContext) IsCreatefunc_opt_itemContext() {} + +func NewCreatefunc_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createfunc_opt_itemContext { + var p = new(Createfunc_opt_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createfunc_opt_item + + return p +} + +func (s *Createfunc_opt_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Createfunc_opt_itemContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Createfunc_opt_itemContext) Func_as() IFunc_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_asContext) +} + +func (s *Createfunc_opt_itemContext) BEGIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEGIN_P, 0) +} + +func (s *Createfunc_opt_itemContext) ATOMIC_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserATOMIC_P, 0) +} + +func (s *Createfunc_opt_itemContext) Stmtmulti() IStmtmultiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtmultiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmtmultiContext) +} + +func (s *Createfunc_opt_itemContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *Createfunc_opt_itemContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *Createfunc_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedword_or_sconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedword_or_sconstContext) +} + +func (s *Createfunc_opt_itemContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSFORM, 0) +} + +func (s *Createfunc_opt_itemContext) Transform_type_list() ITransform_type_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransform_type_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransform_type_listContext) +} + +func (s *Createfunc_opt_itemContext) WINDOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserWINDOW, 0) +} + +func (s *Createfunc_opt_itemContext) Common_func_opt_item() ICommon_func_opt_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_func_opt_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommon_func_opt_itemContext) +} + +func (s *Createfunc_opt_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Createfunc_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Createfunc_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatefunc_opt_item(s) + } +} + +func (s *Createfunc_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatefunc_opt_item(s) + } +} + +func (s *Createfunc_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatefunc_opt_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createfunc_opt_item() (localctx ICreatefunc_opt_itemContext) { + localctx = NewCreatefunc_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 876, RedshiftParserRULE_createfunc_opt_item) + p.SetState(7931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7918) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7919) + p.Func_as() + } + + case RedshiftParserBEGIN_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7920) + p.Match(RedshiftParserBEGIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7921) + p.Match(RedshiftParserATOMIC_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7922) + p.Stmtmulti() + } + { + p.SetState(7923) + p.Match(RedshiftParserEND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserLANGUAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7925) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7926) + p.Nonreservedword_or_sconst() + } + + case RedshiftParserTRANSFORM: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7927) + p.Match(RedshiftParserTRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7928) + p.Transform_type_list() + } + + case RedshiftParserWINDOW: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7929) + p.Match(RedshiftParserWINDOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNOT, RedshiftParserCALLED, RedshiftParserCOST, RedshiftParserEXTERNAL, RedshiftParserIMMUTABLE, RedshiftParserLEAKPROOF, RedshiftParserRESET, RedshiftParserRETURNS, RedshiftParserROWS, RedshiftParserSECURITY, RedshiftParserSET, RedshiftParserSTABLE, RedshiftParserSTRICT_P, RedshiftParserVOLATILE, RedshiftParserSUPPORT, RedshiftParserPARALLEL: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7930) + p.Common_func_opt_item() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_asContext is an interface to support dynamic dispatch. +type IFunc_asContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDef returns the def rule contexts. + GetDef() ISconstContext + + // SetDef sets the def rule contexts. + SetDef(ISconstContext) + + // GetDefinition returns the Definition attribute. + GetDefinition() antlr.ParserRuleContext + + // SetDefinition sets the Definition attribute. + SetDefinition(antlr.ParserRuleContext) + + // Getter signatures + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + COMMA() antlr.TerminalNode + + // IsFunc_asContext differentiates from other interfaces. + IsFunc_asContext() +} + +type Func_asContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + Definition antlr.ParserRuleContext + def ISconstContext +} + +func NewEmptyFunc_asContext() *Func_asContext { + var p = new(Func_asContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_as + return p +} + +func InitEmptyFunc_asContext(p *Func_asContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_as +} + +func (*Func_asContext) IsFunc_asContext() {} + +func NewFunc_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_asContext { + var p = new(Func_asContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_as + + return p +} + +func (s *Func_asContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_asContext) GetDef() ISconstContext { return s.def } + +func (s *Func_asContext) SetDef(v ISconstContext) { s.def = v } + +func (s *Func_asContext) GetDefinition() antlr.ParserRuleContext { return s.Definition } + +func (s *Func_asContext) SetDefinition(v antlr.ParserRuleContext) { s.Definition = v } + +func (s *Func_asContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Func_asContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Func_asContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Func_asContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_asContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_as(s) + } +} + +func (s *Func_asContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_as(s) + } +} + +func (s *Func_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_as(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_as() (localctx IFunc_asContext) { + localctx = NewFunc_asContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 878, RedshiftParserRULE_func_as) + p.SetState(7938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 649, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7933) + + var _x = p.Sconst() + + localctx.(*Func_asContext).def = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7934) + p.Sconst() + } + { + p.SetState(7935) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7936) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransform_type_listContext is an interface to support dynamic dispatch. +type ITransform_type_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFOR() []antlr.TerminalNode + FOR(i int) antlr.TerminalNode + AllTYPE_P() []antlr.TerminalNode + TYPE_P(i int) antlr.TerminalNode + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTransform_type_listContext differentiates from other interfaces. + IsTransform_type_listContext() +} + +type Transform_type_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransform_type_listContext() *Transform_type_listContext { + var p = new(Transform_type_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transform_type_list + return p +} + +func InitEmptyTransform_type_listContext(p *Transform_type_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transform_type_list +} + +func (*Transform_type_listContext) IsTransform_type_listContext() {} + +func NewTransform_type_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transform_type_listContext { + var p = new(Transform_type_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transform_type_list + + return p +} + +func (s *Transform_type_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transform_type_listContext) AllFOR() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserFOR) +} + +func (s *Transform_type_listContext) FOR(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, i) +} + +func (s *Transform_type_listContext) AllTYPE_P() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserTYPE_P) +} + +func (s *Transform_type_listContext) TYPE_P(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, i) +} + +func (s *Transform_type_listContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *Transform_type_listContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Transform_type_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Transform_type_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Transform_type_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transform_type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transform_type_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransform_type_list(s) + } +} + +func (s *Transform_type_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransform_type_list(s) + } +} + +func (s *Transform_type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransform_type_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transform_type_list() (localctx ITransform_type_listContext) { + localctx = NewTransform_type_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 880, RedshiftParserRULE_transform_type_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7940) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7941) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7942) + p.Typename() + } + p.SetState(7949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7943) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7944) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7945) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7946) + p.Typename() + } + + p.SetState(7951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_definitionContext is an interface to support dynamic dispatch. +type IOpt_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + Definition() IDefinitionContext + + // IsOpt_definitionContext differentiates from other interfaces. + IsOpt_definitionContext() +} + +type Opt_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_definitionContext() *Opt_definitionContext { + var p = new(Opt_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_definition + return p +} + +func InitEmptyOpt_definitionContext(p *Opt_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_definition +} + +func (*Opt_definitionContext) IsOpt_definitionContext() {} + +func NewOpt_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_definitionContext { + var p = new(Opt_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_definition + + return p +} + +func (s *Opt_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_definitionContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_definitionContext) Definition() IDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefinitionContext) +} + +func (s *Opt_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_definition(s) + } +} + +func (s *Opt_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_definition(s) + } +} + +func (s *Opt_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_definition() (localctx IOpt_definitionContext) { + localctx = NewOpt_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 882, RedshiftParserRULE_opt_definition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7952) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7953) + p.Definition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_func_columnContext is an interface to support dynamic dispatch. +type ITable_func_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Param_name() IParam_nameContext + Func_type() IFunc_typeContext + + // IsTable_func_columnContext differentiates from other interfaces. + IsTable_func_columnContext() +} + +type Table_func_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_func_columnContext() *Table_func_columnContext { + var p = new(Table_func_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_func_column + return p +} + +func InitEmptyTable_func_columnContext(p *Table_func_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_func_column +} + +func (*Table_func_columnContext) IsTable_func_columnContext() {} + +func NewTable_func_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_func_columnContext { + var p = new(Table_func_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_func_column + + return p +} + +func (s *Table_func_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_func_columnContext) Param_name() IParam_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParam_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParam_nameContext) +} + +func (s *Table_func_columnContext) Func_type() IFunc_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_typeContext) +} + +func (s *Table_func_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_func_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_func_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_func_column(s) + } +} + +func (s *Table_func_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_func_column(s) + } +} + +func (s *Table_func_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_func_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_func_column() (localctx ITable_func_columnContext) { + localctx = NewTable_func_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 884, RedshiftParserRULE_table_func_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7955) + p.Param_name() + } + { + p.SetState(7956) + p.Func_type() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_func_column_listContext is an interface to support dynamic dispatch. +type ITable_func_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTable_func_column() []ITable_func_columnContext + Table_func_column(i int) ITable_func_columnContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_func_column_listContext differentiates from other interfaces. + IsTable_func_column_listContext() +} + +type Table_func_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_func_column_listContext() *Table_func_column_listContext { + var p = new(Table_func_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_func_column_list + return p +} + +func InitEmptyTable_func_column_listContext(p *Table_func_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_func_column_list +} + +func (*Table_func_column_listContext) IsTable_func_column_listContext() {} + +func NewTable_func_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_func_column_listContext { + var p = new(Table_func_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_func_column_list + + return p +} + +func (s *Table_func_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_func_column_listContext) AllTable_func_column() []ITable_func_columnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_func_columnContext); ok { + len++ + } + } + + tst := make([]ITable_func_columnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_func_columnContext); ok { + tst[i] = t.(ITable_func_columnContext) + i++ + } + } + + return tst +} + +func (s *Table_func_column_listContext) Table_func_column(i int) ITable_func_columnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_func_columnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_func_columnContext) +} + +func (s *Table_func_column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Table_func_column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Table_func_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_func_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_func_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_func_column_list(s) + } +} + +func (s *Table_func_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_func_column_list(s) + } +} + +func (s *Table_func_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_func_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_func_column_list() (localctx ITable_func_column_listContext) { + localctx = NewTable_func_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 886, RedshiftParserRULE_table_func_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7958) + p.Table_func_column() + } + p.SetState(7963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(7959) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7960) + p.Table_func_column() + } + + p.SetState(7965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterfunctionstmtContext is an interface to support dynamic dispatch. +type IAlterfunctionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllFunc_name() []IFunc_nameContext + Func_name(i int) IFunc_nameContext + Func_py_args_or_sql_args() IFunc_py_args_or_sql_argsContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + OWNER() antlr.TerminalNode + Rolespec() IRolespecContext + + // IsAlterfunctionstmtContext differentiates from other interfaces. + IsAlterfunctionstmtContext() +} + +type AlterfunctionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterfunctionstmtContext() *AlterfunctionstmtContext { + var p = new(AlterfunctionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterfunctionstmt + return p +} + +func InitEmptyAlterfunctionstmtContext(p *AlterfunctionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterfunctionstmt +} + +func (*AlterfunctionstmtContext) IsAlterfunctionstmtContext() {} + +func NewAlterfunctionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterfunctionstmtContext { + var p = new(AlterfunctionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterfunctionstmt + + return p +} + +func (s *AlterfunctionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterfunctionstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterfunctionstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *AlterfunctionstmtContext) AllFunc_name() []IFunc_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_nameContext); ok { + len++ + } + } + + tst := make([]IFunc_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_nameContext); ok { + tst[i] = t.(IFunc_nameContext) + i++ + } + } + + return tst +} + +func (s *AlterfunctionstmtContext) Func_name(i int) IFunc_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *AlterfunctionstmtContext) Func_py_args_or_sql_args() IFunc_py_args_or_sql_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_py_args_or_sql_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_py_args_or_sql_argsContext) +} + +func (s *AlterfunctionstmtContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *AlterfunctionstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AlterfunctionstmtContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *AlterfunctionstmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *AlterfunctionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterfunctionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterfunctionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterfunctionstmt(s) + } +} + +func (s *AlterfunctionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterfunctionstmt(s) + } +} + +func (s *AlterfunctionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterfunctionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterfunctionstmt() (localctx IAlterfunctionstmtContext) { + localctx = NewAlterfunctionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 888, RedshiftParserRULE_alterfunctionstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7966) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7967) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7968) + p.Func_name() + } + { + p.SetState(7969) + p.Func_py_args_or_sql_args() + } + p.SetState(7976) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserRENAME: + { + p.SetState(7970) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7971) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7972) + p.Func_name() + } + + case RedshiftParserOWNER: + { + p.SetState(7973) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7974) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7975) + p.Rolespec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterprocedurestmtContext is an interface to support dynamic dispatch. +type IAlterprocedurestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + AllFunc_name() []IFunc_nameContext + Func_name(i int) IFunc_nameContext + Func_args() IFunc_argsContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + OWNER() antlr.TerminalNode + Rolespec() IRolespecContext + + // IsAlterprocedurestmtContext differentiates from other interfaces. + IsAlterprocedurestmtContext() +} + +type AlterprocedurestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterprocedurestmtContext() *AlterprocedurestmtContext { + var p = new(AlterprocedurestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterprocedurestmt + return p +} + +func InitEmptyAlterprocedurestmtContext(p *AlterprocedurestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterprocedurestmt +} + +func (*AlterprocedurestmtContext) IsAlterprocedurestmtContext() {} + +func NewAlterprocedurestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterprocedurestmtContext { + var p = new(AlterprocedurestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterprocedurestmt + + return p +} + +func (s *AlterprocedurestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterprocedurestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterprocedurestmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *AlterprocedurestmtContext) AllFunc_name() []IFunc_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_nameContext); ok { + len++ + } + } + + tst := make([]IFunc_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_nameContext); ok { + tst[i] = t.(IFunc_nameContext) + i++ + } + } + + return tst +} + +func (s *AlterprocedurestmtContext) Func_name(i int) IFunc_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *AlterprocedurestmtContext) Func_args() IFunc_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argsContext) +} + +func (s *AlterprocedurestmtContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *AlterprocedurestmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AlterprocedurestmtContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *AlterprocedurestmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *AlterprocedurestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterprocedurestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterprocedurestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterprocedurestmt(s) + } +} + +func (s *AlterprocedurestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterprocedurestmt(s) + } +} + +func (s *AlterprocedurestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterprocedurestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterprocedurestmt() (localctx IAlterprocedurestmtContext) { + localctx = NewAlterprocedurestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 890, RedshiftParserRULE_alterprocedurestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7978) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7979) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7980) + p.Func_name() + } + { + p.SetState(7981) + p.Func_args() + } + p.SetState(7988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserRENAME: + { + p.SetState(7982) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7983) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7984) + p.Func_name() + } + + case RedshiftParserOWNER: + { + p.SetState(7985) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7986) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7987) + p.Rolespec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterfunc_opt_listContext is an interface to support dynamic dispatch. +type IAlterfunc_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCommon_func_opt_item() []ICommon_func_opt_itemContext + Common_func_opt_item(i int) ICommon_func_opt_itemContext + + // IsAlterfunc_opt_listContext differentiates from other interfaces. + IsAlterfunc_opt_listContext() +} + +type Alterfunc_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterfunc_opt_listContext() *Alterfunc_opt_listContext { + var p = new(Alterfunc_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterfunc_opt_list + return p +} + +func InitEmptyAlterfunc_opt_listContext(p *Alterfunc_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterfunc_opt_list +} + +func (*Alterfunc_opt_listContext) IsAlterfunc_opt_listContext() {} + +func NewAlterfunc_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alterfunc_opt_listContext { + var p = new(Alterfunc_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterfunc_opt_list + + return p +} + +func (s *Alterfunc_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alterfunc_opt_listContext) AllCommon_func_opt_item() []ICommon_func_opt_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICommon_func_opt_itemContext); ok { + len++ + } + } + + tst := make([]ICommon_func_opt_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICommon_func_opt_itemContext); ok { + tst[i] = t.(ICommon_func_opt_itemContext) + i++ + } + } + + return tst +} + +func (s *Alterfunc_opt_listContext) Common_func_opt_item(i int) ICommon_func_opt_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_func_opt_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICommon_func_opt_itemContext) +} + +func (s *Alterfunc_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alterfunc_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alterfunc_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterfunc_opt_list(s) + } +} + +func (s *Alterfunc_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterfunc_opt_list(s) + } +} + +func (s *Alterfunc_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterfunc_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterfunc_opt_list() (localctx IAlterfunc_opt_listContext) { + localctx = NewAlterfunc_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 892, RedshiftParserRULE_alterfunc_opt_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserNOT || ((int64((_la-151)) & ^0x3f) == 0 && ((int64(1)<<(_la-151))&288230376153808897) != 0) || _la == RedshiftParserIMMUTABLE || _la == RedshiftParserLEAKPROOF || ((int64((_la-311)) & ^0x3f) == 0 && ((int64(1)<<(_la-311))&8624554121) != 0) || _la == RedshiftParserVOLATILE || _la == RedshiftParserSUPPORT || _la == RedshiftParserPARALLEL { + { + p.SetState(7990) + p.Common_func_opt_item() + } + + p.SetState(7993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_restrictContext is an interface to support dynamic dispatch. +type IOpt_restrictContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESTRICT() antlr.TerminalNode + + // IsOpt_restrictContext differentiates from other interfaces. + IsOpt_restrictContext() +} + +type Opt_restrictContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_restrictContext() *Opt_restrictContext { + var p = new(Opt_restrictContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_restrict + return p +} + +func InitEmptyOpt_restrictContext(p *Opt_restrictContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_restrict +} + +func (*Opt_restrictContext) IsOpt_restrictContext() {} + +func NewOpt_restrictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_restrictContext { + var p = new(Opt_restrictContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_restrict + + return p +} + +func (s *Opt_restrictContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_restrictContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *Opt_restrictContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_restrictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_restrictContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_restrict(s) + } +} + +func (s *Opt_restrictContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_restrict(s) + } +} + +func (s *Opt_restrictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_restrict(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_restrict() (localctx IOpt_restrictContext) { + localctx = NewOpt_restrictContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 894, RedshiftParserRULE_opt_restrict) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7995) + p.Match(RedshiftParserRESTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRemovefuncstmtContext is an interface to support dynamic dispatch. +type IRemovefuncstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes_list() IFunction_with_argtypes_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + + // IsRemovefuncstmtContext differentiates from other interfaces. + IsRemovefuncstmtContext() +} + +type RemovefuncstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRemovefuncstmtContext() *RemovefuncstmtContext { + var p = new(RemovefuncstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_removefuncstmt + return p +} + +func InitEmptyRemovefuncstmtContext(p *RemovefuncstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_removefuncstmt +} + +func (*RemovefuncstmtContext) IsRemovefuncstmtContext() {} + +func NewRemovefuncstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemovefuncstmtContext { + var p = new(RemovefuncstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_removefuncstmt + + return p +} + +func (s *RemovefuncstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RemovefuncstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *RemovefuncstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *RemovefuncstmtContext) Function_with_argtypes_list() IFunction_with_argtypes_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypes_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypes_listContext) +} + +func (s *RemovefuncstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *RemovefuncstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *RemovefuncstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *RemovefuncstmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *RemovefuncstmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *RemovefuncstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RemovefuncstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RemovefuncstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRemovefuncstmt(s) + } +} + +func (s *RemovefuncstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRemovefuncstmt(s) + } +} + +func (s *RemovefuncstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRemovefuncstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Removefuncstmt() (localctx IRemovefuncstmtContext) { + localctx = NewRemovefuncstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 896, RedshiftParserRULE_removefuncstmt) + var _la int + + p.SetState(8039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 661, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7997) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7998) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7999) + p.Function_with_argtypes_list() + } + p.SetState(8001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8000) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8003) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8004) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8005) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8006) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8007) + p.Function_with_argtypes_list() + } + p.SetState(8009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8008) + p.Opt_drop_behavior() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8011) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8012) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8013) + p.Function_with_argtypes_list() + } + p.SetState(8015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8014) + p.Opt_drop_behavior() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8017) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8018) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8019) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8020) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8021) + p.Function_with_argtypes_list() + } + p.SetState(8023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8022) + p.Opt_drop_behavior() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8025) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8026) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8027) + p.Function_with_argtypes_list() + } + p.SetState(8029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8028) + p.Opt_drop_behavior() + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8031) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8032) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8033) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8034) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8035) + p.Function_with_argtypes_list() + } + p.SetState(8037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8036) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRemoveaggrstmtContext is an interface to support dynamic dispatch. +type IRemoveaggrstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + Aggregate_with_argtypes_list() IAggregate_with_argtypes_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsRemoveaggrstmtContext differentiates from other interfaces. + IsRemoveaggrstmtContext() +} + +type RemoveaggrstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRemoveaggrstmtContext() *RemoveaggrstmtContext { + var p = new(RemoveaggrstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_removeaggrstmt + return p +} + +func InitEmptyRemoveaggrstmtContext(p *RemoveaggrstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_removeaggrstmt +} + +func (*RemoveaggrstmtContext) IsRemoveaggrstmtContext() {} + +func NewRemoveaggrstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveaggrstmtContext { + var p = new(RemoveaggrstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_removeaggrstmt + + return p +} + +func (s *RemoveaggrstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RemoveaggrstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *RemoveaggrstmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *RemoveaggrstmtContext) Aggregate_with_argtypes_list() IAggregate_with_argtypes_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypes_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypes_listContext) +} + +func (s *RemoveaggrstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *RemoveaggrstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *RemoveaggrstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *RemoveaggrstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RemoveaggrstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RemoveaggrstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRemoveaggrstmt(s) + } +} + +func (s *RemoveaggrstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRemoveaggrstmt(s) + } +} + +func (s *RemoveaggrstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRemoveaggrstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Removeaggrstmt() (localctx IRemoveaggrstmtContext) { + localctx = NewRemoveaggrstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 898, RedshiftParserRULE_removeaggrstmt) + var _la int + + p.SetState(8055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 664, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8041) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8042) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8043) + p.Aggregate_with_argtypes_list() + } + p.SetState(8045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8044) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8047) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8048) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8049) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8050) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8051) + p.Aggregate_with_argtypes_list() + } + p.SetState(8053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8052) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRemoveoperstmtContext is an interface to support dynamic dispatch. +type IRemoveoperstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_with_argtypes_list() IOperator_with_argtypes_listContext + Opt_drop_behavior() IOpt_drop_behaviorContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsRemoveoperstmtContext differentiates from other interfaces. + IsRemoveoperstmtContext() +} + +type RemoveoperstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRemoveoperstmtContext() *RemoveoperstmtContext { + var p = new(RemoveoperstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_removeoperstmt + return p +} + +func InitEmptyRemoveoperstmtContext(p *RemoveoperstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_removeoperstmt +} + +func (*RemoveoperstmtContext) IsRemoveoperstmtContext() {} + +func NewRemoveoperstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveoperstmtContext { + var p = new(RemoveoperstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_removeoperstmt + + return p +} + +func (s *RemoveoperstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RemoveoperstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *RemoveoperstmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *RemoveoperstmtContext) Operator_with_argtypes_list() IOperator_with_argtypes_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypes_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypes_listContext) +} + +func (s *RemoveoperstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *RemoveoperstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *RemoveoperstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *RemoveoperstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RemoveoperstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RemoveoperstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRemoveoperstmt(s) + } +} + +func (s *RemoveoperstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRemoveoperstmt(s) + } +} + +func (s *RemoveoperstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRemoveoperstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Removeoperstmt() (localctx IRemoveoperstmtContext) { + localctx = NewRemoveoperstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 900, RedshiftParserRULE_removeoperstmt) + var _la int + + p.SetState(8071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 667, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8057) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8058) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8059) + p.Operator_with_argtypes_list() + } + p.SetState(8061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8060) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8063) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8064) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8065) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8066) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8067) + p.Operator_with_argtypes_list() + } + p.SetState(8069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8068) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOper_argtypesContext is an interface to support dynamic dispatch. +type IOper_argtypesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + CLOSE_PAREN() antlr.TerminalNode + COMMA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsOper_argtypesContext differentiates from other interfaces. + IsOper_argtypesContext() +} + +type Oper_argtypesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOper_argtypesContext() *Oper_argtypesContext { + var p = new(Oper_argtypesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_oper_argtypes + return p +} + +func InitEmptyOper_argtypesContext(p *Oper_argtypesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_oper_argtypes +} + +func (*Oper_argtypesContext) IsOper_argtypesContext() {} + +func NewOper_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oper_argtypesContext { + var p = new(Oper_argtypesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_oper_argtypes + + return p +} + +func (s *Oper_argtypesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Oper_argtypesContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Oper_argtypesContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *Oper_argtypesContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Oper_argtypesContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Oper_argtypesContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Oper_argtypesContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *Oper_argtypesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Oper_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Oper_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOper_argtypes(s) + } +} + +func (s *Oper_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOper_argtypes(s) + } +} + +func (s *Oper_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOper_argtypes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Oper_argtypes() (localctx IOper_argtypesContext) { + localctx = NewOper_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 902, RedshiftParserRULE_oper_argtypes) + p.SetState(8095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 668, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8073) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8074) + p.Typename() + } + { + p.SetState(8075) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8077) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8078) + p.Typename() + } + { + p.SetState(8079) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8080) + p.Typename() + } + { + p.SetState(8081) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8083) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8084) + p.Match(RedshiftParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8085) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8086) + p.Typename() + } + { + p.SetState(8087) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8089) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8090) + p.Typename() + } + { + p.SetState(8091) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8092) + p.Match(RedshiftParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8093) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAny_operatorContext is an interface to support dynamic dispatch. +type IAny_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + All_op() IAll_opContext + AllColid() []IColidContext + Colid(i int) IColidContext + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsAny_operatorContext differentiates from other interfaces. + IsAny_operatorContext() +} + +type Any_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAny_operatorContext() *Any_operatorContext { + var p = new(Any_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_operator + return p +} + +func InitEmptyAny_operatorContext(p *Any_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_operator +} + +func (*Any_operatorContext) IsAny_operatorContext() {} + +func NewAny_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_operatorContext { + var p = new(Any_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_any_operator + + return p +} + +func (s *Any_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Any_operatorContext) All_op() IAll_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_opContext) +} + +func (s *Any_operatorContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Any_operatorContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Any_operatorContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserDOT) +} + +func (s *Any_operatorContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, i) +} + +func (s *Any_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Any_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Any_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAny_operator(s) + } +} + +func (s *Any_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAny_operator(s) + } +} + +func (s *Any_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAny_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Any_operator() (localctx IAny_operatorContext) { + localctx = NewAny_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 904, RedshiftParserRULE_any_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(8097) + p.Colid() + } + { + p.SetState(8098) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8105) + p.All_op() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_with_argtypes_listContext is an interface to support dynamic dispatch. +type IOperator_with_argtypes_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOperator_with_argtypes() []IOperator_with_argtypesContext + Operator_with_argtypes(i int) IOperator_with_argtypesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOperator_with_argtypes_listContext differentiates from other interfaces. + IsOperator_with_argtypes_listContext() +} + +type Operator_with_argtypes_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_with_argtypes_listContext() *Operator_with_argtypes_listContext { + var p = new(Operator_with_argtypes_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_with_argtypes_list + return p +} + +func InitEmptyOperator_with_argtypes_listContext(p *Operator_with_argtypes_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_with_argtypes_list +} + +func (*Operator_with_argtypes_listContext) IsOperator_with_argtypes_listContext() {} + +func NewOperator_with_argtypes_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_with_argtypes_listContext { + var p = new(Operator_with_argtypes_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_operator_with_argtypes_list + + return p +} + +func (s *Operator_with_argtypes_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_with_argtypes_listContext) AllOperator_with_argtypes() []IOperator_with_argtypesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + len++ + } + } + + tst := make([]IOperator_with_argtypesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOperator_with_argtypesContext); ok { + tst[i] = t.(IOperator_with_argtypesContext) + i++ + } + } + + return tst +} + +func (s *Operator_with_argtypes_listContext) Operator_with_argtypes(i int) IOperator_with_argtypesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypesContext) +} + +func (s *Operator_with_argtypes_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Operator_with_argtypes_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Operator_with_argtypes_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_with_argtypes_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_with_argtypes_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOperator_with_argtypes_list(s) + } +} + +func (s *Operator_with_argtypes_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOperator_with_argtypes_list(s) + } +} + +func (s *Operator_with_argtypes_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOperator_with_argtypes_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Operator_with_argtypes_list() (localctx IOperator_with_argtypes_listContext) { + localctx = NewOperator_with_argtypes_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 906, RedshiftParserRULE_operator_with_argtypes_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8107) + p.Operator_with_argtypes() + } + p.SetState(8112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(8108) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8109) + p.Operator_with_argtypes() + } + + p.SetState(8114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_with_argtypesContext is an interface to support dynamic dispatch. +type IOperator_with_argtypesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Any_operator() IAny_operatorContext + Oper_argtypes() IOper_argtypesContext + + // IsOperator_with_argtypesContext differentiates from other interfaces. + IsOperator_with_argtypesContext() +} + +type Operator_with_argtypesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_with_argtypesContext() *Operator_with_argtypesContext { + var p = new(Operator_with_argtypesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_with_argtypes + return p +} + +func InitEmptyOperator_with_argtypesContext(p *Operator_with_argtypesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_with_argtypes +} + +func (*Operator_with_argtypesContext) IsOperator_with_argtypesContext() {} + +func NewOperator_with_argtypesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_with_argtypesContext { + var p = new(Operator_with_argtypesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_operator_with_argtypes + + return p +} + +func (s *Operator_with_argtypesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_with_argtypesContext) Any_operator() IAny_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_operatorContext) +} + +func (s *Operator_with_argtypesContext) Oper_argtypes() IOper_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOper_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOper_argtypesContext) +} + +func (s *Operator_with_argtypesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_with_argtypesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_with_argtypesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOperator_with_argtypes(s) + } +} + +func (s *Operator_with_argtypesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOperator_with_argtypes(s) + } +} + +func (s *Operator_with_argtypesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOperator_with_argtypes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Operator_with_argtypes() (localctx IOperator_with_argtypesContext) { + localctx = NewOperator_with_argtypesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 908, RedshiftParserRULE_operator_with_argtypes) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8115) + p.Any_operator() + } + { + p.SetState(8116) + p.Oper_argtypes() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDostmtContext is an interface to support dynamic dispatch. +type IDostmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DO() antlr.TerminalNode + Dostmt_opt_list() IDostmt_opt_listContext + + // IsDostmtContext differentiates from other interfaces. + IsDostmtContext() +} + +type DostmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDostmtContext() *DostmtContext { + var p = new(DostmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dostmt + return p +} + +func InitEmptyDostmtContext(p *DostmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dostmt +} + +func (*DostmtContext) IsDostmtContext() {} + +func NewDostmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DostmtContext { + var p = new(DostmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dostmt + + return p +} + +func (s *DostmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DostmtContext) DO() antlr.TerminalNode { + return s.GetToken(RedshiftParserDO, 0) +} + +func (s *DostmtContext) Dostmt_opt_list() IDostmt_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDostmt_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDostmt_opt_listContext) +} + +func (s *DostmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DostmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DostmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDostmt(s) + } +} + +func (s *DostmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDostmt(s) + } +} + +func (s *DostmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDostmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dostmt() (localctx IDostmtContext) { + localctx = NewDostmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 910, RedshiftParserRULE_dostmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8118) + p.Match(RedshiftParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8119) + p.Dostmt_opt_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDostmt_opt_listContext is an interface to support dynamic dispatch. +type IDostmt_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDostmt_opt_item() []IDostmt_opt_itemContext + Dostmt_opt_item(i int) IDostmt_opt_itemContext + + // IsDostmt_opt_listContext differentiates from other interfaces. + IsDostmt_opt_listContext() +} + +type Dostmt_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDostmt_opt_listContext() *Dostmt_opt_listContext { + var p = new(Dostmt_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dostmt_opt_list + return p +} + +func InitEmptyDostmt_opt_listContext(p *Dostmt_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dostmt_opt_list +} + +func (*Dostmt_opt_listContext) IsDostmt_opt_listContext() {} + +func NewDostmt_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dostmt_opt_listContext { + var p = new(Dostmt_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dostmt_opt_list + + return p +} + +func (s *Dostmt_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dostmt_opt_listContext) AllDostmt_opt_item() []IDostmt_opt_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDostmt_opt_itemContext); ok { + len++ + } + } + + tst := make([]IDostmt_opt_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDostmt_opt_itemContext); ok { + tst[i] = t.(IDostmt_opt_itemContext) + i++ + } + } + + return tst +} + +func (s *Dostmt_opt_listContext) Dostmt_opt_item(i int) IDostmt_opt_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDostmt_opt_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDostmt_opt_itemContext) +} + +func (s *Dostmt_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dostmt_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dostmt_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDostmt_opt_list(s) + } +} + +func (s *Dostmt_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDostmt_opt_list(s) + } +} + +func (s *Dostmt_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDostmt_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dostmt_opt_list() (localctx IDostmt_opt_listContext) { + localctx = NewDostmt_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 912, RedshiftParserRULE_dostmt_opt_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserLANGUAGE || ((int64((_la-862)) & ^0x3f) == 0 && ((int64(1)<<(_la-862))&67108885) != 0) { + { + p.SetState(8121) + p.Dostmt_opt_item() + } + + p.SetState(8124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDostmt_opt_itemContext is an interface to support dynamic dispatch. +type IDostmt_opt_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + LANGUAGE() antlr.TerminalNode + Nonreservedword_or_sconst() INonreservedword_or_sconstContext + + // IsDostmt_opt_itemContext differentiates from other interfaces. + IsDostmt_opt_itemContext() +} + +type Dostmt_opt_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDostmt_opt_itemContext() *Dostmt_opt_itemContext { + var p = new(Dostmt_opt_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dostmt_opt_item + return p +} + +func InitEmptyDostmt_opt_itemContext(p *Dostmt_opt_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dostmt_opt_item +} + +func (*Dostmt_opt_itemContext) IsDostmt_opt_itemContext() {} + +func NewDostmt_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dostmt_opt_itemContext { + var p = new(Dostmt_opt_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dostmt_opt_item + + return p +} + +func (s *Dostmt_opt_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dostmt_opt_itemContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Dostmt_opt_itemContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *Dostmt_opt_itemContext) Nonreservedword_or_sconst() INonreservedword_or_sconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedword_or_sconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedword_or_sconstContext) +} + +func (s *Dostmt_opt_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dostmt_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dostmt_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDostmt_opt_item(s) + } +} + +func (s *Dostmt_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDostmt_opt_item(s) + } +} + +func (s *Dostmt_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDostmt_opt_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dostmt_opt_item() (localctx IDostmt_opt_itemContext) { + localctx = NewDostmt_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 914, RedshiftParserRULE_dostmt_opt_item) + p.SetState(8129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8126) + p.Sconst() + } + + case RedshiftParserLANGUAGE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8127) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8128) + p.Nonreservedword_or_sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatecaststmtContext is an interface to support dynamic dispatch. +type ICreatecaststmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CAST() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + AS() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + WITH() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + Cast_context() ICast_contextContext + WITHOUT() antlr.TerminalNode + INOUT() antlr.TerminalNode + + // IsCreatecaststmtContext differentiates from other interfaces. + IsCreatecaststmtContext() +} + +type CreatecaststmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatecaststmtContext() *CreatecaststmtContext { + var p = new(CreatecaststmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createcaststmt + return p +} + +func InitEmptyCreatecaststmtContext(p *CreatecaststmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createcaststmt +} + +func (*CreatecaststmtContext) IsCreatecaststmtContext() {} + +func NewCreatecaststmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatecaststmtContext { + var p = new(CreatecaststmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createcaststmt + + return p +} + +func (s *CreatecaststmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatecaststmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatecaststmtContext) CAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCAST, 0) +} + +func (s *CreatecaststmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreatecaststmtContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *CreatecaststmtContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *CreatecaststmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CreatecaststmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreatecaststmtContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *CreatecaststmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *CreatecaststmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *CreatecaststmtContext) Cast_context() ICast_contextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICast_contextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICast_contextContext) +} + +func (s *CreatecaststmtContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHOUT, 0) +} + +func (s *CreatecaststmtContext) INOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINOUT, 0) +} + +func (s *CreatecaststmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatecaststmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatecaststmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatecaststmt(s) + } +} + +func (s *CreatecaststmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatecaststmt(s) + } +} + +func (s *CreatecaststmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatecaststmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createcaststmt() (localctx ICreatecaststmtContext) { + localctx = NewCreatecaststmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 916, RedshiftParserRULE_createcaststmt) + var _la int + + p.SetState(8168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 676, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8131) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8132) + p.Match(RedshiftParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8133) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8134) + p.Typename() + } + { + p.SetState(8135) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8136) + p.Typename() + } + { + p.SetState(8137) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8138) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8139) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8140) + p.Function_with_argtypes() + } + p.SetState(8142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(8141) + p.Cast_context() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8144) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8145) + p.Match(RedshiftParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8146) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8147) + p.Typename() + } + { + p.SetState(8148) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8149) + p.Typename() + } + { + p.SetState(8150) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8151) + p.Match(RedshiftParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8152) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(8153) + p.Cast_context() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8156) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8157) + p.Match(RedshiftParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8158) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8159) + p.Typename() + } + { + p.SetState(8160) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8161) + p.Typename() + } + { + p.SetState(8162) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8163) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8164) + p.Match(RedshiftParserINOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(8165) + p.Cast_context() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICast_contextContext is an interface to support dynamic dispatch. +type ICast_contextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + IMPLICIT_P() antlr.TerminalNode + ASSIGNMENT() antlr.TerminalNode + + // IsCast_contextContext differentiates from other interfaces. + IsCast_contextContext() +} + +type Cast_contextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCast_contextContext() *Cast_contextContext { + var p = new(Cast_contextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cast_context + return p +} + +func InitEmptyCast_contextContext(p *Cast_contextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cast_context +} + +func (*Cast_contextContext) IsCast_contextContext() {} + +func NewCast_contextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cast_contextContext { + var p = new(Cast_contextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cast_context + + return p +} + +func (s *Cast_contextContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cast_contextContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Cast_contextContext) IMPLICIT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMPLICIT_P, 0) +} + +func (s *Cast_contextContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSIGNMENT, 0) +} + +func (s *Cast_contextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cast_contextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cast_contextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCast_context(s) + } +} + +func (s *Cast_contextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCast_context(s) + } +} + +func (s *Cast_contextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCast_context(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cast_context() (localctx ICast_contextContext) { + localctx = NewCast_contextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 918, RedshiftParserRULE_cast_context) + p.SetState(8174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 677, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8170) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8171) + p.Match(RedshiftParserIMPLICIT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8172) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8173) + p.Match(RedshiftParserASSIGNMENT) + 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 +} + +// IDropcaststmtContext is an interface to support dynamic dispatch. +type IDropcaststmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + CAST() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + AS() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Opt_if_exists() IOpt_if_existsContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsDropcaststmtContext differentiates from other interfaces. + IsDropcaststmtContext() +} + +type DropcaststmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropcaststmtContext() *DropcaststmtContext { + var p = new(DropcaststmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropcaststmt + return p +} + +func InitEmptyDropcaststmtContext(p *DropcaststmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropcaststmt +} + +func (*DropcaststmtContext) IsDropcaststmtContext() {} + +func NewDropcaststmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropcaststmtContext { + var p = new(DropcaststmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropcaststmt + + return p +} + +func (s *DropcaststmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropcaststmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropcaststmtContext) CAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCAST, 0) +} + +func (s *DropcaststmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *DropcaststmtContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *DropcaststmtContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *DropcaststmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *DropcaststmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *DropcaststmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropcaststmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DropcaststmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropcaststmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropcaststmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropcaststmt(s) + } +} + +func (s *DropcaststmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropcaststmt(s) + } +} + +func (s *DropcaststmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropcaststmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropcaststmt() (localctx IDropcaststmtContext) { + localctx = NewDropcaststmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 920, RedshiftParserRULE_dropcaststmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8176) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8177) + p.Match(RedshiftParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIF_P { + { + p.SetState(8178) + p.Opt_if_exists() + } + + } + { + p.SetState(8181) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8182) + p.Typename() + } + { + p.SetState(8183) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8184) + p.Typename() + } + { + p.SetState(8185) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8186) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_if_existsContext is an interface to support dynamic dispatch. +type IOpt_if_existsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsOpt_if_existsContext differentiates from other interfaces. + IsOpt_if_existsContext() +} + +type Opt_if_existsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_if_existsContext() *Opt_if_existsContext { + var p = new(Opt_if_existsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_if_exists + return p +} + +func InitEmptyOpt_if_existsContext(p *Opt_if_existsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_if_exists +} + +func (*Opt_if_existsContext) IsOpt_if_existsContext() {} + +func NewOpt_if_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_if_existsContext { + var p = new(Opt_if_existsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_if_exists + + return p +} + +func (s *Opt_if_existsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_if_existsContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *Opt_if_existsContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *Opt_if_existsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_if_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_if_existsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_if_exists(s) + } +} + +func (s *Opt_if_existsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_if_exists(s) + } +} + +func (s *Opt_if_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_if_exists(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_if_exists() (localctx IOpt_if_existsContext) { + localctx = NewOpt_if_existsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 922, RedshiftParserRULE_opt_if_exists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8189) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8190) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatetransformstmtContext is an interface to support dynamic dispatch. +type ICreatetransformstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + FOR() antlr.TerminalNode + Typename() ITypenameContext + LANGUAGE() antlr.TerminalNode + Name() INameContext + OPEN_PAREN() antlr.TerminalNode + Transform_element_list() ITransform_element_listContext + CLOSE_PAREN() antlr.TerminalNode + Opt_or_replace() IOpt_or_replaceContext + + // IsCreatetransformstmtContext differentiates from other interfaces. + IsCreatetransformstmtContext() +} + +type CreatetransformstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatetransformstmtContext() *CreatetransformstmtContext { + var p = new(CreatetransformstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createtransformstmt + return p +} + +func InitEmptyCreatetransformstmtContext(p *CreatetransformstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createtransformstmt +} + +func (*CreatetransformstmtContext) IsCreatetransformstmtContext() {} + +func NewCreatetransformstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatetransformstmtContext { + var p = new(CreatetransformstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createtransformstmt + + return p +} + +func (s *CreatetransformstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatetransformstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatetransformstmtContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSFORM, 0) +} + +func (s *CreatetransformstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *CreatetransformstmtContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *CreatetransformstmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *CreatetransformstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatetransformstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreatetransformstmtContext) Transform_element_list() ITransform_element_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransform_element_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransform_element_listContext) +} + +func (s *CreatetransformstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreatetransformstmtContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *CreatetransformstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatetransformstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatetransformstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatetransformstmt(s) + } +} + +func (s *CreatetransformstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatetransformstmt(s) + } +} + +func (s *CreatetransformstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatetransformstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createtransformstmt() (localctx ICreatetransformstmtContext) { + localctx = NewCreatetransformstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 924, RedshiftParserRULE_createtransformstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8192) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(8193) + p.Opt_or_replace() + } + + } + { + p.SetState(8196) + p.Match(RedshiftParserTRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8197) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8198) + p.Typename() + } + { + p.SetState(8199) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8200) + p.Name() + } + { + p.SetState(8201) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8202) + p.Transform_element_list() + } + { + p.SetState(8203) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransform_element_listContext is an interface to support dynamic dispatch. +type ITransform_element_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + AllSQL_P() []antlr.TerminalNode + SQL_P(i int) antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllFUNCTION() []antlr.TerminalNode + FUNCTION(i int) antlr.TerminalNode + AllFunction_with_argtypes() []IFunction_with_argtypesContext + Function_with_argtypes(i int) IFunction_with_argtypesContext + COMMA() antlr.TerminalNode + TO() antlr.TerminalNode + + // IsTransform_element_listContext differentiates from other interfaces. + IsTransform_element_listContext() +} + +type Transform_element_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransform_element_listContext() *Transform_element_listContext { + var p = new(Transform_element_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transform_element_list + return p +} + +func InitEmptyTransform_element_listContext(p *Transform_element_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transform_element_list +} + +func (*Transform_element_listContext) IsTransform_element_listContext() {} + +func NewTransform_element_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transform_element_listContext { + var p = new(Transform_element_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transform_element_list + + return p +} + +func (s *Transform_element_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transform_element_listContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Transform_element_listContext) AllSQL_P() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserSQL_P) +} + +func (s *Transform_element_listContext) SQL_P(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserSQL_P, i) +} + +func (s *Transform_element_listContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserWITH) +} + +func (s *Transform_element_listContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, i) +} + +func (s *Transform_element_listContext) AllFUNCTION() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserFUNCTION) +} + +func (s *Transform_element_listContext) FUNCTION(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, i) +} + +func (s *Transform_element_listContext) AllFunction_with_argtypes() []IFunction_with_argtypesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + len++ + } + } + + tst := make([]IFunction_with_argtypesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_with_argtypesContext); ok { + tst[i] = t.(IFunction_with_argtypesContext) + i++ + } + } + + return tst +} + +func (s *Transform_element_listContext) Function_with_argtypes(i int) IFunction_with_argtypesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *Transform_element_listContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Transform_element_listContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Transform_element_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transform_element_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transform_element_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransform_element_list(s) + } +} + +func (s *Transform_element_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransform_element_list(s) + } +} + +func (s *Transform_element_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransform_element_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transform_element_list() (localctx ITransform_element_listContext) { + localctx = NewTransform_element_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 926, RedshiftParserRULE_transform_element_list) + p.SetState(8239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 681, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8205) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8206) + p.Match(RedshiftParserSQL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8207) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8208) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8209) + p.Function_with_argtypes() + } + { + p.SetState(8210) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8211) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8212) + p.Match(RedshiftParserSQL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8213) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8214) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8215) + p.Function_with_argtypes() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8217) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8218) + p.Match(RedshiftParserSQL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8219) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8220) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8221) + p.Function_with_argtypes() + } + { + p.SetState(8222) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8223) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8224) + p.Match(RedshiftParserSQL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8225) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8226) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8227) + p.Function_with_argtypes() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8229) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8230) + p.Match(RedshiftParserSQL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8231) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8232) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8233) + p.Function_with_argtypes() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8234) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8235) + p.Match(RedshiftParserSQL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8236) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8237) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8238) + p.Function_with_argtypes() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDroptransformstmtContext is an interface to support dynamic dispatch. +type IDroptransformstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + FOR() antlr.TerminalNode + Typename() ITypenameContext + LANGUAGE() antlr.TerminalNode + Name() INameContext + Opt_if_exists() IOpt_if_existsContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsDroptransformstmtContext differentiates from other interfaces. + IsDroptransformstmtContext() +} + +type DroptransformstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDroptransformstmtContext() *DroptransformstmtContext { + var p = new(DroptransformstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droptransformstmt + return p +} + +func InitEmptyDroptransformstmtContext(p *DroptransformstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droptransformstmt +} + +func (*DroptransformstmtContext) IsDroptransformstmtContext() {} + +func NewDroptransformstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroptransformstmtContext { + var p = new(DroptransformstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_droptransformstmt + + return p +} + +func (s *DroptransformstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DroptransformstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DroptransformstmtContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSFORM, 0) +} + +func (s *DroptransformstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *DroptransformstmtContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *DroptransformstmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *DroptransformstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DroptransformstmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DroptransformstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DroptransformstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DroptransformstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DroptransformstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDroptransformstmt(s) + } +} + +func (s *DroptransformstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDroptransformstmt(s) + } +} + +func (s *DroptransformstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDroptransformstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Droptransformstmt() (localctx IDroptransformstmtContext) { + localctx = NewDroptransformstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 928, RedshiftParserRULE_droptransformstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8241) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8242) + p.Match(RedshiftParserTRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIF_P { + { + p.SetState(8243) + p.Opt_if_exists() + } + + } + { + p.SetState(8246) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8247) + p.Typename() + } + { + p.SetState(8248) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8249) + p.Name() + } + p.SetState(8251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8250) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReindexstmtContext is an interface to support dynamic dispatch. +type IReindexstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REINDEX() antlr.TerminalNode + Reindex_target_type() IReindex_target_typeContext + Qualified_name() IQualified_nameContext + Opt_concurrently() IOpt_concurrentlyContext + Reindex_target_multitable() IReindex_target_multitableContext + Name() INameContext + OPEN_PAREN() antlr.TerminalNode + Reindex_option_list() IReindex_option_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsReindexstmtContext differentiates from other interfaces. + IsReindexstmtContext() +} + +type ReindexstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReindexstmtContext() *ReindexstmtContext { + var p = new(ReindexstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindexstmt + return p +} + +func InitEmptyReindexstmtContext(p *ReindexstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindexstmt +} + +func (*ReindexstmtContext) IsReindexstmtContext() {} + +func NewReindexstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReindexstmtContext { + var p = new(ReindexstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reindexstmt + + return p +} + +func (s *ReindexstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ReindexstmtContext) REINDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserREINDEX, 0) +} + +func (s *ReindexstmtContext) Reindex_target_type() IReindex_target_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReindex_target_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReindex_target_typeContext) +} + +func (s *ReindexstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ReindexstmtContext) Opt_concurrently() IOpt_concurrentlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_concurrentlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_concurrentlyContext) +} + +func (s *ReindexstmtContext) Reindex_target_multitable() IReindex_target_multitableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReindex_target_multitableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReindex_target_multitableContext) +} + +func (s *ReindexstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *ReindexstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ReindexstmtContext) Reindex_option_list() IReindex_option_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReindex_option_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReindex_option_listContext) +} + +func (s *ReindexstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ReindexstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ReindexstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ReindexstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReindexstmt(s) + } +} + +func (s *ReindexstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReindexstmt(s) + } +} + +func (s *ReindexstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReindexstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reindexstmt() (localctx IReindexstmtContext) { + localctx = NewReindexstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 930, RedshiftParserRULE_reindexstmt) + var _la int + + p.SetState(8287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 688, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8253) + p.Match(RedshiftParserREINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8254) + p.Reindex_target_type() + } + p.SetState(8256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONCURRENTLY { + { + p.SetState(8255) + p.Opt_concurrently() + } + + } + { + p.SetState(8258) + p.Qualified_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8260) + p.Match(RedshiftParserREINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8261) + p.Reindex_target_multitable() + } + p.SetState(8263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONCURRENTLY { + { + p.SetState(8262) + p.Opt_concurrently() + } + + } + { + p.SetState(8265) + p.Name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8267) + p.Match(RedshiftParserREINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8268) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8269) + p.Reindex_option_list() + } + { + p.SetState(8270) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8271) + p.Reindex_target_type() + } + p.SetState(8273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONCURRENTLY { + { + p.SetState(8272) + p.Opt_concurrently() + } + + } + { + p.SetState(8275) + p.Qualified_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8277) + p.Match(RedshiftParserREINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8278) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8279) + p.Reindex_option_list() + } + { + p.SetState(8280) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8281) + p.Reindex_target_multitable() + } + p.SetState(8283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONCURRENTLY { + { + p.SetState(8282) + p.Opt_concurrently() + } + + } + { + p.SetState(8285) + p.Name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReindex_target_typeContext is an interface to support dynamic dispatch. +type IReindex_target_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEX() antlr.TerminalNode + TABLE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SYSTEM_P() antlr.TerminalNode + + // IsReindex_target_typeContext differentiates from other interfaces. + IsReindex_target_typeContext() +} + +type Reindex_target_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReindex_target_typeContext() *Reindex_target_typeContext { + var p = new(Reindex_target_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_target_type + return p +} + +func InitEmptyReindex_target_typeContext(p *Reindex_target_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_target_type +} + +func (*Reindex_target_typeContext) IsReindex_target_typeContext() {} + +func NewReindex_target_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_target_typeContext { + var p = new(Reindex_target_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reindex_target_type + + return p +} + +func (s *Reindex_target_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reindex_target_typeContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *Reindex_target_typeContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Reindex_target_typeContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Reindex_target_typeContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Reindex_target_typeContext) SYSTEM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSTEM_P, 0) +} + +func (s *Reindex_target_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reindex_target_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reindex_target_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReindex_target_type(s) + } +} + +func (s *Reindex_target_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReindex_target_type(s) + } +} + +func (s *Reindex_target_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReindex_target_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reindex_target_type() (localctx IReindex_target_typeContext) { + localctx = NewReindex_target_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 932, RedshiftParserRULE_reindex_target_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8289) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTABLE || _la == RedshiftParserDATABASE || _la == RedshiftParserINDEX || _la == RedshiftParserSCHEMA || _la == RedshiftParserSYSTEM_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReindex_target_multitableContext is an interface to support dynamic dispatch. +type IReindex_target_multitableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCHEMA() antlr.TerminalNode + SYSTEM_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + + // IsReindex_target_multitableContext differentiates from other interfaces. + IsReindex_target_multitableContext() +} + +type Reindex_target_multitableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReindex_target_multitableContext() *Reindex_target_multitableContext { + var p = new(Reindex_target_multitableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_target_multitable + return p +} + +func InitEmptyReindex_target_multitableContext(p *Reindex_target_multitableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_target_multitable +} + +func (*Reindex_target_multitableContext) IsReindex_target_multitableContext() {} + +func NewReindex_target_multitableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_target_multitableContext { + var p = new(Reindex_target_multitableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reindex_target_multitable + + return p +} + +func (s *Reindex_target_multitableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reindex_target_multitableContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Reindex_target_multitableContext) SYSTEM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSTEM_P, 0) +} + +func (s *Reindex_target_multitableContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Reindex_target_multitableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reindex_target_multitableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reindex_target_multitableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReindex_target_multitable(s) + } +} + +func (s *Reindex_target_multitableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReindex_target_multitable(s) + } +} + +func (s *Reindex_target_multitableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReindex_target_multitable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reindex_target_multitable() (localctx IReindex_target_multitableContext) { + localctx = NewReindex_target_multitableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 934, RedshiftParserRULE_reindex_target_multitable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8291) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserDATABASE || _la == RedshiftParserSCHEMA || _la == RedshiftParserSYSTEM_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReindex_option_listContext is an interface to support dynamic dispatch. +type IReindex_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllReindex_option_elem() []IReindex_option_elemContext + Reindex_option_elem(i int) IReindex_option_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReindex_option_listContext differentiates from other interfaces. + IsReindex_option_listContext() +} + +type Reindex_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReindex_option_listContext() *Reindex_option_listContext { + var p = new(Reindex_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_option_list + return p +} + +func InitEmptyReindex_option_listContext(p *Reindex_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_option_list +} + +func (*Reindex_option_listContext) IsReindex_option_listContext() {} + +func NewReindex_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_option_listContext { + var p = new(Reindex_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reindex_option_list + + return p +} + +func (s *Reindex_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reindex_option_listContext) AllReindex_option_elem() []IReindex_option_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReindex_option_elemContext); ok { + len++ + } + } + + tst := make([]IReindex_option_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReindex_option_elemContext); ok { + tst[i] = t.(IReindex_option_elemContext) + i++ + } + } + + return tst +} + +func (s *Reindex_option_listContext) Reindex_option_elem(i int) IReindex_option_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReindex_option_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReindex_option_elemContext) +} + +func (s *Reindex_option_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Reindex_option_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Reindex_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reindex_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reindex_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReindex_option_list(s) + } +} + +func (s *Reindex_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReindex_option_list(s) + } +} + +func (s *Reindex_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReindex_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reindex_option_list() (localctx IReindex_option_listContext) { + localctx = NewReindex_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 936, RedshiftParserRULE_reindex_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8293) + p.Reindex_option_elem() + } + p.SetState(8298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(8294) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8295) + p.Reindex_option_elem() + } + + p.SetState(8300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReindex_option_elemContext is an interface to support dynamic dispatch. +type IReindex_option_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERBOSE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + CONCURRENTLY() antlr.TerminalNode + + // IsReindex_option_elemContext differentiates from other interfaces. + IsReindex_option_elemContext() +} + +type Reindex_option_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReindex_option_elemContext() *Reindex_option_elemContext { + var p = new(Reindex_option_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_option_elem + return p +} + +func InitEmptyReindex_option_elemContext(p *Reindex_option_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reindex_option_elem +} + +func (*Reindex_option_elemContext) IsReindex_option_elemContext() {} + +func NewReindex_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reindex_option_elemContext { + var p = new(Reindex_option_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reindex_option_elem + + return p +} + +func (s *Reindex_option_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reindex_option_elemContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERBOSE, 0) +} + +func (s *Reindex_option_elemContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *Reindex_option_elemContext) CONCURRENTLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONCURRENTLY, 0) +} + +func (s *Reindex_option_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reindex_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reindex_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReindex_option_elem(s) + } +} + +func (s *Reindex_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReindex_option_elem(s) + } +} + +func (s *Reindex_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReindex_option_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reindex_option_elem() (localctx IReindex_option_elemContext) { + localctx = NewReindex_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 938, RedshiftParserRULE_reindex_option_elem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8301) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCONCURRENTLY || _la == RedshiftParserVERBOSE || _la == RedshiftParserTABLESPACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltertblspcstmtContext is an interface to support dynamic dispatch. +type IAltertblspcstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Name() INameContext + SET() antlr.TerminalNode + Reloptions() IReloptionsContext + RESET() antlr.TerminalNode + + // IsAltertblspcstmtContext differentiates from other interfaces. + IsAltertblspcstmtContext() +} + +type AltertblspcstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltertblspcstmtContext() *AltertblspcstmtContext { + var p = new(AltertblspcstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertblspcstmt + return p +} + +func InitEmptyAltertblspcstmtContext(p *AltertblspcstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertblspcstmt +} + +func (*AltertblspcstmtContext) IsAltertblspcstmtContext() {} + +func NewAltertblspcstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertblspcstmtContext { + var p = new(AltertblspcstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altertblspcstmt + + return p +} + +func (s *AltertblspcstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltertblspcstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltertblspcstmtContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *AltertblspcstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AltertblspcstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AltertblspcstmtContext) Reloptions() IReloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReloptionsContext) +} + +func (s *AltertblspcstmtContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *AltertblspcstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltertblspcstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltertblspcstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltertblspcstmt(s) + } +} + +func (s *AltertblspcstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltertblspcstmt(s) + } +} + +func (s *AltertblspcstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltertblspcstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altertblspcstmt() (localctx IAltertblspcstmtContext) { + localctx = NewAltertblspcstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 940, RedshiftParserRULE_altertblspcstmt) + p.SetState(8315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 690, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8303) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8304) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8305) + p.Name() + } + { + p.SetState(8306) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8307) + p.Reloptions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8309) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8310) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8311) + p.Name() + } + { + p.SetState(8312) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8313) + p.Reloptions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRenamestmtContext is an interface to support dynamic dispatch. +type IRenamestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + Aggregate_with_argtypes() IAggregate_with_argtypesContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + AllName() []INameContext + Name(i int) INameContext + COLLATION() antlr.TerminalNode + Any_name() IAny_nameContext + CONVERSION_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + DOMAIN_P() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + DATA_P() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + GROUP_P() antlr.TerminalNode + AllRoleid() []IRoleidContext + Roleid(i int) IRoleidContext + LANGUAGE() antlr.TerminalNode + Opt_procedural() IOpt_proceduralContext + OPERATOR() antlr.TerminalNode + CLASS() antlr.TerminalNode + USING() antlr.TerminalNode + FAMILY() antlr.TerminalNode + POLICY() antlr.TerminalNode + ON() antlr.TerminalNode + Qualified_name() IQualified_nameContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PUBLICATION() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SERVER() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + TABLE() antlr.TerminalNode + Relation_expr() IRelation_exprContext + SEQUENCE() antlr.TerminalNode + VIEW() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + INDEX() antlr.TerminalNode + Opt_column() IOpt_columnContext + RULE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + EVENT() antlr.TerminalNode + ROLE() antlr.TerminalNode + USER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + TEXT_P() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PARSER() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsRenamestmtContext differentiates from other interfaces. + IsRenamestmtContext() +} + +type RenamestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRenamestmtContext() *RenamestmtContext { + var p = new(RenamestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_renamestmt + return p +} + +func InitEmptyRenamestmtContext(p *RenamestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_renamestmt +} + +func (*RenamestmtContext) IsRenamestmtContext() {} + +func NewRenamestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RenamestmtContext { + var p = new(RenamestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_renamestmt + + return p +} + +func (s *RenamestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RenamestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *RenamestmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *RenamestmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypesContext) +} + +func (s *RenamestmtContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *RenamestmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *RenamestmtContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *RenamestmtContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *RenamestmtContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *RenamestmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *RenamestmtContext) CONVERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONVERSION_P, 0) +} + +func (s *RenamestmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *RenamestmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *RenamestmtContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *RenamestmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *RenamestmtContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *RenamestmtContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *RenamestmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *RenamestmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *RenamestmtContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *RenamestmtContext) AllRoleid() []IRoleidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRoleidContext); ok { + len++ + } + } + + tst := make([]IRoleidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRoleidContext); ok { + tst[i] = t.(IRoleidContext) + i++ + } + } + + return tst +} + +func (s *RenamestmtContext) Roleid(i int) IRoleidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoleidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRoleidContext) +} + +func (s *RenamestmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *RenamestmtContext) Opt_procedural() IOpt_proceduralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_proceduralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_proceduralContext) +} + +func (s *RenamestmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *RenamestmtContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *RenamestmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *RenamestmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *RenamestmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *RenamestmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *RenamestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *RenamestmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *RenamestmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *RenamestmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *RenamestmtContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *RenamestmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *RenamestmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *RenamestmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *RenamestmtContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSCRIPTION, 0) +} + +func (s *RenamestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *RenamestmtContext) Relation_expr() IRelation_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *RenamestmtContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *RenamestmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *RenamestmtContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *RenamestmtContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *RenamestmtContext) Opt_column() IOpt_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_columnContext) +} + +func (s *RenamestmtContext) RULE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRULE, 0) +} + +func (s *RenamestmtContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *RenamestmtContext) EVENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVENT, 0) +} + +func (s *RenamestmtContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *RenamestmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *RenamestmtContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *RenamestmtContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *RenamestmtContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *RenamestmtContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *RenamestmtContext) PARSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARSER, 0) +} + +func (s *RenamestmtContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDICTIONARY, 0) +} + +func (s *RenamestmtContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPLATE, 0) +} + +func (s *RenamestmtContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFIGURATION, 0) +} + +func (s *RenamestmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *RenamestmtContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTRIBUTE, 0) +} + +func (s *RenamestmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *RenamestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RenamestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RenamestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRenamestmt(s) + } +} + +func (s *RenamestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRenamestmt(s) + } +} + +func (s *RenamestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRenamestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Renamestmt() (localctx IRenamestmtContext) { + localctx = NewRenamestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 942, RedshiftParserRULE_renamestmt) + var _la int + + p.SetState(8804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 701, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8317) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8318) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8319) + p.Aggregate_with_argtypes() + } + { + p.SetState(8320) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8321) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8322) + p.Name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8324) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8325) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8326) + p.Any_name() + } + { + p.SetState(8327) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8328) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8329) + p.Name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8331) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8332) + p.Match(RedshiftParserCONVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8333) + p.Any_name() + } + { + p.SetState(8334) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8335) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8336) + p.Name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8338) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8339) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8340) + p.Name() + } + { + p.SetState(8341) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8342) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8343) + p.Name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8345) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8346) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8347) + p.Any_name() + } + { + p.SetState(8348) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8349) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8350) + p.Name() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8352) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8353) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8354) + p.Any_name() + } + { + p.SetState(8355) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8356) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8357) + p.Name() + } + { + p.SetState(8358) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8359) + p.Name() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8361) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8362) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8363) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8364) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8365) + p.Name() + } + { + p.SetState(8366) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8367) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8368) + p.Name() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8370) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8371) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8372) + p.Function_with_argtypes() + } + { + p.SetState(8373) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8374) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8375) + p.Name() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(8377) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8378) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8379) + p.Roleid() + } + { + p.SetState(8380) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8381) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8382) + p.Roleid() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(8384) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROCEDURAL { + { + p.SetState(8385) + p.Opt_procedural() + } + + } + { + p.SetState(8388) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8389) + p.Name() + } + { + p.SetState(8390) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8391) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8392) + p.Name() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(8394) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8395) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8396) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8397) + p.Any_name() + } + { + p.SetState(8398) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8399) + p.Name() + } + { + p.SetState(8400) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8401) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8402) + p.Name() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(8404) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8405) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8406) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8407) + p.Any_name() + } + { + p.SetState(8408) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8409) + p.Name() + } + { + p.SetState(8410) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8411) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8412) + p.Name() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(8414) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8415) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8416) + p.Name() + } + { + p.SetState(8417) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8418) + p.Qualified_name() + } + { + p.SetState(8419) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8420) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8421) + p.Name() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(8423) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8424) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8425) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8426) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8427) + p.Name() + } + { + p.SetState(8428) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8429) + p.Qualified_name() + } + { + p.SetState(8430) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8431) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8432) + p.Name() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(8434) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8435) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8436) + p.Function_with_argtypes() + } + { + p.SetState(8437) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8438) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8439) + p.Name() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(8441) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8442) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8443) + p.Name() + } + { + p.SetState(8444) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8445) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8446) + p.Name() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(8448) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8449) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8450) + p.Function_with_argtypes() + } + { + p.SetState(8451) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8452) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8453) + p.Name() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(8455) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8456) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8457) + p.Name() + } + { + p.SetState(8458) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8459) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8460) + p.Name() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(8462) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8463) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8464) + p.Name() + } + { + p.SetState(8465) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8466) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8467) + p.Name() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(8469) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8470) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8471) + p.Name() + } + { + p.SetState(8472) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8473) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8474) + p.Name() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(8476) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8477) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8478) + p.Relation_expr() + } + { + p.SetState(8479) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8480) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8481) + p.Name() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(8483) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8484) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8485) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8486) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8487) + p.Relation_expr() + } + { + p.SetState(8488) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8489) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8490) + p.Name() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(8492) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8493) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8494) + p.Qualified_name() + } + { + p.SetState(8495) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8496) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8497) + p.Name() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(8499) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8500) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8501) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8502) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8503) + p.Qualified_name() + } + { + p.SetState(8504) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8505) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8506) + p.Name() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(8508) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8509) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8510) + p.Qualified_name() + } + { + p.SetState(8511) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8512) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8513) + p.Name() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(8515) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8516) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8517) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8518) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8519) + p.Qualified_name() + } + { + p.SetState(8520) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8521) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8522) + p.Name() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(8524) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8525) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8526) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8527) + p.Qualified_name() + } + { + p.SetState(8528) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8529) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8530) + p.Name() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(8532) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8533) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8534) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8535) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8536) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8537) + p.Qualified_name() + } + { + p.SetState(8538) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8539) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8540) + p.Name() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(8542) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8543) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8544) + p.Qualified_name() + } + { + p.SetState(8545) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8546) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8547) + p.Name() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(8549) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8550) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8551) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8552) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8553) + p.Qualified_name() + } + { + p.SetState(8554) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8555) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8556) + p.Name() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(8558) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8559) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8560) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8561) + p.Relation_expr() + } + { + p.SetState(8562) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8563) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8564) + p.Name() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(8566) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8567) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8568) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8569) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8570) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8571) + p.Relation_expr() + } + { + p.SetState(8572) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8573) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8574) + p.Name() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(8576) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8577) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8578) + p.Relation_expr() + } + { + p.SetState(8579) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8581) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 692, p.GetParserRuleContext()) == 1 { + { + p.SetState(8580) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8583) + p.Name() + } + { + p.SetState(8584) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8585) + p.Name() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(8587) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8588) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8589) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8590) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8591) + p.Relation_expr() + } + { + p.SetState(8592) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8594) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 693, p.GetParserRuleContext()) == 1 { + { + p.SetState(8593) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8596) + p.Name() + } + { + p.SetState(8597) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8598) + p.Name() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(8600) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8601) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8602) + p.Qualified_name() + } + { + p.SetState(8603) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8605) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 694, p.GetParserRuleContext()) == 1 { + { + p.SetState(8604) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8607) + p.Name() + } + { + p.SetState(8608) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8609) + p.Name() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(8611) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8612) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8613) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8614) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8615) + p.Qualified_name() + } + { + p.SetState(8616) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8618) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 695, p.GetParserRuleContext()) == 1 { + { + p.SetState(8617) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8620) + p.Name() + } + { + p.SetState(8621) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8622) + p.Name() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(8624) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8625) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8626) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8627) + p.Qualified_name() + } + { + p.SetState(8628) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8630) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 696, p.GetParserRuleContext()) == 1 { + { + p.SetState(8629) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8632) + p.Name() + } + { + p.SetState(8633) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8634) + p.Name() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(8636) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8637) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8638) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8639) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8640) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8641) + p.Qualified_name() + } + { + p.SetState(8642) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8644) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 697, p.GetParserRuleContext()) == 1 { + { + p.SetState(8643) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8646) + p.Name() + } + { + p.SetState(8647) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8648) + p.Name() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(8650) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8651) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8652) + p.Relation_expr() + } + { + p.SetState(8653) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8654) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8655) + p.Name() + } + { + p.SetState(8656) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8657) + p.Name() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(8659) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8660) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8661) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8662) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8663) + p.Relation_expr() + } + { + p.SetState(8664) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8665) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8666) + p.Name() + } + { + p.SetState(8667) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8668) + p.Name() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(8670) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8671) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8672) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8673) + p.Relation_expr() + } + { + p.SetState(8674) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8676) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 698, p.GetParserRuleContext()) == 1 { + { + p.SetState(8675) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8678) + p.Name() + } + { + p.SetState(8679) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8680) + p.Name() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(8682) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8683) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8684) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8685) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8686) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8687) + p.Relation_expr() + } + { + p.SetState(8688) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 699, p.GetParserRuleContext()) == 1 { + { + p.SetState(8689) + p.Opt_column() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8692) + p.Name() + } + { + p.SetState(8693) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8694) + p.Name() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(8696) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8697) + p.Match(RedshiftParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8698) + p.Name() + } + { + p.SetState(8699) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8700) + p.Qualified_name() + } + { + p.SetState(8701) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8702) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8703) + p.Name() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(8705) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8706) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8707) + p.Name() + } + { + p.SetState(8708) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8709) + p.Qualified_name() + } + { + p.SetState(8710) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8711) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8712) + p.Name() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(8714) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8715) + p.Match(RedshiftParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8716) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8717) + p.Name() + } + { + p.SetState(8718) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8719) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8720) + p.Name() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(8722) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8723) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8724) + p.Roleid() + } + { + p.SetState(8725) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8726) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8727) + p.Roleid() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(8729) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8730) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8731) + p.Roleid() + } + { + p.SetState(8732) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8733) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8734) + p.Roleid() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(8736) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8737) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8738) + p.Name() + } + { + p.SetState(8739) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8740) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8741) + p.Name() + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(8743) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8744) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8745) + p.Any_name() + } + { + p.SetState(8746) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8747) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8748) + p.Name() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(8750) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8751) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8752) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8753) + p.Match(RedshiftParserPARSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8754) + p.Any_name() + } + { + p.SetState(8755) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8756) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8757) + p.Name() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(8759) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8760) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8761) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8762) + p.Match(RedshiftParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8763) + p.Any_name() + } + { + p.SetState(8764) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8765) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8766) + p.Name() + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(8768) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8769) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8770) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8771) + p.Match(RedshiftParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8772) + p.Any_name() + } + { + p.SetState(8773) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8774) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8775) + p.Name() + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(8777) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8778) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8779) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8780) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8781) + p.Any_name() + } + { + p.SetState(8782) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8783) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8784) + p.Name() + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(8786) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8787) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8788) + p.Any_name() + } + { + p.SetState(8789) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8790) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8791) + p.Name() + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(8793) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8794) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8795) + p.Any_name() + } + { + p.SetState(8796) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8797) + p.Match(RedshiftParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8798) + p.Name() + } + { + p.SetState(8799) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8800) + p.Name() + } + p.SetState(8802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(8801) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_columnContext is an interface to support dynamic dispatch. +type IOpt_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMN() antlr.TerminalNode + + // IsOpt_columnContext differentiates from other interfaces. + IsOpt_columnContext() +} + +type Opt_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_columnContext() *Opt_columnContext { + var p = new(Opt_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_column + return p +} + +func InitEmptyOpt_columnContext(p *Opt_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_column +} + +func (*Opt_columnContext) IsOpt_columnContext() {} + +func NewOpt_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_columnContext { + var p = new(Opt_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_column + + return p +} + +func (s *Opt_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_columnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMN, 0) +} + +func (s *Opt_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_column(s) + } +} + +func (s *Opt_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_column(s) + } +} + +func (s *Opt_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_column() (localctx IOpt_columnContext) { + localctx = NewOpt_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 944, RedshiftParserRULE_opt_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8806) + p.Match(RedshiftParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_set_dataContext is an interface to support dynamic dispatch. +type IOpt_set_dataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + DATA_P() antlr.TerminalNode + + // IsOpt_set_dataContext differentiates from other interfaces. + IsOpt_set_dataContext() +} + +type Opt_set_dataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_set_dataContext() *Opt_set_dataContext { + var p = new(Opt_set_dataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_set_data + return p +} + +func InitEmptyOpt_set_dataContext(p *Opt_set_dataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_set_data +} + +func (*Opt_set_dataContext) IsOpt_set_dataContext() {} + +func NewOpt_set_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_set_dataContext { + var p = new(Opt_set_dataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_set_data + + return p +} + +func (s *Opt_set_dataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_set_dataContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Opt_set_dataContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *Opt_set_dataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_set_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_set_dataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_set_data(s) + } +} + +func (s *Opt_set_dataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_set_data(s) + } +} + +func (s *Opt_set_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_set_data(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_set_data() (localctx IOpt_set_dataContext) { + localctx = NewOpt_set_dataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 946, RedshiftParserRULE_opt_set_data) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8808) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8809) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterobjectdependsstmtContext is an interface to support dynamic dispatch. +type IAlterobjectdependsstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + DEPENDS() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + EXTENSION() antlr.TerminalNode + AllName() []INameContext + Name(i int) INameContext + Opt_no() IOpt_noContext + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Qualified_name() IQualified_nameContext + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + INDEX() antlr.TerminalNode + + // IsAlterobjectdependsstmtContext differentiates from other interfaces. + IsAlterobjectdependsstmtContext() +} + +type AlterobjectdependsstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterobjectdependsstmtContext() *AlterobjectdependsstmtContext { + var p = new(AlterobjectdependsstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterobjectdependsstmt + return p +} + +func InitEmptyAlterobjectdependsstmtContext(p *AlterobjectdependsstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterobjectdependsstmt +} + +func (*AlterobjectdependsstmtContext) IsAlterobjectdependsstmtContext() {} + +func NewAlterobjectdependsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterobjectdependsstmtContext { + var p = new(AlterobjectdependsstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterobjectdependsstmt + + return p +} + +func (s *AlterobjectdependsstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterobjectdependsstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterobjectdependsstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *AlterobjectdependsstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *AlterobjectdependsstmtContext) DEPENDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEPENDS, 0) +} + +func (s *AlterobjectdependsstmtContext) AllON() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserON) +} + +func (s *AlterobjectdependsstmtContext) ON(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserON, i) +} + +func (s *AlterobjectdependsstmtContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *AlterobjectdependsstmtContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *AlterobjectdependsstmtContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterobjectdependsstmtContext) Opt_no() IOpt_noContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_noContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_noContext) +} + +func (s *AlterobjectdependsstmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *AlterobjectdependsstmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *AlterobjectdependsstmtContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *AlterobjectdependsstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AlterobjectdependsstmtContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *AlterobjectdependsstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *AlterobjectdependsstmtContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *AlterobjectdependsstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterobjectdependsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterobjectdependsstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterobjectdependsstmt(s) + } +} + +func (s *AlterobjectdependsstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterobjectdependsstmt(s) + } +} + +func (s *AlterobjectdependsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterobjectdependsstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterobjectdependsstmt() (localctx IAlterobjectdependsstmtContext) { + localctx = NewAlterobjectdependsstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 948, RedshiftParserRULE_alterobjectdependsstmt) + var _la int + + p.SetState(8880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 708, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8811) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8812) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8813) + p.Function_with_argtypes() + } + p.SetState(8815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(8814) + p.Opt_no() + } + + } + { + p.SetState(8817) + p.Match(RedshiftParserDEPENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8818) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8819) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8820) + p.Name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8822) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8823) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8824) + p.Function_with_argtypes() + } + p.SetState(8826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(8825) + p.Opt_no() + } + + } + { + p.SetState(8828) + p.Match(RedshiftParserDEPENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8829) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8830) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8831) + p.Name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8833) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8834) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8835) + p.Function_with_argtypes() + } + p.SetState(8837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(8836) + p.Opt_no() + } + + } + { + p.SetState(8839) + p.Match(RedshiftParserDEPENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8840) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8841) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8842) + p.Name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8844) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8845) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8846) + p.Name() + } + { + p.SetState(8847) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8848) + p.Qualified_name() + } + p.SetState(8850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(8849) + p.Opt_no() + } + + } + { + p.SetState(8852) + p.Match(RedshiftParserDEPENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8853) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8854) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8855) + p.Name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8857) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8858) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8859) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8860) + p.Qualified_name() + } + p.SetState(8862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(8861) + p.Opt_no() + } + + } + { + p.SetState(8864) + p.Match(RedshiftParserDEPENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8865) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8866) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8867) + p.Name() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8869) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8870) + p.Match(RedshiftParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8871) + p.Qualified_name() + } + p.SetState(8873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(8872) + p.Opt_no() + } + + } + { + p.SetState(8875) + p.Match(RedshiftParserDEPENDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8876) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8877) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8878) + p.Name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_noContext is an interface to support dynamic dispatch. +type IOpt_noContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + + // IsOpt_noContext differentiates from other interfaces. + IsOpt_noContext() +} + +type Opt_noContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_noContext() *Opt_noContext { + var p = new(Opt_noContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_no + return p +} + +func InitEmptyOpt_noContext(p *Opt_noContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_no +} + +func (*Opt_noContext) IsOpt_noContext() {} + +func NewOpt_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_noContext { + var p = new(Opt_noContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_no + + return p +} + +func (s *Opt_noContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_noContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_noContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_noContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_no(s) + } +} + +func (s *Opt_noContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_no(s) + } +} + +func (s *Opt_noContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_no(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_no() (localctx IOpt_noContext) { + localctx = NewOpt_noContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 950, RedshiftParserRULE_opt_no) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8882) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterobjectschemastmtContext is an interface to support dynamic dispatch. +type IAlterobjectschemastmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + Aggregate_with_argtypes() IAggregate_with_argtypesContext + SET() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AllName() []INameContext + Name(i int) INameContext + COLLATION() antlr.TerminalNode + Any_name() IAny_nameContext + CONVERSION_P() antlr.TerminalNode + DOMAIN_P() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + OPERATOR() antlr.TerminalNode + Operator_with_argtypes() IOperator_with_argtypesContext + CLASS() antlr.TerminalNode + USING() antlr.TerminalNode + FAMILY() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Relation_expr() IRelation_exprContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + TEXT_P() antlr.TerminalNode + SEARCH() antlr.TerminalNode + PARSER() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + VIEW() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + + // IsAlterobjectschemastmtContext differentiates from other interfaces. + IsAlterobjectschemastmtContext() +} + +type AlterobjectschemastmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterobjectschemastmtContext() *AlterobjectschemastmtContext { + var p = new(AlterobjectschemastmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterobjectschemastmt + return p +} + +func InitEmptyAlterobjectschemastmtContext(p *AlterobjectschemastmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterobjectschemastmt +} + +func (*AlterobjectschemastmtContext) IsAlterobjectschemastmtContext() {} + +func NewAlterobjectschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterobjectschemastmtContext { + var p = new(AlterobjectschemastmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterobjectschemastmt + + return p +} + +func (s *AlterobjectschemastmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterobjectschemastmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterobjectschemastmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *AlterobjectschemastmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypesContext) +} + +func (s *AlterobjectschemastmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlterobjectschemastmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *AlterobjectschemastmtContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *AlterobjectschemastmtContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterobjectschemastmtContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *AlterobjectschemastmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AlterobjectschemastmtContext) CONVERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONVERSION_P, 0) +} + +func (s *AlterobjectschemastmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *AlterobjectschemastmtContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *AlterobjectschemastmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *AlterobjectschemastmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *AlterobjectschemastmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *AlterobjectschemastmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypesContext) +} + +func (s *AlterobjectschemastmtContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *AlterobjectschemastmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *AlterobjectschemastmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *AlterobjectschemastmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *AlterobjectschemastmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *AlterobjectschemastmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *AlterobjectschemastmtContext) Relation_expr() IRelation_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *AlterobjectschemastmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *AlterobjectschemastmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *AlterobjectschemastmtContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *AlterobjectschemastmtContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *AlterobjectschemastmtContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *AlterobjectschemastmtContext) PARSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARSER, 0) +} + +func (s *AlterobjectschemastmtContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDICTIONARY, 0) +} + +func (s *AlterobjectschemastmtContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPLATE, 0) +} + +func (s *AlterobjectschemastmtContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFIGURATION, 0) +} + +func (s *AlterobjectschemastmtContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *AlterobjectschemastmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AlterobjectschemastmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *AlterobjectschemastmtContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *AlterobjectschemastmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *AlterobjectschemastmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *AlterobjectschemastmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterobjectschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterobjectschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterobjectschemastmt(s) + } +} + +func (s *AlterobjectschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterobjectschemastmt(s) + } +} + +func (s *AlterobjectschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterobjectschemastmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterobjectschemastmt() (localctx IAlterobjectschemastmtContext) { + localctx = NewAlterobjectschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 952, RedshiftParserRULE_alterobjectschemastmt) + p.SetState(9101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 709, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8884) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8885) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8886) + p.Aggregate_with_argtypes() + } + { + p.SetState(8887) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8888) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8889) + p.Name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8891) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8892) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8893) + p.Any_name() + } + { + p.SetState(8894) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8895) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8896) + p.Name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8898) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8899) + p.Match(RedshiftParserCONVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8900) + p.Any_name() + } + { + p.SetState(8901) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8902) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8903) + p.Name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8905) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8906) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8907) + p.Any_name() + } + { + p.SetState(8908) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8909) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8910) + p.Name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8912) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8913) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8914) + p.Name() + } + { + p.SetState(8915) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8916) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8917) + p.Name() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8919) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8920) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8921) + p.Function_with_argtypes() + } + { + p.SetState(8922) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8923) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8924) + p.Name() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8926) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8927) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8928) + p.Operator_with_argtypes() + } + { + p.SetState(8929) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8930) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8931) + p.Name() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8933) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8934) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8935) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8936) + p.Any_name() + } + { + p.SetState(8937) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8938) + p.Name() + } + { + p.SetState(8939) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8940) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8941) + p.Name() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(8943) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8944) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8945) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8946) + p.Any_name() + } + { + p.SetState(8947) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8948) + p.Name() + } + { + p.SetState(8949) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8950) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8951) + p.Name() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(8953) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8954) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8955) + p.Function_with_argtypes() + } + { + p.SetState(8956) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8957) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8958) + p.Name() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(8960) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8961) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8962) + p.Function_with_argtypes() + } + { + p.SetState(8963) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8964) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8965) + p.Name() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(8967) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8968) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8969) + p.Relation_expr() + } + { + p.SetState(8970) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8971) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8972) + p.Name() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(8974) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8975) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8976) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8977) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8978) + p.Relation_expr() + } + { + p.SetState(8979) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8980) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8981) + p.Name() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(8983) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8984) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8985) + p.Any_name() + } + { + p.SetState(8986) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8987) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8988) + p.Name() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(8990) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8991) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8992) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8993) + p.Match(RedshiftParserPARSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8994) + p.Any_name() + } + { + p.SetState(8995) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8996) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8997) + p.Name() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(8999) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9000) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9001) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9002) + p.Match(RedshiftParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9003) + p.Any_name() + } + { + p.SetState(9004) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9005) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9006) + p.Name() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(9008) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9009) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9010) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9011) + p.Match(RedshiftParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9012) + p.Any_name() + } + { + p.SetState(9013) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9014) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9015) + p.Name() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(9017) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9018) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9019) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9020) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9021) + p.Any_name() + } + { + p.SetState(9022) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9023) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9024) + p.Name() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(9026) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9027) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9028) + p.Qualified_name() + } + { + p.SetState(9029) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9030) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9031) + p.Name() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(9033) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9034) + p.Match(RedshiftParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9035) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9036) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9037) + p.Qualified_name() + } + { + p.SetState(9038) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9039) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9040) + p.Name() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(9042) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9043) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9044) + p.Qualified_name() + } + { + p.SetState(9045) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9046) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9047) + p.Name() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(9049) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9050) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9051) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9052) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9053) + p.Qualified_name() + } + { + p.SetState(9054) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9055) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9056) + p.Name() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(9058) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9059) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9060) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9061) + p.Qualified_name() + } + { + p.SetState(9062) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9063) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9064) + p.Name() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(9066) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9067) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9068) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9069) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9070) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9071) + p.Qualified_name() + } + { + p.SetState(9072) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9073) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9074) + p.Name() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(9076) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9077) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9078) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9079) + p.Relation_expr() + } + { + p.SetState(9080) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9081) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9082) + p.Name() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(9084) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9085) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9086) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9087) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9088) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9089) + p.Relation_expr() + } + { + p.SetState(9090) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9091) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9092) + p.Name() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(9094) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9095) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9096) + p.Any_name() + } + { + p.SetState(9097) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9098) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9099) + p.Name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlteroperatorstmtContext is an interface to support dynamic dispatch. +type IAlteroperatorstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_with_argtypes() IOperator_with_argtypesContext + SET() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Operator_def_list() IOperator_def_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsAlteroperatorstmtContext differentiates from other interfaces. + IsAlteroperatorstmtContext() +} + +type AlteroperatorstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlteroperatorstmtContext() *AlteroperatorstmtContext { + var p = new(AlteroperatorstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteroperatorstmt + return p +} + +func InitEmptyAlteroperatorstmtContext(p *AlteroperatorstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteroperatorstmt +} + +func (*AlteroperatorstmtContext) IsAlteroperatorstmtContext() {} + +func NewAlteroperatorstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteroperatorstmtContext { + var p = new(AlteroperatorstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteroperatorstmt + + return p +} + +func (s *AlteroperatorstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteroperatorstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlteroperatorstmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *AlteroperatorstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypesContext) +} + +func (s *AlteroperatorstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlteroperatorstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AlteroperatorstmtContext) Operator_def_list() IOperator_def_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_def_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_def_listContext) +} + +func (s *AlteroperatorstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AlteroperatorstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteroperatorstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteroperatorstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteroperatorstmt(s) + } +} + +func (s *AlteroperatorstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteroperatorstmt(s) + } +} + +func (s *AlteroperatorstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteroperatorstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteroperatorstmt() (localctx IAlteroperatorstmtContext) { + localctx = NewAlteroperatorstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 954, RedshiftParserRULE_alteroperatorstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9103) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9104) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9105) + p.Operator_with_argtypes() + } + { + p.SetState(9106) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9107) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9108) + p.Operator_def_list() + } + { + p.SetState(9109) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_def_listContext is an interface to support dynamic dispatch. +type IOperator_def_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOperator_def_elem() []IOperator_def_elemContext + Operator_def_elem(i int) IOperator_def_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOperator_def_listContext differentiates from other interfaces. + IsOperator_def_listContext() +} + +type Operator_def_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_def_listContext() *Operator_def_listContext { + var p = new(Operator_def_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_def_list + return p +} + +func InitEmptyOperator_def_listContext(p *Operator_def_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_def_list +} + +func (*Operator_def_listContext) IsOperator_def_listContext() {} + +func NewOperator_def_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_listContext { + var p = new(Operator_def_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_operator_def_list + + return p +} + +func (s *Operator_def_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_def_listContext) AllOperator_def_elem() []IOperator_def_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOperator_def_elemContext); ok { + len++ + } + } + + tst := make([]IOperator_def_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOperator_def_elemContext); ok { + tst[i] = t.(IOperator_def_elemContext) + i++ + } + } + + return tst +} + +func (s *Operator_def_listContext) Operator_def_elem(i int) IOperator_def_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_def_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOperator_def_elemContext) +} + +func (s *Operator_def_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Operator_def_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Operator_def_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_def_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOperator_def_list(s) + } +} + +func (s *Operator_def_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOperator_def_list(s) + } +} + +func (s *Operator_def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOperator_def_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Operator_def_list() (localctx IOperator_def_listContext) { + localctx = NewOperator_def_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 956, RedshiftParserRULE_operator_def_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9111) + p.Operator_def_elem() + } + p.SetState(9116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(9112) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9113) + p.Operator_def_elem() + } + + p.SetState(9118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_def_elemContext is an interface to support dynamic dispatch. +type IOperator_def_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Collabel() ICollabelContext + EQUAL() antlr.TerminalNode + NONE() antlr.TerminalNode + Operator_def_arg() IOperator_def_argContext + + // IsOperator_def_elemContext differentiates from other interfaces. + IsOperator_def_elemContext() +} + +type Operator_def_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_def_elemContext() *Operator_def_elemContext { + var p = new(Operator_def_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_def_elem + return p +} + +func InitEmptyOperator_def_elemContext(p *Operator_def_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_def_elem +} + +func (*Operator_def_elemContext) IsOperator_def_elemContext() {} + +func NewOperator_def_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_elemContext { + var p = new(Operator_def_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_operator_def_elem + + return p +} + +func (s *Operator_def_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_def_elemContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Operator_def_elemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Operator_def_elemContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *Operator_def_elemContext) Operator_def_arg() IOperator_def_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_def_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_def_argContext) +} + +func (s *Operator_def_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_def_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_def_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOperator_def_elem(s) + } +} + +func (s *Operator_def_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOperator_def_elem(s) + } +} + +func (s *Operator_def_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOperator_def_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Operator_def_elem() (localctx IOperator_def_elemContext) { + localctx = NewOperator_def_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 958, RedshiftParserRULE_operator_def_elem) + p.SetState(9127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 711, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9119) + p.Collabel() + } + { + p.SetState(9120) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9121) + p.Match(RedshiftParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9123) + p.Collabel() + } + { + p.SetState(9124) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9125) + p.Operator_def_arg() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_def_argContext is an interface to support dynamic dispatch. +type IOperator_def_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_type() IFunc_typeContext + Reserved_keyword() IReserved_keywordContext + Qual_all_op() IQual_all_opContext + Numericonly() INumericonlyContext + Sconst() ISconstContext + + // IsOperator_def_argContext differentiates from other interfaces. + IsOperator_def_argContext() +} + +type Operator_def_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_def_argContext() *Operator_def_argContext { + var p = new(Operator_def_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_def_arg + return p +} + +func InitEmptyOperator_def_argContext(p *Operator_def_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_operator_def_arg +} + +func (*Operator_def_argContext) IsOperator_def_argContext() {} + +func NewOperator_def_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_def_argContext { + var p = new(Operator_def_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_operator_def_arg + + return p +} + +func (s *Operator_def_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_def_argContext) Func_type() IFunc_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_typeContext) +} + +func (s *Operator_def_argContext) Reserved_keyword() IReserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReserved_keywordContext) +} + +func (s *Operator_def_argContext) Qual_all_op() IQual_all_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQual_all_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQual_all_opContext) +} + +func (s *Operator_def_argContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Operator_def_argContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Operator_def_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_def_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_def_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOperator_def_arg(s) + } +} + +func (s *Operator_def_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOperator_def_arg(s) + } +} + +func (s *Operator_def_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOperator_def_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Operator_def_arg() (localctx IOperator_def_argContext) { + localctx = NewOperator_def_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 960, RedshiftParserRULE_operator_def_arg) + p.SetState(9134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 712, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9129) + p.Func_type() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9130) + p.Reserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9131) + p.Qual_all_op() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9132) + p.Numericonly() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9133) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltertypestmtContext is an interface to support dynamic dispatch. +type IAltertypestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + Any_name() IAny_nameContext + SET() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Operator_def_list() IOperator_def_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsAltertypestmtContext differentiates from other interfaces. + IsAltertypestmtContext() +} + +type AltertypestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltertypestmtContext() *AltertypestmtContext { + var p = new(AltertypestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertypestmt + return p +} + +func InitEmptyAltertypestmtContext(p *AltertypestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertypestmt +} + +func (*AltertypestmtContext) IsAltertypestmtContext() {} + +func NewAltertypestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertypestmtContext { + var p = new(AltertypestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altertypestmt + + return p +} + +func (s *AltertypestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltertypestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltertypestmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *AltertypestmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AltertypestmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AltertypestmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AltertypestmtContext) Operator_def_list() IOperator_def_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_def_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_def_listContext) +} + +func (s *AltertypestmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AltertypestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltertypestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltertypestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltertypestmt(s) + } +} + +func (s *AltertypestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltertypestmt(s) + } +} + +func (s *AltertypestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltertypestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altertypestmt() (localctx IAltertypestmtContext) { + localctx = NewAltertypestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 962, RedshiftParserRULE_altertypestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9136) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9137) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9138) + p.Any_name() + } + { + p.SetState(9139) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9140) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9141) + p.Operator_def_list() + } + { + p.SetState(9142) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterownerstmtContext is an interface to support dynamic dispatch. +type IAlterownerstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + Aggregate_with_argtypes() IAggregate_with_argtypesContext + OWNER() antlr.TerminalNode + TO() antlr.TerminalNode + Rolespec() IRolespecContext + COLLATION() antlr.TerminalNode + Any_name() IAny_nameContext + CONVERSION_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Name() INameContext + DOMAIN_P() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_with_argtypes() IFunction_with_argtypesContext + LANGUAGE() antlr.TerminalNode + Opt_procedural() IOpt_proceduralContext + LARGE_P() antlr.TerminalNode + OBJECT_P() antlr.TerminalNode + Numericonly() INumericonlyContext + OPERATOR() antlr.TerminalNode + Operator_with_argtypes() IOperator_with_argtypesContext + CLASS() antlr.TerminalNode + USING() antlr.TerminalNode + FAMILY() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + TEXT_P() antlr.TerminalNode + SEARCH() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + DATA_P() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + SERVER() antlr.TerminalNode + EVENT() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + PUBLICATION() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + + // IsAlterownerstmtContext differentiates from other interfaces. + IsAlterownerstmtContext() +} + +type AlterownerstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterownerstmtContext() *AlterownerstmtContext { + var p = new(AlterownerstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterownerstmt + return p +} + +func InitEmptyAlterownerstmtContext(p *AlterownerstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterownerstmt +} + +func (*AlterownerstmtContext) IsAlterownerstmtContext() {} + +func NewAlterownerstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterownerstmtContext { + var p = new(AlterownerstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterownerstmt + + return p +} + +func (s *AlterownerstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterownerstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterownerstmtContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *AlterownerstmtContext) Aggregate_with_argtypes() IAggregate_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_with_argtypesContext) +} + +func (s *AlterownerstmtContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *AlterownerstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AlterownerstmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *AlterownerstmtContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *AlterownerstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AlterownerstmtContext) CONVERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONVERSION_P, 0) +} + +func (s *AlterownerstmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *AlterownerstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterownerstmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *AlterownerstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *AlterownerstmtContext) Function_with_argtypes() IFunction_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_with_argtypesContext) +} + +func (s *AlterownerstmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *AlterownerstmtContext) Opt_procedural() IOpt_proceduralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_proceduralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_proceduralContext) +} + +func (s *AlterownerstmtContext) LARGE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLARGE_P, 0) +} + +func (s *AlterownerstmtContext) OBJECT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOBJECT_P, 0) +} + +func (s *AlterownerstmtContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *AlterownerstmtContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *AlterownerstmtContext) Operator_with_argtypes() IOperator_with_argtypesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_with_argtypesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_with_argtypesContext) +} + +func (s *AlterownerstmtContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *AlterownerstmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *AlterownerstmtContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *AlterownerstmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *AlterownerstmtContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *AlterownerstmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *AlterownerstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *AlterownerstmtContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *AlterownerstmtContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *AlterownerstmtContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *AlterownerstmtContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *AlterownerstmtContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDICTIONARY, 0) +} + +func (s *AlterownerstmtContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFIGURATION, 0) +} + +func (s *AlterownerstmtContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *AlterownerstmtContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *AlterownerstmtContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *AlterownerstmtContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *AlterownerstmtContext) EVENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVENT, 0) +} + +func (s *AlterownerstmtContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *AlterownerstmtContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *AlterownerstmtContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSCRIPTION, 0) +} + +func (s *AlterownerstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterownerstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterownerstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterownerstmt(s) + } +} + +func (s *AlterownerstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterownerstmt(s) + } +} + +func (s *AlterownerstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterownerstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterownerstmt() (localctx IAlterownerstmtContext) { + localctx = NewAlterownerstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 964, RedshiftParserRULE_alterownerstmt) + var _la int + + p.SetState(9329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 714, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9144) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9145) + p.Match(RedshiftParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9146) + p.Aggregate_with_argtypes() + } + { + p.SetState(9147) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9148) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9149) + p.Rolespec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9151) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9152) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9153) + p.Any_name() + } + { + p.SetState(9154) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9155) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9156) + p.Rolespec() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9158) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9159) + p.Match(RedshiftParserCONVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9160) + p.Any_name() + } + { + p.SetState(9161) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9162) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9163) + p.Rolespec() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9165) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9166) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9167) + p.Name() + } + { + p.SetState(9168) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9169) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9170) + p.Rolespec() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9172) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9173) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9174) + p.Any_name() + } + { + p.SetState(9175) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9176) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9177) + p.Rolespec() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9179) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9180) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9181) + p.Function_with_argtypes() + } + { + p.SetState(9182) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9183) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9184) + p.Rolespec() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9186) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROCEDURAL { + { + p.SetState(9187) + p.Opt_procedural() + } + + } + { + p.SetState(9190) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9191) + p.Name() + } + { + p.SetState(9192) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9193) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9194) + p.Rolespec() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9196) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9197) + p.Match(RedshiftParserLARGE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9198) + p.Match(RedshiftParserOBJECT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9199) + p.Numericonly() + } + { + p.SetState(9200) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9201) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9202) + p.Rolespec() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9204) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9205) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9206) + p.Operator_with_argtypes() + } + { + p.SetState(9207) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9208) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9209) + p.Rolespec() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9211) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9212) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9213) + p.Match(RedshiftParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9214) + p.Any_name() + } + { + p.SetState(9215) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9216) + p.Name() + } + { + p.SetState(9217) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9218) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9219) + p.Rolespec() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9221) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9222) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9223) + p.Match(RedshiftParserFAMILY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9224) + p.Any_name() + } + { + p.SetState(9225) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9226) + p.Name() + } + { + p.SetState(9227) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9228) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9229) + p.Rolespec() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9231) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9232) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9233) + p.Function_with_argtypes() + } + { + p.SetState(9234) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9235) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9236) + p.Rolespec() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(9238) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9239) + p.Match(RedshiftParserROUTINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9240) + p.Function_with_argtypes() + } + { + p.SetState(9241) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9242) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9243) + p.Rolespec() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(9245) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9246) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9247) + p.Name() + } + { + p.SetState(9248) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9249) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9250) + p.Rolespec() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(9252) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9253) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9254) + p.Any_name() + } + { + p.SetState(9255) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9256) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9257) + p.Rolespec() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(9259) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9260) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9261) + p.Name() + } + { + p.SetState(9262) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9263) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9264) + p.Rolespec() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(9266) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9267) + p.Match(RedshiftParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9268) + p.Any_name() + } + { + p.SetState(9269) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9270) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9271) + p.Rolespec() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(9273) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9274) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9275) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9276) + p.Match(RedshiftParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9277) + p.Any_name() + } + { + p.SetState(9278) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9279) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9280) + p.Rolespec() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(9282) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9283) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9284) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9285) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9286) + p.Any_name() + } + { + p.SetState(9287) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9288) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9289) + p.Rolespec() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(9291) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9292) + p.Match(RedshiftParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9293) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9294) + p.Match(RedshiftParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9295) + p.Name() + } + { + p.SetState(9296) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9297) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9298) + p.Rolespec() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(9300) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9301) + p.Match(RedshiftParserSERVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9302) + p.Name() + } + { + p.SetState(9303) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9304) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9305) + p.Rolespec() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(9307) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9308) + p.Match(RedshiftParserEVENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9309) + p.Match(RedshiftParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9310) + p.Name() + } + { + p.SetState(9311) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9312) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9313) + p.Rolespec() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(9315) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9316) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9317) + p.Name() + } + { + p.SetState(9318) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9319) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9320) + p.Rolespec() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(9322) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9323) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9324) + p.Name() + } + { + p.SetState(9325) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9326) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9327) + p.Rolespec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatepublicationstmtContext is an interface to support dynamic dispatch. +type ICreatepublicationstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PUBLICATION() antlr.TerminalNode + Name() INameContext + Opt_definition() IOpt_definitionContext + FOR() antlr.TerminalNode + ALL() antlr.TerminalNode + TABLES() antlr.TerminalNode + Pub_obj_list() IPub_obj_listContext + + // IsCreatepublicationstmtContext differentiates from other interfaces. + IsCreatepublicationstmtContext() +} + +type CreatepublicationstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatepublicationstmtContext() *CreatepublicationstmtContext { + var p = new(CreatepublicationstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createpublicationstmt + return p +} + +func InitEmptyCreatepublicationstmtContext(p *CreatepublicationstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createpublicationstmt +} + +func (*CreatepublicationstmtContext) IsCreatepublicationstmtContext() {} + +func NewCreatepublicationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatepublicationstmtContext { + var p = new(CreatepublicationstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createpublicationstmt + + return p +} + +func (s *CreatepublicationstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatepublicationstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatepublicationstmtContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *CreatepublicationstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatepublicationstmtContext) Opt_definition() IOpt_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_definitionContext) +} + +func (s *CreatepublicationstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *CreatepublicationstmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *CreatepublicationstmtContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *CreatepublicationstmtContext) Pub_obj_list() IPub_obj_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPub_obj_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPub_obj_listContext) +} + +func (s *CreatepublicationstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatepublicationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatepublicationstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatepublicationstmt(s) + } +} + +func (s *CreatepublicationstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatepublicationstmt(s) + } +} + +func (s *CreatepublicationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatepublicationstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createpublicationstmt() (localctx ICreatepublicationstmtContext) { + localctx = NewCreatepublicationstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 966, RedshiftParserRULE_createpublicationstmt) + p.SetState(9354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 718, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9331) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9332) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9333) + p.Name() + } + p.SetState(9335) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 715, p.GetParserRuleContext()) == 1 { + { + p.SetState(9334) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9337) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9338) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9339) + p.Name() + } + { + p.SetState(9340) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9341) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9342) + p.Match(RedshiftParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9344) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) == 1 { + { + p.SetState(9343) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9346) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9347) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9348) + p.Name() + } + { + p.SetState(9349) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9350) + p.Pub_obj_list() + } + p.SetState(9352) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 717, p.GetParserRuleContext()) == 1 { + { + p.SetState(9351) + p.Opt_definition() + } + + } 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 +} + +// IPub_obj_listContext is an interface to support dynamic dispatch. +type IPub_obj_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPublication_obj_spec() []IPublication_obj_specContext + Publication_obj_spec(i int) IPublication_obj_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPub_obj_listContext differentiates from other interfaces. + IsPub_obj_listContext() +} + +type Pub_obj_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPub_obj_listContext() *Pub_obj_listContext { + var p = new(Pub_obj_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_pub_obj_list + return p +} + +func InitEmptyPub_obj_listContext(p *Pub_obj_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_pub_obj_list +} + +func (*Pub_obj_listContext) IsPub_obj_listContext() {} + +func NewPub_obj_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pub_obj_listContext { + var p = new(Pub_obj_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_pub_obj_list + + return p +} + +func (s *Pub_obj_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pub_obj_listContext) AllPublication_obj_spec() []IPublication_obj_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPublication_obj_specContext); ok { + len++ + } + } + + tst := make([]IPublication_obj_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPublication_obj_specContext); ok { + tst[i] = t.(IPublication_obj_specContext) + i++ + } + } + + return tst +} + +func (s *Pub_obj_listContext) Publication_obj_spec(i int) IPublication_obj_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPublication_obj_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPublication_obj_specContext) +} + +func (s *Pub_obj_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Pub_obj_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Pub_obj_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pub_obj_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pub_obj_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPub_obj_list(s) + } +} + +func (s *Pub_obj_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPub_obj_list(s) + } +} + +func (s *Pub_obj_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPub_obj_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Pub_obj_list() (localctx IPub_obj_listContext) { + localctx = NewPub_obj_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 968, RedshiftParserRULE_pub_obj_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9356) + p.Publication_obj_spec() + } + p.SetState(9361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(9357) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9358) + p.Publication_obj_spec() + } + + p.SetState(9363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPublication_obj_specContext is an interface to support dynamic dispatch. +type IPublication_obj_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + Relation_expr() IRelation_exprContext + Opt_column_list() IOpt_column_listContext + Opt_where_clause() IOpt_where_clauseContext + IN_P() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Colid() IColidContext + CURRENT_SCHEMA() antlr.TerminalNode + Indirection() IIndirectionContext + + // IsPublication_obj_specContext differentiates from other interfaces. + IsPublication_obj_specContext() +} + +type Publication_obj_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPublication_obj_specContext() *Publication_obj_specContext { + var p = new(Publication_obj_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_publication_obj_spec + return p +} + +func InitEmptyPublication_obj_specContext(p *Publication_obj_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_publication_obj_spec +} + +func (*Publication_obj_specContext) IsPublication_obj_specContext() {} + +func NewPublication_obj_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_obj_specContext { + var p = new(Publication_obj_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_publication_obj_spec + + return p +} + +func (s *Publication_obj_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Publication_obj_specContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Publication_obj_specContext) Relation_expr() IRelation_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *Publication_obj_specContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *Publication_obj_specContext) Opt_where_clause() IOpt_where_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_where_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_where_clauseContext) +} + +func (s *Publication_obj_specContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Publication_obj_specContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Publication_obj_specContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Publication_obj_specContext) CURRENT_SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_SCHEMA, 0) +} + +func (s *Publication_obj_specContext) Indirection() IIndirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndirectionContext) +} + +func (s *Publication_obj_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Publication_obj_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Publication_obj_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPublication_obj_spec(s) + } +} + +func (s *Publication_obj_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPublication_obj_spec(s) + } +} + +func (s *Publication_obj_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPublication_obj_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Publication_obj_spec() (localctx IPublication_obj_specContext) { + localctx = NewPublication_obj_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 970, RedshiftParserRULE_publication_obj_spec) + var _la int + + p.SetState(9402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 729, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9364) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9365) + p.Relation_expr() + } + p.SetState(9367) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 720, p.GetParserRuleContext()) == 1 { + { + p.SetState(9366) + p.Opt_column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(9369) + p.Opt_where_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9372) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9373) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9374) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(9375) + p.Colid() + } + + case RedshiftParserCURRENT_SCHEMA: + { + p.SetState(9376) + p.Match(RedshiftParserCURRENT_SCHEMA) + 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(9379) + p.Colid() + } + p.SetState(9381) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 723, p.GetParserRuleContext()) == 1 { + { + p.SetState(9380) + p.Opt_column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(9383) + p.Opt_where_clause() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9386) + p.Colid() + } + { + p.SetState(9387) + p.Indirection() + } + p.SetState(9389) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 725, p.GetParserRuleContext()) == 1 { + { + p.SetState(9388) + p.Opt_column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(9391) + p.Opt_where_clause() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9394) + p.Relation_expr() + } + p.SetState(9396) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 727, p.GetParserRuleContext()) == 1 { + { + p.SetState(9395) + p.Opt_column_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(9398) + p.Opt_where_clause() + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9401) + p.Match(RedshiftParserCURRENT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_where_clauseContext is an interface to support dynamic dispatch. +type IOpt_where_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_where_clauseContext differentiates from other interfaces. + IsOpt_where_clauseContext() +} + +type Opt_where_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_where_clauseContext() *Opt_where_clauseContext { + var p = new(Opt_where_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_where_clause + return p +} + +func InitEmptyOpt_where_clauseContext(p *Opt_where_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_where_clause +} + +func (*Opt_where_clauseContext) IsOpt_where_clauseContext() {} + +func NewOpt_where_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_where_clauseContext { + var p = new(Opt_where_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_where_clause + + return p +} + +func (s *Opt_where_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_where_clauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHERE, 0) +} + +func (s *Opt_where_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_where_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_where_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_where_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_where_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_where_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_where_clause(s) + } +} + +func (s *Opt_where_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_where_clause(s) + } +} + +func (s *Opt_where_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_where_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_where_clause() (localctx IOpt_where_clauseContext) { + localctx = NewOpt_where_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 972, RedshiftParserRULE_opt_where_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9404) + p.Match(RedshiftParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9405) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9406) + p.A_expr() + } + { + p.SetState(9407) + p.Match(RedshiftParserCLOSE_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 +} + +// IAlterpublicationstmtContext is an interface to support dynamic dispatch. +type IAlterpublicationstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + PUBLICATION() antlr.TerminalNode + Name() INameContext + SET() antlr.TerminalNode + Definition() IDefinitionContext + ADD_P() antlr.TerminalNode + Pub_obj_list() IPub_obj_listContext + DROP() antlr.TerminalNode + + // IsAlterpublicationstmtContext differentiates from other interfaces. + IsAlterpublicationstmtContext() +} + +type AlterpublicationstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterpublicationstmtContext() *AlterpublicationstmtContext { + var p = new(AlterpublicationstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterpublicationstmt + return p +} + +func InitEmptyAlterpublicationstmtContext(p *AlterpublicationstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterpublicationstmt +} + +func (*AlterpublicationstmtContext) IsAlterpublicationstmtContext() {} + +func NewAlterpublicationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterpublicationstmtContext { + var p = new(AlterpublicationstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterpublicationstmt + + return p +} + +func (s *AlterpublicationstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterpublicationstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterpublicationstmtContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *AlterpublicationstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterpublicationstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlterpublicationstmtContext) Definition() IDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefinitionContext) +} + +func (s *AlterpublicationstmtContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *AlterpublicationstmtContext) Pub_obj_list() IPub_obj_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPub_obj_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPub_obj_listContext) +} + +func (s *AlterpublicationstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *AlterpublicationstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterpublicationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterpublicationstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterpublicationstmt(s) + } +} + +func (s *AlterpublicationstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterpublicationstmt(s) + } +} + +func (s *AlterpublicationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterpublicationstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterpublicationstmt() (localctx IAlterpublicationstmtContext) { + localctx = NewAlterpublicationstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 974, RedshiftParserRULE_alterpublicationstmt) + p.SetState(9433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 730, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9409) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9410) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9411) + p.Name() + } + { + p.SetState(9412) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9413) + p.Definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9415) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9416) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9417) + p.Name() + } + { + p.SetState(9418) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9419) + p.Pub_obj_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9421) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9422) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9423) + p.Name() + } + { + p.SetState(9424) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9425) + p.Pub_obj_list() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9427) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9428) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9429) + p.Name() + } + { + p.SetState(9430) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9431) + p.Pub_obj_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatesubscriptionstmtContext is an interface to support dynamic dispatch. +type ICreatesubscriptionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + Name() INameContext + CONNECTION() antlr.TerminalNode + Sconst() ISconstContext + PUBLICATION() antlr.TerminalNode + Publication_name_list() IPublication_name_listContext + Opt_definition() IOpt_definitionContext + + // IsCreatesubscriptionstmtContext differentiates from other interfaces. + IsCreatesubscriptionstmtContext() +} + +type CreatesubscriptionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatesubscriptionstmtContext() *CreatesubscriptionstmtContext { + var p = new(CreatesubscriptionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createsubscriptionstmt + return p +} + +func InitEmptyCreatesubscriptionstmtContext(p *CreatesubscriptionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createsubscriptionstmt +} + +func (*CreatesubscriptionstmtContext) IsCreatesubscriptionstmtContext() {} + +func NewCreatesubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatesubscriptionstmtContext { + var p = new(CreatesubscriptionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createsubscriptionstmt + + return p +} + +func (s *CreatesubscriptionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatesubscriptionstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatesubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSCRIPTION, 0) +} + +func (s *CreatesubscriptionstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatesubscriptionstmtContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECTION, 0) +} + +func (s *CreatesubscriptionstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreatesubscriptionstmtContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *CreatesubscriptionstmtContext) Publication_name_list() IPublication_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPublication_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPublication_name_listContext) +} + +func (s *CreatesubscriptionstmtContext) Opt_definition() IOpt_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_definitionContext) +} + +func (s *CreatesubscriptionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatesubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatesubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatesubscriptionstmt(s) + } +} + +func (s *CreatesubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatesubscriptionstmt(s) + } +} + +func (s *CreatesubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatesubscriptionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createsubscriptionstmt() (localctx ICreatesubscriptionstmtContext) { + localctx = NewCreatesubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 976, RedshiftParserRULE_createsubscriptionstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9435) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9436) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9437) + p.Name() + } + { + p.SetState(9438) + p.Match(RedshiftParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9439) + p.Sconst() + } + { + p.SetState(9440) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9441) + p.Publication_name_list() + } + p.SetState(9443) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 731, p.GetParserRuleContext()) == 1 { + { + p.SetState(9442) + p.Opt_definition() + } + + } 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 +} + +// IPublication_name_listContext is an interface to support dynamic dispatch. +type IPublication_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPublication_name_item() []IPublication_name_itemContext + Publication_name_item(i int) IPublication_name_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPublication_name_listContext differentiates from other interfaces. + IsPublication_name_listContext() +} + +type Publication_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPublication_name_listContext() *Publication_name_listContext { + var p = new(Publication_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_publication_name_list + return p +} + +func InitEmptyPublication_name_listContext(p *Publication_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_publication_name_list +} + +func (*Publication_name_listContext) IsPublication_name_listContext() {} + +func NewPublication_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_name_listContext { + var p = new(Publication_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_publication_name_list + + return p +} + +func (s *Publication_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Publication_name_listContext) AllPublication_name_item() []IPublication_name_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPublication_name_itemContext); ok { + len++ + } + } + + tst := make([]IPublication_name_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPublication_name_itemContext); ok { + tst[i] = t.(IPublication_name_itemContext) + i++ + } + } + + return tst +} + +func (s *Publication_name_listContext) Publication_name_item(i int) IPublication_name_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPublication_name_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPublication_name_itemContext) +} + +func (s *Publication_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Publication_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Publication_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Publication_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Publication_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPublication_name_list(s) + } +} + +func (s *Publication_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPublication_name_list(s) + } +} + +func (s *Publication_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPublication_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Publication_name_list() (localctx IPublication_name_listContext) { + localctx = NewPublication_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 978, RedshiftParserRULE_publication_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9445) + p.Publication_name_item() + } + p.SetState(9450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(9446) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9447) + p.Publication_name_item() + } + + p.SetState(9452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPublication_name_itemContext is an interface to support dynamic dispatch. +type IPublication_name_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Collabel() ICollabelContext + + // IsPublication_name_itemContext differentiates from other interfaces. + IsPublication_name_itemContext() +} + +type Publication_name_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPublication_name_itemContext() *Publication_name_itemContext { + var p = new(Publication_name_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_publication_name_item + return p +} + +func InitEmptyPublication_name_itemContext(p *Publication_name_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_publication_name_item +} + +func (*Publication_name_itemContext) IsPublication_name_itemContext() {} + +func NewPublication_name_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Publication_name_itemContext { + var p = new(Publication_name_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_publication_name_item + + return p +} + +func (s *Publication_name_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Publication_name_itemContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Publication_name_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Publication_name_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Publication_name_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPublication_name_item(s) + } +} + +func (s *Publication_name_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPublication_name_item(s) + } +} + +func (s *Publication_name_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPublication_name_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Publication_name_item() (localctx IPublication_name_itemContext) { + localctx = NewPublication_name_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 980, RedshiftParserRULE_publication_name_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9453) + p.Collabel() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltersubscriptionstmtContext is an interface to support dynamic dispatch. +type IAltersubscriptionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + Name() INameContext + SET() antlr.TerminalNode + Definition() IDefinitionContext + CONNECTION() antlr.TerminalNode + Sconst() ISconstContext + REFRESH() antlr.TerminalNode + PUBLICATION() antlr.TerminalNode + Opt_definition() IOpt_definitionContext + Publication_name_list() IPublication_name_listContext + ENABLE_P() antlr.TerminalNode + DISABLE_P() antlr.TerminalNode + SKIP_P() antlr.TerminalNode + + // IsAltersubscriptionstmtContext differentiates from other interfaces. + IsAltersubscriptionstmtContext() +} + +type AltersubscriptionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltersubscriptionstmtContext() *AltersubscriptionstmtContext { + var p = new(AltersubscriptionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altersubscriptionstmt + return p +} + +func InitEmptyAltersubscriptionstmtContext(p *AltersubscriptionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altersubscriptionstmt +} + +func (*AltersubscriptionstmtContext) IsAltersubscriptionstmtContext() {} + +func NewAltersubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltersubscriptionstmtContext { + var p = new(AltersubscriptionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altersubscriptionstmt + + return p +} + +func (s *AltersubscriptionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltersubscriptionstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltersubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSCRIPTION, 0) +} + +func (s *AltersubscriptionstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AltersubscriptionstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AltersubscriptionstmtContext) Definition() IDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefinitionContext) +} + +func (s *AltersubscriptionstmtContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECTION, 0) +} + +func (s *AltersubscriptionstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *AltersubscriptionstmtContext) REFRESH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFRESH, 0) +} + +func (s *AltersubscriptionstmtContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *AltersubscriptionstmtContext) Opt_definition() IOpt_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_definitionContext) +} + +func (s *AltersubscriptionstmtContext) Publication_name_list() IPublication_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPublication_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPublication_name_listContext) +} + +func (s *AltersubscriptionstmtContext) ENABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserENABLE_P, 0) +} + +func (s *AltersubscriptionstmtContext) DISABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISABLE_P, 0) +} + +func (s *AltersubscriptionstmtContext) SKIP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSKIP_P, 0) +} + +func (s *AltersubscriptionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltersubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltersubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltersubscriptionstmt(s) + } +} + +func (s *AltersubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltersubscriptionstmt(s) + } +} + +func (s *AltersubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltersubscriptionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altersubscriptionstmt() (localctx IAltersubscriptionstmtContext) { + localctx = NewAltersubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 982, RedshiftParserRULE_altersubscriptionstmt) + p.SetState(9500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 735, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9455) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9456) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9457) + p.Name() + } + { + p.SetState(9458) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9459) + p.Definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9461) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9462) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9463) + p.Name() + } + { + p.SetState(9464) + p.Match(RedshiftParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9465) + p.Sconst() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9467) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9468) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9469) + p.Name() + } + { + p.SetState(9470) + p.Match(RedshiftParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9471) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9473) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 733, p.GetParserRuleContext()) == 1 { + { + p.SetState(9472) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9475) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9476) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9477) + p.Name() + } + { + p.SetState(9478) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9479) + p.Match(RedshiftParserPUBLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9480) + p.Publication_name_list() + } + p.SetState(9482) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 734, p.GetParserRuleContext()) == 1 { + { + p.SetState(9481) + p.Opt_definition() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9484) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9485) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9486) + p.Name() + } + { + p.SetState(9487) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9489) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9490) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9491) + p.Name() + } + { + p.SetState(9492) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9494) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9495) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9496) + p.Name() + } + { + p.SetState(9497) + p.Match(RedshiftParserSKIP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9498) + p.Definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropsubscriptionstmtContext is an interface to support dynamic dispatch. +type IDropsubscriptionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + Name() INameContext + Opt_drop_behavior() IOpt_drop_behaviorContext + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsDropsubscriptionstmtContext differentiates from other interfaces. + IsDropsubscriptionstmtContext() +} + +type DropsubscriptionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropsubscriptionstmtContext() *DropsubscriptionstmtContext { + var p = new(DropsubscriptionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropsubscriptionstmt + return p +} + +func InitEmptyDropsubscriptionstmtContext(p *DropsubscriptionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropsubscriptionstmt +} + +func (*DropsubscriptionstmtContext) IsDropsubscriptionstmtContext() {} + +func NewDropsubscriptionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropsubscriptionstmtContext { + var p = new(DropsubscriptionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropsubscriptionstmt + + return p +} + +func (s *DropsubscriptionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropsubscriptionstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropsubscriptionstmtContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSCRIPTION, 0) +} + +func (s *DropsubscriptionstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DropsubscriptionstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DropsubscriptionstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *DropsubscriptionstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *DropsubscriptionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropsubscriptionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropsubscriptionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropsubscriptionstmt(s) + } +} + +func (s *DropsubscriptionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropsubscriptionstmt(s) + } +} + +func (s *DropsubscriptionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropsubscriptionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropsubscriptionstmt() (localctx IDropsubscriptionstmtContext) { + localctx = NewDropsubscriptionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 984, RedshiftParserRULE_dropsubscriptionstmt) + var _la int + + p.SetState(9516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 738, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9502) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9503) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9504) + p.Name() + } + p.SetState(9506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(9505) + p.Opt_drop_behavior() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9508) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9509) + p.Match(RedshiftParserSUBSCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9510) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9511) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9512) + p.Name() + } + p.SetState(9514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(9513) + p.Opt_drop_behavior() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRulestmtContext is an interface to support dynamic dispatch. +type IRulestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + RULE() antlr.TerminalNode + Name() INameContext + AS() antlr.TerminalNode + ON() antlr.TerminalNode + Event() IEventContext + TO() antlr.TerminalNode + Qualified_name() IQualified_nameContext + DO() antlr.TerminalNode + Ruleactionlist() IRuleactionlistContext + Opt_or_replace() IOpt_or_replaceContext + Where_clause() IWhere_clauseContext + Opt_instead() IOpt_insteadContext + + // IsRulestmtContext differentiates from other interfaces. + IsRulestmtContext() +} + +type RulestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRulestmtContext() *RulestmtContext { + var p = new(RulestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rulestmt + return p +} + +func InitEmptyRulestmtContext(p *RulestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rulestmt +} + +func (*RulestmtContext) IsRulestmtContext() {} + +func NewRulestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RulestmtContext { + var p = new(RulestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rulestmt + + return p +} + +func (s *RulestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RulestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *RulestmtContext) RULE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRULE, 0) +} + +func (s *RulestmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *RulestmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *RulestmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *RulestmtContext) Event() IEventContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEventContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEventContext) +} + +func (s *RulestmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *RulestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *RulestmtContext) DO() antlr.TerminalNode { + return s.GetToken(RedshiftParserDO, 0) +} + +func (s *RulestmtContext) Ruleactionlist() IRuleactionlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRuleactionlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRuleactionlistContext) +} + +func (s *RulestmtContext) Opt_or_replace() IOpt_or_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_or_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_or_replaceContext) +} + +func (s *RulestmtContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *RulestmtContext) Opt_instead() IOpt_insteadContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_insteadContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_insteadContext) +} + +func (s *RulestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RulestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RulestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRulestmt(s) + } +} + +func (s *RulestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRulestmt(s) + } +} + +func (s *RulestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRulestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rulestmt() (localctx IRulestmtContext) { + localctx = NewRulestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 986, RedshiftParserRULE_rulestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9518) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(9519) + p.Opt_or_replace() + } + + } + { + p.SetState(9522) + p.Match(RedshiftParserRULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9523) + p.Name() + } + { + p.SetState(9524) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9525) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9526) + p.Event() + } + { + p.SetState(9527) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9528) + p.Qualified_name() + } + p.SetState(9530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(9529) + p.Where_clause() + } + + } + { + p.SetState(9532) + p.Match(RedshiftParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserALSO || _la == RedshiftParserINSTEAD { + { + p.SetState(9533) + p.Opt_instead() + } + + } + { + p.SetState(9536) + p.Ruleactionlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRuleactionlistContext is an interface to support dynamic dispatch. +type IRuleactionlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOTHING() antlr.TerminalNode + Ruleactionstmt() IRuleactionstmtContext + OPEN_PAREN() antlr.TerminalNode + Ruleactionmulti() IRuleactionmultiContext + CLOSE_PAREN() antlr.TerminalNode + + // IsRuleactionlistContext differentiates from other interfaces. + IsRuleactionlistContext() +} + +type RuleactionlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRuleactionlistContext() *RuleactionlistContext { + var p = new(RuleactionlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionlist + return p +} + +func InitEmptyRuleactionlistContext(p *RuleactionlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionlist +} + +func (*RuleactionlistContext) IsRuleactionlistContext() {} + +func NewRuleactionlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionlistContext { + var p = new(RuleactionlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_ruleactionlist + + return p +} + +func (s *RuleactionlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *RuleactionlistContext) NOTHING() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTHING, 0) +} + +func (s *RuleactionlistContext) Ruleactionstmt() IRuleactionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRuleactionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRuleactionstmtContext) +} + +func (s *RuleactionlistContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *RuleactionlistContext) Ruleactionmulti() IRuleactionmultiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRuleactionmultiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRuleactionmultiContext) +} + +func (s *RuleactionlistContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *RuleactionlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RuleactionlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RuleactionlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRuleactionlist(s) + } +} + +func (s *RuleactionlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRuleactionlist(s) + } +} + +func (s *RuleactionlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRuleactionlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Ruleactionlist() (localctx IRuleactionlistContext) { + localctx = NewRuleactionlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 988, RedshiftParserRULE_ruleactionlist) + p.SetState(9544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 742, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9538) + p.Match(RedshiftParserNOTHING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9539) + p.Ruleactionstmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9540) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9541) + p.Ruleactionmulti() + } + { + p.SetState(9542) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRuleactionmultiContext is an interface to support dynamic dispatch. +type IRuleactionmultiContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRuleactionstmtOrEmpty() []IRuleactionstmtOrEmptyContext + RuleactionstmtOrEmpty(i int) IRuleactionstmtOrEmptyContext + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + + // IsRuleactionmultiContext differentiates from other interfaces. + IsRuleactionmultiContext() +} + +type RuleactionmultiContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRuleactionmultiContext() *RuleactionmultiContext { + var p = new(RuleactionmultiContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionmulti + return p +} + +func InitEmptyRuleactionmultiContext(p *RuleactionmultiContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionmulti +} + +func (*RuleactionmultiContext) IsRuleactionmultiContext() {} + +func NewRuleactionmultiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionmultiContext { + var p = new(RuleactionmultiContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_ruleactionmulti + + return p +} + +func (s *RuleactionmultiContext) GetParser() antlr.Parser { return s.parser } + +func (s *RuleactionmultiContext) AllRuleactionstmtOrEmpty() []IRuleactionstmtOrEmptyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRuleactionstmtOrEmptyContext); ok { + len++ + } + } + + tst := make([]IRuleactionstmtOrEmptyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRuleactionstmtOrEmptyContext); ok { + tst[i] = t.(IRuleactionstmtOrEmptyContext) + i++ + } + } + + return tst +} + +func (s *RuleactionmultiContext) RuleactionstmtOrEmpty(i int) IRuleactionstmtOrEmptyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRuleactionstmtOrEmptyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRuleactionstmtOrEmptyContext) +} + +func (s *RuleactionmultiContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserSEMI) +} + +func (s *RuleactionmultiContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, i) +} + +func (s *RuleactionmultiContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RuleactionmultiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RuleactionmultiContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRuleactionmulti(s) + } +} + +func (s *RuleactionmultiContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRuleactionmulti(s) + } +} + +func (s *RuleactionmultiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRuleactionmulti(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Ruleactionmulti() (localctx IRuleactionmultiContext) { + localctx = NewRuleactionmultiContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 990, RedshiftParserRULE_ruleactionmulti) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN || ((int64((_la-89)) & ^0x3f) == 0 && ((int64(1)<<(_la-89))&131089) != 0) || _la == RedshiftParserDELETE_P || _la == RedshiftParserINSERT || _la == RedshiftParserNOTIFY || _la == RedshiftParserUPDATE || _la == RedshiftParserVALUES { + { + p.SetState(9546) + p.RuleactionstmtOrEmpty() + } + + } + p.SetState(9555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserSEMI { + { + p.SetState(9549) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN || ((int64((_la-89)) & ^0x3f) == 0 && ((int64(1)<<(_la-89))&131089) != 0) || _la == RedshiftParserDELETE_P || _la == RedshiftParserINSERT || _la == RedshiftParserNOTIFY || _la == RedshiftParserUPDATE || _la == RedshiftParserVALUES { + { + p.SetState(9550) + p.RuleactionstmtOrEmpty() + } + + } + + p.SetState(9557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRuleactionstmtContext is an interface to support dynamic dispatch. +type IRuleactionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Selectstmt() ISelectstmtContext + Insertstmt() IInsertstmtContext + Updatestmt() IUpdatestmtContext + Deletestmt() IDeletestmtContext + Notifystmt() INotifystmtContext + + // IsRuleactionstmtContext differentiates from other interfaces. + IsRuleactionstmtContext() +} + +type RuleactionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRuleactionstmtContext() *RuleactionstmtContext { + var p = new(RuleactionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionstmt + return p +} + +func InitEmptyRuleactionstmtContext(p *RuleactionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionstmt +} + +func (*RuleactionstmtContext) IsRuleactionstmtContext() {} + +func NewRuleactionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionstmtContext { + var p = new(RuleactionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_ruleactionstmt + + return p +} + +func (s *RuleactionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *RuleactionstmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *RuleactionstmtContext) Insertstmt() IInsertstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertstmtContext) +} + +func (s *RuleactionstmtContext) Updatestmt() IUpdatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdatestmtContext) +} + +func (s *RuleactionstmtContext) Deletestmt() IDeletestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeletestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeletestmtContext) +} + +func (s *RuleactionstmtContext) Notifystmt() INotifystmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INotifystmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INotifystmtContext) +} + +func (s *RuleactionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RuleactionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RuleactionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRuleactionstmt(s) + } +} + +func (s *RuleactionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRuleactionstmt(s) + } +} + +func (s *RuleactionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRuleactionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Ruleactionstmt() (localctx IRuleactionstmtContext) { + localctx = NewRuleactionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 992, RedshiftParserRULE_ruleactionstmt) + p.SetState(9563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 746, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9558) + p.Selectstmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9559) + p.Insertstmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9560) + p.Updatestmt() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9561) + p.Deletestmt() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9562) + p.Notifystmt() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRuleactionstmtOrEmptyContext is an interface to support dynamic dispatch. +type IRuleactionstmtOrEmptyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Ruleactionstmt() IRuleactionstmtContext + + // IsRuleactionstmtOrEmptyContext differentiates from other interfaces. + IsRuleactionstmtOrEmptyContext() +} + +type RuleactionstmtOrEmptyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRuleactionstmtOrEmptyContext() *RuleactionstmtOrEmptyContext { + var p = new(RuleactionstmtOrEmptyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionstmtOrEmpty + return p +} + +func InitEmptyRuleactionstmtOrEmptyContext(p *RuleactionstmtOrEmptyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_ruleactionstmtOrEmpty +} + +func (*RuleactionstmtOrEmptyContext) IsRuleactionstmtOrEmptyContext() {} + +func NewRuleactionstmtOrEmptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RuleactionstmtOrEmptyContext { + var p = new(RuleactionstmtOrEmptyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_ruleactionstmtOrEmpty + + return p +} + +func (s *RuleactionstmtOrEmptyContext) GetParser() antlr.Parser { return s.parser } + +func (s *RuleactionstmtOrEmptyContext) Ruleactionstmt() IRuleactionstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRuleactionstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRuleactionstmtContext) +} + +func (s *RuleactionstmtOrEmptyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RuleactionstmtOrEmptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RuleactionstmtOrEmptyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRuleactionstmtOrEmpty(s) + } +} + +func (s *RuleactionstmtOrEmptyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRuleactionstmtOrEmpty(s) + } +} + +func (s *RuleactionstmtOrEmptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRuleactionstmtOrEmpty(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) RuleactionstmtOrEmpty() (localctx IRuleactionstmtOrEmptyContext) { + localctx = NewRuleactionstmtOrEmptyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 994, RedshiftParserRULE_ruleactionstmtOrEmpty) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9565) + p.Ruleactionstmt() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEventContext is an interface to support dynamic dispatch. +type IEventContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + INSERT() antlr.TerminalNode + + // IsEventContext differentiates from other interfaces. + IsEventContext() +} + +type EventContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEventContext() *EventContext { + var p = new(EventContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event + return p +} + +func InitEmptyEventContext(p *EventContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_event +} + +func (*EventContext) IsEventContext() {} + +func NewEventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EventContext { + var p = new(EventContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_event + + return p +} + +func (s *EventContext) GetParser() antlr.Parser { return s.parser } + +func (s *EventContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *EventContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *EventContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *EventContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *EventContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EventContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEvent(s) + } +} + +func (s *EventContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEvent(s) + } +} + +func (s *EventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEvent(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Event() (localctx IEventContext) { + localctx = NewEventContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 996, RedshiftParserRULE_event) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9567) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserSELECT || _la == RedshiftParserDELETE_P || _la == RedshiftParserINSERT || _la == RedshiftParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_insteadContext is an interface to support dynamic dispatch. +type IOpt_insteadContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSTEAD() antlr.TerminalNode + ALSO() antlr.TerminalNode + + // IsOpt_insteadContext differentiates from other interfaces. + IsOpt_insteadContext() +} + +type Opt_insteadContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_insteadContext() *Opt_insteadContext { + var p = new(Opt_insteadContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_instead + return p +} + +func InitEmptyOpt_insteadContext(p *Opt_insteadContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_instead +} + +func (*Opt_insteadContext) IsOpt_insteadContext() {} + +func NewOpt_insteadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_insteadContext { + var p = new(Opt_insteadContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_instead + + return p +} + +func (s *Opt_insteadContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_insteadContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSTEAD, 0) +} + +func (s *Opt_insteadContext) ALSO() antlr.TerminalNode { + return s.GetToken(RedshiftParserALSO, 0) +} + +func (s *Opt_insteadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_insteadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_insteadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_instead(s) + } +} + +func (s *Opt_insteadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_instead(s) + } +} + +func (s *Opt_insteadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_instead(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_instead() (localctx IOpt_insteadContext) { + localctx = NewOpt_insteadContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 998, RedshiftParserRULE_opt_instead) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9569) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALSO || _la == RedshiftParserINSTEAD) { + 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 +} + +// INotifystmtContext is an interface to support dynamic dispatch. +type INotifystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOTIFY() antlr.TerminalNode + Colid() IColidContext + Notify_payload() INotify_payloadContext + + // IsNotifystmtContext differentiates from other interfaces. + IsNotifystmtContext() +} + +type NotifystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNotifystmtContext() *NotifystmtContext { + var p = new(NotifystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_notifystmt + return p +} + +func InitEmptyNotifystmtContext(p *NotifystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_notifystmt +} + +func (*NotifystmtContext) IsNotifystmtContext() {} + +func NewNotifystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NotifystmtContext { + var p = new(NotifystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_notifystmt + + return p +} + +func (s *NotifystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *NotifystmtContext) NOTIFY() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTIFY, 0) +} + +func (s *NotifystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *NotifystmtContext) Notify_payload() INotify_payloadContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INotify_payloadContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INotify_payloadContext) +} + +func (s *NotifystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NotifystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NotifystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNotifystmt(s) + } +} + +func (s *NotifystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNotifystmt(s) + } +} + +func (s *NotifystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNotifystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Notifystmt() (localctx INotifystmtContext) { + localctx = NewNotifystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1000, RedshiftParserRULE_notifystmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9571) + p.Match(RedshiftParserNOTIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9572) + p.Colid() + } + p.SetState(9574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(9573) + p.Notify_payload() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INotify_payloadContext is an interface to support dynamic dispatch. +type INotify_payloadContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA() antlr.TerminalNode + Sconst() ISconstContext + + // IsNotify_payloadContext differentiates from other interfaces. + IsNotify_payloadContext() +} + +type Notify_payloadContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNotify_payloadContext() *Notify_payloadContext { + var p = new(Notify_payloadContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_notify_payload + return p +} + +func InitEmptyNotify_payloadContext(p *Notify_payloadContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_notify_payload +} + +func (*Notify_payloadContext) IsNotify_payloadContext() {} + +func NewNotify_payloadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Notify_payloadContext { + var p = new(Notify_payloadContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_notify_payload + + return p +} + +func (s *Notify_payloadContext) GetParser() antlr.Parser { return s.parser } + +func (s *Notify_payloadContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Notify_payloadContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Notify_payloadContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Notify_payloadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Notify_payloadContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNotify_payload(s) + } +} + +func (s *Notify_payloadContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNotify_payload(s) + } +} + +func (s *Notify_payloadContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNotify_payload(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Notify_payload() (localctx INotify_payloadContext) { + localctx = NewNotify_payloadContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1002, RedshiftParserRULE_notify_payload) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9576) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9577) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IListenstmtContext is an interface to support dynamic dispatch. +type IListenstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LISTEN() antlr.TerminalNode + Colid() IColidContext + + // IsListenstmtContext differentiates from other interfaces. + IsListenstmtContext() +} + +type ListenstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyListenstmtContext() *ListenstmtContext { + var p = new(ListenstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_listenstmt + return p +} + +func InitEmptyListenstmtContext(p *ListenstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_listenstmt +} + +func (*ListenstmtContext) IsListenstmtContext() {} + +func NewListenstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListenstmtContext { + var p = new(ListenstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_listenstmt + + return p +} + +func (s *ListenstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ListenstmtContext) LISTEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserLISTEN, 0) +} + +func (s *ListenstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ListenstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ListenstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ListenstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterListenstmt(s) + } +} + +func (s *ListenstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitListenstmt(s) + } +} + +func (s *ListenstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitListenstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Listenstmt() (localctx IListenstmtContext) { + localctx = NewListenstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1004, RedshiftParserRULE_listenstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9579) + p.Match(RedshiftParserLISTEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9580) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnlistenstmtContext is an interface to support dynamic dispatch. +type IUnlistenstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNLISTEN() antlr.TerminalNode + Colid() IColidContext + STAR() antlr.TerminalNode + + // IsUnlistenstmtContext differentiates from other interfaces. + IsUnlistenstmtContext() +} + +type UnlistenstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnlistenstmtContext() *UnlistenstmtContext { + var p = new(UnlistenstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unlistenstmt + return p +} + +func InitEmptyUnlistenstmtContext(p *UnlistenstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unlistenstmt +} + +func (*UnlistenstmtContext) IsUnlistenstmtContext() {} + +func NewUnlistenstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnlistenstmtContext { + var p = new(UnlistenstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_unlistenstmt + + return p +} + +func (s *UnlistenstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnlistenstmtContext) UNLISTEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLISTEN, 0) +} + +func (s *UnlistenstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *UnlistenstmtContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *UnlistenstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnlistenstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnlistenstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUnlistenstmt(s) + } +} + +func (s *UnlistenstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUnlistenstmt(s) + } +} + +func (s *UnlistenstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUnlistenstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Unlistenstmt() (localctx IUnlistenstmtContext) { + localctx = NewUnlistenstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1006, RedshiftParserRULE_unlistenstmt) + p.SetState(9586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 748, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9582) + p.Match(RedshiftParserUNLISTEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9583) + p.Colid() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9584) + p.Match(RedshiftParserUNLISTEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9585) + p.Match(RedshiftParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransactionstmtContext is an interface to support dynamic dispatch. +type ITransactionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT_P() antlr.TerminalNode + Opt_transaction() IOpt_transactionContext + Opt_transaction_chain() IOpt_transaction_chainContext + BEGIN_P() antlr.TerminalNode + Transaction_mode_list_or_empty() ITransaction_mode_list_or_emptyContext + START() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + COMMIT() antlr.TerminalNode + END_P() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SAVEPOINT() antlr.TerminalNode + Colid() IColidContext + RELEASE() antlr.TerminalNode + TO() antlr.TerminalNode + PREPARE() antlr.TerminalNode + Sconst() ISconstContext + PREPARED() antlr.TerminalNode + + // IsTransactionstmtContext differentiates from other interfaces. + IsTransactionstmtContext() +} + +type TransactionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransactionstmtContext() *TransactionstmtContext { + var p = new(TransactionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transactionstmt + return p +} + +func InitEmptyTransactionstmtContext(p *TransactionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transactionstmt +} + +func (*TransactionstmtContext) IsTransactionstmtContext() {} + +func NewTransactionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransactionstmtContext { + var p = new(TransactionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transactionstmt + + return p +} + +func (s *TransactionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransactionstmtContext) ABORT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserABORT_P, 0) +} + +func (s *TransactionstmtContext) Opt_transaction() IOpt_transactionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_transactionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_transactionContext) +} + +func (s *TransactionstmtContext) Opt_transaction_chain() IOpt_transaction_chainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_transaction_chainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_transaction_chainContext) +} + +func (s *TransactionstmtContext) BEGIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEGIN_P, 0) +} + +func (s *TransactionstmtContext) Transaction_mode_list_or_empty() ITransaction_mode_list_or_emptyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_mode_list_or_emptyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_mode_list_or_emptyContext) +} + +func (s *TransactionstmtContext) START() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTART, 0) +} + +func (s *TransactionstmtContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *TransactionstmtContext) COMMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMIT, 0) +} + +func (s *TransactionstmtContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *TransactionstmtContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLLBACK, 0) +} + +func (s *TransactionstmtContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSAVEPOINT, 0) +} + +func (s *TransactionstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *TransactionstmtContext) RELEASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRELEASE, 0) +} + +func (s *TransactionstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *TransactionstmtContext) PREPARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPARE, 0) +} + +func (s *TransactionstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *TransactionstmtContext) PREPARED() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPARED, 0) +} + +func (s *TransactionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransactionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransactionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransactionstmt(s) + } +} + +func (s *TransactionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransactionstmt(s) + } +} + +func (s *TransactionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransactionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transactionstmt() (localctx ITransactionstmtContext) { + localctx = NewTransactionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1008, RedshiftParserRULE_transactionstmt) + var _la int + + p.SetState(9657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 762, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9588) + p.Match(RedshiftParserABORT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK { + { + p.SetState(9589) + p.Opt_transaction() + } + + } + p.SetState(9593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(9592) + p.Opt_transaction_chain() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9595) + p.Match(RedshiftParserBEGIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK { + { + p.SetState(9596) + p.Opt_transaction() + } + + } + p.SetState(9600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDEFERRABLE || _la == RedshiftParserNOT || _la == RedshiftParserISOLATION || _la == RedshiftParserREAD { + { + p.SetState(9599) + p.Transaction_mode_list_or_empty() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9602) + p.Match(RedshiftParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9603) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDEFERRABLE || _la == RedshiftParserNOT || _la == RedshiftParserISOLATION || _la == RedshiftParserREAD { + { + p.SetState(9604) + p.Transaction_mode_list_or_empty() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9607) + p.Match(RedshiftParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK { + { + p.SetState(9608) + p.Opt_transaction() + } + + } + p.SetState(9612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(9611) + p.Opt_transaction_chain() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9614) + p.Match(RedshiftParserEND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK { + { + p.SetState(9615) + p.Opt_transaction() + } + + } + p.SetState(9619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(9618) + p.Opt_transaction_chain() + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9621) + p.Match(RedshiftParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK { + { + p.SetState(9622) + p.Opt_transaction() + } + + } + p.SetState(9626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(9625) + p.Opt_transaction_chain() + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9628) + p.Match(RedshiftParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9629) + p.Colid() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9630) + p.Match(RedshiftParserRELEASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9631) + p.Match(RedshiftParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9632) + p.Colid() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9633) + p.Match(RedshiftParserRELEASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9634) + p.Colid() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9635) + p.Match(RedshiftParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK { + { + p.SetState(9636) + p.Opt_transaction() + } + + } + { + p.SetState(9639) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9640) + p.Match(RedshiftParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9641) + p.Colid() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9642) + p.Match(RedshiftParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK { + { + p.SetState(9643) + p.Opt_transaction() + } + + } + { + p.SetState(9646) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9647) + p.Colid() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9648) + p.Match(RedshiftParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9649) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9650) + p.Sconst() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(9651) + p.Match(RedshiftParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9652) + p.Match(RedshiftParserPREPARED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9653) + p.Sconst() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(9654) + p.Match(RedshiftParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9655) + p.Match(RedshiftParserPREPARED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9656) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_transactionContext is an interface to support dynamic dispatch. +type IOpt_transactionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WORK() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + + // IsOpt_transactionContext differentiates from other interfaces. + IsOpt_transactionContext() +} + +type Opt_transactionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_transactionContext() *Opt_transactionContext { + var p = new(Opt_transactionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_transaction + return p +} + +func InitEmptyOpt_transactionContext(p *Opt_transactionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_transaction +} + +func (*Opt_transactionContext) IsOpt_transactionContext() {} + +func NewOpt_transactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_transactionContext { + var p = new(Opt_transactionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_transaction + + return p +} + +func (s *Opt_transactionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_transactionContext) WORK() antlr.TerminalNode { + return s.GetToken(RedshiftParserWORK, 0) +} + +func (s *Opt_transactionContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *Opt_transactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_transactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_transactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_transaction(s) + } +} + +func (s *Opt_transactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_transaction(s) + } +} + +func (s *Opt_transactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_transaction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_transaction() (localctx IOpt_transactionContext) { + localctx = NewOpt_transactionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1010, RedshiftParserRULE_opt_transaction) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9659) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTRANSACTION || _la == RedshiftParserWORK) { + 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 +} + +// ITransaction_mode_itemContext is an interface to support dynamic dispatch. +type ITransaction_mode_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + Iso_level() IIso_levelContext + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + DEFERRABLE() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsTransaction_mode_itemContext differentiates from other interfaces. + IsTransaction_mode_itemContext() +} + +type Transaction_mode_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_mode_itemContext() *Transaction_mode_itemContext { + var p = new(Transaction_mode_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transaction_mode_item + return p +} + +func InitEmptyTransaction_mode_itemContext(p *Transaction_mode_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transaction_mode_item +} + +func (*Transaction_mode_itemContext) IsTransaction_mode_itemContext() {} + +func NewTransaction_mode_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_itemContext { + var p = new(Transaction_mode_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transaction_mode_item + + return p +} + +func (s *Transaction_mode_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_mode_itemContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserISOLATION, 0) +} + +func (s *Transaction_mode_itemContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *Transaction_mode_itemContext) Iso_level() IIso_levelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIso_levelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIso_levelContext) +} + +func (s *Transaction_mode_itemContext) READ() antlr.TerminalNode { + return s.GetToken(RedshiftParserREAD, 0) +} + +func (s *Transaction_mode_itemContext) ONLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserONLY, 0) +} + +func (s *Transaction_mode_itemContext) WRITE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRITE, 0) +} + +func (s *Transaction_mode_itemContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRABLE, 0) +} + +func (s *Transaction_mode_itemContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Transaction_mode_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_mode_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_mode_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransaction_mode_item(s) + } +} + +func (s *Transaction_mode_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransaction_mode_item(s) + } +} + +func (s *Transaction_mode_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransaction_mode_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transaction_mode_item() (localctx ITransaction_mode_itemContext) { + localctx = NewTransaction_mode_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1012, RedshiftParserRULE_transaction_mode_item) + p.SetState(9671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 763, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9661) + p.Match(RedshiftParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9662) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9663) + p.Iso_level() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9664) + p.Match(RedshiftParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9665) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9666) + p.Match(RedshiftParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9667) + p.Match(RedshiftParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9668) + p.Match(RedshiftParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9669) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9670) + p.Match(RedshiftParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransaction_mode_listContext is an interface to support dynamic dispatch. +type ITransaction_mode_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTransaction_mode_item() []ITransaction_mode_itemContext + Transaction_mode_item(i int) ITransaction_mode_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTransaction_mode_listContext differentiates from other interfaces. + IsTransaction_mode_listContext() +} + +type Transaction_mode_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_mode_listContext() *Transaction_mode_listContext { + var p = new(Transaction_mode_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transaction_mode_list + return p +} + +func InitEmptyTransaction_mode_listContext(p *Transaction_mode_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transaction_mode_list +} + +func (*Transaction_mode_listContext) IsTransaction_mode_listContext() {} + +func NewTransaction_mode_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_listContext { + var p = new(Transaction_mode_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transaction_mode_list + + return p +} + +func (s *Transaction_mode_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_mode_listContext) AllTransaction_mode_item() []ITransaction_mode_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITransaction_mode_itemContext); ok { + len++ + } + } + + tst := make([]ITransaction_mode_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITransaction_mode_itemContext); ok { + tst[i] = t.(ITransaction_mode_itemContext) + i++ + } + } + + return tst +} + +func (s *Transaction_mode_listContext) Transaction_mode_item(i int) ITransaction_mode_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_mode_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_mode_itemContext) +} + +func (s *Transaction_mode_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Transaction_mode_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Transaction_mode_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_mode_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_mode_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransaction_mode_list(s) + } +} + +func (s *Transaction_mode_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransaction_mode_list(s) + } +} + +func (s *Transaction_mode_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransaction_mode_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transaction_mode_list() (localctx ITransaction_mode_listContext) { + localctx = NewTransaction_mode_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1014, RedshiftParserRULE_transaction_mode_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9673) + p.Transaction_mode_item() + } + p.SetState(9680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA || _la == RedshiftParserDEFERRABLE || _la == RedshiftParserNOT || _la == RedshiftParserISOLATION || _la == RedshiftParserREAD { + p.SetState(9675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(9674) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9677) + p.Transaction_mode_item() + } + + p.SetState(9682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransaction_mode_list_or_emptyContext is an interface to support dynamic dispatch. +type ITransaction_mode_list_or_emptyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Transaction_mode_list() ITransaction_mode_listContext + + // IsTransaction_mode_list_or_emptyContext differentiates from other interfaces. + IsTransaction_mode_list_or_emptyContext() +} + +type Transaction_mode_list_or_emptyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_mode_list_or_emptyContext() *Transaction_mode_list_or_emptyContext { + var p = new(Transaction_mode_list_or_emptyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transaction_mode_list_or_empty + return p +} + +func InitEmptyTransaction_mode_list_or_emptyContext(p *Transaction_mode_list_or_emptyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_transaction_mode_list_or_empty +} + +func (*Transaction_mode_list_or_emptyContext) IsTransaction_mode_list_or_emptyContext() {} + +func NewTransaction_mode_list_or_emptyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_mode_list_or_emptyContext { + var p = new(Transaction_mode_list_or_emptyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_transaction_mode_list_or_empty + + return p +} + +func (s *Transaction_mode_list_or_emptyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_mode_list_or_emptyContext) Transaction_mode_list() ITransaction_mode_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_mode_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_mode_listContext) +} + +func (s *Transaction_mode_list_or_emptyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_mode_list_or_emptyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_mode_list_or_emptyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTransaction_mode_list_or_empty(s) + } +} + +func (s *Transaction_mode_list_or_emptyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTransaction_mode_list_or_empty(s) + } +} + +func (s *Transaction_mode_list_or_emptyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTransaction_mode_list_or_empty(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Transaction_mode_list_or_empty() (localctx ITransaction_mode_list_or_emptyContext) { + localctx = NewTransaction_mode_list_or_emptyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1016, RedshiftParserRULE_transaction_mode_list_or_empty) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9683) + p.Transaction_mode_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_transaction_chainContext is an interface to support dynamic dispatch. +type IOpt_transaction_chainContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AND() antlr.TerminalNode + CHAIN() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsOpt_transaction_chainContext differentiates from other interfaces. + IsOpt_transaction_chainContext() +} + +type Opt_transaction_chainContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_transaction_chainContext() *Opt_transaction_chainContext { + var p = new(Opt_transaction_chainContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_transaction_chain + return p +} + +func InitEmptyOpt_transaction_chainContext(p *Opt_transaction_chainContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_transaction_chain +} + +func (*Opt_transaction_chainContext) IsOpt_transaction_chainContext() {} + +func NewOpt_transaction_chainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_transaction_chainContext { + var p = new(Opt_transaction_chainContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_transaction_chain + + return p +} + +func (s *Opt_transaction_chainContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_transaction_chainContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Opt_transaction_chainContext) CHAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHAIN, 0) +} + +func (s *Opt_transaction_chainContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_transaction_chainContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_transaction_chainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_transaction_chainContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_transaction_chain(s) + } +} + +func (s *Opt_transaction_chainContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_transaction_chain(s) + } +} + +func (s *Opt_transaction_chainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_transaction_chain(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_transaction_chain() (localctx IOpt_transaction_chainContext) { + localctx = NewOpt_transaction_chainContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1018, RedshiftParserRULE_opt_transaction_chain) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9685) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(9686) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9689) + p.Match(RedshiftParserCHAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IViewstmtContext is an interface to support dynamic dispatch. +type IViewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + AS() antlr.TerminalNode + Selectstmt() ISelectstmtContext + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + RECURSIVE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Opttemp() IOpttempContext + Opt_check_option() IOpt_check_optionContext + With_no_schema_binding() IWith_no_schema_bindingContext + Opt_column_list() IOpt_column_listContext + Opt_reloptions() IOpt_reloptionsContext + + // IsViewstmtContext differentiates from other interfaces. + IsViewstmtContext() +} + +type ViewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyViewstmtContext() *ViewstmtContext { + var p = new(ViewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_viewstmt + return p +} + +func InitEmptyViewstmtContext(p *ViewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_viewstmt +} + +func (*ViewstmtContext) IsViewstmtContext() {} + +func NewViewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ViewstmtContext { + var p = new(ViewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_viewstmt + + return p +} + +func (s *ViewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ViewstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *ViewstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *ViewstmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *ViewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *ViewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ViewstmtContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRECURSIVE, 0) +} + +func (s *ViewstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ViewstmtContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *ViewstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ViewstmtContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *ViewstmtContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *ViewstmtContext) Opttemp() IOpttempContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttempContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttempContext) +} + +func (s *ViewstmtContext) Opt_check_option() IOpt_check_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_check_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_check_optionContext) +} + +func (s *ViewstmtContext) With_no_schema_binding() IWith_no_schema_bindingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_no_schema_bindingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_no_schema_bindingContext) +} + +func (s *ViewstmtContext) Opt_column_list() IOpt_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_column_listContext) +} + +func (s *ViewstmtContext) Opt_reloptions() IOpt_reloptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_reloptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_reloptionsContext) +} + +func (s *ViewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ViewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ViewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterViewstmt(s) + } +} + +func (s *ViewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitViewstmt(s) + } +} + +func (s *ViewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitViewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Viewstmt() (localctx IViewstmtContext) { + localctx = NewViewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1020, RedshiftParserRULE_viewstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9691) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(9692) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9693) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLOCAL || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY { + { + p.SetState(9696) + p.Opttemp() + } + + } + p.SetState(9716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserVIEW: + { + p.SetState(9699) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9700) + p.Qualified_name() + } + p.SetState(9702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(9701) + p.Opt_column_list() + } + + } + p.SetState(9705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(9704) + p.Opt_reloptions() + } + + } + + case RedshiftParserRECURSIVE: + { + p.SetState(9707) + p.Match(RedshiftParserRECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9708) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9709) + p.Qualified_name() + } + { + p.SetState(9710) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9711) + p.Columnlist() + } + { + p.SetState(9712) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(9713) + p.Opt_reloptions() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(9718) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9719) + p.Selectstmt() + } + p.SetState(9721) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 773, p.GetParserRuleContext()) == 1 { + { + p.SetState(9720) + p.Opt_check_option() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9724) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 774, p.GetParserRuleContext()) == 1 { + { + p.SetState(9723) + p.With_no_schema_binding() + } + + } 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 +} + +// IWith_no_schema_bindingContext is an interface to support dynamic dispatch. +type IWith_no_schema_bindingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + NO() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + BINDING() antlr.TerminalNode + + // IsWith_no_schema_bindingContext differentiates from other interfaces. + IsWith_no_schema_bindingContext() +} + +type With_no_schema_bindingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_no_schema_bindingContext() *With_no_schema_bindingContext { + var p = new(With_no_schema_bindingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_with_no_schema_binding + return p +} + +func InitEmptyWith_no_schema_bindingContext(p *With_no_schema_bindingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_with_no_schema_binding +} + +func (*With_no_schema_bindingContext) IsWith_no_schema_bindingContext() {} + +func NewWith_no_schema_bindingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_no_schema_bindingContext { + var p = new(With_no_schema_bindingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_with_no_schema_binding + + return p +} + +func (s *With_no_schema_bindingContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_no_schema_bindingContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *With_no_schema_bindingContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *With_no_schema_bindingContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *With_no_schema_bindingContext) BINDING() antlr.TerminalNode { + return s.GetToken(RedshiftParserBINDING, 0) +} + +func (s *With_no_schema_bindingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_no_schema_bindingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_no_schema_bindingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWith_no_schema_binding(s) + } +} + +func (s *With_no_schema_bindingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWith_no_schema_binding(s) + } +} + +func (s *With_no_schema_bindingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWith_no_schema_binding(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) With_no_schema_binding() (localctx IWith_no_schema_bindingContext) { + localctx = NewWith_no_schema_bindingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1022, RedshiftParserRULE_with_no_schema_binding) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9726) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9727) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9728) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9729) + p.Match(RedshiftParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_check_optionContext is an interface to support dynamic dispatch. +type IOpt_check_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + CHECK() antlr.TerminalNode + OPTION() antlr.TerminalNode + CASCADED() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsOpt_check_optionContext differentiates from other interfaces. + IsOpt_check_optionContext() +} + +type Opt_check_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_check_optionContext() *Opt_check_optionContext { + var p = new(Opt_check_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_check_option + return p +} + +func InitEmptyOpt_check_optionContext(p *Opt_check_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_check_option +} + +func (*Opt_check_optionContext) IsOpt_check_optionContext() {} + +func NewOpt_check_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_check_optionContext { + var p = new(Opt_check_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_check_option + + return p +} + +func (s *Opt_check_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_check_optionContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_check_optionContext) CHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECK, 0) +} + +func (s *Opt_check_optionContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Opt_check_optionContext) CASCADED() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADED, 0) +} + +func (s *Opt_check_optionContext) LOCAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCAL, 0) +} + +func (s *Opt_check_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_check_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_check_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_check_option(s) + } +} + +func (s *Opt_check_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_check_option(s) + } +} + +func (s *Opt_check_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_check_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_check_option() (localctx IOpt_check_optionContext) { + localctx = NewOpt_check_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1024, RedshiftParserRULE_opt_check_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9731) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADED || _la == RedshiftParserLOCAL { + { + p.SetState(9732) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASCADED || _la == RedshiftParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(9735) + p.Match(RedshiftParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9736) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoadstmtContext is an interface to support dynamic dispatch. +type ILoadstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOAD() antlr.TerminalNode + File_name() IFile_nameContext + + // IsLoadstmtContext differentiates from other interfaces. + IsLoadstmtContext() +} + +type LoadstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoadstmtContext() *LoadstmtContext { + var p = new(LoadstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_loadstmt + return p +} + +func InitEmptyLoadstmtContext(p *LoadstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_loadstmt +} + +func (*LoadstmtContext) IsLoadstmtContext() {} + +func NewLoadstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LoadstmtContext { + var p = new(LoadstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_loadstmt + + return p +} + +func (s *LoadstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *LoadstmtContext) LOAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOAD, 0) +} + +func (s *LoadstmtContext) File_name() IFile_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_nameContext) +} + +func (s *LoadstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LoadstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LoadstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLoadstmt(s) + } +} + +func (s *LoadstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLoadstmt(s) + } +} + +func (s *LoadstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLoadstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Loadstmt() (localctx ILoadstmtContext) { + localctx = NewLoadstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1026, RedshiftParserRULE_loadstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9738) + p.Match(RedshiftParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9739) + p.File_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterdatasharestmtContext is an interface to support dynamic dispatch. +type IAlterdatasharestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + Colid() IColidContext + Alterdatashare_action() IAlterdatashare_actionContext + + // IsAlterdatasharestmtContext differentiates from other interfaces. + IsAlterdatasharestmtContext() +} + +type AlterdatasharestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdatasharestmtContext() *AlterdatasharestmtContext { + var p = new(AlterdatasharestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatasharestmt + return p +} + +func InitEmptyAlterdatasharestmtContext(p *AlterdatasharestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatasharestmt +} + +func (*AlterdatasharestmtContext) IsAlterdatasharestmtContext() {} + +func NewAlterdatasharestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdatasharestmtContext { + var p = new(AlterdatasharestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdatasharestmt + + return p +} + +func (s *AlterdatasharestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterdatasharestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterdatasharestmtContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *AlterdatasharestmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AlterdatasharestmtContext) Alterdatashare_action() IAlterdatashare_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdatashare_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdatashare_actionContext) +} + +func (s *AlterdatasharestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterdatasharestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterdatasharestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdatasharestmt(s) + } +} + +func (s *AlterdatasharestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdatasharestmt(s) + } +} + +func (s *AlterdatasharestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdatasharestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdatasharestmt() (localctx IAlterdatasharestmtContext) { + localctx = NewAlterdatasharestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1028, RedshiftParserRULE_alterdatasharestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9741) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9742) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9743) + p.Colid() + } + { + p.SetState(9744) + p.Alterdatashare_action() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterdatashare_actionContext is an interface to support dynamic dispatch. +type IAlterdatashare_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alterdatashare_add_drop() IAlterdatashare_add_dropContext + Alterdatashare_objects() IAlterdatashare_objectsContext + SET() antlr.TerminalNode + PUBLICACCESSIBLE() antlr.TerminalNode + Opt_boolean_or_string() IOpt_boolean_or_stringContext + Opt_equal() IOpt_equalContext + INCLUDENEW() antlr.TerminalNode + FOR() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Colid() IColidContext + + // IsAlterdatashare_actionContext differentiates from other interfaces. + IsAlterdatashare_actionContext() +} + +type Alterdatashare_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdatashare_actionContext() *Alterdatashare_actionContext { + var p = new(Alterdatashare_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatashare_action + return p +} + +func InitEmptyAlterdatashare_actionContext(p *Alterdatashare_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatashare_action +} + +func (*Alterdatashare_actionContext) IsAlterdatashare_actionContext() {} + +func NewAlterdatashare_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alterdatashare_actionContext { + var p = new(Alterdatashare_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdatashare_action + + return p +} + +func (s *Alterdatashare_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alterdatashare_actionContext) Alterdatashare_add_drop() IAlterdatashare_add_dropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdatashare_add_dropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdatashare_add_dropContext) +} + +func (s *Alterdatashare_actionContext) Alterdatashare_objects() IAlterdatashare_objectsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlterdatashare_objectsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlterdatashare_objectsContext) +} + +func (s *Alterdatashare_actionContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Alterdatashare_actionContext) PUBLICACCESSIBLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICACCESSIBLE, 0) +} + +func (s *Alterdatashare_actionContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_boolean_or_stringContext) +} + +func (s *Alterdatashare_actionContext) Opt_equal() IOpt_equalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_equalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_equalContext) +} + +func (s *Alterdatashare_actionContext) INCLUDENEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDENEW, 0) +} + +func (s *Alterdatashare_actionContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Alterdatashare_actionContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Alterdatashare_actionContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Alterdatashare_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alterdatashare_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alterdatashare_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdatashare_action(s) + } +} + +func (s *Alterdatashare_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdatashare_action(s) + } +} + +func (s *Alterdatashare_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdatashare_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdatashare_action() (localctx IAlterdatashare_actionContext) { + localctx = NewAlterdatashare_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1030, RedshiftParserRULE_alterdatashare_action) + var _la int + + p.SetState(9765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 778, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9746) + p.Alterdatashare_add_drop() + } + { + p.SetState(9747) + p.Alterdatashare_objects() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9749) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9750) + p.Match(RedshiftParserPUBLICACCESSIBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL { + { + p.SetState(9751) + p.Opt_equal() + } + + } + { + p.SetState(9754) + p.Opt_boolean_or_string() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9755) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9756) + p.Match(RedshiftParserINCLUDENEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9758) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL { + { + p.SetState(9757) + p.Opt_equal() + } + + } + { + p.SetState(9760) + p.Opt_boolean_or_string() + } + { + p.SetState(9761) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9762) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9763) + p.Colid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterdatashare_add_dropContext is an interface to support dynamic dispatch. +type IAlterdatashare_add_dropContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD_P() antlr.TerminalNode + REMOVE() antlr.TerminalNode + + // IsAlterdatashare_add_dropContext differentiates from other interfaces. + IsAlterdatashare_add_dropContext() +} + +type Alterdatashare_add_dropContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdatashare_add_dropContext() *Alterdatashare_add_dropContext { + var p = new(Alterdatashare_add_dropContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatashare_add_drop + return p +} + +func InitEmptyAlterdatashare_add_dropContext(p *Alterdatashare_add_dropContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatashare_add_drop +} + +func (*Alterdatashare_add_dropContext) IsAlterdatashare_add_dropContext() {} + +func NewAlterdatashare_add_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alterdatashare_add_dropContext { + var p = new(Alterdatashare_add_dropContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdatashare_add_drop + + return p +} + +func (s *Alterdatashare_add_dropContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alterdatashare_add_dropContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *Alterdatashare_add_dropContext) REMOVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREMOVE, 0) +} + +func (s *Alterdatashare_add_dropContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alterdatashare_add_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alterdatashare_add_dropContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdatashare_add_drop(s) + } +} + +func (s *Alterdatashare_add_dropContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdatashare_add_drop(s) + } +} + +func (s *Alterdatashare_add_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdatashare_add_drop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdatashare_add_drop() (localctx IAlterdatashare_add_dropContext) { + localctx = NewAlterdatashare_add_dropContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1032, RedshiftParserRULE_alterdatashare_add_drop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9767) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserADD_P || _la == RedshiftParserREMOVE) { + 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 +} + +// IAlterdatashare_objectsContext is an interface to support dynamic dispatch. +type IAlterdatashare_objectsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + Datashare_table_list() IDatashare_table_listContext + SCHEMA() antlr.TerminalNode + Name_list() IName_listContext + FUNCTION() antlr.TerminalNode + Datashare_function_list() IDatashare_function_listContext + ALL() antlr.TerminalNode + TABLES() antlr.TerminalNode + IN_P() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + + // IsAlterdatashare_objectsContext differentiates from other interfaces. + IsAlterdatashare_objectsContext() +} + +type Alterdatashare_objectsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdatashare_objectsContext() *Alterdatashare_objectsContext { + var p = new(Alterdatashare_objectsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatashare_objects + return p +} + +func InitEmptyAlterdatashare_objectsContext(p *Alterdatashare_objectsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatashare_objects +} + +func (*Alterdatashare_objectsContext) IsAlterdatashare_objectsContext() {} + +func NewAlterdatashare_objectsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alterdatashare_objectsContext { + var p = new(Alterdatashare_objectsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdatashare_objects + + return p +} + +func (s *Alterdatashare_objectsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alterdatashare_objectsContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Alterdatashare_objectsContext) Datashare_table_list() IDatashare_table_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatashare_table_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatashare_table_listContext) +} + +func (s *Alterdatashare_objectsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Alterdatashare_objectsContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *Alterdatashare_objectsContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Alterdatashare_objectsContext) Datashare_function_list() IDatashare_function_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatashare_function_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatashare_function_listContext) +} + +func (s *Alterdatashare_objectsContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Alterdatashare_objectsContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *Alterdatashare_objectsContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Alterdatashare_objectsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTIONS, 0) +} + +func (s *Alterdatashare_objectsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alterdatashare_objectsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alterdatashare_objectsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdatashare_objects(s) + } +} + +func (s *Alterdatashare_objectsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdatashare_objects(s) + } +} + +func (s *Alterdatashare_objectsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdatashare_objects(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdatashare_objects() (localctx IAlterdatashare_objectsContext) { + localctx = NewAlterdatashare_objectsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1034, RedshiftParserRULE_alterdatashare_objects) + p.SetState(9785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 779, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9769) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9770) + p.Datashare_table_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9771) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9772) + p.Name_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9773) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9774) + p.Datashare_function_list() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9775) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9776) + p.Match(RedshiftParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9777) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9778) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9779) + p.Name_list() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9780) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9781) + p.Match(RedshiftParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9782) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9783) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9784) + p.Name_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatashare_table_listContext is an interface to support dynamic dispatch. +type IDatashare_table_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDatashare_table_name() []IDatashare_table_nameContext + Datashare_table_name(i int) IDatashare_table_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDatashare_table_listContext differentiates from other interfaces. + IsDatashare_table_listContext() +} + +type Datashare_table_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatashare_table_listContext() *Datashare_table_listContext { + var p = new(Datashare_table_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_table_list + return p +} + +func InitEmptyDatashare_table_listContext(p *Datashare_table_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_table_list +} + +func (*Datashare_table_listContext) IsDatashare_table_listContext() {} + +func NewDatashare_table_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datashare_table_listContext { + var p = new(Datashare_table_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_datashare_table_list + + return p +} + +func (s *Datashare_table_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datashare_table_listContext) AllDatashare_table_name() []IDatashare_table_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatashare_table_nameContext); ok { + len++ + } + } + + tst := make([]IDatashare_table_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatashare_table_nameContext); ok { + tst[i] = t.(IDatashare_table_nameContext) + i++ + } + } + + return tst +} + +func (s *Datashare_table_listContext) Datashare_table_name(i int) IDatashare_table_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatashare_table_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatashare_table_nameContext) +} + +func (s *Datashare_table_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Datashare_table_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Datashare_table_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datashare_table_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datashare_table_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatashare_table_list(s) + } +} + +func (s *Datashare_table_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatashare_table_list(s) + } +} + +func (s *Datashare_table_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatashare_table_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Datashare_table_list() (localctx IDatashare_table_listContext) { + localctx = NewDatashare_table_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1036, RedshiftParserRULE_datashare_table_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9787) + p.Datashare_table_name() + } + p.SetState(9792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(9788) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9789) + p.Datashare_table_name() + } + + p.SetState(9794) + 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 +} + +// IDatashare_table_nameContext is an interface to support dynamic dispatch. +type IDatashare_table_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColid() []IColidContext + Colid(i int) IColidContext + DOT() antlr.TerminalNode + + // IsDatashare_table_nameContext differentiates from other interfaces. + IsDatashare_table_nameContext() +} + +type Datashare_table_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatashare_table_nameContext() *Datashare_table_nameContext { + var p = new(Datashare_table_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_table_name + return p +} + +func InitEmptyDatashare_table_nameContext(p *Datashare_table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_table_name +} + +func (*Datashare_table_nameContext) IsDatashare_table_nameContext() {} + +func NewDatashare_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datashare_table_nameContext { + var p = new(Datashare_table_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_datashare_table_name + + return p +} + +func (s *Datashare_table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datashare_table_nameContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Datashare_table_nameContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Datashare_table_nameContext) DOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, 0) +} + +func (s *Datashare_table_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datashare_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datashare_table_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatashare_table_name(s) + } +} + +func (s *Datashare_table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatashare_table_name(s) + } +} + +func (s *Datashare_table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatashare_table_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Datashare_table_name() (localctx IDatashare_table_nameContext) { + localctx = NewDatashare_table_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1038, RedshiftParserRULE_datashare_table_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9795) + p.Colid() + } + p.SetState(9798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDOT { + { + p.SetState(9796) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9797) + p.Colid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_nameContext is an interface to support dynamic dispatch. +type ITable_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name() IQualified_nameContext + Temporary_table_name() ITemporary_table_nameContext + + // 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 = RedshiftParserRULE_table_name + return p +} + +func InitEmptyTable_nameContext(p *Table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_table_name + + return p +} + +func (s *Table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_nameContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Table_nameContext) Temporary_table_name() ITemporary_table_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemporary_table_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemporary_table_nameContext) +} + +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.(RedshiftParserListener); ok { + listenerT.EnterTable_name(s) + } +} + +func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_name(s) + } +} + +func (s *Table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_name() (localctx ITable_nameContext) { + localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1040, RedshiftParserRULE_table_name) + p.SetState(9802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9800) + p.Qualified_name() + } + + case RedshiftParserTemporaryIdentifier: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9801) + p.Temporary_table_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 +} + +// ITemporary_table_nameContext is an interface to support dynamic dispatch. +type ITemporary_table_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TemporaryIdentifier() antlr.TerminalNode + + // IsTemporary_table_nameContext differentiates from other interfaces. + IsTemporary_table_nameContext() +} + +type Temporary_table_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTemporary_table_nameContext() *Temporary_table_nameContext { + var p = new(Temporary_table_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_temporary_table_name + return p +} + +func InitEmptyTemporary_table_nameContext(p *Temporary_table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_temporary_table_name +} + +func (*Temporary_table_nameContext) IsTemporary_table_nameContext() {} + +func NewTemporary_table_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Temporary_table_nameContext { + var p = new(Temporary_table_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_temporary_table_name + + return p +} + +func (s *Temporary_table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Temporary_table_nameContext) TemporaryIdentifier() antlr.TerminalNode { + return s.GetToken(RedshiftParserTemporaryIdentifier, 0) +} + +func (s *Temporary_table_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Temporary_table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Temporary_table_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTemporary_table_name(s) + } +} + +func (s *Temporary_table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTemporary_table_name(s) + } +} + +func (s *Temporary_table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTemporary_table_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Temporary_table_name() (localctx ITemporary_table_nameContext) { + localctx = NewTemporary_table_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1042, RedshiftParserRULE_temporary_table_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9804) + p.Match(RedshiftParserTemporaryIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatashare_function_listContext is an interface to support dynamic dispatch. +type IDatashare_function_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDatashare_function() []IDatashare_functionContext + Datashare_function(i int) IDatashare_functionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDatashare_function_listContext differentiates from other interfaces. + IsDatashare_function_listContext() +} + +type Datashare_function_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatashare_function_listContext() *Datashare_function_listContext { + var p = new(Datashare_function_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_function_list + return p +} + +func InitEmptyDatashare_function_listContext(p *Datashare_function_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_function_list +} + +func (*Datashare_function_listContext) IsDatashare_function_listContext() {} + +func NewDatashare_function_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datashare_function_listContext { + var p = new(Datashare_function_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_datashare_function_list + + return p +} + +func (s *Datashare_function_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datashare_function_listContext) AllDatashare_function() []IDatashare_functionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatashare_functionContext); ok { + len++ + } + } + + tst := make([]IDatashare_functionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatashare_functionContext); ok { + tst[i] = t.(IDatashare_functionContext) + i++ + } + } + + return tst +} + +func (s *Datashare_function_listContext) Datashare_function(i int) IDatashare_functionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatashare_functionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatashare_functionContext) +} + +func (s *Datashare_function_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Datashare_function_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Datashare_function_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datashare_function_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datashare_function_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatashare_function_list(s) + } +} + +func (s *Datashare_function_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatashare_function_list(s) + } +} + +func (s *Datashare_function_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatashare_function_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Datashare_function_list() (localctx IDatashare_function_listContext) { + localctx = NewDatashare_function_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1044, RedshiftParserRULE_datashare_function_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9806) + p.Datashare_function() + } + p.SetState(9811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(9807) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9808) + p.Datashare_function() + } + + p.SetState(9813) + 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 +} + +// IDatashare_functionContext is an interface to support dynamic dispatch. +type IDatashare_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Datashare_function_name() IDatashare_function_nameContext + Func_args() IFunc_argsContext + + // IsDatashare_functionContext differentiates from other interfaces. + IsDatashare_functionContext() +} + +type Datashare_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatashare_functionContext() *Datashare_functionContext { + var p = new(Datashare_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_function + return p +} + +func InitEmptyDatashare_functionContext(p *Datashare_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_function +} + +func (*Datashare_functionContext) IsDatashare_functionContext() {} + +func NewDatashare_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datashare_functionContext { + var p = new(Datashare_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_datashare_function + + return p +} + +func (s *Datashare_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datashare_functionContext) Datashare_function_name() IDatashare_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatashare_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatashare_function_nameContext) +} + +func (s *Datashare_functionContext) Func_args() IFunc_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argsContext) +} + +func (s *Datashare_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datashare_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datashare_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatashare_function(s) + } +} + +func (s *Datashare_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatashare_function(s) + } +} + +func (s *Datashare_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatashare_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Datashare_function() (localctx IDatashare_functionContext) { + localctx = NewDatashare_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1046, RedshiftParserRULE_datashare_function) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9814) + p.Datashare_function_name() + } + { + p.SetState(9815) + p.Func_args() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatashare_function_nameContext is an interface to support dynamic dispatch. +type IDatashare_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColid() []IColidContext + Colid(i int) IColidContext + DOT() antlr.TerminalNode + + // IsDatashare_function_nameContext differentiates from other interfaces. + IsDatashare_function_nameContext() +} + +type Datashare_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatashare_function_nameContext() *Datashare_function_nameContext { + var p = new(Datashare_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_function_name + return p +} + +func InitEmptyDatashare_function_nameContext(p *Datashare_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datashare_function_name +} + +func (*Datashare_function_nameContext) IsDatashare_function_nameContext() {} + +func NewDatashare_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datashare_function_nameContext { + var p = new(Datashare_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_datashare_function_name + + return p +} + +func (s *Datashare_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datashare_function_nameContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *Datashare_function_nameContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Datashare_function_nameContext) DOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, 0) +} + +func (s *Datashare_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datashare_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datashare_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatashare_function_name(s) + } +} + +func (s *Datashare_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatashare_function_name(s) + } +} + +func (s *Datashare_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatashare_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Datashare_function_name() (localctx IDatashare_function_nameContext) { + localctx = NewDatashare_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1048, RedshiftParserRULE_datashare_function_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9817) + p.Colid() + } + p.SetState(9820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDOT { + { + p.SetState(9818) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9819) + p.Colid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatedatasharestmtContext is an interface to support dynamic dispatch. +type ICreatedatasharestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Createdatashareoptions() ICreatedatashareoptionsContext + + // IsCreatedatasharestmtContext differentiates from other interfaces. + IsCreatedatasharestmtContext() +} + +type CreatedatasharestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedatasharestmtContext() *CreatedatasharestmtContext { + var p = new(CreatedatasharestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdatasharestmt + return p +} + +func InitEmptyCreatedatasharestmtContext(p *CreatedatasharestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdatasharestmt +} + +func (*CreatedatasharestmtContext) IsCreatedatasharestmtContext() {} + +func NewCreatedatasharestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedatasharestmtContext { + var p = new(CreatedatasharestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdatasharestmt + + return p +} + +func (s *CreatedatasharestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatedatasharestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatedatasharestmtContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *CreatedatasharestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreatedatasharestmtContext) Createdatashareoptions() ICreatedatashareoptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedatashareoptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedatashareoptionsContext) +} + +func (s *CreatedatasharestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatedatasharestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatedatasharestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedatasharestmt(s) + } +} + +func (s *CreatedatasharestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedatasharestmt(s) + } +} + +func (s *CreatedatasharestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedatasharestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdatasharestmt() (localctx ICreatedatasharestmtContext) { + localctx = NewCreatedatasharestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1050, RedshiftParserRULE_createdatasharestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9822) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9823) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9824) + p.Qualified_name() + } + p.SetState(9826) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 785, p.GetParserRuleContext()) == 1 { + { + p.SetState(9825) + p.Createdatashareoptions() + } + + } 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 +} + +// ICreatedatashareoptionsContext is an interface to support dynamic dispatch. +type ICreatedatashareoptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCreatedatashareoption() []ICreatedatashareoptionContext + Createdatashareoption(i int) ICreatedatashareoptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreatedatashareoptionsContext differentiates from other interfaces. + IsCreatedatashareoptionsContext() +} + +type CreatedatashareoptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedatashareoptionsContext() *CreatedatashareoptionsContext { + var p = new(CreatedatashareoptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdatashareoptions + return p +} + +func InitEmptyCreatedatashareoptionsContext(p *CreatedatashareoptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdatashareoptions +} + +func (*CreatedatashareoptionsContext) IsCreatedatashareoptionsContext() {} + +func NewCreatedatashareoptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedatashareoptionsContext { + var p = new(CreatedatashareoptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdatashareoptions + + return p +} + +func (s *CreatedatashareoptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatedatashareoptionsContext) AllCreatedatashareoption() []ICreatedatashareoptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreatedatashareoptionContext); ok { + len++ + } + } + + tst := make([]ICreatedatashareoptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreatedatashareoptionContext); ok { + tst[i] = t.(ICreatedatashareoptionContext) + i++ + } + } + + return tst +} + +func (s *CreatedatashareoptionsContext) Createdatashareoption(i int) ICreatedatashareoptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedatashareoptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreatedatashareoptionContext) +} + +func (s *CreatedatashareoptionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *CreatedatashareoptionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *CreatedatashareoptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatedatashareoptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatedatashareoptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedatashareoptions(s) + } +} + +func (s *CreatedatashareoptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedatashareoptions(s) + } +} + +func (s *CreatedatashareoptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedatashareoptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdatashareoptions() (localctx ICreatedatashareoptionsContext) { + localctx = NewCreatedatashareoptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1052, RedshiftParserRULE_createdatashareoptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9828) + p.Createdatashareoption() + } + p.SetState(9833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(9829) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9830) + p.Createdatashareoption() + } + + p.SetState(9835) + 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 +} + +// ICreatedatashareoptionContext is an interface to support dynamic dispatch. +type ICreatedatashareoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Setpublicaccessibleoption() ISetpublicaccessibleoptionContext + Managedbyoption() IManagedbyoptionContext + + // IsCreatedatashareoptionContext differentiates from other interfaces. + IsCreatedatashareoptionContext() +} + +type CreatedatashareoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedatashareoptionContext() *CreatedatashareoptionContext { + var p = new(CreatedatashareoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdatashareoption + return p +} + +func InitEmptyCreatedatashareoptionContext(p *CreatedatashareoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdatashareoption +} + +func (*CreatedatashareoptionContext) IsCreatedatashareoptionContext() {} + +func NewCreatedatashareoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedatashareoptionContext { + var p = new(CreatedatashareoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdatashareoption + + return p +} + +func (s *CreatedatashareoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatedatashareoptionContext) Setpublicaccessibleoption() ISetpublicaccessibleoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetpublicaccessibleoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetpublicaccessibleoptionContext) +} + +func (s *CreatedatashareoptionContext) Managedbyoption() IManagedbyoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IManagedbyoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IManagedbyoptionContext) +} + +func (s *CreatedatashareoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatedatashareoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatedatashareoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedatashareoption(s) + } +} + +func (s *CreatedatashareoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedatashareoption(s) + } +} + +func (s *CreatedatashareoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedatashareoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdatashareoption() (localctx ICreatedatashareoptionContext) { + localctx = NewCreatedatashareoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1054, RedshiftParserRULE_createdatashareoption) + p.SetState(9838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSET, RedshiftParserPUBLICACCESSIBLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9836) + p.Setpublicaccessibleoption() + } + + case RedshiftParserMANAGEDBY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9837) + p.Managedbyoption() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISetpublicaccessibleoptionContext is an interface to support dynamic dispatch. +type ISetpublicaccessibleoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PUBLICACCESSIBLE() antlr.TerminalNode + SET() antlr.TerminalNode + TRUE_P() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + EQUAL() antlr.TerminalNode + + // IsSetpublicaccessibleoptionContext differentiates from other interfaces. + IsSetpublicaccessibleoptionContext() +} + +type SetpublicaccessibleoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetpublicaccessibleoptionContext() *SetpublicaccessibleoptionContext { + var p = new(SetpublicaccessibleoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setpublicaccessibleoption + return p +} + +func InitEmptySetpublicaccessibleoptionContext(p *SetpublicaccessibleoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setpublicaccessibleoption +} + +func (*SetpublicaccessibleoptionContext) IsSetpublicaccessibleoptionContext() {} + +func NewSetpublicaccessibleoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetpublicaccessibleoptionContext { + var p = new(SetpublicaccessibleoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_setpublicaccessibleoption + + return p +} + +func (s *SetpublicaccessibleoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetpublicaccessibleoptionContext) PUBLICACCESSIBLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICACCESSIBLE, 0) +} + +func (s *SetpublicaccessibleoptionContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *SetpublicaccessibleoptionContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *SetpublicaccessibleoptionContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *SetpublicaccessibleoptionContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *SetpublicaccessibleoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetpublicaccessibleoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetpublicaccessibleoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSetpublicaccessibleoption(s) + } +} + +func (s *SetpublicaccessibleoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSetpublicaccessibleoption(s) + } +} + +func (s *SetpublicaccessibleoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSetpublicaccessibleoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Setpublicaccessibleoption() (localctx ISetpublicaccessibleoptionContext) { + localctx = NewSetpublicaccessibleoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1056, RedshiftParserRULE_setpublicaccessibleoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSET { + { + p.SetState(9840) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9843) + p.Match(RedshiftParserPUBLICACCESSIBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL || _la == RedshiftParserFALSE_P || _la == RedshiftParserTRUE_P { + p.SetState(9845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL { + { + p.SetState(9844) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9847) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFALSE_P || _la == RedshiftParserTRUE_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IManagedbyoptionContext is an interface to support dynamic dispatch. +type IManagedbyoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MANAGEDBY() antlr.TerminalNode + ADX() antlr.TerminalNode + + // IsManagedbyoptionContext differentiates from other interfaces. + IsManagedbyoptionContext() +} + +type ManagedbyoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyManagedbyoptionContext() *ManagedbyoptionContext { + var p = new(ManagedbyoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_managedbyoption + return p +} + +func InitEmptyManagedbyoptionContext(p *ManagedbyoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_managedbyoption +} + +func (*ManagedbyoptionContext) IsManagedbyoptionContext() {} + +func NewManagedbyoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ManagedbyoptionContext { + var p = new(ManagedbyoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_managedbyoption + + return p +} + +func (s *ManagedbyoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ManagedbyoptionContext) MANAGEDBY() antlr.TerminalNode { + return s.GetToken(RedshiftParserMANAGEDBY, 0) +} + +func (s *ManagedbyoptionContext) ADX() antlr.TerminalNode { + return s.GetToken(RedshiftParserADX, 0) +} + +func (s *ManagedbyoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ManagedbyoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ManagedbyoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterManagedbyoption(s) + } +} + +func (s *ManagedbyoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitManagedbyoption(s) + } +} + +func (s *ManagedbyoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitManagedbyoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Managedbyoption() (localctx IManagedbyoptionContext) { + localctx = NewManagedbyoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1058, RedshiftParserRULE_managedbyoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9850) + p.Match(RedshiftParserMANAGEDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9851) + p.Match(RedshiftParserADX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescdatasharestmtContext is an interface to support dynamic dispatch. +type IDescdatasharestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatashare_name returns the datashare_name rule contexts. + GetDatashare_name() IColidContext + + // GetAccount_id returns the account_id rule contexts. + GetAccount_id() ISconstContext + + // GetNamespace_guid returns the namespace_guid rule contexts. + GetNamespace_guid() ISconstContext + + // SetDatashare_name sets the datashare_name rule contexts. + SetDatashare_name(IColidContext) + + // SetAccount_id sets the account_id rule contexts. + SetAccount_id(ISconstContext) + + // SetNamespace_guid sets the namespace_guid rule contexts. + SetNamespace_guid(ISconstContext) + + // Getter signatures + DATASHARE() antlr.TerminalNode + DESC() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + Colid() IColidContext + OF() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + ACCOUNT() antlr.TerminalNode + + // IsDescdatasharestmtContext differentiates from other interfaces. + IsDescdatasharestmtContext() +} + +type DescdatasharestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + datashare_name IColidContext + account_id ISconstContext + namespace_guid ISconstContext +} + +func NewEmptyDescdatasharestmtContext() *DescdatasharestmtContext { + var p = new(DescdatasharestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_descdatasharestmt + return p +} + +func InitEmptyDescdatasharestmtContext(p *DescdatasharestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_descdatasharestmt +} + +func (*DescdatasharestmtContext) IsDescdatasharestmtContext() {} + +func NewDescdatasharestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DescdatasharestmtContext { + var p = new(DescdatasharestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_descdatasharestmt + + return p +} + +func (s *DescdatasharestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DescdatasharestmtContext) GetDatashare_name() IColidContext { return s.datashare_name } + +func (s *DescdatasharestmtContext) GetAccount_id() ISconstContext { return s.account_id } + +func (s *DescdatasharestmtContext) GetNamespace_guid() ISconstContext { return s.namespace_guid } + +func (s *DescdatasharestmtContext) SetDatashare_name(v IColidContext) { s.datashare_name = v } + +func (s *DescdatasharestmtContext) SetAccount_id(v ISconstContext) { s.account_id = v } + +func (s *DescdatasharestmtContext) SetNamespace_guid(v ISconstContext) { s.namespace_guid = v } + +func (s *DescdatasharestmtContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *DescdatasharestmtContext) DESC() antlr.TerminalNode { + return s.GetToken(RedshiftParserDESC, 0) +} + +func (s *DescdatasharestmtContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDESCRIBE, 0) +} + +func (s *DescdatasharestmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DescdatasharestmtContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *DescdatasharestmtContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMESPACE, 0) +} + +func (s *DescdatasharestmtContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *DescdatasharestmtContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *DescdatasharestmtContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCOUNT, 0) +} + +func (s *DescdatasharestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescdatasharestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DescdatasharestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDescdatasharestmt(s) + } +} + +func (s *DescdatasharestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDescdatasharestmt(s) + } +} + +func (s *DescdatasharestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDescdatasharestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Descdatasharestmt() (localctx IDescdatasharestmtContext) { + localctx = NewDescdatasharestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1060, RedshiftParserRULE_descdatasharestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9853) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserDESC || _la == RedshiftParserDESCRIBE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9854) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9855) + + var _x = p.Colid() + + localctx.(*DescdatasharestmtContext).datashare_name = _x + } + p.SetState(9863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOF { + { + p.SetState(9856) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserACCOUNT { + { + p.SetState(9857) + p.Match(RedshiftParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9858) + + var _x = p.Sconst() + + localctx.(*DescdatasharestmtContext).account_id = _x + } + + } + { + p.SetState(9861) + p.Match(RedshiftParserNAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9862) + + var _x = p.Sconst() + + localctx.(*DescdatasharestmtContext).namespace_guid = _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 +} + +// IDropdatasharestmtContext is an interface to support dynamic dispatch. +type IDropdatasharestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + Colid() IColidContext + Opt_if_exists() IOpt_if_existsContext + + // IsDropdatasharestmtContext differentiates from other interfaces. + IsDropdatasharestmtContext() +} + +type DropdatasharestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropdatasharestmtContext() *DropdatasharestmtContext { + var p = new(DropdatasharestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropdatasharestmt + return p +} + +func InitEmptyDropdatasharestmtContext(p *DropdatasharestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropdatasharestmt +} + +func (*DropdatasharestmtContext) IsDropdatasharestmtContext() {} + +func NewDropdatasharestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropdatasharestmtContext { + var p = new(DropdatasharestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropdatasharestmt + + return p +} + +func (s *DropdatasharestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropdatasharestmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropdatasharestmtContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *DropdatasharestmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DropdatasharestmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropdatasharestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropdatasharestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropdatasharestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropdatasharestmt(s) + } +} + +func (s *DropdatasharestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropdatasharestmt(s) + } +} + +func (s *DropdatasharestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropdatasharestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropdatasharestmt() (localctx IDropdatasharestmtContext) { + localctx = NewDropdatasharestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1062, RedshiftParserRULE_dropdatasharestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9865) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9866) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9868) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) == 1 { + { + p.SetState(9867) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9870) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterexternalschemastmtContext is an interface to support dynamic dispatch. +type IAlterexternalschemastmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Colid() IColidContext + AllAltexternalschemaopts() []IAltexternalschemaoptsContext + Altexternalschemaopts(i int) IAltexternalschemaoptsContext + + // IsAlterexternalschemastmtContext differentiates from other interfaces. + IsAlterexternalschemastmtContext() +} + +type AlterexternalschemastmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterexternalschemastmtContext() *AlterexternalschemastmtContext { + var p = new(AlterexternalschemastmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterexternalschemastmt + return p +} + +func InitEmptyAlterexternalschemastmtContext(p *AlterexternalschemastmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterexternalschemastmt +} + +func (*AlterexternalschemastmtContext) IsAlterexternalschemastmtContext() {} + +func NewAlterexternalschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterexternalschemastmtContext { + var p = new(AlterexternalschemastmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterexternalschemastmt + + return p +} + +func (s *AlterexternalschemastmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterexternalschemastmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterexternalschemastmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *AlterexternalschemastmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *AlterexternalschemastmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AlterexternalschemastmtContext) AllAltexternalschemaopts() []IAltexternalschemaoptsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAltexternalschemaoptsContext); ok { + len++ + } + } + + tst := make([]IAltexternalschemaoptsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAltexternalschemaoptsContext); ok { + tst[i] = t.(IAltexternalschemaoptsContext) + i++ + } + } + + return tst +} + +func (s *AlterexternalschemastmtContext) Altexternalschemaopts(i int) IAltexternalschemaoptsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltexternalschemaoptsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAltexternalschemaoptsContext) +} + +func (s *AlterexternalschemastmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterexternalschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterexternalschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterexternalschemastmt(s) + } +} + +func (s *AlterexternalschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterexternalschemastmt(s) + } +} + +func (s *AlterexternalschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterexternalschemastmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterexternalschemastmt() (localctx IAlterexternalschemastmtContext) { + localctx = NewAlterexternalschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1064, RedshiftParserRULE_alterexternalschemastmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9872) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9873) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9874) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9875) + p.Colid() + } + p.SetState(9877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserOWNER || _la == RedshiftParserRENAME || ((int64((_la-396)) & ^0x3f) == 0 && ((int64(1)<<(_la-396))&12577) != 0) { + { + p.SetState(9876) + p.Altexternalschemaopts() + } + + p.SetState(9879) + 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 +} + +// IAltexternalschemaoptsContext is an interface to support dynamic dispatch. +type IAltexternalschemaoptsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Colid() IColidContext + OWNER() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + SESSION() antlr.TerminalNode + Sconst() ISconstContext + AUTHENTICATION() antlr.TerminalNode + NONE() antlr.TerminalNode + IAM() antlr.TerminalNode + MTLS() antlr.TerminalNode + AUTHENTICATION_ARN() antlr.TerminalNode + SECRET_ARN() antlr.TerminalNode + URI() antlr.TerminalNode + + // IsAltexternalschemaoptsContext differentiates from other interfaces. + IsAltexternalschemaoptsContext() +} + +type AltexternalschemaoptsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltexternalschemaoptsContext() *AltexternalschemaoptsContext { + var p = new(AltexternalschemaoptsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altexternalschemaopts + return p +} + +func InitEmptyAltexternalschemaoptsContext(p *AltexternalschemaoptsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altexternalschemaopts +} + +func (*AltexternalschemaoptsContext) IsAltexternalschemaoptsContext() {} + +func NewAltexternalschemaoptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltexternalschemaoptsContext { + var p = new(AltexternalschemaoptsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altexternalschemaopts + + return p +} + +func (s *AltexternalschemaoptsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltexternalschemaoptsContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *AltexternalschemaoptsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AltexternalschemaoptsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AltexternalschemaoptsContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *AltexternalschemaoptsContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *AltexternalschemaoptsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *AltexternalschemaoptsContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *AltexternalschemaoptsContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *AltexternalschemaoptsContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION, 0) +} + +func (s *AltexternalschemaoptsContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *AltexternalschemaoptsContext) IAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM, 0) +} + +func (s *AltexternalschemaoptsContext) MTLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMTLS, 0) +} + +func (s *AltexternalschemaoptsContext) AUTHENTICATION_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION_ARN, 0) +} + +func (s *AltexternalschemaoptsContext) SECRET_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECRET_ARN, 0) +} + +func (s *AltexternalschemaoptsContext) URI() antlr.TerminalNode { + return s.GetToken(RedshiftParserURI, 0) +} + +func (s *AltexternalschemaoptsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltexternalschemaoptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltexternalschemaoptsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltexternalschemaopts(s) + } +} + +func (s *AltexternalschemaoptsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltexternalschemaopts(s) + } +} + +func (s *AltexternalschemaoptsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltexternalschemaopts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altexternalschemaopts() (localctx IAltexternalschemaoptsContext) { + localctx = NewAltexternalschemaoptsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1066, RedshiftParserRULE_altexternalschemaopts) + var _la int + + p.SetState(9901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserRENAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9881) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9882) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9883) + p.Colid() + } + + case RedshiftParserOWNER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9884) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9885) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9886) + p.Colid() + } + + case RedshiftParserIAM_ROLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9887) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + { + p.SetState(9888) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSESSION: + { + p.SetState(9889) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(9890) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case RedshiftParserAUTHENTICATION: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9893) + p.Match(RedshiftParserAUTHENTICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9894) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserMTLS || _la == RedshiftParserIAM || _la == RedshiftParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserAUTHENTICATION_ARN: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9895) + p.Match(RedshiftParserAUTHENTICATION_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9896) + p.Sconst() + } + + case RedshiftParserSECRET_ARN: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9897) + p.Match(RedshiftParserSECRET_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9898) + p.Sconst() + } + + case RedshiftParserURI: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9899) + p.Match(RedshiftParserURI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9900) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterexternalviewstmtContext is an interface to support dynamic dispatch. +type IAlterexternalviewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + FORCE() antlr.TerminalNode + AS() antlr.TerminalNode + Selectstmt() ISelectstmtContext + REMOVE() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + + // IsAlterexternalviewstmtContext differentiates from other interfaces. + IsAlterexternalviewstmtContext() +} + +type AlterexternalviewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterexternalviewstmtContext() *AlterexternalviewstmtContext { + var p = new(AlterexternalviewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterexternalviewstmt + return p +} + +func InitEmptyAlterexternalviewstmtContext(p *AlterexternalviewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterexternalviewstmt +} + +func (*AlterexternalviewstmtContext) IsAlterexternalviewstmtContext() {} + +func NewAlterexternalviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterexternalviewstmtContext { + var p = new(AlterexternalviewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterexternalviewstmt + + return p +} + +func (s *AlterexternalviewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterexternalviewstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterexternalviewstmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *AlterexternalviewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *AlterexternalviewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AlterexternalviewstmtContext) FORCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORCE, 0) +} + +func (s *AlterexternalviewstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *AlterexternalviewstmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *AlterexternalviewstmtContext) REMOVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREMOVE, 0) +} + +func (s *AlterexternalviewstmtContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFINITION, 0) +} + +func (s *AlterexternalviewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterexternalviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterexternalviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterexternalviewstmt(s) + } +} + +func (s *AlterexternalviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterexternalviewstmt(s) + } +} + +func (s *AlterexternalviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterexternalviewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterexternalviewstmt() (localctx IAlterexternalviewstmtContext) { + localctx = NewAlterexternalviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1068, RedshiftParserRULE_alterexternalviewstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9903) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9904) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9905) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9906) + p.Qualified_name() + } + p.SetState(9908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFORCE { + { + p.SetState(9907) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case RedshiftParserAS: + { + p.SetState(9910) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9911) + p.Selectstmt() + } + + case RedshiftParserREMOVE: + { + p.SetState(9912) + p.Match(RedshiftParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9913) + p.Match(RedshiftParserDEFINITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEOF, RedshiftParserOPEN_PAREN, RedshiftParserSEMI, RedshiftParserANALYSE, RedshiftParserANALYZE, RedshiftParserCREATE, RedshiftParserDESC, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserGRANT, RedshiftParserINTO, RedshiftParserSELECT, RedshiftParserTABLE, RedshiftParserWITH, RedshiftParserABORT_P, RedshiftParserALTER, RedshiftParserBEGIN_P, RedshiftParserCHECKPOINT, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMIT, RedshiftParserCOPY, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDELETE_P, RedshiftParserDISCARD, RedshiftParserDROP, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserINSERT, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCK_P, RedshiftParserMERGE, RedshiftParserNOTIFY, RedshiftParserPREPARE, RedshiftParserREASSIGN, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELEASE, RedshiftParserRESET, RedshiftParserREVOKE, RedshiftParserROLLBACK, RedshiftParserSAVEPOINT, RedshiftParserSECURITY, RedshiftParserSET, RedshiftParserSHOW, RedshiftParserSTART, RedshiftParserTRUNCATE, RedshiftParserUNLISTEN, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserUNLOAD, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserDESCRIBE, RedshiftParserVALUES, RedshiftParserCALL, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserIMPORT_P, RedshiftParserEND_P, RedshiftParserMetaCommand: + + 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 +} + +// ICreateexternalschemastmtContext is an interface to support dynamic dispatch. +type ICreateexternalschemastmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IColidContext + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IColidContext) + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Colid() IColidContext + Fromdatacatalogclause() IFromdatacatalogclauseContext + Fromhivemetastoreclause() IFromhivemetastoreclauseContext + Frompostgresclause() IFrompostgresclauseContext + Frommysqlclause() IFrommysqlclauseContext + Fromkinesisclause() IFromkinesisclauseContext + Fromkafkaclause() IFromkafkaclauseContext + Frommskclause() IFrommskclauseContext + Fromredshiftclause() IFromredshiftclauseContext + Implicitdatacatalogclause() IImplicitdatacatalogclauseContext + Opt_if_not_exists() IOpt_if_not_existsContext + + // IsCreateexternalschemastmtContext differentiates from other interfaces. + IsCreateexternalschemastmtContext() +} + +type CreateexternalschemastmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + schema_name IColidContext +} + +func NewEmptyCreateexternalschemastmtContext() *CreateexternalschemastmtContext { + var p = new(CreateexternalschemastmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalschemastmt + return p +} + +func InitEmptyCreateexternalschemastmtContext(p *CreateexternalschemastmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalschemastmt +} + +func (*CreateexternalschemastmtContext) IsCreateexternalschemastmtContext() {} + +func NewCreateexternalschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateexternalschemastmtContext { + var p = new(CreateexternalschemastmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createexternalschemastmt + + return p +} + +func (s *CreateexternalschemastmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateexternalschemastmtContext) GetSchema_name() IColidContext { return s.schema_name } + +func (s *CreateexternalschemastmtContext) SetSchema_name(v IColidContext) { s.schema_name = v } + +func (s *CreateexternalschemastmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateexternalschemastmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *CreateexternalschemastmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *CreateexternalschemastmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CreateexternalschemastmtContext) Fromdatacatalogclause() IFromdatacatalogclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromdatacatalogclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromdatacatalogclauseContext) +} + +func (s *CreateexternalschemastmtContext) Fromhivemetastoreclause() IFromhivemetastoreclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromhivemetastoreclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromhivemetastoreclauseContext) +} + +func (s *CreateexternalschemastmtContext) Frompostgresclause() IFrompostgresclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrompostgresclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrompostgresclauseContext) +} + +func (s *CreateexternalschemastmtContext) Frommysqlclause() IFrommysqlclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrommysqlclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrommysqlclauseContext) +} + +func (s *CreateexternalschemastmtContext) Fromkinesisclause() IFromkinesisclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromkinesisclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromkinesisclauseContext) +} + +func (s *CreateexternalschemastmtContext) Fromkafkaclause() IFromkafkaclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromkafkaclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromkafkaclauseContext) +} + +func (s *CreateexternalschemastmtContext) Frommskclause() IFrommskclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrommskclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrommskclauseContext) +} + +func (s *CreateexternalschemastmtContext) Fromredshiftclause() IFromredshiftclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFromredshiftclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFromredshiftclauseContext) +} + +func (s *CreateexternalschemastmtContext) Implicitdatacatalogclause() IImplicitdatacatalogclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplicitdatacatalogclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplicitdatacatalogclauseContext) +} + +func (s *CreateexternalschemastmtContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *CreateexternalschemastmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateexternalschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateexternalschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateexternalschemastmt(s) + } +} + +func (s *CreateexternalschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateexternalschemastmt(s) + } +} + +func (s *CreateexternalschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateexternalschemastmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createexternalschemastmt() (localctx ICreateexternalschemastmtContext) { + localctx = NewCreateexternalschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1070, RedshiftParserRULE_createexternalschemastmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9916) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9917) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9918) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9920) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 799, p.GetParserRuleContext()) == 1 { + { + p.SetState(9919) + p.Opt_if_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9922) + + var _x = p.Colid() + + localctx.(*CreateexternalschemastmtContext).schema_name = _x + } + p.SetState(9932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9923) + p.Fromdatacatalogclause() + } + + case 2: + { + p.SetState(9924) + p.Fromhivemetastoreclause() + } + + case 3: + { + p.SetState(9925) + p.Frompostgresclause() + } + + case 4: + { + p.SetState(9926) + p.Frommysqlclause() + } + + case 5: + { + p.SetState(9927) + p.Fromkinesisclause() + } + + case 6: + { + p.SetState(9928) + p.Fromkafkaclause() + } + + case 7: + { + p.SetState(9929) + p.Frommskclause() + } + + case 8: + { + p.SetState(9930) + p.Fromredshiftclause() + } + + case 9: + { + p.SetState(9931) + p.Implicitdatacatalogclause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromdatacatalogclauseContext is an interface to support dynamic dispatch. +type IFromdatacatalogclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + AllDATABASE() []antlr.TerminalNode + DATABASE(i int) antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + Colid() IColidContext + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + DATA_P() antlr.TerminalNode + CATALOG() antlr.TerminalNode + DATA_CATALOG() antlr.TerminalNode + CATALOG_ROLE() antlr.TerminalNode + Catalogrolevalue() ICatalogrolevalueContext + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + Opt_if_not_exists() IOpt_if_not_existsContext + CATALOG_ID() antlr.TerminalNode + + // IsFromdatacatalogclauseContext differentiates from other interfaces. + IsFromdatacatalogclauseContext() +} + +type FromdatacatalogclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromdatacatalogclauseContext() *FromdatacatalogclauseContext { + var p = new(FromdatacatalogclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromdatacatalogclause + return p +} + +func InitEmptyFromdatacatalogclauseContext(p *FromdatacatalogclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromdatacatalogclause +} + +func (*FromdatacatalogclauseContext) IsFromdatacatalogclauseContext() {} + +func NewFromdatacatalogclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromdatacatalogclauseContext { + var p = new(FromdatacatalogclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fromdatacatalogclause + + return p +} + +func (s *FromdatacatalogclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromdatacatalogclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FromdatacatalogclauseContext) AllDATABASE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserDATABASE) +} + +func (s *FromdatacatalogclauseContext) DATABASE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, i) +} + +func (s *FromdatacatalogclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *FromdatacatalogclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FromdatacatalogclauseContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *FromdatacatalogclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FromdatacatalogclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *FromdatacatalogclauseContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *FromdatacatalogclauseContext) CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG, 0) +} + +func (s *FromdatacatalogclauseContext) DATA_CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_CATALOG, 0) +} + +func (s *FromdatacatalogclauseContext) CATALOG_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG_ROLE, 0) +} + +func (s *FromdatacatalogclauseContext) Catalogrolevalue() ICatalogrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICatalogrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICatalogrolevalueContext) +} + +func (s *FromdatacatalogclauseContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *FromdatacatalogclauseContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *FromdatacatalogclauseContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *FromdatacatalogclauseContext) CATALOG_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG_ID, 0) +} + +func (s *FromdatacatalogclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromdatacatalogclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromdatacatalogclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFromdatacatalogclause(s) + } +} + +func (s *FromdatacatalogclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFromdatacatalogclause(s) + } +} + +func (s *FromdatacatalogclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFromdatacatalogclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fromdatacatalogclause() (localctx IFromdatacatalogclauseContext) { + localctx = NewFromdatacatalogclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1072, RedshiftParserRULE_fromdatacatalogclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9934) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDATA_P: + { + p.SetState(9935) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9936) + p.Match(RedshiftParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDATA_CATALOG: + { + p.SetState(9937) + p.Match(RedshiftParserDATA_CATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(9940) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9941) + p.Sconst() + } + { + p.SetState(9942) + p.Colid() + } + { + p.SetState(9943) + p.Sconst() + } + { + p.SetState(9944) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9945) + p.Iamrolevalue() + } + p.SetState(9948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCATALOG_ROLE { + { + p.SetState(9946) + p.Match(RedshiftParserCATALOG_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9947) + p.Catalogrolevalue() + } + + } + p.SetState(9954) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 803, p.GetParserRuleContext()) == 1 { + { + p.SetState(9950) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9951) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9952) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9953) + p.Opt_if_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCATALOG_ID { + { + p.SetState(9956) + p.Match(RedshiftParserCATALOG_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9957) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropschemastmtContext is an interface to support dynamic dispatch. +type IDropschemastmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + Opt_if_exists() IOpt_if_existsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + DATABASE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + + // IsDropschemastmtContext differentiates from other interfaces. + IsDropschemastmtContext() +} + +type DropschemastmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropschemastmtContext() *DropschemastmtContext { + var p = new(DropschemastmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropschemastmt + return p +} + +func InitEmptyDropschemastmtContext(p *DropschemastmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropschemastmt +} + +func (*DropschemastmtContext) IsDropschemastmtContext() {} + +func NewDropschemastmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropschemastmtContext { + var p = new(DropschemastmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropschemastmt + + return p +} + +func (s *DropschemastmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropschemastmtContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserDROP) +} + +func (s *DropschemastmtContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, i) +} + +func (s *DropschemastmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *DropschemastmtContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *DropschemastmtContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *DropschemastmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropschemastmtContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *DropschemastmtContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *DropschemastmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *DropschemastmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *DropschemastmtContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *DropschemastmtContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *DropschemastmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropschemastmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropschemastmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropschemastmt(s) + } +} + +func (s *DropschemastmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropschemastmt(s) + } +} + +func (s *DropschemastmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropschemastmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropschemastmt() (localctx IDropschemastmtContext) { + localctx = NewDropschemastmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1074, RedshiftParserRULE_dropschemastmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9960) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9961) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9963) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 805, p.GetParserRuleContext()) == 1 { + { + p.SetState(9962) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9965) + p.Qualified_name() + } + p.SetState(9970) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(9966) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9967) + p.Qualified_name() + } + + p.SetState(9972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(9976) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 807, p.GetParserRuleContext()) == 1 { + { + p.SetState(9973) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9974) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9975) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(9978) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT) { + 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 +} + +// IImplicitdatacatalogclauseContext is an interface to support dynamic dispatch. +type IImplicitdatacatalogclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + AllDATABASE() []antlr.TerminalNode + DATABASE(i int) antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + Colid() IColidContext + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + CATALOG_ROLE() antlr.TerminalNode + Catalogrolevalue() ICatalogrolevalueContext + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + Opt_if_not_exists() IOpt_if_not_existsContext + CATALOG_ID() antlr.TerminalNode + + // IsImplicitdatacatalogclauseContext differentiates from other interfaces. + IsImplicitdatacatalogclauseContext() +} + +type ImplicitdatacatalogclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImplicitdatacatalogclauseContext() *ImplicitdatacatalogclauseContext { + var p = new(ImplicitdatacatalogclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_implicitdatacatalogclause + return p +} + +func InitEmptyImplicitdatacatalogclauseContext(p *ImplicitdatacatalogclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_implicitdatacatalogclause +} + +func (*ImplicitdatacatalogclauseContext) IsImplicitdatacatalogclauseContext() {} + +func NewImplicitdatacatalogclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ImplicitdatacatalogclauseContext { + var p = new(ImplicitdatacatalogclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_implicitdatacatalogclause + + return p +} + +func (s *ImplicitdatacatalogclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *ImplicitdatacatalogclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *ImplicitdatacatalogclauseContext) AllDATABASE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserDATABASE) +} + +func (s *ImplicitdatacatalogclauseContext) DATABASE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, i) +} + +func (s *ImplicitdatacatalogclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *ImplicitdatacatalogclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ImplicitdatacatalogclauseContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ImplicitdatacatalogclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *ImplicitdatacatalogclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *ImplicitdatacatalogclauseContext) CATALOG_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG_ROLE, 0) +} + +func (s *ImplicitdatacatalogclauseContext) Catalogrolevalue() ICatalogrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICatalogrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICatalogrolevalueContext) +} + +func (s *ImplicitdatacatalogclauseContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *ImplicitdatacatalogclauseContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *ImplicitdatacatalogclauseContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *ImplicitdatacatalogclauseContext) CATALOG_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG_ID, 0) +} + +func (s *ImplicitdatacatalogclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ImplicitdatacatalogclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ImplicitdatacatalogclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterImplicitdatacatalogclause(s) + } +} + +func (s *ImplicitdatacatalogclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitImplicitdatacatalogclause(s) + } +} + +func (s *ImplicitdatacatalogclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitImplicitdatacatalogclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Implicitdatacatalogclause() (localctx IImplicitdatacatalogclauseContext) { + localctx = NewImplicitdatacatalogclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1076, RedshiftParserRULE_implicitdatacatalogclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9981) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9982) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9983) + p.Sconst() + } + { + p.SetState(9984) + p.Colid() + } + { + p.SetState(9985) + p.Sconst() + } + { + p.SetState(9986) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9987) + p.Iamrolevalue() + } + p.SetState(9990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCATALOG_ROLE { + { + p.SetState(9988) + p.Match(RedshiftParserCATALOG_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9989) + p.Catalogrolevalue() + } + + } + p.SetState(9996) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 810, p.GetParserRuleContext()) == 1 { + { + p.SetState(9992) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9993) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9994) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9995) + p.Opt_if_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCATALOG_ID { + { + p.SetState(9998) + p.Match(RedshiftParserCATALOG_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9999) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromhivemetastoreclauseContext is an interface to support dynamic dispatch. +type IFromhivemetastoreclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + HIVE() antlr.TerminalNode + METASTORE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + URI() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + PORT() antlr.TerminalNode + Iconst() IIconstContext + + // IsFromhivemetastoreclauseContext differentiates from other interfaces. + IsFromhivemetastoreclauseContext() +} + +type FromhivemetastoreclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromhivemetastoreclauseContext() *FromhivemetastoreclauseContext { + var p = new(FromhivemetastoreclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromhivemetastoreclause + return p +} + +func InitEmptyFromhivemetastoreclauseContext(p *FromhivemetastoreclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromhivemetastoreclause +} + +func (*FromhivemetastoreclauseContext) IsFromhivemetastoreclauseContext() {} + +func NewFromhivemetastoreclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromhivemetastoreclauseContext { + var p = new(FromhivemetastoreclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fromhivemetastoreclause + + return p +} + +func (s *FromhivemetastoreclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromhivemetastoreclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FromhivemetastoreclauseContext) HIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserHIVE, 0) +} + +func (s *FromhivemetastoreclauseContext) METASTORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMETASTORE, 0) +} + +func (s *FromhivemetastoreclauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *FromhivemetastoreclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *FromhivemetastoreclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FromhivemetastoreclauseContext) URI() antlr.TerminalNode { + return s.GetToken(RedshiftParserURI, 0) +} + +func (s *FromhivemetastoreclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FromhivemetastoreclauseContext) PORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPORT, 0) +} + +func (s *FromhivemetastoreclauseContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *FromhivemetastoreclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromhivemetastoreclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromhivemetastoreclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFromhivemetastoreclause(s) + } +} + +func (s *FromhivemetastoreclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFromhivemetastoreclause(s) + } +} + +func (s *FromhivemetastoreclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFromhivemetastoreclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fromhivemetastoreclause() (localctx IFromhivemetastoreclauseContext) { + localctx = NewFromhivemetastoreclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1078, RedshiftParserRULE_fromhivemetastoreclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10002) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10003) + p.Match(RedshiftParserHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10004) + p.Match(RedshiftParserMETASTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10005) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10006) + p.Sconst() + } + { + p.SetState(10007) + p.Match(RedshiftParserURI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10008) + p.Sconst() + } + p.SetState(10011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPORT { + { + p.SetState(10009) + p.Match(RedshiftParserPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10010) + p.Iconst() + } + + } + { + p.SetState(10013) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10014) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrompostgresclauseContext is an interface to support dynamic dispatch. +type IFrompostgresclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + POSTGRES() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + URI() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + SECRET_ARN() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + PORT() antlr.TerminalNode + Iconst() IIconstContext + + // IsFrompostgresclauseContext differentiates from other interfaces. + IsFrompostgresclauseContext() +} + +type FrompostgresclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrompostgresclauseContext() *FrompostgresclauseContext { + var p = new(FrompostgresclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frompostgresclause + return p +} + +func InitEmptyFrompostgresclauseContext(p *FrompostgresclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frompostgresclause +} + +func (*FrompostgresclauseContext) IsFrompostgresclauseContext() {} + +func NewFrompostgresclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrompostgresclauseContext { + var p = new(FrompostgresclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_frompostgresclause + + return p +} + +func (s *FrompostgresclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrompostgresclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FrompostgresclauseContext) POSTGRES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOSTGRES, 0) +} + +func (s *FrompostgresclauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *FrompostgresclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *FrompostgresclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FrompostgresclauseContext) URI() antlr.TerminalNode { + return s.GetToken(RedshiftParserURI, 0) +} + +func (s *FrompostgresclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FrompostgresclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *FrompostgresclauseContext) SECRET_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECRET_ARN, 0) +} + +func (s *FrompostgresclauseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *FrompostgresclauseContext) PORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPORT, 0) +} + +func (s *FrompostgresclauseContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *FrompostgresclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrompostgresclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrompostgresclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFrompostgresclause(s) + } +} + +func (s *FrompostgresclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFrompostgresclause(s) + } +} + +func (s *FrompostgresclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFrompostgresclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Frompostgresclause() (localctx IFrompostgresclauseContext) { + localctx = NewFrompostgresclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1080, RedshiftParserRULE_frompostgresclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10016) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10017) + p.Match(RedshiftParserPOSTGRES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10018) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10019) + p.Sconst() + } + p.SetState(10022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSCHEMA { + { + p.SetState(10020) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10021) + p.Sconst() + } + + } + { + p.SetState(10024) + p.Match(RedshiftParserURI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10025) + p.Sconst() + } + p.SetState(10028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPORT { + { + p.SetState(10026) + p.Match(RedshiftParserPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10027) + p.Iconst() + } + + } + { + p.SetState(10030) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10031) + p.Iamrolevalue() + } + { + p.SetState(10032) + p.Match(RedshiftParserSECRET_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10033) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrommysqlclauseContext is an interface to support dynamic dispatch. +type IFrommysqlclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + MYSQL() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + URI() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + SECRET_ARN() antlr.TerminalNode + PORT() antlr.TerminalNode + Iconst() IIconstContext + + // IsFrommysqlclauseContext differentiates from other interfaces. + IsFrommysqlclauseContext() +} + +type FrommysqlclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrommysqlclauseContext() *FrommysqlclauseContext { + var p = new(FrommysqlclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frommysqlclause + return p +} + +func InitEmptyFrommysqlclauseContext(p *FrommysqlclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frommysqlclause +} + +func (*FrommysqlclauseContext) IsFrommysqlclauseContext() {} + +func NewFrommysqlclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrommysqlclauseContext { + var p = new(FrommysqlclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_frommysqlclause + + return p +} + +func (s *FrommysqlclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrommysqlclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FrommysqlclauseContext) MYSQL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMYSQL, 0) +} + +func (s *FrommysqlclauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *FrommysqlclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *FrommysqlclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FrommysqlclauseContext) URI() antlr.TerminalNode { + return s.GetToken(RedshiftParserURI, 0) +} + +func (s *FrommysqlclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FrommysqlclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *FrommysqlclauseContext) SECRET_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECRET_ARN, 0) +} + +func (s *FrommysqlclauseContext) PORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPORT, 0) +} + +func (s *FrommysqlclauseContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *FrommysqlclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrommysqlclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrommysqlclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFrommysqlclause(s) + } +} + +func (s *FrommysqlclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFrommysqlclause(s) + } +} + +func (s *FrommysqlclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFrommysqlclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Frommysqlclause() (localctx IFrommysqlclauseContext) { + localctx = NewFrommysqlclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1082, RedshiftParserRULE_frommysqlclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10035) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10036) + p.Match(RedshiftParserMYSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10037) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10038) + p.Sconst() + } + { + p.SetState(10039) + p.Match(RedshiftParserURI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10040) + p.Sconst() + } + p.SetState(10043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPORT { + { + p.SetState(10041) + p.Match(RedshiftParserPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10042) + p.Iconst() + } + + } + { + p.SetState(10045) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10046) + p.Iamrolevalue() + } + { + p.SetState(10047) + p.Match(RedshiftParserSECRET_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10048) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromkinesisclauseContext is an interface to support dynamic dispatch. +type IFromkinesisclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + KINESIS() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + + // IsFromkinesisclauseContext differentiates from other interfaces. + IsFromkinesisclauseContext() +} + +type FromkinesisclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromkinesisclauseContext() *FromkinesisclauseContext { + var p = new(FromkinesisclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromkinesisclause + return p +} + +func InitEmptyFromkinesisclauseContext(p *FromkinesisclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromkinesisclause +} + +func (*FromkinesisclauseContext) IsFromkinesisclauseContext() {} + +func NewFromkinesisclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromkinesisclauseContext { + var p = new(FromkinesisclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fromkinesisclause + + return p +} + +func (s *FromkinesisclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromkinesisclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FromkinesisclauseContext) KINESIS() antlr.TerminalNode { + return s.GetToken(RedshiftParserKINESIS, 0) +} + +func (s *FromkinesisclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FromkinesisclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *FromkinesisclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromkinesisclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromkinesisclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFromkinesisclause(s) + } +} + +func (s *FromkinesisclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFromkinesisclause(s) + } +} + +func (s *FromkinesisclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFromkinesisclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fromkinesisclause() (localctx IFromkinesisclauseContext) { + localctx = NewFromkinesisclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1084, RedshiftParserRULE_fromkinesisclause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10050) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10051) + p.Match(RedshiftParserKINESIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10052) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10053) + p.Iamrolevalue() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromkafkaclauseContext is an interface to support dynamic dispatch. +type IFromkafkaclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + KAFKA() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + URI() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + AUTHENTICATION() antlr.TerminalNode + Authenticationvalue() IAuthenticationvalueContext + AUTHENTICATION_ARN() antlr.TerminalNode + + // IsFromkafkaclauseContext differentiates from other interfaces. + IsFromkafkaclauseContext() +} + +type FromkafkaclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromkafkaclauseContext() *FromkafkaclauseContext { + var p = new(FromkafkaclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromkafkaclause + return p +} + +func InitEmptyFromkafkaclauseContext(p *FromkafkaclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromkafkaclause +} + +func (*FromkafkaclauseContext) IsFromkafkaclauseContext() {} + +func NewFromkafkaclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromkafkaclauseContext { + var p = new(FromkafkaclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fromkafkaclause + + return p +} + +func (s *FromkafkaclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromkafkaclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FromkafkaclauseContext) KAFKA() antlr.TerminalNode { + return s.GetToken(RedshiftParserKAFKA, 0) +} + +func (s *FromkafkaclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FromkafkaclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *FromkafkaclauseContext) URI() antlr.TerminalNode { + return s.GetToken(RedshiftParserURI, 0) +} + +func (s *FromkafkaclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *FromkafkaclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FromkafkaclauseContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION, 0) +} + +func (s *FromkafkaclauseContext) Authenticationvalue() IAuthenticationvalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthenticationvalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthenticationvalueContext) +} + +func (s *FromkafkaclauseContext) AUTHENTICATION_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION_ARN, 0) +} + +func (s *FromkafkaclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromkafkaclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromkafkaclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFromkafkaclause(s) + } +} + +func (s *FromkafkaclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFromkafkaclause(s) + } +} + +func (s *FromkafkaclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFromkafkaclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fromkafkaclause() (localctx IFromkafkaclauseContext) { + localctx = NewFromkafkaclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1086, RedshiftParserRULE_fromkafkaclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10055) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10056) + p.Match(RedshiftParserKAFKA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10057) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10058) + p.Iamrolevalue() + } + p.SetState(10061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserURI { + { + p.SetState(10059) + p.Match(RedshiftParserURI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10060) + p.Sconst() + } + + } + p.SetState(10065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAUTHENTICATION { + { + p.SetState(10063) + p.Match(RedshiftParserAUTHENTICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10064) + p.Authenticationvalue() + } + + } + p.SetState(10069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAUTHENTICATION_ARN { + { + p.SetState(10067) + p.Match(RedshiftParserAUTHENTICATION_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10068) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrommskclauseContext is an interface to support dynamic dispatch. +type IFrommskclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + MSK() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + URI() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + AUTHENTICATION() antlr.TerminalNode + Authenticationvalue() IAuthenticationvalueContext + AUTHENTICATION_ARN() antlr.TerminalNode + + // IsFrommskclauseContext differentiates from other interfaces. + IsFrommskclauseContext() +} + +type FrommskclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrommskclauseContext() *FrommskclauseContext { + var p = new(FrommskclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frommskclause + return p +} + +func InitEmptyFrommskclauseContext(p *FrommskclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frommskclause +} + +func (*FrommskclauseContext) IsFrommskclauseContext() {} + +func NewFrommskclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrommskclauseContext { + var p = new(FrommskclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_frommskclause + + return p +} + +func (s *FrommskclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrommskclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FrommskclauseContext) MSK() antlr.TerminalNode { + return s.GetToken(RedshiftParserMSK, 0) +} + +func (s *FrommskclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FrommskclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *FrommskclauseContext) URI() antlr.TerminalNode { + return s.GetToken(RedshiftParserURI, 0) +} + +func (s *FrommskclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *FrommskclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FrommskclauseContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION, 0) +} + +func (s *FrommskclauseContext) Authenticationvalue() IAuthenticationvalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuthenticationvalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuthenticationvalueContext) +} + +func (s *FrommskclauseContext) AUTHENTICATION_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION_ARN, 0) +} + +func (s *FrommskclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrommskclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrommskclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFrommskclause(s) + } +} + +func (s *FrommskclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFrommskclause(s) + } +} + +func (s *FrommskclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFrommskclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Frommskclause() (localctx IFrommskclauseContext) { + localctx = NewFrommskclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1088, RedshiftParserRULE_frommskclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10071) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10072) + p.Match(RedshiftParserMSK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10073) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10074) + p.Iamrolevalue() + } + p.SetState(10077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserURI { + { + p.SetState(10075) + p.Match(RedshiftParserURI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10076) + p.Sconst() + } + + } + p.SetState(10081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAUTHENTICATION { + { + p.SetState(10079) + p.Match(RedshiftParserAUTHENTICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10080) + p.Authenticationvalue() + } + + } + p.SetState(10085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAUTHENTICATION_ARN { + { + p.SetState(10083) + p.Match(RedshiftParserAUTHENTICATION_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10084) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFromredshiftclauseContext is an interface to support dynamic dispatch. +type IFromredshiftclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + REDSHIFT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + SCHEMA() antlr.TerminalNode + Colid() IColidContext + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + + // IsFromredshiftclauseContext differentiates from other interfaces. + IsFromredshiftclauseContext() +} + +type FromredshiftclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFromredshiftclauseContext() *FromredshiftclauseContext { + var p = new(FromredshiftclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromredshiftclause + return p +} + +func InitEmptyFromredshiftclauseContext(p *FromredshiftclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fromredshiftclause +} + +func (*FromredshiftclauseContext) IsFromredshiftclauseContext() {} + +func NewFromredshiftclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FromredshiftclauseContext { + var p = new(FromredshiftclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fromredshiftclause + + return p +} + +func (s *FromredshiftclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *FromredshiftclauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *FromredshiftclauseContext) REDSHIFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserREDSHIFT, 0) +} + +func (s *FromredshiftclauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *FromredshiftclauseContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *FromredshiftclauseContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FromredshiftclauseContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *FromredshiftclauseContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *FromredshiftclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *FromredshiftclauseContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *FromredshiftclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FromredshiftclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FromredshiftclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFromredshiftclause(s) + } +} + +func (s *FromredshiftclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFromredshiftclause(s) + } +} + +func (s *FromredshiftclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFromredshiftclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fromredshiftclause() (localctx IFromredshiftclauseContext) { + localctx = NewFromredshiftclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1090, RedshiftParserRULE_fromredshiftclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10087) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10088) + p.Match(RedshiftParserREDSHIFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10089) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10090) + p.Sconst() + } + p.SetState(10093) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 822, p.GetParserRuleContext()) == 1 { + { + p.SetState(10091) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10092) + p.Sconst() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10098) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 823, p.GetParserRuleContext()) == 1 { + { + p.SetState(10095) + p.Colid() + } + { + p.SetState(10096) + p.Sconst() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIAM_ROLE { + { + p.SetState(10100) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10101) + p.Iamrolevalue() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIamrolevalueContext is an interface to support dynamic dispatch. +type IIamrolevalueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + SESSION_TOKEN() antlr.TerminalNode + Sconst() ISconstContext + + // IsIamrolevalueContext differentiates from other interfaces. + IsIamrolevalueContext() +} + +type IamrolevalueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIamrolevalueContext() *IamrolevalueContext { + var p = new(IamrolevalueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolevalue + return p +} + +func InitEmptyIamrolevalueContext(p *IamrolevalueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolevalue +} + +func (*IamrolevalueContext) IsIamrolevalueContext() {} + +func NewIamrolevalueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IamrolevalueContext { + var p = new(IamrolevalueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_iamrolevalue + + return p +} + +func (s *IamrolevalueContext) GetParser() antlr.Parser { return s.parser } + +func (s *IamrolevalueContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *IamrolevalueContext) SESSION_TOKEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_TOKEN, 0) +} + +func (s *IamrolevalueContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *IamrolevalueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IamrolevalueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IamrolevalueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIamrolevalue(s) + } +} + +func (s *IamrolevalueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIamrolevalue(s) + } +} + +func (s *IamrolevalueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIamrolevalue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Iamrolevalue() (localctx IIamrolevalueContext) { + localctx = NewIamrolevalueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1092, RedshiftParserRULE_iamrolevalue) + p.SetState(10107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10104) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSESSION_TOKEN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10105) + p.Match(RedshiftParserSESSION_TOKEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10106) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICatalogrolevalueContext is an interface to support dynamic dispatch. +type ICatalogrolevalueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SESSION_TOKEN() antlr.TerminalNode + Sconst() ISconstContext + + // IsCatalogrolevalueContext differentiates from other interfaces. + IsCatalogrolevalueContext() +} + +type CatalogrolevalueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCatalogrolevalueContext() *CatalogrolevalueContext { + var p = new(CatalogrolevalueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_catalogrolevalue + return p +} + +func InitEmptyCatalogrolevalueContext(p *CatalogrolevalueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_catalogrolevalue +} + +func (*CatalogrolevalueContext) IsCatalogrolevalueContext() {} + +func NewCatalogrolevalueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CatalogrolevalueContext { + var p = new(CatalogrolevalueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_catalogrolevalue + + return p +} + +func (s *CatalogrolevalueContext) GetParser() antlr.Parser { return s.parser } + +func (s *CatalogrolevalueContext) SESSION_TOKEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_TOKEN, 0) +} + +func (s *CatalogrolevalueContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CatalogrolevalueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CatalogrolevalueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CatalogrolevalueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCatalogrolevalue(s) + } +} + +func (s *CatalogrolevalueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCatalogrolevalue(s) + } +} + +func (s *CatalogrolevalueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCatalogrolevalue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Catalogrolevalue() (localctx ICatalogrolevalueContext) { + localctx = NewCatalogrolevalueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1094, RedshiftParserRULE_catalogrolevalue) + p.SetState(10111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSESSION_TOKEN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10109) + p.Match(RedshiftParserSESSION_TOKEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10110) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuthenticationvalueContext is an interface to support dynamic dispatch. +type IAuthenticationvalueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NONE() antlr.TerminalNode + IAM() antlr.TerminalNode + MTLS() antlr.TerminalNode + + // IsAuthenticationvalueContext differentiates from other interfaces. + IsAuthenticationvalueContext() +} + +type AuthenticationvalueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuthenticationvalueContext() *AuthenticationvalueContext { + var p = new(AuthenticationvalueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_authenticationvalue + return p +} + +func InitEmptyAuthenticationvalueContext(p *AuthenticationvalueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_authenticationvalue +} + +func (*AuthenticationvalueContext) IsAuthenticationvalueContext() {} + +func NewAuthenticationvalueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AuthenticationvalueContext { + var p = new(AuthenticationvalueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_authenticationvalue + + return p +} + +func (s *AuthenticationvalueContext) GetParser() antlr.Parser { return s.parser } + +func (s *AuthenticationvalueContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *AuthenticationvalueContext) IAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM, 0) +} + +func (s *AuthenticationvalueContext) MTLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMTLS, 0) +} + +func (s *AuthenticationvalueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AuthenticationvalueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AuthenticationvalueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAuthenticationvalue(s) + } +} + +func (s *AuthenticationvalueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAuthenticationvalue(s) + } +} + +func (s *AuthenticationvalueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAuthenticationvalue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Authenticationvalue() (localctx IAuthenticationvalueContext) { + localctx = NewAuthenticationvalueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1096, RedshiftParserRULE_authenticationvalue) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10113) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserMTLS || _la == RedshiftParserIAM || _la == RedshiftParserNONE) { + 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 +} + +// ICreateexternalfunctionstmtContext is an interface to support dynamic dispatch. +type ICreateexternalfunctionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFunction_name returns the function_name rule contexts. + GetFunction_name() IQualified_nameContext + + // SetFunction_name sets the function_name rule contexts. + SetFunction_name(IQualified_nameContext) + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + RETURNS() antlr.TerminalNode + Typename() ITypenameContext + LAMBDA() antlr.TerminalNode + Sconst() ISconstContext + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + Qualified_name() IQualified_nameContext + STABLE() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + VOLATILE() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + External_func_params() IExternal_func_paramsContext + RETRY_TIMEOUT() antlr.TerminalNode + AllIconst() []IIconstContext + Iconst(i int) IIconstContext + MAX_BATCH_ROWS() antlr.TerminalNode + MAX_BATCH_SIZE() antlr.TerminalNode + KB() antlr.TerminalNode + MB() antlr.TerminalNode + + // IsCreateexternalfunctionstmtContext differentiates from other interfaces. + IsCreateexternalfunctionstmtContext() +} + +type CreateexternalfunctionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + function_name IQualified_nameContext +} + +func NewEmptyCreateexternalfunctionstmtContext() *CreateexternalfunctionstmtContext { + var p = new(CreateexternalfunctionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalfunctionstmt + return p +} + +func InitEmptyCreateexternalfunctionstmtContext(p *CreateexternalfunctionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalfunctionstmt +} + +func (*CreateexternalfunctionstmtContext) IsCreateexternalfunctionstmtContext() {} + +func NewCreateexternalfunctionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateexternalfunctionstmtContext { + var p = new(CreateexternalfunctionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createexternalfunctionstmt + + return p +} + +func (s *CreateexternalfunctionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateexternalfunctionstmtContext) GetFunction_name() IQualified_nameContext { + return s.function_name +} + +func (s *CreateexternalfunctionstmtContext) SetFunction_name(v IQualified_nameContext) { + s.function_name = v +} + +func (s *CreateexternalfunctionstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateexternalfunctionstmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *CreateexternalfunctionstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *CreateexternalfunctionstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreateexternalfunctionstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreateexternalfunctionstmtContext) RETURNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNS, 0) +} + +func (s *CreateexternalfunctionstmtContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *CreateexternalfunctionstmtContext) LAMBDA() antlr.TerminalNode { + return s.GetToken(RedshiftParserLAMBDA, 0) +} + +func (s *CreateexternalfunctionstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreateexternalfunctionstmtContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *CreateexternalfunctionstmtContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *CreateexternalfunctionstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreateexternalfunctionstmtContext) STABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTABLE, 0) +} + +func (s *CreateexternalfunctionstmtContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMUTABLE, 0) +} + +func (s *CreateexternalfunctionstmtContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVOLATILE, 0) +} + +func (s *CreateexternalfunctionstmtContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *CreateexternalfunctionstmtContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *CreateexternalfunctionstmtContext) External_func_params() IExternal_func_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_func_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_func_paramsContext) +} + +func (s *CreateexternalfunctionstmtContext) RETRY_TIMEOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETRY_TIMEOUT, 0) +} + +func (s *CreateexternalfunctionstmtContext) AllIconst() []IIconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIconstContext); ok { + len++ + } + } + + tst := make([]IIconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIconstContext); ok { + tst[i] = t.(IIconstContext) + i++ + } + } + + return tst +} + +func (s *CreateexternalfunctionstmtContext) Iconst(i int) IIconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *CreateexternalfunctionstmtContext) MAX_BATCH_ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_BATCH_ROWS, 0) +} + +func (s *CreateexternalfunctionstmtContext) MAX_BATCH_SIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_BATCH_SIZE, 0) +} + +func (s *CreateexternalfunctionstmtContext) KB() antlr.TerminalNode { + return s.GetToken(RedshiftParserKB, 0) +} + +func (s *CreateexternalfunctionstmtContext) MB() antlr.TerminalNode { + return s.GetToken(RedshiftParserMB, 0) +} + +func (s *CreateexternalfunctionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateexternalfunctionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateexternalfunctionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateexternalfunctionstmt(s) + } +} + +func (s *CreateexternalfunctionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateexternalfunctionstmt(s) + } +} + +func (s *CreateexternalfunctionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateexternalfunctionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createexternalfunctionstmt() (localctx ICreateexternalfunctionstmtContext) { + localctx = NewCreateexternalfunctionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1098, RedshiftParserRULE_createexternalfunctionstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10115) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(10116) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10117) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10120) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10121) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10122) + + var _x = p.Qualified_name() + + localctx.(*CreateexternalfunctionstmtContext).function_name = _x + } + { + p.SetState(10123) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-107)) & ^0x3f) == 0 && ((int64(1)<<(_la-107))&-5) != 0) || ((int64((_la-171)) & ^0x3f) == 0 && ((int64(1)<<(_la-171))&-129) != 0) || ((int64((_la-235)) & ^0x3f) == 0 && ((int64(1)<<(_la-235))&-4503599632089089) != 0) || ((int64((_la-299)) & ^0x3f) == 0 && ((int64(1)<<(_la-299))&-1) != 0) || ((int64((_la-363)) & ^0x3f) == 0 && ((int64(1)<<(_la-363))&-1237319681) != 0) || ((int64((_la-427)) & ^0x3f) == 0 && ((int64(1)<<(_la-427))&-1) != 0) || ((int64((_la-491)) & ^0x3f) == 0 && ((int64(1)<<(_la-491))&-1) != 0) || ((int64((_la-555)) & ^0x3f) == 0 && ((int64(1)<<(_la-555))&72057594037927935) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372036854759423) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(10124) + p.External_func_params() + } + + } + { + p.SetState(10127) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10128) + p.Match(RedshiftParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10129) + p.Typename() + } + { + p.SetState(10130) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserIMMUTABLE || _la == RedshiftParserSTABLE || _la == RedshiftParserVOLATILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10131) + p.Match(RedshiftParserLAMBDA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10132) + p.Sconst() + } + { + p.SetState(10133) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10134) + p.Iamrolevalue() + } + p.SetState(10137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRETRY_TIMEOUT { + { + p.SetState(10135) + p.Match(RedshiftParserRETRY_TIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10136) + p.Iconst() + } + + } + p.SetState(10141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMAX_BATCH_ROWS { + { + p.SetState(10139) + p.Match(RedshiftParserMAX_BATCH_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10140) + p.Iconst() + } + + } + p.SetState(10148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMAX_BATCH_SIZE { + { + p.SetState(10143) + p.Match(RedshiftParserMAX_BATCH_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10144) + p.Iconst() + } + p.SetState(10146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMB || _la == RedshiftParserKB { + { + p.SetState(10145) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserMB || _la == RedshiftParserKB) { + 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_func_paramsContext is an interface to support dynamic dispatch. +type IExternal_func_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExternal_func_paramsContext differentiates from other interfaces. + IsExternal_func_paramsContext() +} + +type External_func_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_func_paramsContext() *External_func_paramsContext { + var p = new(External_func_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_external_func_params + return p +} + +func InitEmptyExternal_func_paramsContext(p *External_func_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_external_func_params +} + +func (*External_func_paramsContext) IsExternal_func_paramsContext() {} + +func NewExternal_func_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_func_paramsContext { + var p = new(External_func_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_external_func_params + + return p +} + +func (s *External_func_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_func_paramsContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *External_func_paramsContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *External_func_paramsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *External_func_paramsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *External_func_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_func_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_func_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExternal_func_params(s) + } +} + +func (s *External_func_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExternal_func_params(s) + } +} + +func (s *External_func_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExternal_func_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) External_func_params() (localctx IExternal_func_paramsContext) { + localctx = NewExternal_func_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1100, RedshiftParserRULE_external_func_params) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10150) + p.Typename() + } + p.SetState(10155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10151) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10152) + p.Typename() + } + + p.SetState(10157) + 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 +} + +// IParamlistContext is an interface to support dynamic dispatch. +type IParamlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllParam_spec() []IParam_specContext + Param_spec(i int) IParam_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsParamlistContext differentiates from other interfaces. + IsParamlistContext() +} + +type ParamlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParamlistContext() *ParamlistContext { + var p = new(ParamlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_paramlist + return p +} + +func InitEmptyParamlistContext(p *ParamlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_paramlist +} + +func (*ParamlistContext) IsParamlistContext() {} + +func NewParamlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamlistContext { + var p = new(ParamlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_paramlist + + return p +} + +func (s *ParamlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParamlistContext) AllParam_spec() []IParam_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParam_specContext); ok { + len++ + } + } + + tst := make([]IParam_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParam_specContext); ok { + tst[i] = t.(IParam_specContext) + i++ + } + } + + return tst +} + +func (s *ParamlistContext) Param_spec(i int) IParam_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParam_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParam_specContext) +} + +func (s *ParamlistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *ParamlistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *ParamlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParamlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParamlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterParamlist(s) + } +} + +func (s *ParamlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitParamlist(s) + } +} + +func (s *ParamlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitParamlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Paramlist() (localctx IParamlistContext) { + localctx = NewParamlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1102, RedshiftParserRULE_paramlist) + var _la int + + p.SetState(10167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10158) + p.Param_spec() + } + p.SetState(10163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10159) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10160) + p.Param_spec() + } + + p.SetState(10165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserEOF: + p.EnterOuterAlt(localctx, 2) + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParam_specContext is an interface to support dynamic dispatch. +type IParam_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetParamname returns the paramname rule contexts. + GetParamname() IColidContext + + // SetParamname sets the paramname rule contexts. + SetParamname(IColidContext) + + // Getter signatures + Typename() ITypenameContext + Colid() IColidContext + + // IsParam_specContext differentiates from other interfaces. + IsParam_specContext() +} + +type Param_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + paramname IColidContext +} + +func NewEmptyParam_specContext() *Param_specContext { + var p = new(Param_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_param_spec + return p +} + +func InitEmptyParam_specContext(p *Param_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_param_spec +} + +func (*Param_specContext) IsParam_specContext() {} + +func NewParam_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Param_specContext { + var p = new(Param_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_param_spec + + return p +} + +func (s *Param_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Param_specContext) GetParamname() IColidContext { return s.paramname } + +func (s *Param_specContext) SetParamname(v IColidContext) { s.paramname = v } + +func (s *Param_specContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Param_specContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Param_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Param_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Param_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterParam_spec(s) + } +} + +func (s *Param_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitParam_spec(s) + } +} + +func (s *Param_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitParam_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Param_spec() (localctx IParam_specContext) { + localctx = NewParam_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1104, RedshiftParserRULE_param_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10169) + + var _x = p.Colid() + + localctx.(*Param_specContext).paramname = _x + } + { + p.SetState(10170) + p.Typename() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateexternalmodelstmtContext is an interface to support dynamic dispatch. +type ICreateexternalmodelstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + MODEL() antlr.TerminalNode + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + FROM() antlr.TerminalNode + Sconst() ISconstContext + IAM_ROLE() antlr.TerminalNode + Iamrolevalue() IIamrolevalueContext + FUNCTION_NAME() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Settingsclause() ISettingsclauseContext + CLOSE_PAREN() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + MODEL_TYPE() antlr.TerminalNode + BEDROCK() antlr.TerminalNode + + // IsCreateexternalmodelstmtContext differentiates from other interfaces. + IsCreateexternalmodelstmtContext() +} + +type CreateexternalmodelstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateexternalmodelstmtContext() *CreateexternalmodelstmtContext { + var p = new(CreateexternalmodelstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalmodelstmt + return p +} + +func InitEmptyCreateexternalmodelstmtContext(p *CreateexternalmodelstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalmodelstmt +} + +func (*CreateexternalmodelstmtContext) IsCreateexternalmodelstmtContext() {} + +func NewCreateexternalmodelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateexternalmodelstmtContext { + var p = new(CreateexternalmodelstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createexternalmodelstmt + + return p +} + +func (s *CreateexternalmodelstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateexternalmodelstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateexternalmodelstmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *CreateexternalmodelstmtContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *CreateexternalmodelstmtContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *CreateexternalmodelstmtContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreateexternalmodelstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *CreateexternalmodelstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreateexternalmodelstmtContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *CreateexternalmodelstmtContext) Iamrolevalue() IIamrolevalueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolevalueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolevalueContext) +} + +func (s *CreateexternalmodelstmtContext) FUNCTION_NAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION_NAME, 0) +} + +func (s *CreateexternalmodelstmtContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETTINGS, 0) +} + +func (s *CreateexternalmodelstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreateexternalmodelstmtContext) Settingsclause() ISettingsclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISettingsclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISettingsclauseContext) +} + +func (s *CreateexternalmodelstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreateexternalmodelstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *CreateexternalmodelstmtContext) MODEL_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL_TYPE, 0) +} + +func (s *CreateexternalmodelstmtContext) BEDROCK() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEDROCK, 0) +} + +func (s *CreateexternalmodelstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateexternalmodelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateexternalmodelstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateexternalmodelstmt(s) + } +} + +func (s *CreateexternalmodelstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateexternalmodelstmt(s) + } +} + +func (s *CreateexternalmodelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateexternalmodelstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createexternalmodelstmt() (localctx ICreateexternalmodelstmtContext) { + localctx = NewCreateexternalmodelstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1106, RedshiftParserRULE_createexternalmodelstmt) + var _la int + + p.SetState(10206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 838, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10172) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10173) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10174) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10175) + p.Qualified_name() + } + { + p.SetState(10176) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10177) + p.Sconst() + } + p.SetState(10180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFUNCTION_NAME { + { + p.SetState(10178) + p.Match(RedshiftParserFUNCTION_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10179) + p.Qualified_name() + } + + } + { + p.SetState(10182) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10183) + p.Iamrolevalue() + } + p.SetState(10189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSETTINGS { + { + p.SetState(10184) + p.Match(RedshiftParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10185) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10186) + p.Settingsclause() + } + { + p.SetState(10187) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10191) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10192) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10193) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10194) + p.Qualified_name() + } + { + p.SetState(10195) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10196) + p.Qualified_name() + } + { + p.SetState(10197) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10198) + p.Iamrolevalue() + } + { + p.SetState(10199) + p.Match(RedshiftParserMODEL_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10200) + p.Match(RedshiftParserBEDROCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10201) + p.Match(RedshiftParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10202) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10203) + p.Settingsclause() + } + { + p.SetState(10204) + p.Match(RedshiftParserCLOSE_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 +} + +// ICreateexternaltablestmtContext is an interface to support dynamic dispatch. +type ICreateexternaltablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + AllTABLE() []antlr.TerminalNode + TABLE(i int) antlr.TerminalNode + Qualified_name() IQualified_nameContext + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + AllExtern_column_list() []IExtern_column_listContext + Extern_column_list(i int) IExtern_column_listContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + Extern_table_format() IExtern_table_formatContext + LOCATION() antlr.TerminalNode + Sconst() ISconstContext + Opt_if_not_exists() IOpt_if_not_existsContext + PARTITIONED() antlr.TerminalNode + BY() antlr.TerminalNode + PROPERTIES() antlr.TerminalNode + Table_properties_list() ITable_properties_listContext + + // IsCreateexternaltablestmtContext differentiates from other interfaces. + IsCreateexternaltablestmtContext() +} + +type CreateexternaltablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateexternaltablestmtContext() *CreateexternaltablestmtContext { + var p = new(CreateexternaltablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternaltablestmt + return p +} + +func InitEmptyCreateexternaltablestmtContext(p *CreateexternaltablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternaltablestmt +} + +func (*CreateexternaltablestmtContext) IsCreateexternaltablestmtContext() {} + +func NewCreateexternaltablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateexternaltablestmtContext { + var p = new(CreateexternaltablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createexternaltablestmt + + return p +} + +func (s *CreateexternaltablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateexternaltablestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateexternaltablestmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *CreateexternaltablestmtContext) AllTABLE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserTABLE) +} + +func (s *CreateexternaltablestmtContext) TABLE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, i) +} + +func (s *CreateexternaltablestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreateexternaltablestmtContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *CreateexternaltablestmtContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *CreateexternaltablestmtContext) AllExtern_column_list() []IExtern_column_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtern_column_listContext); ok { + len++ + } + } + + tst := make([]IExtern_column_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtern_column_listContext); ok { + tst[i] = t.(IExtern_column_listContext) + i++ + } + } + + return tst +} + +func (s *CreateexternaltablestmtContext) Extern_column_list(i int) IExtern_column_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtern_column_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtern_column_listContext) +} + +func (s *CreateexternaltablestmtContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *CreateexternaltablestmtContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *CreateexternaltablestmtContext) Extern_table_format() IExtern_table_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtern_table_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtern_table_formatContext) +} + +func (s *CreateexternaltablestmtContext) LOCATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCATION, 0) +} + +func (s *CreateexternaltablestmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreateexternaltablestmtContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *CreateexternaltablestmtContext) PARTITIONED() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITIONED, 0) +} + +func (s *CreateexternaltablestmtContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *CreateexternaltablestmtContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROPERTIES, 0) +} + +func (s *CreateexternaltablestmtContext) Table_properties_list() ITable_properties_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_properties_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_properties_listContext) +} + +func (s *CreateexternaltablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateexternaltablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateexternaltablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateexternaltablestmt(s) + } +} + +func (s *CreateexternaltablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateexternaltablestmt(s) + } +} + +func (s *CreateexternaltablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateexternaltablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createexternaltablestmt() (localctx ICreateexternaltablestmtContext) { + localctx = NewCreateexternaltablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1108, RedshiftParserRULE_createexternaltablestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10208) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10209) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10210) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10212) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 839, p.GetParserRuleContext()) == 1 { + { + p.SetState(10211) + p.Opt_if_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10214) + p.Qualified_name() + } + { + p.SetState(10215) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10216) + p.Extern_column_list() + } + { + p.SetState(10217) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPARTITIONED { + { + p.SetState(10218) + p.Match(RedshiftParserPARTITIONED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10219) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10220) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10221) + p.Extern_column_list() + } + { + p.SetState(10222) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10226) + p.Extern_table_format() + } + { + p.SetState(10227) + p.Match(RedshiftParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10228) + p.Sconst() + } + p.SetState(10235) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 841, p.GetParserRuleContext()) == 1 { + { + p.SetState(10229) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10230) + p.Match(RedshiftParserPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10231) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10232) + p.Table_properties_list() + } + { + p.SetState(10233) + p.Match(RedshiftParserCLOSE_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 +} + +// IExtern_column_listContext is an interface to support dynamic dispatch. +type IExtern_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExtern_column_def() []IExtern_column_defContext + Extern_column_def(i int) IExtern_column_defContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExtern_column_listContext differentiates from other interfaces. + IsExtern_column_listContext() +} + +type Extern_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtern_column_listContext() *Extern_column_listContext { + var p = new(Extern_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_column_list + return p +} + +func InitEmptyExtern_column_listContext(p *Extern_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_column_list +} + +func (*Extern_column_listContext) IsExtern_column_listContext() {} + +func NewExtern_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extern_column_listContext { + var p = new(Extern_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_extern_column_list + + return p +} + +func (s *Extern_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extern_column_listContext) AllExtern_column_def() []IExtern_column_defContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtern_column_defContext); ok { + len++ + } + } + + tst := make([]IExtern_column_defContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtern_column_defContext); ok { + tst[i] = t.(IExtern_column_defContext) + i++ + } + } + + return tst +} + +func (s *Extern_column_listContext) Extern_column_def(i int) IExtern_column_defContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtern_column_defContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtern_column_defContext) +} + +func (s *Extern_column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Extern_column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Extern_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extern_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extern_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExtern_column_list(s) + } +} + +func (s *Extern_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExtern_column_list(s) + } +} + +func (s *Extern_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExtern_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Extern_column_list() (localctx IExtern_column_listContext) { + localctx = NewExtern_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1110, RedshiftParserRULE_extern_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10237) + p.Extern_column_def() + } + p.SetState(10242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10238) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10239) + p.Extern_column_def() + } + + p.SetState(10244) + 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 +} + +// IExtern_column_defContext is an interface to support dynamic dispatch. +type IExtern_column_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Extern_typename() IExtern_typenameContext + + // IsExtern_column_defContext differentiates from other interfaces. + IsExtern_column_defContext() +} + +type Extern_column_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtern_column_defContext() *Extern_column_defContext { + var p = new(Extern_column_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_column_def + return p +} + +func InitEmptyExtern_column_defContext(p *Extern_column_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_column_def +} + +func (*Extern_column_defContext) IsExtern_column_defContext() {} + +func NewExtern_column_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extern_column_defContext { + var p = new(Extern_column_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_extern_column_def + + return p +} + +func (s *Extern_column_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extern_column_defContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Extern_column_defContext) Extern_typename() IExtern_typenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtern_typenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtern_typenameContext) +} + +func (s *Extern_column_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extern_column_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extern_column_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExtern_column_def(s) + } +} + +func (s *Extern_column_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExtern_column_def(s) + } +} + +func (s *Extern_column_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExtern_column_def(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Extern_column_def() (localctx IExtern_column_defContext) { + localctx = NewExtern_column_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1112, RedshiftParserRULE_extern_column_def) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10245) + p.Colid() + } + { + p.SetState(10246) + p.Extern_typename() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtern_typenameContext is an interface to support dynamic dispatch. +type IExtern_typenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Typename() ITypenameContext + STRING() antlr.TerminalNode + + // IsExtern_typenameContext differentiates from other interfaces. + IsExtern_typenameContext() +} + +type Extern_typenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtern_typenameContext() *Extern_typenameContext { + var p = new(Extern_typenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_typename + return p +} + +func InitEmptyExtern_typenameContext(p *Extern_typenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_typename +} + +func (*Extern_typenameContext) IsExtern_typenameContext() {} + +func NewExtern_typenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extern_typenameContext { + var p = new(Extern_typenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_extern_typename + + return p +} + +func (s *Extern_typenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extern_typenameContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Extern_typenameContext) STRING() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRING, 0) +} + +func (s *Extern_typenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extern_typenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extern_typenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExtern_typename(s) + } +} + +func (s *Extern_typenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExtern_typename(s) + } +} + +func (s *Extern_typenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExtern_typename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Extern_typename() (localctx IExtern_typenameContext) { + localctx = NewExtern_typenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1114, RedshiftParserRULE_extern_typename) + p.SetState(10250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserVARBYTE, RedshiftParserVARBINARY, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10248) + p.Typename() + } + + case RedshiftParserSTRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10249) + p.Match(RedshiftParserSTRING) + 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 +} + +// IExtern_table_formatContext is an interface to support dynamic dispatch. +type IExtern_table_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORED() antlr.TerminalNode + AS() antlr.TerminalNode + External_format_spec() IExternal_format_specContext + Row_format_spec() IRow_format_specContext + INPUTFORMAT() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + OUTPUTFORMAT() antlr.TerminalNode + + // IsExtern_table_formatContext differentiates from other interfaces. + IsExtern_table_formatContext() +} + +type Extern_table_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtern_table_formatContext() *Extern_table_formatContext { + var p = new(Extern_table_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_table_format + return p +} + +func InitEmptyExtern_table_formatContext(p *Extern_table_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extern_table_format +} + +func (*Extern_table_formatContext) IsExtern_table_formatContext() {} + +func NewExtern_table_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extern_table_formatContext { + var p = new(Extern_table_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_extern_table_format + + return p +} + +func (s *Extern_table_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extern_table_formatContext) STORED() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTORED, 0) +} + +func (s *Extern_table_formatContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Extern_table_formatContext) External_format_spec() IExternal_format_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_format_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_format_specContext) +} + +func (s *Extern_table_formatContext) Row_format_spec() IRow_format_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_format_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_format_specContext) +} + +func (s *Extern_table_formatContext) INPUTFORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINPUTFORMAT, 0) +} + +func (s *Extern_table_formatContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Extern_table_formatContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Extern_table_formatContext) OUTPUTFORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserOUTPUTFORMAT, 0) +} + +func (s *Extern_table_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extern_table_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extern_table_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExtern_table_format(s) + } +} + +func (s *Extern_table_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExtern_table_format(s) + } +} + +func (s *Extern_table_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExtern_table_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Extern_table_format() (localctx IExtern_table_formatContext) { + localctx = NewExtern_table_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1116, RedshiftParserRULE_extern_table_format) + p.SetState(10267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 844, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10252) + p.Match(RedshiftParserSTORED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10253) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10254) + p.External_format_spec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10255) + p.Row_format_spec() + } + { + p.SetState(10256) + p.Match(RedshiftParserSTORED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10257) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10258) + p.External_format_spec() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10260) + p.Match(RedshiftParserSTORED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10261) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10262) + p.Match(RedshiftParserINPUTFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10263) + p.Sconst() + } + { + p.SetState(10264) + p.Match(RedshiftParserOUTPUTFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10265) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_format_specContext is an interface to support dynamic dispatch. +type IRow_format_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + FORMAT() antlr.TerminalNode + DELIMITED() antlr.TerminalNode + FIELDS() antlr.TerminalNode + AllTERMINATED() []antlr.TerminalNode + TERMINATED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + COLLECTION() antlr.TerminalNode + ITEMS() antlr.TerminalNode + MAP() antlr.TerminalNode + KEYS() antlr.TerminalNode + LINES() antlr.TerminalNode + NULL_P() antlr.TerminalNode + DEFINED() antlr.TerminalNode + AS() antlr.TerminalNode + ESCAPED() antlr.TerminalNode + SERDE() antlr.TerminalNode + WITH() antlr.TerminalNode + SERDEPROPERTIES() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Serde_properties_list() ISerde_properties_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsRow_format_specContext differentiates from other interfaces. + IsRow_format_specContext() +} + +type Row_format_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_format_specContext() *Row_format_specContext { + var p = new(Row_format_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row_format_spec + return p +} + +func InitEmptyRow_format_specContext(p *Row_format_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row_format_spec +} + +func (*Row_format_specContext) IsRow_format_specContext() {} + +func NewRow_format_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_format_specContext { + var p = new(Row_format_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_row_format_spec + + return p +} + +func (s *Row_format_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_format_specContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Row_format_specContext) FORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORMAT, 0) +} + +func (s *Row_format_specContext) DELIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELIMITED, 0) +} + +func (s *Row_format_specContext) FIELDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIELDS, 0) +} + +func (s *Row_format_specContext) AllTERMINATED() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserTERMINATED) +} + +func (s *Row_format_specContext) TERMINATED(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserTERMINATED, i) +} + +func (s *Row_format_specContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserBY) +} + +func (s *Row_format_specContext) BY(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, i) +} + +func (s *Row_format_specContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Row_format_specContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Row_format_specContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLECTION, 0) +} + +func (s *Row_format_specContext) ITEMS() antlr.TerminalNode { + return s.GetToken(RedshiftParserITEMS, 0) +} + +func (s *Row_format_specContext) MAP() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAP, 0) +} + +func (s *Row_format_specContext) KEYS() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEYS, 0) +} + +func (s *Row_format_specContext) LINES() antlr.TerminalNode { + return s.GetToken(RedshiftParserLINES, 0) +} + +func (s *Row_format_specContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Row_format_specContext) DEFINED() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFINED, 0) +} + +func (s *Row_format_specContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Row_format_specContext) ESCAPED() antlr.TerminalNode { + return s.GetToken(RedshiftParserESCAPED, 0) +} + +func (s *Row_format_specContext) SERDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERDE, 0) +} + +func (s *Row_format_specContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Row_format_specContext) SERDEPROPERTIES() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERDEPROPERTIES, 0) +} + +func (s *Row_format_specContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Row_format_specContext) Serde_properties_list() ISerde_properties_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISerde_properties_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISerde_properties_listContext) +} + +func (s *Row_format_specContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Row_format_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_format_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_format_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRow_format_spec(s) + } +} + +func (s *Row_format_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRow_format_spec(s) + } +} + +func (s *Row_format_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRow_format_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Row_format_spec() (localctx IRow_format_specContext) { + localctx = NewRow_format_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1118, RedshiftParserRULE_row_format_spec) + var _la int + + p.SetState(10321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 852, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10269) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10270) + p.Match(RedshiftParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10271) + p.Match(RedshiftParserDELIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFIELDS { + { + p.SetState(10272) + p.Match(RedshiftParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10273) + p.Match(RedshiftParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10274) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10275) + p.Sconst() + } + p.SetState(10279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserESCAPED { + { + p.SetState(10276) + p.Match(RedshiftParserESCAPED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10277) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10278) + p.Sconst() + } + + } + + } + p.SetState(10288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLLECTION { + { + p.SetState(10283) + p.Match(RedshiftParserCOLLECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10284) + p.Match(RedshiftParserITEMS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10285) + p.Match(RedshiftParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10286) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10287) + p.Sconst() + } + + } + p.SetState(10295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMAP { + { + p.SetState(10290) + p.Match(RedshiftParserMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10291) + p.Match(RedshiftParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10292) + p.Match(RedshiftParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10293) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10294) + p.Sconst() + } + + } + p.SetState(10301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLINES { + { + p.SetState(10297) + p.Match(RedshiftParserLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10298) + p.Match(RedshiftParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10299) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10300) + p.Sconst() + } + + } + p.SetState(10307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNULL_P { + { + p.SetState(10303) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10304) + p.Match(RedshiftParserDEFINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10305) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10306) + p.Sconst() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10309) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10310) + p.Match(RedshiftParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10311) + p.Match(RedshiftParserSERDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10312) + p.Sconst() + } + p.SetState(10319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(10313) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10314) + p.Match(RedshiftParserSERDEPROPERTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10315) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10316) + p.Serde_properties_list() + } + { + p.SetState(10317) + p.Match(RedshiftParserCLOSE_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 +} + +// ISerde_properties_listContext is an interface to support dynamic dispatch. +type ISerde_properties_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSerde_property() []ISerde_propertyContext + Serde_property(i int) ISerde_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSerde_properties_listContext differentiates from other interfaces. + IsSerde_properties_listContext() +} + +type Serde_properties_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySerde_properties_listContext() *Serde_properties_listContext { + var p = new(Serde_properties_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_serde_properties_list + return p +} + +func InitEmptySerde_properties_listContext(p *Serde_properties_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_serde_properties_list +} + +func (*Serde_properties_listContext) IsSerde_properties_listContext() {} + +func NewSerde_properties_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Serde_properties_listContext { + var p = new(Serde_properties_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_serde_properties_list + + return p +} + +func (s *Serde_properties_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Serde_properties_listContext) AllSerde_property() []ISerde_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISerde_propertyContext); ok { + len++ + } + } + + tst := make([]ISerde_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISerde_propertyContext); ok { + tst[i] = t.(ISerde_propertyContext) + i++ + } + } + + return tst +} + +func (s *Serde_properties_listContext) Serde_property(i int) ISerde_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISerde_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISerde_propertyContext) +} + +func (s *Serde_properties_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Serde_properties_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Serde_properties_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Serde_properties_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Serde_properties_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSerde_properties_list(s) + } +} + +func (s *Serde_properties_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSerde_properties_list(s) + } +} + +func (s *Serde_properties_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSerde_properties_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Serde_properties_list() (localctx ISerde_properties_listContext) { + localctx = NewSerde_properties_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1120, RedshiftParserRULE_serde_properties_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10323) + p.Serde_property() + } + p.SetState(10328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10324) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10325) + p.Serde_property() + } + + p.SetState(10330) + 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 +} + +// ISerde_propertyContext is an interface to support dynamic dispatch. +type ISerde_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + EQUAL() antlr.TerminalNode + + // IsSerde_propertyContext differentiates from other interfaces. + IsSerde_propertyContext() +} + +type Serde_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySerde_propertyContext() *Serde_propertyContext { + var p = new(Serde_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_serde_property + return p +} + +func InitEmptySerde_propertyContext(p *Serde_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_serde_property +} + +func (*Serde_propertyContext) IsSerde_propertyContext() {} + +func NewSerde_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Serde_propertyContext { + var p = new(Serde_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_serde_property + + return p +} + +func (s *Serde_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Serde_propertyContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Serde_propertyContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Serde_propertyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Serde_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Serde_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Serde_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSerde_property(s) + } +} + +func (s *Serde_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSerde_property(s) + } +} + +func (s *Serde_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSerde_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Serde_property() (localctx ISerde_propertyContext) { + localctx = NewSerde_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1122, RedshiftParserRULE_serde_property) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10331) + p.Sconst() + } + { + p.SetState(10332) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10333) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_format_specContext is an interface to support dynamic dispatch. +type IExternal_format_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARQUET() antlr.TerminalNode + AVRO() antlr.TerminalNode + RCFILE() antlr.TerminalNode + SEQUENCEFILE() antlr.TerminalNode + TEXTFILE() antlr.TerminalNode + ORC() antlr.TerminalNode + ION() antlr.TerminalNode + JSON() antlr.TerminalNode + + // IsExternal_format_specContext differentiates from other interfaces. + IsExternal_format_specContext() +} + +type External_format_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_format_specContext() *External_format_specContext { + var p = new(External_format_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_external_format_spec + return p +} + +func InitEmptyExternal_format_specContext(p *External_format_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_external_format_spec +} + +func (*External_format_specContext) IsExternal_format_specContext() {} + +func NewExternal_format_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_format_specContext { + var p = new(External_format_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_external_format_spec + + return p +} + +func (s *External_format_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_format_specContext) PARQUET() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARQUET, 0) +} + +func (s *External_format_specContext) AVRO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAVRO, 0) +} + +func (s *External_format_specContext) RCFILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRCFILE, 0) +} + +func (s *External_format_specContext) SEQUENCEFILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCEFILE, 0) +} + +func (s *External_format_specContext) TEXTFILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXTFILE, 0) +} + +func (s *External_format_specContext) ORC() antlr.TerminalNode { + return s.GetToken(RedshiftParserORC, 0) +} + +func (s *External_format_specContext) ION() antlr.TerminalNode { + return s.GetToken(RedshiftParserION, 0) +} + +func (s *External_format_specContext) JSON() antlr.TerminalNode { + return s.GetToken(RedshiftParserJSON, 0) +} + +func (s *External_format_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_format_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_format_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExternal_format_spec(s) + } +} + +func (s *External_format_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExternal_format_spec(s) + } +} + +func (s *External_format_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExternal_format_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) External_format_spec() (localctx IExternal_format_specContext) { + localctx = NewExternal_format_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1124, RedshiftParserRULE_external_format_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10335) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserJSON || ((int64((_la-513)) & ^0x3f) == 0 && ((int64(1)<<(_la-513))&319) != 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 +} + +// ITable_properties_listContext is an interface to support dynamic dispatch. +type ITable_properties_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTable_property() []ITable_propertyContext + Table_property(i int) ITable_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_properties_listContext differentiates from other interfaces. + IsTable_properties_listContext() +} + +type Table_properties_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_properties_listContext() *Table_properties_listContext { + var p = new(Table_properties_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_properties_list + return p +} + +func InitEmptyTable_properties_listContext(p *Table_properties_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_properties_list +} + +func (*Table_properties_listContext) IsTable_properties_listContext() {} + +func NewTable_properties_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_properties_listContext { + var p = new(Table_properties_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_properties_list + + return p +} + +func (s *Table_properties_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_properties_listContext) AllTable_property() []ITable_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_propertyContext); ok { + len++ + } + } + + tst := make([]ITable_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_propertyContext); ok { + tst[i] = t.(ITable_propertyContext) + i++ + } + } + + return tst +} + +func (s *Table_properties_listContext) Table_property(i int) ITable_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_propertyContext) +} + +func (s *Table_properties_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Table_properties_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Table_properties_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_properties_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_properties_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_properties_list(s) + } +} + +func (s *Table_properties_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_properties_list(s) + } +} + +func (s *Table_properties_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_properties_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_properties_list() (localctx ITable_properties_listContext) { + localctx = NewTable_properties_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1126, RedshiftParserRULE_table_properties_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10337) + p.Table_property() + } + p.SetState(10342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10338) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10339) + p.Table_property() + } + + p.SetState(10344) + 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 +} + +// ITable_propertyContext is an interface to support dynamic dispatch. +type ITable_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + EQUAL() antlr.TerminalNode + + // IsTable_propertyContext differentiates from other interfaces. + IsTable_propertyContext() +} + +type Table_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_propertyContext() *Table_propertyContext { + var p = new(Table_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_property + return p +} + +func InitEmptyTable_propertyContext(p *Table_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_property +} + +func (*Table_propertyContext) IsTable_propertyContext() {} + +func NewTable_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_propertyContext { + var p = new(Table_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_property + + return p +} + +func (s *Table_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_propertyContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *Table_propertyContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Table_propertyContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Table_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_property(s) + } +} + +func (s *Table_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_property(s) + } +} + +func (s *Table_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_property() (localctx ITable_propertyContext) { + localctx = NewTable_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1128, RedshiftParserRULE_table_property) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10345) + p.Sconst() + } + { + p.SetState(10346) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10347) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateexternalviewstmtContext is an interface to support dynamic dispatch. +type ICreateexternalviewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + AS() antlr.TerminalNode + Selectstmt() ISelectstmtContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + PROTECTED() antlr.TerminalNode + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Name_list() IName_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsCreateexternalviewstmtContext differentiates from other interfaces. + IsCreateexternalviewstmtContext() +} + +type CreateexternalviewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateexternalviewstmtContext() *CreateexternalviewstmtContext { + var p = new(CreateexternalviewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalviewstmt + return p +} + +func InitEmptyCreateexternalviewstmtContext(p *CreateexternalviewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createexternalviewstmt +} + +func (*CreateexternalviewstmtContext) IsCreateexternalviewstmtContext() {} + +func NewCreateexternalviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateexternalviewstmtContext { + var p = new(CreateexternalviewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createexternalviewstmt + + return p +} + +func (s *CreateexternalviewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateexternalviewstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateexternalviewstmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *CreateexternalviewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *CreateexternalviewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreateexternalviewstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CreateexternalviewstmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *CreateexternalviewstmtContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *CreateexternalviewstmtContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *CreateexternalviewstmtContext) PROTECTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROTECTED, 0) +} + +func (s *CreateexternalviewstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *CreateexternalviewstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *CreateexternalviewstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *CreateexternalviewstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreateexternalviewstmtContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *CreateexternalviewstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreateexternalviewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateexternalviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateexternalviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateexternalviewstmt(s) + } +} + +func (s *CreateexternalviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateexternalviewstmt(s) + } +} + +func (s *CreateexternalviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateexternalviewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createexternalviewstmt() (localctx ICreateexternalviewstmtContext) { + localctx = NewCreateexternalviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1130, RedshiftParserRULE_createexternalviewstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10349) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(10350) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10351) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10354) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROTECTED { + { + p.SetState(10355) + p.Match(RedshiftParserPROTECTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10358) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10359) + p.Qualified_name() + } + p.SetState(10363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIF_P { + { + p.SetState(10360) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10361) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10362) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(10365) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10366) + p.Name_list() + } + { + p.SetState(10367) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10371) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10372) + p.Selectstmt() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropexternalviewstmtContext is an interface to support dynamic dispatch. +type IDropexternalviewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_if_exists() IOpt_if_existsContext + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsDropexternalviewstmtContext differentiates from other interfaces. + IsDropexternalviewstmtContext() +} + +type DropexternalviewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropexternalviewstmtContext() *DropexternalviewstmtContext { + var p = new(DropexternalviewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropexternalviewstmt + return p +} + +func InitEmptyDropexternalviewstmtContext(p *DropexternalviewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropexternalviewstmt +} + +func (*DropexternalviewstmtContext) IsDropexternalviewstmtContext() {} + +func NewDropexternalviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropexternalviewstmtContext { + var p = new(DropexternalviewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropexternalviewstmt + + return p +} + +func (s *DropexternalviewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropexternalviewstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropexternalviewstmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *DropexternalviewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *DropexternalviewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *DropexternalviewstmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropexternalviewstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *DropexternalviewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropexternalviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropexternalviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropexternalviewstmt(s) + } +} + +func (s *DropexternalviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropexternalviewstmt(s) + } +} + +func (s *DropexternalviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropexternalviewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropexternalviewstmt() (localctx IDropexternalviewstmtContext) { + localctx = NewDropexternalviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1132, RedshiftParserRULE_dropexternalviewstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10374) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10375) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10376) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10378) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 859, p.GetParserRuleContext()) == 1 { + { + p.SetState(10377) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10380) + p.Qualified_name() + } + p.SetState(10382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(10381) + p.Opt_drop_behavior() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlteridentityproviderstmtContext is an interface to support dynamic dispatch. +type IAlteridentityproviderstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIdentity_provider_name returns the identity_provider_name rule contexts. + GetIdentity_provider_name() IColidContext + + // SetIdentity_provider_name sets the identity_provider_name rule contexts. + SetIdentity_provider_name(IColidContext) + + // Getter signatures + ALTER() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + Colid() IColidContext + AllAlteridprovideropts() []IAlteridprovideroptsContext + Alteridprovideropts(i int) IAlteridprovideroptsContext + + // IsAlteridentityproviderstmtContext differentiates from other interfaces. + IsAlteridentityproviderstmtContext() +} + +type AlteridentityproviderstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + identity_provider_name IColidContext +} + +func NewEmptyAlteridentityproviderstmtContext() *AlteridentityproviderstmtContext { + var p = new(AlteridentityproviderstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteridentityproviderstmt + return p +} + +func InitEmptyAlteridentityproviderstmtContext(p *AlteridentityproviderstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteridentityproviderstmt +} + +func (*AlteridentityproviderstmtContext) IsAlteridentityproviderstmtContext() {} + +func NewAlteridentityproviderstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteridentityproviderstmtContext { + var p = new(AlteridentityproviderstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteridentityproviderstmt + + return p +} + +func (s *AlteridentityproviderstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteridentityproviderstmtContext) GetIdentity_provider_name() IColidContext { + return s.identity_provider_name +} + +func (s *AlteridentityproviderstmtContext) SetIdentity_provider_name(v IColidContext) { + s.identity_provider_name = v +} + +func (s *AlteridentityproviderstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlteridentityproviderstmtContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *AlteridentityproviderstmtContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER, 0) +} + +func (s *AlteridentityproviderstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AlteridentityproviderstmtContext) AllAlteridprovideropts() []IAlteridprovideroptsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlteridprovideroptsContext); ok { + len++ + } + } + + tst := make([]IAlteridprovideroptsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlteridprovideroptsContext); ok { + tst[i] = t.(IAlteridprovideroptsContext) + i++ + } + } + + return tst +} + +func (s *AlteridentityproviderstmtContext) Alteridprovideropts(i int) IAlteridprovideroptsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteridprovideroptsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlteridprovideroptsContext) +} + +func (s *AlteridentityproviderstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteridentityproviderstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteridentityproviderstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteridentityproviderstmt(s) + } +} + +func (s *AlteridentityproviderstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteridentityproviderstmt(s) + } +} + +func (s *AlteridentityproviderstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteridentityproviderstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteridentityproviderstmt() (localctx IAlteridentityproviderstmtContext) { + localctx = NewAlteridentityproviderstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1134, RedshiftParserRULE_alteridentityproviderstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10384) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10385) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10386) + p.Match(RedshiftParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10387) + + var _x = p.Colid() + + localctx.(*AlteridentityproviderstmtContext).identity_provider_name = _x + } + p.SetState(10389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserDISABLE_P || _la == RedshiftParserENABLE_P || _la == RedshiftParserIAM_ROLE || ((int64((_la-467)) & ^0x3f) == 0 && ((int64(1)<<(_la-467))&343597383681) != 0) { + { + p.SetState(10388) + p.Alteridprovideropts() + } + + p.SetState(10391) + 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 +} + +// IAlteridprovideroptsContext is an interface to support dynamic dispatch. +type IAlteridprovideroptsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetParameter_string returns the parameter_string rule contexts. + GetParameter_string() ISconstContext + + // GetNamespace returns the namespace rule contexts. + GetNamespace() ISconstContext + + // GetIam_role returns the iam_role rule contexts. + GetIam_role() ISconstContext + + // GetFilter_pattern returns the filter_pattern rule contexts. + GetFilter_pattern() ISconstContext + + // SetParameter_string sets the parameter_string rule contexts. + SetParameter_string(ISconstContext) + + // SetNamespace sets the namespace rule contexts. + SetNamespace(ISconstContext) + + // SetIam_role sets the iam_role rule contexts. + SetIam_role(ISconstContext) + + // SetFilter_pattern sets the filter_pattern rule contexts. + SetFilter_pattern(ISconstContext) + + // Getter signatures + PARAMETERS() antlr.TerminalNode + Sconst() ISconstContext + NAMESPACE() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + AUTO_CREATE_ROLES() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + TRUE_P() antlr.TerminalNode + GROUPS() antlr.TerminalNode + LIKE() antlr.TerminalNode + INCLUDE() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + DISABLE_P() antlr.TerminalNode + ENABLE_P() antlr.TerminalNode + + // IsAlteridprovideroptsContext differentiates from other interfaces. + IsAlteridprovideroptsContext() +} + +type AlteridprovideroptsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + parameter_string ISconstContext + namespace ISconstContext + iam_role ISconstContext + filter_pattern ISconstContext +} + +func NewEmptyAlteridprovideroptsContext() *AlteridprovideroptsContext { + var p = new(AlteridprovideroptsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteridprovideropts + return p +} + +func InitEmptyAlteridprovideroptsContext(p *AlteridprovideroptsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteridprovideropts +} + +func (*AlteridprovideroptsContext) IsAlteridprovideroptsContext() {} + +func NewAlteridprovideroptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteridprovideroptsContext { + var p = new(AlteridprovideroptsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteridprovideropts + + return p +} + +func (s *AlteridprovideroptsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteridprovideroptsContext) GetParameter_string() ISconstContext { return s.parameter_string } + +func (s *AlteridprovideroptsContext) GetNamespace() ISconstContext { return s.namespace } + +func (s *AlteridprovideroptsContext) GetIam_role() ISconstContext { return s.iam_role } + +func (s *AlteridprovideroptsContext) GetFilter_pattern() ISconstContext { return s.filter_pattern } + +func (s *AlteridprovideroptsContext) SetParameter_string(v ISconstContext) { s.parameter_string = v } + +func (s *AlteridprovideroptsContext) SetNamespace(v ISconstContext) { s.namespace = v } + +func (s *AlteridprovideroptsContext) SetIam_role(v ISconstContext) { s.iam_role = v } + +func (s *AlteridprovideroptsContext) SetFilter_pattern(v ISconstContext) { s.filter_pattern = v } + +func (s *AlteridprovideroptsContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAMETERS, 0) +} + +func (s *AlteridprovideroptsContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *AlteridprovideroptsContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMESPACE, 0) +} + +func (s *AlteridprovideroptsContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *AlteridprovideroptsContext) AUTO_CREATE_ROLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO_CREATE_ROLES, 0) +} + +func (s *AlteridprovideroptsContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *AlteridprovideroptsContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *AlteridprovideroptsContext) GROUPS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUPS, 0) +} + +func (s *AlteridprovideroptsContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *AlteridprovideroptsContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDE, 0) +} + +func (s *AlteridprovideroptsContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDE, 0) +} + +func (s *AlteridprovideroptsContext) DISABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISABLE_P, 0) +} + +func (s *AlteridprovideroptsContext) ENABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserENABLE_P, 0) +} + +func (s *AlteridprovideroptsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteridprovideroptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteridprovideroptsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteridprovideropts(s) + } +} + +func (s *AlteridprovideroptsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteridprovideropts(s) + } +} + +func (s *AlteridprovideroptsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteridprovideropts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteridprovideropts() (localctx IAlteridprovideroptsContext) { + localctx = NewAlteridprovideroptsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1136, RedshiftParserRULE_alteridprovideropts) + var _la int + + p.SetState(10412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserPARAMETERS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10393) + p.Match(RedshiftParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10394) + + var _x = p.Sconst() + + localctx.(*AlteridprovideroptsContext).parameter_string = _x + } + + case RedshiftParserNAMESPACE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10395) + p.Match(RedshiftParserNAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10396) + + var _x = p.Sconst() + + localctx.(*AlteridprovideroptsContext).namespace = _x + } + + case RedshiftParserIAM_ROLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10397) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10398) + + var _x = p.Sconst() + + localctx.(*AlteridprovideroptsContext).iam_role = _x + } + + case RedshiftParserAUTO_CREATE_ROLES: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10399) + p.Match(RedshiftParserAUTO_CREATE_ROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case RedshiftParserTRUE_P: + { + p.SetState(10400) + p.Match(RedshiftParserTRUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCLUDE || _la == RedshiftParserINCLUDE { + { + p.SetState(10401) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXCLUDE || _la == RedshiftParserINCLUDE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10402) + p.Match(RedshiftParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10403) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10404) + + var _x = p.Sconst() + + localctx.(*AlteridprovideroptsContext).filter_pattern = _x + } + + } + + case RedshiftParserFALSE_P: + { + p.SetState(10407) + p.Match(RedshiftParserFALSE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEOF, RedshiftParserOPEN_PAREN, RedshiftParserSEMI, RedshiftParserANALYSE, RedshiftParserANALYZE, RedshiftParserCREATE, RedshiftParserDESC, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserGRANT, RedshiftParserINTO, RedshiftParserSELECT, RedshiftParserTABLE, RedshiftParserWITH, RedshiftParserABORT_P, RedshiftParserALTER, RedshiftParserBEGIN_P, RedshiftParserCHECKPOINT, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMIT, RedshiftParserCOPY, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDELETE_P, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDROP, RedshiftParserENABLE_P, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserINSERT, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCK_P, RedshiftParserMERGE, RedshiftParserNOTIFY, RedshiftParserPREPARE, RedshiftParserREASSIGN, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELEASE, RedshiftParserRESET, RedshiftParserREVOKE, RedshiftParserROLLBACK, RedshiftParserSAVEPOINT, RedshiftParserSECURITY, RedshiftParserSET, RedshiftParserSHOW, RedshiftParserSTART, RedshiftParserTRUNCATE, RedshiftParserUNLISTEN, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserIAM_ROLE, RedshiftParserUNLOAD, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserPARAMETERS, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserVALUES, RedshiftParserCALL, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserIMPORT_P, RedshiftParserEND_P, RedshiftParserMetaCommand: + + default: + } + + case RedshiftParserDISABLE_P: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10410) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserENABLE_P: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10411) + p.Match(RedshiftParserENABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltermaskingpolicystmtContext is an interface to support dynamic dispatch. +type IAltermaskingpolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Colid() IColidContext + Altmaskingpolicyopts() IAltmaskingpolicyoptsContext + + // IsAltermaskingpolicystmtContext differentiates from other interfaces. + IsAltermaskingpolicystmtContext() +} + +type AltermaskingpolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltermaskingpolicystmtContext() *AltermaskingpolicystmtContext { + var p = new(AltermaskingpolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altermaskingpolicystmt + return p +} + +func InitEmptyAltermaskingpolicystmtContext(p *AltermaskingpolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altermaskingpolicystmt +} + +func (*AltermaskingpolicystmtContext) IsAltermaskingpolicystmtContext() {} + +func NewAltermaskingpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltermaskingpolicystmtContext { + var p = new(AltermaskingpolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altermaskingpolicystmt + + return p +} + +func (s *AltermaskingpolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltermaskingpolicystmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltermaskingpolicystmtContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *AltermaskingpolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *AltermaskingpolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AltermaskingpolicystmtContext) Altmaskingpolicyopts() IAltmaskingpolicyoptsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltmaskingpolicyoptsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltmaskingpolicyoptsContext) +} + +func (s *AltermaskingpolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltermaskingpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltermaskingpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltermaskingpolicystmt(s) + } +} + +func (s *AltermaskingpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltermaskingpolicystmt(s) + } +} + +func (s *AltermaskingpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltermaskingpolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altermaskingpolicystmt() (localctx IAltermaskingpolicystmtContext) { + localctx = NewAltermaskingpolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1138, RedshiftParserRULE_altermaskingpolicystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10414) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10415) + p.Match(RedshiftParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10416) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10417) + p.Colid() + } + { + p.SetState(10418) + p.Altmaskingpolicyopts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltermaterializedviewstmtContext is an interface to support dynamic dispatch. +type IAltermaterializedviewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllALTER() []antlr.TerminalNode + ALTER(i int) antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + AUTO() antlr.TerminalNode + REFRESH() antlr.TerminalNode + DISTKEY() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + DISTSTYLE() antlr.TerminalNode + SORTKEY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + ROW() antlr.TerminalNode + LEVEL() antlr.TerminalNode + SECURITY() antlr.TerminalNode + YES_P() antlr.TerminalNode + NO() antlr.TerminalNode + NONE() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + ALL() antlr.TerminalNode + EVEN() antlr.TerminalNode + COMPOUND() antlr.TerminalNode + CONJUNCTION() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + FOR() antlr.TerminalNode + DATASHARES() antlr.TerminalNode + KEY() antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAltermaterializedviewstmtContext differentiates from other interfaces. + IsAltermaterializedviewstmtContext() +} + +type AltermaterializedviewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltermaterializedviewstmtContext() *AltermaterializedviewstmtContext { + var p = new(AltermaterializedviewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altermaterializedviewstmt + return p +} + +func InitEmptyAltermaterializedviewstmtContext(p *AltermaterializedviewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altermaterializedviewstmt +} + +func (*AltermaterializedviewstmtContext) IsAltermaterializedviewstmtContext() {} + +func NewAltermaterializedviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltermaterializedviewstmtContext { + var p = new(AltermaterializedviewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altermaterializedviewstmt + + return p +} + +func (s *AltermaterializedviewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltermaterializedviewstmtContext) AllALTER() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserALTER) +} + +func (s *AltermaterializedviewstmtContext) ALTER(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, i) +} + +func (s *AltermaterializedviewstmtContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *AltermaterializedviewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *AltermaterializedviewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AltermaterializedviewstmtContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *AltermaterializedviewstmtContext) REFRESH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFRESH, 0) +} + +func (s *AltermaterializedviewstmtContext) DISTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTKEY, 0) +} + +func (s *AltermaterializedviewstmtContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *AltermaterializedviewstmtContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AltermaterializedviewstmtContext) DISTSTYLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTSTYLE, 0) +} + +func (s *AltermaterializedviewstmtContext) SORTKEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSORTKEY, 0) +} + +func (s *AltermaterializedviewstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AltermaterializedviewstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AltermaterializedviewstmtContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *AltermaterializedviewstmtContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *AltermaterializedviewstmtContext) SECURITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECURITY, 0) +} + +func (s *AltermaterializedviewstmtContext) YES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYES_P, 0) +} + +func (s *AltermaterializedviewstmtContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *AltermaterializedviewstmtContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *AltermaterializedviewstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *AltermaterializedviewstmtContext) OFF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFF, 0) +} + +func (s *AltermaterializedviewstmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *AltermaterializedviewstmtContext) EVEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVEN, 0) +} + +func (s *AltermaterializedviewstmtContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPOUND, 0) +} + +func (s *AltermaterializedviewstmtContext) CONJUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONJUNCTION, 0) +} + +func (s *AltermaterializedviewstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *AltermaterializedviewstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *AltermaterializedviewstmtContext) DATASHARES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARES, 0) +} + +func (s *AltermaterializedviewstmtContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *AltermaterializedviewstmtContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *AltermaterializedviewstmtContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *AltermaterializedviewstmtContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *AltermaterializedviewstmtContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *AltermaterializedviewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltermaterializedviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltermaterializedviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltermaterializedviewstmt(s) + } +} + +func (s *AltermaterializedviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltermaterializedviewstmt(s) + } +} + +func (s *AltermaterializedviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltermaterializedviewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altermaterializedviewstmt() (localctx IAltermaterializedviewstmtContext) { + localctx = NewAltermaterializedviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1140, RedshiftParserRULE_altermaterializedviewstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10420) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10421) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10422) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10423) + p.Qualified_name() + } + p.SetState(10472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 870, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10424) + p.Match(RedshiftParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10425) + p.Match(RedshiftParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10426) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserNO || _la == RedshiftParserYES_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(10427) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10428) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10429) + p.Colid() + } + + case 3: + { + p.SetState(10430) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10431) + p.Match(RedshiftParserDISTSTYLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserALL: + { + p.SetState(10432) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEVEN: + { + p.SetState(10433) + p.Match(RedshiftParserEVEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserKEY: + { + p.SetState(10434) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10435) + p.Match(RedshiftParserDISTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10436) + p.Colid() + } + + case RedshiftParserAUTO: + { + p.SetState(10437) + p.Match(RedshiftParserAUTO) + 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(10440) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMPOUND { + { + p.SetState(10441) + p.Match(RedshiftParserCOMPOUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10444) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10445) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(10446) + p.Colid() + } + p.SetState(10451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10447) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10448) + p.Colid() + } + + p.SetState(10453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(10454) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(10456) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10457) + p.Match(RedshiftParserSORTKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10458) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserAUTO || _la == RedshiftParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 6: + { + p.SetState(10459) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10460) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10461) + p.Match(RedshiftParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10462) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserON || _la == RedshiftParserOFF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCONJUNCTION { + { + p.SetState(10463) + p.Match(RedshiftParserCONJUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10464) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10465) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserAND || _la == RedshiftParserOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(10468) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10469) + p.Match(RedshiftParserDATASHARES) + 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 +} + +// IAltmaskingpolicyoptsContext is an interface to support dynamic dispatch. +type IAltmaskingpolicyoptsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Colid() IColidContext + OWNER() antlr.TerminalNode + SET() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Altmaskingpolicyargs() IAltmaskingpolicyargsContext + CLOSE_PAREN() antlr.TerminalNode + USING() antlr.TerminalNode + Maskingexpression() IMaskingexpressionContext + + // IsAltmaskingpolicyoptsContext differentiates from other interfaces. + IsAltmaskingpolicyoptsContext() +} + +type AltmaskingpolicyoptsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltmaskingpolicyoptsContext() *AltmaskingpolicyoptsContext { + var p = new(AltmaskingpolicyoptsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyopts + return p +} + +func InitEmptyAltmaskingpolicyoptsContext(p *AltmaskingpolicyoptsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyopts +} + +func (*AltmaskingpolicyoptsContext) IsAltmaskingpolicyoptsContext() {} + +func NewAltmaskingpolicyoptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltmaskingpolicyoptsContext { + var p = new(AltmaskingpolicyoptsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyopts + + return p +} + +func (s *AltmaskingpolicyoptsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltmaskingpolicyoptsContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *AltmaskingpolicyoptsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AltmaskingpolicyoptsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AltmaskingpolicyoptsContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *AltmaskingpolicyoptsContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AltmaskingpolicyoptsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AltmaskingpolicyoptsContext) Altmaskingpolicyargs() IAltmaskingpolicyargsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltmaskingpolicyargsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAltmaskingpolicyargsContext) +} + +func (s *AltmaskingpolicyoptsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AltmaskingpolicyoptsContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *AltmaskingpolicyoptsContext) Maskingexpression() IMaskingexpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaskingexpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaskingexpressionContext) +} + +func (s *AltmaskingpolicyoptsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltmaskingpolicyoptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltmaskingpolicyoptsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltmaskingpolicyopts(s) + } +} + +func (s *AltmaskingpolicyoptsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltmaskingpolicyopts(s) + } +} + +func (s *AltmaskingpolicyoptsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltmaskingpolicyopts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altmaskingpolicyopts() (localctx IAltmaskingpolicyoptsContext) { + localctx = NewAltmaskingpolicyoptsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1142, RedshiftParserRULE_altmaskingpolicyopts) + p.SetState(10490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserRENAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10474) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10475) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10476) + p.Colid() + } + + case RedshiftParserOWNER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10477) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10478) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10479) + p.Colid() + } + + case RedshiftParserSET: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10480) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10481) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10482) + p.Altmaskingpolicyargs() + } + { + p.SetState(10483) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUSING: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10485) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10486) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10487) + p.Maskingexpression() + } + { + p.SetState(10488) + p.Match(RedshiftParserCLOSE_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 +} + +// IAltmaskingpolicyargsContext is an interface to support dynamic dispatch. +type IAltmaskingpolicyargsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAltmaskingpolicyarg() []IAltmaskingpolicyargContext + Altmaskingpolicyarg(i int) IAltmaskingpolicyargContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAltmaskingpolicyargsContext differentiates from other interfaces. + IsAltmaskingpolicyargsContext() +} + +type AltmaskingpolicyargsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltmaskingpolicyargsContext() *AltmaskingpolicyargsContext { + var p = new(AltmaskingpolicyargsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyargs + return p +} + +func InitEmptyAltmaskingpolicyargsContext(p *AltmaskingpolicyargsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyargs +} + +func (*AltmaskingpolicyargsContext) IsAltmaskingpolicyargsContext() {} + +func NewAltmaskingpolicyargsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltmaskingpolicyargsContext { + var p = new(AltmaskingpolicyargsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyargs + + return p +} + +func (s *AltmaskingpolicyargsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltmaskingpolicyargsContext) AllAltmaskingpolicyarg() []IAltmaskingpolicyargContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAltmaskingpolicyargContext); ok { + len++ + } + } + + tst := make([]IAltmaskingpolicyargContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAltmaskingpolicyargContext); ok { + tst[i] = t.(IAltmaskingpolicyargContext) + i++ + } + } + + return tst +} + +func (s *AltmaskingpolicyargsContext) Altmaskingpolicyarg(i int) IAltmaskingpolicyargContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAltmaskingpolicyargContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAltmaskingpolicyargContext) +} + +func (s *AltmaskingpolicyargsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *AltmaskingpolicyargsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *AltmaskingpolicyargsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltmaskingpolicyargsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltmaskingpolicyargsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltmaskingpolicyargs(s) + } +} + +func (s *AltmaskingpolicyargsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltmaskingpolicyargs(s) + } +} + +func (s *AltmaskingpolicyargsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltmaskingpolicyargs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altmaskingpolicyargs() (localctx IAltmaskingpolicyargsContext) { + localctx = NewAltmaskingpolicyargsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1144, RedshiftParserRULE_altmaskingpolicyargs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10492) + p.Altmaskingpolicyarg() + } + p.SetState(10497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10493) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10494) + p.Altmaskingpolicyarg() + } + + p.SetState(10499) + 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 +} + +// IAltmaskingpolicyargContext is an interface to support dynamic dispatch. +type IAltmaskingpolicyargContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Typename() ITypenameContext + + // IsAltmaskingpolicyargContext differentiates from other interfaces. + IsAltmaskingpolicyargContext() +} + +type AltmaskingpolicyargContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltmaskingpolicyargContext() *AltmaskingpolicyargContext { + var p = new(AltmaskingpolicyargContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyarg + return p +} + +func InitEmptyAltmaskingpolicyargContext(p *AltmaskingpolicyargContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyarg +} + +func (*AltmaskingpolicyargContext) IsAltmaskingpolicyargContext() {} + +func NewAltmaskingpolicyargContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltmaskingpolicyargContext { + var p = new(AltmaskingpolicyargContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altmaskingpolicyarg + + return p +} + +func (s *AltmaskingpolicyargContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltmaskingpolicyargContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AltmaskingpolicyargContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *AltmaskingpolicyargContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltmaskingpolicyargContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltmaskingpolicyargContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltmaskingpolicyarg(s) + } +} + +func (s *AltmaskingpolicyargContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltmaskingpolicyarg(s) + } +} + +func (s *AltmaskingpolicyargContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltmaskingpolicyarg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altmaskingpolicyarg() (localctx IAltmaskingpolicyargContext) { + localctx = NewAltmaskingpolicyargContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1146, RedshiftParserRULE_altmaskingpolicyarg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10500) + p.Colid() + } + { + p.SetState(10501) + p.Typename() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterrlspolicystmtContext is an interface to support dynamic dispatch. +type IAlterrlspolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + RLS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Colid() IColidContext + USING() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsAlterrlspolicystmtContext differentiates from other interfaces. + IsAlterrlspolicystmtContext() +} + +type AlterrlspolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterrlspolicystmtContext() *AlterrlspolicystmtContext { + var p = new(AlterrlspolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterrlspolicystmt + return p +} + +func InitEmptyAlterrlspolicystmtContext(p *AlterrlspolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterrlspolicystmt +} + +func (*AlterrlspolicystmtContext) IsAlterrlspolicystmtContext() {} + +func NewAlterrlspolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterrlspolicystmtContext { + var p = new(AlterrlspolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterrlspolicystmt + + return p +} + +func (s *AlterrlspolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterrlspolicystmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterrlspolicystmtContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *AlterrlspolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *AlterrlspolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AlterrlspolicystmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *AlterrlspolicystmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AlterrlspolicystmtContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *AlterrlspolicystmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AlterrlspolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterrlspolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterrlspolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterrlspolicystmt(s) + } +} + +func (s *AlterrlspolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterrlspolicystmt(s) + } +} + +func (s *AlterrlspolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterrlspolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterrlspolicystmt() (localctx IAlterrlspolicystmtContext) { + localctx = NewAlterrlspolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1148, RedshiftParserRULE_alterrlspolicystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10503) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10504) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10505) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10506) + p.Colid() + } + { + p.SetState(10507) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10508) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10509) + p.A_expr() + } + { + p.SetState(10510) + p.Match(RedshiftParserCLOSE_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 +} + +// IAttachmaskingpolicystmtContext is an interface to support dynamic dispatch. +type IAttachmaskingpolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTACH() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Colid() IColidContext + ON() antlr.TerminalNode + Qualified_name() IQualified_nameContext + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + AllAttachpolicycollist() []IAttachpolicycollistContext + Attachpolicycollist(i int) IAttachpolicycollistContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + TO() antlr.TerminalNode + Attachpolicytargets() IAttachpolicytargetsContext + USING() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + Iconst() IIconstContext + + // IsAttachmaskingpolicystmtContext differentiates from other interfaces. + IsAttachmaskingpolicystmtContext() +} + +type AttachmaskingpolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttachmaskingpolicystmtContext() *AttachmaskingpolicystmtContext { + var p = new(AttachmaskingpolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachmaskingpolicystmt + return p +} + +func InitEmptyAttachmaskingpolicystmtContext(p *AttachmaskingpolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachmaskingpolicystmt +} + +func (*AttachmaskingpolicystmtContext) IsAttachmaskingpolicystmtContext() {} + +func NewAttachmaskingpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttachmaskingpolicystmtContext { + var p = new(AttachmaskingpolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attachmaskingpolicystmt + + return p +} + +func (s *AttachmaskingpolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AttachmaskingpolicystmtContext) ATTACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTACH, 0) +} + +func (s *AttachmaskingpolicystmtContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *AttachmaskingpolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *AttachmaskingpolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AttachmaskingpolicystmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *AttachmaskingpolicystmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AttachmaskingpolicystmtContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *AttachmaskingpolicystmtContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *AttachmaskingpolicystmtContext) AllAttachpolicycollist() []IAttachpolicycollistContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttachpolicycollistContext); ok { + len++ + } + } + + tst := make([]IAttachpolicycollistContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttachpolicycollistContext); ok { + tst[i] = t.(IAttachpolicycollistContext) + i++ + } + } + + return tst +} + +func (s *AttachmaskingpolicystmtContext) Attachpolicycollist(i int) IAttachpolicycollistContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachpolicycollistContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttachpolicycollistContext) +} + +func (s *AttachmaskingpolicystmtContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *AttachmaskingpolicystmtContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *AttachmaskingpolicystmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AttachmaskingpolicystmtContext) Attachpolicytargets() IAttachpolicytargetsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachpolicytargetsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttachpolicytargetsContext) +} + +func (s *AttachmaskingpolicystmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *AttachmaskingpolicystmtContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIORITY, 0) +} + +func (s *AttachmaskingpolicystmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *AttachmaskingpolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AttachmaskingpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AttachmaskingpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttachmaskingpolicystmt(s) + } +} + +func (s *AttachmaskingpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttachmaskingpolicystmt(s) + } +} + +func (s *AttachmaskingpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttachmaskingpolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attachmaskingpolicystmt() (localctx IAttachmaskingpolicystmtContext) { + localctx = NewAttachmaskingpolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1150, RedshiftParserRULE_attachmaskingpolicystmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10512) + p.Match(RedshiftParserATTACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10513) + p.Match(RedshiftParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10514) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10515) + p.Colid() + } + { + p.SetState(10516) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10517) + p.Qualified_name() + } + { + p.SetState(10518) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10519) + p.Attachpolicycollist() + } + { + p.SetState(10520) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(10521) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10522) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10523) + p.Attachpolicycollist() + } + { + p.SetState(10524) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10528) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10529) + p.Attachpolicytargets() + } + p.SetState(10532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPRIORITY { + { + p.SetState(10530) + p.Match(RedshiftParserPRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10531) + p.Iconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttachpolicycollistContext is an interface to support dynamic dispatch. +type IAttachpolicycollistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAttachpolicycolumn() []IAttachpolicycolumnContext + Attachpolicycolumn(i int) IAttachpolicycolumnContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAttachpolicycollistContext differentiates from other interfaces. + IsAttachpolicycollistContext() +} + +type AttachpolicycollistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttachpolicycollistContext() *AttachpolicycollistContext { + var p = new(AttachpolicycollistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicycollist + return p +} + +func InitEmptyAttachpolicycollistContext(p *AttachpolicycollistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicycollist +} + +func (*AttachpolicycollistContext) IsAttachpolicycollistContext() {} + +func NewAttachpolicycollistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttachpolicycollistContext { + var p = new(AttachpolicycollistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attachpolicycollist + + return p +} + +func (s *AttachpolicycollistContext) GetParser() antlr.Parser { return s.parser } + +func (s *AttachpolicycollistContext) AllAttachpolicycolumn() []IAttachpolicycolumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttachpolicycolumnContext); ok { + len++ + } + } + + tst := make([]IAttachpolicycolumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttachpolicycolumnContext); ok { + tst[i] = t.(IAttachpolicycolumnContext) + i++ + } + } + + return tst +} + +func (s *AttachpolicycollistContext) Attachpolicycolumn(i int) IAttachpolicycolumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachpolicycolumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttachpolicycolumnContext) +} + +func (s *AttachpolicycollistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *AttachpolicycollistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *AttachpolicycollistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AttachpolicycollistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AttachpolicycollistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttachpolicycollist(s) + } +} + +func (s *AttachpolicycollistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttachpolicycollist(s) + } +} + +func (s *AttachpolicycollistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttachpolicycollist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attachpolicycollist() (localctx IAttachpolicycollistContext) { + localctx = NewAttachpolicycollistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1152, RedshiftParserRULE_attachpolicycollist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10534) + p.Attachpolicycolumn() + } + p.SetState(10539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10535) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10536) + p.Attachpolicycolumn() + } + + p.SetState(10541) + 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 +} + +// IAttachpolicycolumnContext is an interface to support dynamic dispatch. +type IAttachpolicycolumnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name() IQualified_nameContext + + // IsAttachpolicycolumnContext differentiates from other interfaces. + IsAttachpolicycolumnContext() +} + +type AttachpolicycolumnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttachpolicycolumnContext() *AttachpolicycolumnContext { + var p = new(AttachpolicycolumnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicycolumn + return p +} + +func InitEmptyAttachpolicycolumnContext(p *AttachpolicycolumnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicycolumn +} + +func (*AttachpolicycolumnContext) IsAttachpolicycolumnContext() {} + +func NewAttachpolicycolumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttachpolicycolumnContext { + var p = new(AttachpolicycolumnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attachpolicycolumn + + return p +} + +func (s *AttachpolicycolumnContext) GetParser() antlr.Parser { return s.parser } + +func (s *AttachpolicycolumnContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AttachpolicycolumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AttachpolicycolumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AttachpolicycolumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttachpolicycolumn(s) + } +} + +func (s *AttachpolicycolumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttachpolicycolumn(s) + } +} + +func (s *AttachpolicycolumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttachpolicycolumn(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attachpolicycolumn() (localctx IAttachpolicycolumnContext) { + localctx = NewAttachpolicycolumnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1154, RedshiftParserRULE_attachpolicycolumn) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10542) + p.Qualified_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttachpolicytargetsContext is an interface to support dynamic dispatch. +type IAttachpolicytargetsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAttachpolicytarget() []IAttachpolicytargetContext + Attachpolicytarget(i int) IAttachpolicytargetContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAttachpolicytargetsContext differentiates from other interfaces. + IsAttachpolicytargetsContext() +} + +type AttachpolicytargetsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttachpolicytargetsContext() *AttachpolicytargetsContext { + var p = new(AttachpolicytargetsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicytargets + return p +} + +func InitEmptyAttachpolicytargetsContext(p *AttachpolicytargetsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicytargets +} + +func (*AttachpolicytargetsContext) IsAttachpolicytargetsContext() {} + +func NewAttachpolicytargetsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttachpolicytargetsContext { + var p = new(AttachpolicytargetsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attachpolicytargets + + return p +} + +func (s *AttachpolicytargetsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AttachpolicytargetsContext) AllAttachpolicytarget() []IAttachpolicytargetContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttachpolicytargetContext); ok { + len++ + } + } + + tst := make([]IAttachpolicytargetContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttachpolicytargetContext); ok { + tst[i] = t.(IAttachpolicytargetContext) + i++ + } + } + + return tst +} + +func (s *AttachpolicytargetsContext) Attachpolicytarget(i int) IAttachpolicytargetContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachpolicytargetContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttachpolicytargetContext) +} + +func (s *AttachpolicytargetsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *AttachpolicytargetsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *AttachpolicytargetsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AttachpolicytargetsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AttachpolicytargetsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttachpolicytargets(s) + } +} + +func (s *AttachpolicytargetsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttachpolicytargets(s) + } +} + +func (s *AttachpolicytargetsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttachpolicytargets(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attachpolicytargets() (localctx IAttachpolicytargetsContext) { + localctx = NewAttachpolicytargetsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1156, RedshiftParserRULE_attachpolicytargets) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10544) + p.Attachpolicytarget() + } + p.SetState(10549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10545) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10546) + p.Attachpolicytarget() + } + + p.SetState(10551) + 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 +} + +// IAttachpolicytargetContext is an interface to support dynamic dispatch. +type IAttachpolicytargetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Colid() IColidContext + + // IsAttachpolicytargetContext differentiates from other interfaces. + IsAttachpolicytargetContext() +} + +type AttachpolicytargetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttachpolicytargetContext() *AttachpolicytargetContext { + var p = new(AttachpolicytargetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicytarget + return p +} + +func InitEmptyAttachpolicytargetContext(p *AttachpolicytargetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachpolicytarget +} + +func (*AttachpolicytargetContext) IsAttachpolicytargetContext() {} + +func NewAttachpolicytargetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttachpolicytargetContext { + var p = new(AttachpolicytargetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attachpolicytarget + + return p +} + +func (s *AttachpolicytargetContext) GetParser() antlr.Parser { return s.parser } + +func (s *AttachpolicytargetContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *AttachpolicytargetContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AttachpolicytargetContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AttachpolicytargetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AttachpolicytargetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AttachpolicytargetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttachpolicytarget(s) + } +} + +func (s *AttachpolicytargetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttachpolicytarget(s) + } +} + +func (s *AttachpolicytargetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttachpolicytarget(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attachpolicytarget() (localctx IAttachpolicytargetContext) { + localctx = NewAttachpolicytargetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1158, RedshiftParserRULE_attachpolicytarget) + p.SetState(10555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 877, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10552) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10553) + p.Qualified_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10554) + p.Colid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttachrlspolicystmtContext is an interface to support dynamic dispatch. +type IAttachrlspolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPolicy_name returns the policy_name rule contexts. + GetPolicy_name() IColidContext + + // SetPolicy_name sets the policy_name rule contexts. + SetPolicy_name(IColidContext) + + // Getter signatures + ATTACH() antlr.TerminalNode + RLS() antlr.TerminalNode + POLICY() antlr.TerminalNode + ON() antlr.TerminalNode + Table_name_list() ITable_name_listContext + TO() antlr.TerminalNode + Attachpolicytargets() IAttachpolicytargetsContext + Colid() IColidContext + TABLE() antlr.TerminalNode + + // IsAttachrlspolicystmtContext differentiates from other interfaces. + IsAttachrlspolicystmtContext() +} + +type AttachrlspolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + policy_name IColidContext +} + +func NewEmptyAttachrlspolicystmtContext() *AttachrlspolicystmtContext { + var p = new(AttachrlspolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachrlspolicystmt + return p +} + +func InitEmptyAttachrlspolicystmtContext(p *AttachrlspolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attachrlspolicystmt +} + +func (*AttachrlspolicystmtContext) IsAttachrlspolicystmtContext() {} + +func NewAttachrlspolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttachrlspolicystmtContext { + var p = new(AttachrlspolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attachrlspolicystmt + + return p +} + +func (s *AttachrlspolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AttachrlspolicystmtContext) GetPolicy_name() IColidContext { return s.policy_name } + +func (s *AttachrlspolicystmtContext) SetPolicy_name(v IColidContext) { s.policy_name = v } + +func (s *AttachrlspolicystmtContext) ATTACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTACH, 0) +} + +func (s *AttachrlspolicystmtContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *AttachrlspolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *AttachrlspolicystmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *AttachrlspolicystmtContext) Table_name_list() ITable_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_name_listContext) +} + +func (s *AttachrlspolicystmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AttachrlspolicystmtContext) Attachpolicytargets() IAttachpolicytargetsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachpolicytargetsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttachpolicytargetsContext) +} + +func (s *AttachrlspolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AttachrlspolicystmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *AttachrlspolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AttachrlspolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AttachrlspolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttachrlspolicystmt(s) + } +} + +func (s *AttachrlspolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttachrlspolicystmt(s) + } +} + +func (s *AttachrlspolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttachrlspolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attachrlspolicystmt() (localctx IAttachrlspolicystmtContext) { + localctx = NewAttachrlspolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1160, RedshiftParserRULE_attachrlspolicystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10557) + p.Match(RedshiftParserATTACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10558) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10559) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10560) + + var _x = p.Colid() + + localctx.(*AttachrlspolicystmtContext).policy_name = _x + } + { + p.SetState(10561) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10563) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 878, p.GetParserRuleContext()) == 1 { + { + p.SetState(10562) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10565) + p.Table_name_list() + } + { + p.SetState(10566) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10567) + p.Attachpolicytargets() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_name_listContext is an interface to support dynamic dispatch. +type ITable_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_name_listContext differentiates from other interfaces. + IsTable_name_listContext() +} + +type Table_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_name_listContext() *Table_name_listContext { + var p = new(Table_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_name_list + return p +} + +func InitEmptyTable_name_listContext(p *Table_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_name_list +} + +func (*Table_name_listContext) IsTable_name_listContext() {} + +func NewTable_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_name_listContext { + var p = new(Table_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_name_list + + return p +} + +func (s *Table_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_name_listContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *Table_name_listContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Table_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Table_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Table_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_name_list(s) + } +} + +func (s *Table_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_name_list(s) + } +} + +func (s *Table_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_name_list() (localctx ITable_name_listContext) { + localctx = NewTable_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1162, RedshiftParserRULE_table_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10569) + p.Qualified_name() + } + p.SetState(10574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10570) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10571) + p.Qualified_name() + } + + p.SetState(10576) + 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 +} + +// ICreateidentityproviderstmtContext is an interface to support dynamic dispatch. +type ICreateidentityproviderstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + TYPE_P() antlr.TerminalNode + Sconst() ISconstContext + AllCreateidprovideropts() []ICreateidprovideroptsContext + Createidprovideropts(i int) ICreateidprovideroptsContext + + // IsCreateidentityproviderstmtContext differentiates from other interfaces. + IsCreateidentityproviderstmtContext() +} + +type CreateidentityproviderstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateidentityproviderstmtContext() *CreateidentityproviderstmtContext { + var p = new(CreateidentityproviderstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createidentityproviderstmt + return p +} + +func InitEmptyCreateidentityproviderstmtContext(p *CreateidentityproviderstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createidentityproviderstmt +} + +func (*CreateidentityproviderstmtContext) IsCreateidentityproviderstmtContext() {} + +func NewCreateidentityproviderstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateidentityproviderstmtContext { + var p = new(CreateidentityproviderstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createidentityproviderstmt + + return p +} + +func (s *CreateidentityproviderstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateidentityproviderstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateidentityproviderstmtContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *CreateidentityproviderstmtContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER, 0) +} + +func (s *CreateidentityproviderstmtContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *CreateidentityproviderstmtContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CreateidentityproviderstmtContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *CreateidentityproviderstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreateidentityproviderstmtContext) AllCreateidprovideropts() []ICreateidprovideroptsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreateidprovideroptsContext); ok { + len++ + } + } + + tst := make([]ICreateidprovideroptsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreateidprovideroptsContext); ok { + tst[i] = t.(ICreateidprovideroptsContext) + i++ + } + } + + return tst +} + +func (s *CreateidentityproviderstmtContext) Createidprovideropts(i int) ICreateidprovideroptsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateidprovideroptsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreateidprovideroptsContext) +} + +func (s *CreateidentityproviderstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateidentityproviderstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateidentityproviderstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateidentityproviderstmt(s) + } +} + +func (s *CreateidentityproviderstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateidentityproviderstmt(s) + } +} + +func (s *CreateidentityproviderstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateidentityproviderstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createidentityproviderstmt() (localctx ICreateidentityproviderstmtContext) { + localctx = NewCreateidentityproviderstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1164, RedshiftParserRULE_createidentityproviderstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10577) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10578) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10579) + p.Match(RedshiftParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10580) + p.Colid() + } + { + p.SetState(10581) + p.Match(RedshiftParserTYPE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(10582) + p.Sconst() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(10583) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserIAM_ROLE || ((int64((_la-467)) & ^0x3f) == 0 && ((int64(1)<<(_la-467))&34565896798209) != 0) { + { + p.SetState(10586) + p.Createidprovideropts() + } + + p.SetState(10591) + 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 +} + +// ICreateidprovideroptsContext is an interface to support dynamic dispatch. +type ICreateidprovideroptsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROVIDER_URL() antlr.TerminalNode + Sconst() ISconstContext + PROVIDER_URL_PORT() antlr.TerminalNode + Iconst() IIconstContext + ATTRIBUTE_MAP() antlr.TerminalNode + PROVIDER_ARN() antlr.TerminalNode + ASSUME_ROLE_ARN() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + APPLICATION_ARN() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AUTO_CREATE_ROLES() antlr.TerminalNode + TRUE_P() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + Groupfilter() IGroupfilterContext + + // IsCreateidprovideroptsContext differentiates from other interfaces. + IsCreateidprovideroptsContext() +} + +type CreateidprovideroptsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateidprovideroptsContext() *CreateidprovideroptsContext { + var p = new(CreateidprovideroptsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createidprovideropts + return p +} + +func InitEmptyCreateidprovideroptsContext(p *CreateidprovideroptsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createidprovideropts +} + +func (*CreateidprovideroptsContext) IsCreateidprovideroptsContext() {} + +func NewCreateidprovideroptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateidprovideroptsContext { + var p = new(CreateidprovideroptsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createidprovideropts + + return p +} + +func (s *CreateidprovideroptsContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateidprovideroptsContext) PROVIDER_URL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER_URL, 0) +} + +func (s *CreateidprovideroptsContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreateidprovideroptsContext) PROVIDER_URL_PORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER_URL_PORT, 0) +} + +func (s *CreateidprovideroptsContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *CreateidprovideroptsContext) ATTRIBUTE_MAP() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTRIBUTE_MAP, 0) +} + +func (s *CreateidprovideroptsContext) PROVIDER_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER_ARN, 0) +} + +func (s *CreateidprovideroptsContext) ASSUME_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSUME_ROLE_ARN, 0) +} + +func (s *CreateidprovideroptsContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMESPACE, 0) +} + +func (s *CreateidprovideroptsContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAMETERS, 0) +} + +func (s *CreateidprovideroptsContext) APPLICATION_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserAPPLICATION_ARN, 0) +} + +func (s *CreateidprovideroptsContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *CreateidprovideroptsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *CreateidprovideroptsContext) AUTO_CREATE_ROLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO_CREATE_ROLES, 0) +} + +func (s *CreateidprovideroptsContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *CreateidprovideroptsContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *CreateidprovideroptsContext) Groupfilter() IGroupfilterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroupfilterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroupfilterContext) +} + +func (s *CreateidprovideroptsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateidprovideroptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateidprovideroptsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateidprovideropts(s) + } +} + +func (s *CreateidprovideroptsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateidprovideropts(s) + } +} + +func (s *CreateidprovideroptsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateidprovideropts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createidprovideropts() (localctx ICreateidprovideroptsContext) { + localctx = NewCreateidprovideroptsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1166, RedshiftParserRULE_createidprovideropts) + var _la int + + p.SetState(10618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserPROVIDER_URL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10592) + p.Match(RedshiftParserPROVIDER_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10593) + p.Sconst() + } + + case RedshiftParserPROVIDER_URL_PORT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10594) + p.Match(RedshiftParserPROVIDER_URL_PORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10595) + p.Iconst() + } + + case RedshiftParserATTRIBUTE_MAP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10596) + p.Match(RedshiftParserATTRIBUTE_MAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10597) + p.Sconst() + } + + case RedshiftParserPROVIDER_ARN: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10598) + p.Match(RedshiftParserPROVIDER_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10599) + p.Sconst() + } + + case RedshiftParserASSUME_ROLE_ARN: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10600) + p.Match(RedshiftParserASSUME_ROLE_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10601) + p.Sconst() + } + + case RedshiftParserNAMESPACE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10602) + p.Match(RedshiftParserNAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10603) + p.Sconst() + } + + case RedshiftParserPARAMETERS: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10604) + p.Match(RedshiftParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10605) + p.Sconst() + } + + case RedshiftParserAPPLICATION_ARN: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10606) + p.Match(RedshiftParserAPPLICATION_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10607) + p.Sconst() + } + + case RedshiftParserIAM_ROLE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10608) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + { + p.SetState(10609) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(10610) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case RedshiftParserAUTO_CREATE_ROLES: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10613) + p.Match(RedshiftParserAUTO_CREATE_ROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10614) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFALSE_P || _la == RedshiftParserTRUE_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCLUDE || _la == RedshiftParserINCLUDE { + { + p.SetState(10615) + p.Groupfilter() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroupfilterContext is an interface to support dynamic dispatch. +type IGroupfilterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCLUDE() antlr.TerminalNode + GROUPS() antlr.TerminalNode + LIKE() antlr.TerminalNode + Sconst() ISconstContext + EXCLUDE() antlr.TerminalNode + + // IsGroupfilterContext differentiates from other interfaces. + IsGroupfilterContext() +} + +type GroupfilterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroupfilterContext() *GroupfilterContext { + var p = new(GroupfilterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_groupfilter + return p +} + +func InitEmptyGroupfilterContext(p *GroupfilterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_groupfilter +} + +func (*GroupfilterContext) IsGroupfilterContext() {} + +func NewGroupfilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GroupfilterContext { + var p = new(GroupfilterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_groupfilter + + return p +} + +func (s *GroupfilterContext) GetParser() antlr.Parser { return s.parser } + +func (s *GroupfilterContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDE, 0) +} + +func (s *GroupfilterContext) GROUPS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUPS, 0) +} + +func (s *GroupfilterContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *GroupfilterContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *GroupfilterContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDE, 0) +} + +func (s *GroupfilterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GroupfilterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GroupfilterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGroupfilter(s) + } +} + +func (s *GroupfilterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGroupfilter(s) + } +} + +func (s *GroupfilterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGroupfilter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Groupfilter() (localctx IGroupfilterContext) { + localctx = NewGroupfilterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1168, RedshiftParserRULE_groupfilter) + p.SetState(10628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserINCLUDE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10620) + p.Match(RedshiftParserINCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10621) + p.Match(RedshiftParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10622) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10623) + p.Sconst() + } + + case RedshiftParserEXCLUDE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10624) + p.Match(RedshiftParserEXCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10625) + p.Match(RedshiftParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10626) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10627) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatelibrarystmtContext is an interface to support dynamic dispatch. +type ICreatelibrarystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Colid() IColidContext + LANGUAGE() antlr.TerminalNode + PLPYTHONU() antlr.TerminalNode + FROM() antlr.TerminalNode + Sconst() ISconstContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllCreatelibraryopts() []ICreatelibraryoptsContext + Createlibraryopts(i int) ICreatelibraryoptsContext + + // IsCreatelibrarystmtContext differentiates from other interfaces. + IsCreatelibrarystmtContext() +} + +type CreatelibrarystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatelibrarystmtContext() *CreatelibrarystmtContext { + var p = new(CreatelibrarystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createlibrarystmt + return p +} + +func InitEmptyCreatelibrarystmtContext(p *CreatelibrarystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createlibrarystmt +} + +func (*CreatelibrarystmtContext) IsCreatelibrarystmtContext() {} + +func NewCreatelibrarystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatelibrarystmtContext { + var p = new(CreatelibrarystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createlibrarystmt + + return p +} + +func (s *CreatelibrarystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatelibrarystmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatelibrarystmtContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIBRARY, 0) +} + +func (s *CreatelibrarystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CreatelibrarystmtContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *CreatelibrarystmtContext) PLPYTHONU() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLPYTHONU, 0) +} + +func (s *CreatelibrarystmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *CreatelibrarystmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreatelibrarystmtContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *CreatelibrarystmtContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *CreatelibrarystmtContext) AllCreatelibraryopts() []ICreatelibraryoptsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreatelibraryoptsContext); ok { + len++ + } + } + + tst := make([]ICreatelibraryoptsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreatelibraryoptsContext); ok { + tst[i] = t.(ICreatelibraryoptsContext) + i++ + } + } + + return tst +} + +func (s *CreatelibrarystmtContext) Createlibraryopts(i int) ICreatelibraryoptsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatelibraryoptsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreatelibraryoptsContext) +} + +func (s *CreatelibrarystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatelibrarystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatelibrarystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatelibrarystmt(s) + } +} + +func (s *CreatelibrarystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatelibrarystmt(s) + } +} + +func (s *CreatelibrarystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatelibrarystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createlibrarystmt() (localctx ICreatelibrarystmtContext) { + localctx = NewCreatelibrarystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1170, RedshiftParserRULE_createlibrarystmt) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10630) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOR { + { + p.SetState(10631) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10632) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10635) + p.Match(RedshiftParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10636) + p.Colid() + } + { + p.SetState(10637) + p.Match(RedshiftParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10638) + p.Match(RedshiftParserPLPYTHONU) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10639) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10640) + p.Sconst() + } + p.SetState(10644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 887, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(10641) + p.Createlibraryopts() + } + + } + p.SetState(10646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 887, 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 +} + +// ICreatelibraryoptsContext is an interface to support dynamic dispatch. +type ICreatelibraryoptsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREDENTIALS() antlr.TerminalNode + Sconst() ISconstContext + Colid() IColidContext + AS() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsCreatelibraryoptsContext differentiates from other interfaces. + IsCreatelibraryoptsContext() +} + +type CreatelibraryoptsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatelibraryoptsContext() *CreatelibraryoptsContext { + var p = new(CreatelibraryoptsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createlibraryopts + return p +} + +func InitEmptyCreatelibraryoptsContext(p *CreatelibraryoptsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createlibraryopts +} + +func (*CreatelibraryoptsContext) IsCreatelibraryoptsContext() {} + +func NewCreatelibraryoptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatelibraryoptsContext { + var p = new(CreatelibraryoptsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createlibraryopts + + return p +} + +func (s *CreatelibraryoptsContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatelibraryoptsContext) CREDENTIALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREDENTIALS, 0) +} + +func (s *CreatelibraryoptsContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreatelibraryoptsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CreatelibraryoptsContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CreatelibraryoptsContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *CreatelibraryoptsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *CreatelibraryoptsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatelibraryoptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatelibraryoptsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatelibraryopts(s) + } +} + +func (s *CreatelibraryoptsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatelibraryopts(s) + } +} + +func (s *CreatelibraryoptsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatelibraryopts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createlibraryopts() (localctx ICreatelibraryoptsContext) { + localctx = NewCreatelibraryoptsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1172, RedshiftParserRULE_createlibraryopts) + var _la int + + p.SetState(10660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 890, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10647) + p.Match(RedshiftParserCREDENTIALS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10648) + p.Sconst() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10649) + p.Colid() + } + p.SetState(10651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(10650) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10653) + p.Sconst() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10655) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + { + p.SetState(10656) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(10657) + p.Sconst() + } + + 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 +} + +// ICreatemaskingpolicystmtContext is an interface to support dynamic dispatch. +type ICreatemaskingpolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPolicy_name returns the policy_name rule contexts. + GetPolicy_name() IColidContext + + // SetPolicy_name sets the policy_name rule contexts. + SetPolicy_name(IColidContext) + + // Getter signatures + CREATE() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + WITH() antlr.TerminalNode + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + Inputcolumnlist() IInputcolumnlistContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + USING() antlr.TerminalNode + Maskingexpression() IMaskingexpressionContext + Colid() IColidContext + Opt_if_not_exists() IOpt_if_not_existsContext + + // IsCreatemaskingpolicystmtContext differentiates from other interfaces. + IsCreatemaskingpolicystmtContext() +} + +type CreatemaskingpolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + policy_name IColidContext +} + +func NewEmptyCreatemaskingpolicystmtContext() *CreatemaskingpolicystmtContext { + var p = new(CreatemaskingpolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createmaskingpolicystmt + return p +} + +func InitEmptyCreatemaskingpolicystmtContext(p *CreatemaskingpolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createmaskingpolicystmt +} + +func (*CreatemaskingpolicystmtContext) IsCreatemaskingpolicystmtContext() {} + +func NewCreatemaskingpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatemaskingpolicystmtContext { + var p = new(CreatemaskingpolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createmaskingpolicystmt + + return p +} + +func (s *CreatemaskingpolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatemaskingpolicystmtContext) GetPolicy_name() IColidContext { return s.policy_name } + +func (s *CreatemaskingpolicystmtContext) SetPolicy_name(v IColidContext) { s.policy_name = v } + +func (s *CreatemaskingpolicystmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatemaskingpolicystmtContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *CreatemaskingpolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *CreatemaskingpolicystmtContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *CreatemaskingpolicystmtContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *CreatemaskingpolicystmtContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *CreatemaskingpolicystmtContext) Inputcolumnlist() IInputcolumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInputcolumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInputcolumnlistContext) +} + +func (s *CreatemaskingpolicystmtContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *CreatemaskingpolicystmtContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *CreatemaskingpolicystmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *CreatemaskingpolicystmtContext) Maskingexpression() IMaskingexpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaskingexpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaskingexpressionContext) +} + +func (s *CreatemaskingpolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CreatemaskingpolicystmtContext) Opt_if_not_exists() IOpt_if_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_not_existsContext) +} + +func (s *CreatemaskingpolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatemaskingpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatemaskingpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatemaskingpolicystmt(s) + } +} + +func (s *CreatemaskingpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatemaskingpolicystmt(s) + } +} + +func (s *CreatemaskingpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatemaskingpolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createmaskingpolicystmt() (localctx ICreatemaskingpolicystmtContext) { + localctx = NewCreatemaskingpolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1174, RedshiftParserRULE_createmaskingpolicystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10662) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10663) + p.Match(RedshiftParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10664) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10666) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 891, p.GetParserRuleContext()) == 1 { + { + p.SetState(10665) + p.Opt_if_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10668) + + var _x = p.Colid() + + localctx.(*CreatemaskingpolicystmtContext).policy_name = _x + } + { + p.SetState(10669) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10670) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10671) + p.Inputcolumnlist() + } + { + p.SetState(10672) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10673) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10674) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10675) + p.Maskingexpression() + } + { + p.SetState(10676) + p.Match(RedshiftParserCLOSE_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 +} + +// IInputcolumnlistContext is an interface to support dynamic dispatch. +type IInputcolumnlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllInputcolumn() []IInputcolumnContext + Inputcolumn(i int) IInputcolumnContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsInputcolumnlistContext differentiates from other interfaces. + IsInputcolumnlistContext() +} + +type InputcolumnlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInputcolumnlistContext() *InputcolumnlistContext { + var p = new(InputcolumnlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_inputcolumnlist + return p +} + +func InitEmptyInputcolumnlistContext(p *InputcolumnlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_inputcolumnlist +} + +func (*InputcolumnlistContext) IsInputcolumnlistContext() {} + +func NewInputcolumnlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InputcolumnlistContext { + var p = new(InputcolumnlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_inputcolumnlist + + return p +} + +func (s *InputcolumnlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *InputcolumnlistContext) AllInputcolumn() []IInputcolumnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInputcolumnContext); ok { + len++ + } + } + + tst := make([]IInputcolumnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInputcolumnContext); ok { + tst[i] = t.(IInputcolumnContext) + i++ + } + } + + return tst +} + +func (s *InputcolumnlistContext) Inputcolumn(i int) IInputcolumnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInputcolumnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInputcolumnContext) +} + +func (s *InputcolumnlistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *InputcolumnlistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *InputcolumnlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InputcolumnlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InputcolumnlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInputcolumnlist(s) + } +} + +func (s *InputcolumnlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInputcolumnlist(s) + } +} + +func (s *InputcolumnlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInputcolumnlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Inputcolumnlist() (localctx IInputcolumnlistContext) { + localctx = NewInputcolumnlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1176, RedshiftParserRULE_inputcolumnlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10678) + p.Inputcolumn() + } + p.SetState(10683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10679) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10680) + p.Inputcolumn() + } + + p.SetState(10685) + 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 +} + +// IInputcolumnContext is an interface to support dynamic dispatch. +type IInputcolumnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetColumn_name returns the column_name rule contexts. + GetColumn_name() IColidContext + + // SetColumn_name sets the column_name rule contexts. + SetColumn_name(IColidContext) + + // Getter signatures + Typename() ITypenameContext + Colid() IColidContext + + // IsInputcolumnContext differentiates from other interfaces. + IsInputcolumnContext() +} + +type InputcolumnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + column_name IColidContext +} + +func NewEmptyInputcolumnContext() *InputcolumnContext { + var p = new(InputcolumnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_inputcolumn + return p +} + +func InitEmptyInputcolumnContext(p *InputcolumnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_inputcolumn +} + +func (*InputcolumnContext) IsInputcolumnContext() {} + +func NewInputcolumnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InputcolumnContext { + var p = new(InputcolumnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_inputcolumn + + return p +} + +func (s *InputcolumnContext) GetParser() antlr.Parser { return s.parser } + +func (s *InputcolumnContext) GetColumn_name() IColidContext { return s.column_name } + +func (s *InputcolumnContext) SetColumn_name(v IColidContext) { s.column_name = v } + +func (s *InputcolumnContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *InputcolumnContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *InputcolumnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InputcolumnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InputcolumnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInputcolumn(s) + } +} + +func (s *InputcolumnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInputcolumn(s) + } +} + +func (s *InputcolumnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInputcolumn(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Inputcolumn() (localctx IInputcolumnContext) { + localctx = NewInputcolumnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1178, RedshiftParserRULE_inputcolumn) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10686) + + var _x = p.Colid() + + localctx.(*InputcolumnContext).column_name = _x + } + { + p.SetState(10687) + p.Typename() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaskingexpressionContext is an interface to support dynamic dispatch. +type IMaskingexpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + + // IsMaskingexpressionContext differentiates from other interfaces. + IsMaskingexpressionContext() +} + +type MaskingexpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaskingexpressionContext() *MaskingexpressionContext { + var p = new(MaskingexpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_maskingexpression + return p +} + +func InitEmptyMaskingexpressionContext(p *MaskingexpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_maskingexpression +} + +func (*MaskingexpressionContext) IsMaskingexpressionContext() {} + +func NewMaskingexpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaskingexpressionContext { + var p = new(MaskingexpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_maskingexpression + + return p +} + +func (s *MaskingexpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *MaskingexpressionContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *MaskingexpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaskingexpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MaskingexpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMaskingexpression(s) + } +} + +func (s *MaskingexpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMaskingexpression(s) + } +} + +func (s *MaskingexpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMaskingexpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Maskingexpression() (localctx IMaskingexpressionContext) { + localctx = NewMaskingexpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1180, RedshiftParserRULE_maskingexpression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10689) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatemodelstmtContext is an interface to support dynamic dispatch. +type ICreatemodelstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetModel_name returns the model_name rule contexts. + GetModel_name() IQualified_nameContext + + // GetTarget_column returns the target_column rule contexts. + GetTarget_column() IQualified_nameContext + + // GetFunction_name returns the function_name rule contexts. + GetFunction_name() IQualified_nameContext + + // SetModel_name sets the model_name rule contexts. + SetModel_name(IQualified_nameContext) + + // SetTarget_column sets the target_column rule contexts. + SetTarget_column(IQualified_nameContext) + + // SetFunction_name sets the function_name rule contexts. + SetFunction_name(IQualified_nameContext) + + // Getter signatures + CREATE() antlr.TerminalNode + MODEL() antlr.TerminalNode + FROM() antlr.TerminalNode + Createmodelfromclause() ICreatemodelfromclauseContext + FUNCTION() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + Iamrolespec() IIamrolespecContext + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + TARGET() antlr.TerminalNode + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + Datatypelist() IDatatypelistContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + RETURNS() antlr.TerminalNode + Typename() ITypenameContext + SAGEMAKER() antlr.TerminalNode + Sagemakerspec() ISagemakerspecContext + AUTO() antlr.TerminalNode + MODEL_TYPE() antlr.TerminalNode + Modeltypespec() IModeltypespecContext + PROBLEM_TYPE() antlr.TerminalNode + Problemtypespec() IProblemtypespecContext + OBJECTIVE() antlr.TerminalNode + Objectivespec() IObjectivespecContext + PREPROCESSORS() antlr.TerminalNode + Sconst() ISconstContext + HYPERPARAMETERS() antlr.TerminalNode + Hyperparametersspec() IHyperparametersspecContext + SETTINGS() antlr.TerminalNode + Settingsclause() ISettingsclauseContext + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsCreatemodelstmtContext differentiates from other interfaces. + IsCreatemodelstmtContext() +} + +type CreatemodelstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + model_name IQualified_nameContext + target_column IQualified_nameContext + function_name IQualified_nameContext +} + +func NewEmptyCreatemodelstmtContext() *CreatemodelstmtContext { + var p = new(CreatemodelstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createmodelstmt + return p +} + +func InitEmptyCreatemodelstmtContext(p *CreatemodelstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createmodelstmt +} + +func (*CreatemodelstmtContext) IsCreatemodelstmtContext() {} + +func NewCreatemodelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatemodelstmtContext { + var p = new(CreatemodelstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createmodelstmt + + return p +} + +func (s *CreatemodelstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatemodelstmtContext) GetModel_name() IQualified_nameContext { return s.model_name } + +func (s *CreatemodelstmtContext) GetTarget_column() IQualified_nameContext { return s.target_column } + +func (s *CreatemodelstmtContext) GetFunction_name() IQualified_nameContext { return s.function_name } + +func (s *CreatemodelstmtContext) SetModel_name(v IQualified_nameContext) { s.model_name = v } + +func (s *CreatemodelstmtContext) SetTarget_column(v IQualified_nameContext) { s.target_column = v } + +func (s *CreatemodelstmtContext) SetFunction_name(v IQualified_nameContext) { s.function_name = v } + +func (s *CreatemodelstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatemodelstmtContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *CreatemodelstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *CreatemodelstmtContext) Createmodelfromclause() ICreatemodelfromclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatemodelfromclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatemodelfromclauseContext) +} + +func (s *CreatemodelstmtContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *CreatemodelstmtContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *CreatemodelstmtContext) Iamrolespec() IIamrolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamrolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamrolespecContext) +} + +func (s *CreatemodelstmtContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *CreatemodelstmtContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreatemodelstmtContext) TARGET() antlr.TerminalNode { + return s.GetToken(RedshiftParserTARGET, 0) +} + +func (s *CreatemodelstmtContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *CreatemodelstmtContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *CreatemodelstmtContext) Datatypelist() IDatatypelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypelistContext) +} + +func (s *CreatemodelstmtContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *CreatemodelstmtContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *CreatemodelstmtContext) RETURNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNS, 0) +} + +func (s *CreatemodelstmtContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *CreatemodelstmtContext) SAGEMAKER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSAGEMAKER, 0) +} + +func (s *CreatemodelstmtContext) Sagemakerspec() ISagemakerspecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISagemakerspecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISagemakerspecContext) +} + +func (s *CreatemodelstmtContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *CreatemodelstmtContext) MODEL_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL_TYPE, 0) +} + +func (s *CreatemodelstmtContext) Modeltypespec() IModeltypespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModeltypespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModeltypespecContext) +} + +func (s *CreatemodelstmtContext) PROBLEM_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROBLEM_TYPE, 0) +} + +func (s *CreatemodelstmtContext) Problemtypespec() IProblemtypespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProblemtypespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProblemtypespecContext) +} + +func (s *CreatemodelstmtContext) OBJECTIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserOBJECTIVE, 0) +} + +func (s *CreatemodelstmtContext) Objectivespec() IObjectivespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObjectivespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObjectivespecContext) +} + +func (s *CreatemodelstmtContext) PREPROCESSORS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPROCESSORS, 0) +} + +func (s *CreatemodelstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreatemodelstmtContext) HYPERPARAMETERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserHYPERPARAMETERS, 0) +} + +func (s *CreatemodelstmtContext) Hyperparametersspec() IHyperparametersspecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHyperparametersspecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHyperparametersspecContext) +} + +func (s *CreatemodelstmtContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETTINGS, 0) +} + +func (s *CreatemodelstmtContext) Settingsclause() ISettingsclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISettingsclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISettingsclauseContext) +} + +func (s *CreatemodelstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *CreatemodelstmtContext) OFF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFF, 0) +} + +func (s *CreatemodelstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatemodelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatemodelstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatemodelstmt(s) + } +} + +func (s *CreatemodelstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatemodelstmt(s) + } +} + +func (s *CreatemodelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatemodelstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createmodelstmt() (localctx ICreatemodelstmtContext) { + localctx = NewCreatemodelstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1182, RedshiftParserRULE_createmodelstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10691) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10692) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10693) + + var _x = p.Qualified_name() + + localctx.(*CreatemodelstmtContext).model_name = _x + } + { + p.SetState(10694) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10695) + p.Createmodelfromclause() + } + p.SetState(10698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTARGET { + { + p.SetState(10696) + p.Match(RedshiftParserTARGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10697) + + var _x = p.Qualified_name() + + localctx.(*CreatemodelstmtContext).target_column = _x + } + + } + { + p.SetState(10700) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10701) + + var _x = p.Qualified_name() + + localctx.(*CreatemodelstmtContext).function_name = _x + } + p.SetState(10706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(10702) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10703) + p.Datatypelist() + } + { + p.SetState(10704) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRETURNS { + { + p.SetState(10708) + p.Match(RedshiftParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10709) + p.Typename() + } + + } + p.SetState(10714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSAGEMAKER { + { + p.SetState(10712) + p.Match(RedshiftParserSAGEMAKER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10713) + p.Sagemakerspec() + } + + } + { + p.SetState(10716) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10717) + p.Iamrolespec() + } + p.SetState(10720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAUTO { + { + p.SetState(10718) + p.Match(RedshiftParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10719) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserON || _la == RedshiftParserOFF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserMODEL_TYPE { + { + p.SetState(10722) + p.Match(RedshiftParserMODEL_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10723) + p.Modeltypespec() + } + + } + p.SetState(10728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPROBLEM_TYPE { + { + p.SetState(10726) + p.Match(RedshiftParserPROBLEM_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10727) + p.Problemtypespec() + } + + } + p.SetState(10732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOBJECTIVE { + { + p.SetState(10730) + p.Match(RedshiftParserOBJECTIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10731) + p.Objectivespec() + } + + } + p.SetState(10736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPREPROCESSORS { + { + p.SetState(10734) + p.Match(RedshiftParserPREPROCESSORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10735) + p.Sconst() + } + + } + p.SetState(10740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserHYPERPARAMETERS { + { + p.SetState(10738) + p.Match(RedshiftParserHYPERPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10739) + p.Hyperparametersspec() + } + + } + p.SetState(10747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSETTINGS { + { + p.SetState(10742) + p.Match(RedshiftParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10743) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10744) + p.Settingsclause() + } + { + p.SetState(10745) + p.Match(RedshiftParserCLOSE_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 +} + +// ICreatemodelfromclauseContext is an interface to support dynamic dispatch. +type ICreatemodelfromclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name() IQualified_nameContext + OPEN_PAREN() antlr.TerminalNode + Selectstmt() ISelectstmtContext + CLOSE_PAREN() antlr.TerminalNode + Sconst() ISconstContext + + // IsCreatemodelfromclauseContext differentiates from other interfaces. + IsCreatemodelfromclauseContext() +} + +type CreatemodelfromclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatemodelfromclauseContext() *CreatemodelfromclauseContext { + var p = new(CreatemodelfromclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createmodelfromclause + return p +} + +func InitEmptyCreatemodelfromclauseContext(p *CreatemodelfromclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createmodelfromclause +} + +func (*CreatemodelfromclauseContext) IsCreatemodelfromclauseContext() {} + +func NewCreatemodelfromclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatemodelfromclauseContext { + var p = new(CreatemodelfromclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createmodelfromclause + + return p +} + +func (s *CreatemodelfromclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatemodelfromclauseContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *CreatemodelfromclauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CreatemodelfromclauseContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *CreatemodelfromclauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CreatemodelfromclauseContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreatemodelfromclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatemodelfromclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatemodelfromclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatemodelfromclause(s) + } +} + +func (s *CreatemodelfromclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatemodelfromclause(s) + } +} + +func (s *CreatemodelfromclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatemodelfromclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createmodelfromclause() (localctx ICreatemodelfromclauseContext) { + localctx = NewCreatemodelfromclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1184, RedshiftParserRULE_createmodelfromclause) + p.SetState(10755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10749) + p.Qualified_name() + } + + case RedshiftParserOPEN_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10750) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10751) + p.Selectstmt() + } + { + p.SetState(10752) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10754) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIamrolespecContext is an interface to support dynamic dispatch. +type IIamrolespecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Sconst() ISconstContext + + // IsIamrolespecContext differentiates from other interfaces. + IsIamrolespecContext() +} + +type IamrolespecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIamrolespecContext() *IamrolespecContext { + var p = new(IamrolespecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolespec + return p +} + +func InitEmptyIamrolespecContext(p *IamrolespecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamrolespec +} + +func (*IamrolespecContext) IsIamrolespecContext() {} + +func NewIamrolespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IamrolespecContext { + var p = new(IamrolespecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_iamrolespec + + return p +} + +func (s *IamrolespecContext) GetParser() antlr.Parser { return s.parser } + +func (s *IamrolespecContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *IamrolespecContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *IamrolespecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IamrolespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IamrolespecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIamrolespec(s) + } +} + +func (s *IamrolespecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIamrolespec(s) + } +} + +func (s *IamrolespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIamrolespec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Iamrolespec() (localctx IIamrolespecContext) { + localctx = NewIamrolespecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1186, RedshiftParserRULE_iamrolespec) + p.SetState(10759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10757) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10758) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISagemakerspecContext is an interface to support dynamic dispatch. +type ISagemakerspecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + COLON() antlr.TerminalNode + + // IsSagemakerspecContext differentiates from other interfaces. + IsSagemakerspecContext() +} + +type SagemakerspecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySagemakerspecContext() *SagemakerspecContext { + var p = new(SagemakerspecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sagemakerspec + return p +} + +func InitEmptySagemakerspecContext(p *SagemakerspecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sagemakerspec +} + +func (*SagemakerspecContext) IsSagemakerspecContext() {} + +func NewSagemakerspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SagemakerspecContext { + var p = new(SagemakerspecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sagemakerspec + + return p +} + +func (s *SagemakerspecContext) GetParser() antlr.Parser { return s.parser } + +func (s *SagemakerspecContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *SagemakerspecContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *SagemakerspecContext) COLON() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLON, 0) +} + +func (s *SagemakerspecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SagemakerspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SagemakerspecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSagemakerspec(s) + } +} + +func (s *SagemakerspecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSagemakerspec(s) + } +} + +func (s *SagemakerspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSagemakerspec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sagemakerspec() (localctx ISagemakerspecContext) { + localctx = NewSagemakerspecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1188, RedshiftParserRULE_sagemakerspec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10761) + p.Sconst() + } + p.SetState(10764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLON { + { + p.SetState(10762) + p.Match(RedshiftParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10763) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModeltypespecContext is an interface to support dynamic dispatch. +type IModeltypespecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XGBOOST() antlr.TerminalNode + MLP() antlr.TerminalNode + LINEAR_LEARNER() antlr.TerminalNode + KMEANS() antlr.TerminalNode + FORECAST() antlr.TerminalNode + + // IsModeltypespecContext differentiates from other interfaces. + IsModeltypespecContext() +} + +type ModeltypespecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModeltypespecContext() *ModeltypespecContext { + var p = new(ModeltypespecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_modeltypespec + return p +} + +func InitEmptyModeltypespecContext(p *ModeltypespecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_modeltypespec +} + +func (*ModeltypespecContext) IsModeltypespecContext() {} + +func NewModeltypespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ModeltypespecContext { + var p = new(ModeltypespecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_modeltypespec + + return p +} + +func (s *ModeltypespecContext) GetParser() antlr.Parser { return s.parser } + +func (s *ModeltypespecContext) XGBOOST() antlr.TerminalNode { + return s.GetToken(RedshiftParserXGBOOST, 0) +} + +func (s *ModeltypespecContext) MLP() antlr.TerminalNode { + return s.GetToken(RedshiftParserMLP, 0) +} + +func (s *ModeltypespecContext) LINEAR_LEARNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserLINEAR_LEARNER, 0) +} + +func (s *ModeltypespecContext) KMEANS() antlr.TerminalNode { + return s.GetToken(RedshiftParserKMEANS, 0) +} + +func (s *ModeltypespecContext) FORECAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORECAST, 0) +} + +func (s *ModeltypespecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ModeltypespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ModeltypespecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterModeltypespec(s) + } +} + +func (s *ModeltypespecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitModeltypespec(s) + } +} + +func (s *ModeltypespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitModeltypespec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Modeltypespec() (localctx IModeltypespecContext) { + localctx = NewModeltypespecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1190, RedshiftParserRULE_modeltypespec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10766) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-426)) & ^0x3f) == 0 && ((int64(1)<<(_la-426))&31) != 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 +} + +// IProblemtypespecContext is an interface to support dynamic dispatch. +type IProblemtypespecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Problemtype() IProblemtypeContext + CLOSE_PAREN() antlr.TerminalNode + + // IsProblemtypespecContext differentiates from other interfaces. + IsProblemtypespecContext() +} + +type ProblemtypespecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProblemtypespecContext() *ProblemtypespecContext { + var p = new(ProblemtypespecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_problemtypespec + return p +} + +func InitEmptyProblemtypespecContext(p *ProblemtypespecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_problemtypespec +} + +func (*ProblemtypespecContext) IsProblemtypespecContext() {} + +func NewProblemtypespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProblemtypespecContext { + var p = new(ProblemtypespecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_problemtypespec + + return p +} + +func (s *ProblemtypespecContext) GetParser() antlr.Parser { return s.parser } + +func (s *ProblemtypespecContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ProblemtypespecContext) Problemtype() IProblemtypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProblemtypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProblemtypeContext) +} + +func (s *ProblemtypespecContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ProblemtypespecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ProblemtypespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ProblemtypespecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProblemtypespec(s) + } +} + +func (s *ProblemtypespecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProblemtypespec(s) + } +} + +func (s *ProblemtypespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProblemtypespec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Problemtypespec() (localctx IProblemtypespecContext) { + localctx = NewProblemtypespecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1192, RedshiftParserRULE_problemtypespec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10768) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10769) + p.Problemtype() + } + { + p.SetState(10770) + p.Match(RedshiftParserCLOSE_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 +} + +// IProblemtypeContext is an interface to support dynamic dispatch. +type IProblemtypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REGRESSION() antlr.TerminalNode + BINARY_CLASSIFICATION() antlr.TerminalNode + MULTICLASS_CLASSIFICATION() antlr.TerminalNode + + // IsProblemtypeContext differentiates from other interfaces. + IsProblemtypeContext() +} + +type ProblemtypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProblemtypeContext() *ProblemtypeContext { + var p = new(ProblemtypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_problemtype + return p +} + +func InitEmptyProblemtypeContext(p *ProblemtypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_problemtype +} + +func (*ProblemtypeContext) IsProblemtypeContext() {} + +func NewProblemtypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProblemtypeContext { + var p = new(ProblemtypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_problemtype + + return p +} + +func (s *ProblemtypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ProblemtypeContext) REGRESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGRESSION, 0) +} + +func (s *ProblemtypeContext) BINARY_CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserBINARY_CLASSIFICATION, 0) +} + +func (s *ProblemtypeContext) MULTICLASS_CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserMULTICLASS_CLASSIFICATION, 0) +} + +func (s *ProblemtypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ProblemtypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ProblemtypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProblemtype(s) + } +} + +func (s *ProblemtypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProblemtype(s) + } +} + +func (s *ProblemtypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProblemtype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Problemtype() (localctx IProblemtypeContext) { + localctx = NewProblemtypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1194, RedshiftParserRULE_problemtype) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10772) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-431)) & ^0x3f) == 0 && ((int64(1)<<(_la-431))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObjectivespecContext is an interface to support dynamic dispatch. +type IObjectivespecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Sconst() ISconstContext + CLOSE_PAREN() antlr.TerminalNode + + // IsObjectivespecContext differentiates from other interfaces. + IsObjectivespecContext() +} + +type ObjectivespecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObjectivespecContext() *ObjectivespecContext { + var p = new(ObjectivespecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_objectivespec + return p +} + +func InitEmptyObjectivespecContext(p *ObjectivespecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_objectivespec +} + +func (*ObjectivespecContext) IsObjectivespecContext() {} + +func NewObjectivespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectivespecContext { + var p = new(ObjectivespecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_objectivespec + + return p +} + +func (s *ObjectivespecContext) GetParser() antlr.Parser { return s.parser } + +func (s *ObjectivespecContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ObjectivespecContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ObjectivespecContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ObjectivespecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ObjectivespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ObjectivespecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterObjectivespec(s) + } +} + +func (s *ObjectivespecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitObjectivespec(s) + } +} + +func (s *ObjectivespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitObjectivespec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Objectivespec() (localctx IObjectivespecContext) { + localctx = NewObjectivespecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1196, RedshiftParserRULE_objectivespec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10774) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10775) + p.Sconst() + } + { + p.SetState(10776) + p.Match(RedshiftParserCLOSE_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 +} + +// IHyperparametersspecContext is an interface to support dynamic dispatch. +type IHyperparametersspecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Hyperparameterslist() IHyperparameterslistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsHyperparametersspecContext differentiates from other interfaces. + IsHyperparametersspecContext() +} + +type HyperparametersspecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHyperparametersspecContext() *HyperparametersspecContext { + var p = new(HyperparametersspecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hyperparametersspec + return p +} + +func InitEmptyHyperparametersspecContext(p *HyperparametersspecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hyperparametersspec +} + +func (*HyperparametersspecContext) IsHyperparametersspecContext() {} + +func NewHyperparametersspecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HyperparametersspecContext { + var p = new(HyperparametersspecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_hyperparametersspec + + return p +} + +func (s *HyperparametersspecContext) GetParser() antlr.Parser { return s.parser } + +func (s *HyperparametersspecContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *HyperparametersspecContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCEPT, 0) +} + +func (s *HyperparametersspecContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *HyperparametersspecContext) Hyperparameterslist() IHyperparameterslistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHyperparameterslistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHyperparameterslistContext) +} + +func (s *HyperparametersspecContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *HyperparametersspecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HyperparametersspecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HyperparametersspecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHyperparametersspec(s) + } +} + +func (s *HyperparametersspecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHyperparametersspec(s) + } +} + +func (s *HyperparametersspecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHyperparametersspec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Hyperparametersspec() (localctx IHyperparametersspecContext) { + localctx = NewHyperparametersspecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1198, RedshiftParserRULE_hyperparametersspec) + p.SetState(10785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 907, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10778) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10779) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10780) + p.Match(RedshiftParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10781) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10782) + p.Hyperparameterslist() + } + { + p.SetState(10783) + p.Match(RedshiftParserCLOSE_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 +} + +// IHyperparameterslistContext is an interface to support dynamic dispatch. +type IHyperparameterslistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllHyperparameteritem() []IHyperparameteritemContext + Hyperparameteritem(i int) IHyperparameteritemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHyperparameterslistContext differentiates from other interfaces. + IsHyperparameterslistContext() +} + +type HyperparameterslistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHyperparameterslistContext() *HyperparameterslistContext { + var p = new(HyperparameterslistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hyperparameterslist + return p +} + +func InitEmptyHyperparameterslistContext(p *HyperparameterslistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hyperparameterslist +} + +func (*HyperparameterslistContext) IsHyperparameterslistContext() {} + +func NewHyperparameterslistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HyperparameterslistContext { + var p = new(HyperparameterslistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_hyperparameterslist + + return p +} + +func (s *HyperparameterslistContext) GetParser() antlr.Parser { return s.parser } + +func (s *HyperparameterslistContext) AllHyperparameteritem() []IHyperparameteritemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHyperparameteritemContext); ok { + len++ + } + } + + tst := make([]IHyperparameteritemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHyperparameteritemContext); ok { + tst[i] = t.(IHyperparameteritemContext) + i++ + } + } + + return tst +} + +func (s *HyperparameterslistContext) Hyperparameteritem(i int) IHyperparameteritemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHyperparameteritemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHyperparameteritemContext) +} + +func (s *HyperparameterslistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *HyperparameterslistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *HyperparameterslistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HyperparameterslistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HyperparameterslistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHyperparameterslist(s) + } +} + +func (s *HyperparameterslistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHyperparameterslist(s) + } +} + +func (s *HyperparameterslistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHyperparameterslist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Hyperparameterslist() (localctx IHyperparameterslistContext) { + localctx = NewHyperparameterslistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1200, RedshiftParserRULE_hyperparameterslist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10787) + p.Hyperparameteritem() + } + p.SetState(10792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10788) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10789) + p.Hyperparameteritem() + } + + p.SetState(10794) + 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 +} + +// IHyperparameteritemContext is an interface to support dynamic dispatch. +type IHyperparameteritemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Sconst() ISconstContext + + // IsHyperparameteritemContext differentiates from other interfaces. + IsHyperparameteritemContext() +} + +type HyperparameteritemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHyperparameteritemContext() *HyperparameteritemContext { + var p = new(HyperparameteritemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hyperparameteritem + return p +} + +func InitEmptyHyperparameteritemContext(p *HyperparameteritemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_hyperparameteritem +} + +func (*HyperparameteritemContext) IsHyperparameteritemContext() {} + +func NewHyperparameteritemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HyperparameteritemContext { + var p = new(HyperparameteritemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_hyperparameteritem + + return p +} + +func (s *HyperparameteritemContext) GetParser() antlr.Parser { return s.parser } + +func (s *HyperparameteritemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *HyperparameteritemContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *HyperparameteritemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HyperparameteritemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HyperparameteritemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHyperparameteritem(s) + } +} + +func (s *HyperparameteritemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHyperparameteritem(s) + } +} + +func (s *HyperparameteritemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHyperparameteritem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Hyperparameteritem() (localctx IHyperparameteritemContext) { + localctx = NewHyperparameteritemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1202, RedshiftParserRULE_hyperparameteritem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10795) + p.Colid() + } + { + p.SetState(10796) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISettingsclauseContext is an interface to support dynamic dispatch. +type ISettingsclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSettingsitem() []ISettingsitemContext + Settingsitem(i int) ISettingsitemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSettingsclauseContext differentiates from other interfaces. + IsSettingsclauseContext() +} + +type SettingsclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySettingsclauseContext() *SettingsclauseContext { + var p = new(SettingsclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_settingsclause + return p +} + +func InitEmptySettingsclauseContext(p *SettingsclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_settingsclause +} + +func (*SettingsclauseContext) IsSettingsclauseContext() {} + +func NewSettingsclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SettingsclauseContext { + var p = new(SettingsclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_settingsclause + + return p +} + +func (s *SettingsclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *SettingsclauseContext) AllSettingsitem() []ISettingsitemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISettingsitemContext); ok { + len++ + } + } + + tst := make([]ISettingsitemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISettingsitemContext); ok { + tst[i] = t.(ISettingsitemContext) + i++ + } + } + + return tst +} + +func (s *SettingsclauseContext) Settingsitem(i int) ISettingsitemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISettingsitemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISettingsitemContext) +} + +func (s *SettingsclauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *SettingsclauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *SettingsclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SettingsclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SettingsclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSettingsclause(s) + } +} + +func (s *SettingsclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSettingsclause(s) + } +} + +func (s *SettingsclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSettingsclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Settingsclause() (localctx ISettingsclauseContext) { + localctx = NewSettingsclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1204, RedshiftParserRULE_settingsclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10798) + p.Settingsitem() + } + p.SetState(10803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10799) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10800) + p.Settingsitem() + } + + p.SetState(10805) + 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 +} + +// ISettingsitemContext is an interface to support dynamic dispatch. +type ISettingsitemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + S3_BUCKET() antlr.TerminalNode + Sconst() ISconstContext + TAGS() antlr.TerminalNode + KMS_KEY_ID() antlr.TerminalNode + S3_GARBAGE_COLLECT() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + MAX_CELLS() antlr.TerminalNode + Iconst() IIconstContext + MAX_RUNTIME() antlr.TerminalNode + MAX_BATCH_SIZE() antlr.TerminalNode + MAX_PAYLOAD_IN_MB() antlr.TerminalNode + HORIZON() antlr.TerminalNode + FREQUENCY() antlr.TerminalNode + PERCENTILES() antlr.TerminalNode + MAX_BATCH_ROWS() antlr.TerminalNode + MODEL_ID() antlr.TerminalNode + PROMPT() antlr.TerminalNode + SUFFIX() antlr.TerminalNode + REQUEST_TYPE() antlr.TerminalNode + RAW() antlr.TerminalNode + UNIFIED() antlr.TerminalNode + RESPONSE_TYPE() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + SUPER() antlr.TerminalNode + + // IsSettingsitemContext differentiates from other interfaces. + IsSettingsitemContext() +} + +type SettingsitemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySettingsitemContext() *SettingsitemContext { + var p = new(SettingsitemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_settingsitem + return p +} + +func InitEmptySettingsitemContext(p *SettingsitemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_settingsitem +} + +func (*SettingsitemContext) IsSettingsitemContext() {} + +func NewSettingsitemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SettingsitemContext { + var p = new(SettingsitemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_settingsitem + + return p +} + +func (s *SettingsitemContext) GetParser() antlr.Parser { return s.parser } + +func (s *SettingsitemContext) S3_BUCKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserS3_BUCKET, 0) +} + +func (s *SettingsitemContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *SettingsitemContext) TAGS() antlr.TerminalNode { + return s.GetToken(RedshiftParserTAGS, 0) +} + +func (s *SettingsitemContext) KMS_KEY_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserKMS_KEY_ID, 0) +} + +func (s *SettingsitemContext) S3_GARBAGE_COLLECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserS3_GARBAGE_COLLECT, 0) +} + +func (s *SettingsitemContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *SettingsitemContext) OFF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFF, 0) +} + +func (s *SettingsitemContext) MAX_CELLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_CELLS, 0) +} + +func (s *SettingsitemContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *SettingsitemContext) MAX_RUNTIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_RUNTIME, 0) +} + +func (s *SettingsitemContext) MAX_BATCH_SIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_BATCH_SIZE, 0) +} + +func (s *SettingsitemContext) MAX_PAYLOAD_IN_MB() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_PAYLOAD_IN_MB, 0) +} + +func (s *SettingsitemContext) HORIZON() antlr.TerminalNode { + return s.GetToken(RedshiftParserHORIZON, 0) +} + +func (s *SettingsitemContext) FREQUENCY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFREQUENCY, 0) +} + +func (s *SettingsitemContext) PERCENTILES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENTILES, 0) +} + +func (s *SettingsitemContext) MAX_BATCH_ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_BATCH_ROWS, 0) +} + +func (s *SettingsitemContext) MODEL_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL_ID, 0) +} + +func (s *SettingsitemContext) PROMPT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROMPT, 0) +} + +func (s *SettingsitemContext) SUFFIX() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUFFIX, 0) +} + +func (s *SettingsitemContext) REQUEST_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREQUEST_TYPE, 0) +} + +func (s *SettingsitemContext) RAW() antlr.TerminalNode { + return s.GetToken(RedshiftParserRAW, 0) +} + +func (s *SettingsitemContext) UNIFIED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIFIED, 0) +} + +func (s *SettingsitemContext) RESPONSE_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESPONSE_TYPE, 0) +} + +func (s *SettingsitemContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARCHAR, 0) +} + +func (s *SettingsitemContext) SUPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUPER, 0) +} + +func (s *SettingsitemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SettingsitemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SettingsitemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSettingsitem(s) + } +} + +func (s *SettingsitemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSettingsitem(s) + } +} + +func (s *SettingsitemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSettingsitem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Settingsitem() (localctx ISettingsitemContext) { + localctx = NewSettingsitemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1206, RedshiftParserRULE_settingsitem) + var _la int + + p.SetState(10840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserS3_BUCKET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10806) + p.Match(RedshiftParserS3_BUCKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10807) + p.Sconst() + } + + case RedshiftParserTAGS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10808) + p.Match(RedshiftParserTAGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10809) + p.Sconst() + } + + case RedshiftParserKMS_KEY_ID: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10810) + p.Match(RedshiftParserKMS_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10811) + p.Sconst() + } + + case RedshiftParserS3_GARBAGE_COLLECT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10812) + p.Match(RedshiftParserS3_GARBAGE_COLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10813) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserON || _la == RedshiftParserOFF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserMAX_CELLS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10814) + p.Match(RedshiftParserMAX_CELLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10815) + p.Iconst() + } + + case RedshiftParserMAX_RUNTIME: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10816) + p.Match(RedshiftParserMAX_RUNTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10817) + p.Iconst() + } + + case RedshiftParserMAX_BATCH_SIZE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10818) + p.Match(RedshiftParserMAX_BATCH_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10819) + p.Sconst() + } + + case RedshiftParserMAX_PAYLOAD_IN_MB: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10820) + p.Match(RedshiftParserMAX_PAYLOAD_IN_MB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10821) + p.Sconst() + } + + case RedshiftParserHORIZON: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10822) + p.Match(RedshiftParserHORIZON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10823) + p.Iconst() + } + + case RedshiftParserFREQUENCY: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10824) + p.Match(RedshiftParserFREQUENCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10825) + p.Iconst() + } + + case RedshiftParserPERCENTILES: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(10826) + p.Match(RedshiftParserPERCENTILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10827) + p.Sconst() + } + + case RedshiftParserMAX_BATCH_ROWS: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(10828) + p.Match(RedshiftParserMAX_BATCH_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10829) + p.Iconst() + } + + case RedshiftParserMODEL_ID: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(10830) + p.Match(RedshiftParserMODEL_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10831) + p.Sconst() + } + + case RedshiftParserPROMPT: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(10832) + p.Match(RedshiftParserPROMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10833) + p.Sconst() + } + + case RedshiftParserSUFFIX: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(10834) + p.Match(RedshiftParserSUFFIX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10835) + p.Sconst() + } + + case RedshiftParserREQUEST_TYPE: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(10836) + p.Match(RedshiftParserREQUEST_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10837) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserRAW || _la == RedshiftParserUNIFIED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserRESPONSE_TYPE: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(10838) + p.Match(RedshiftParserRESPONSE_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10839) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserSUPER || _la == RedshiftParserVARCHAR) { + 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 +} + +// IDatatypelistContext is an interface to support dynamic dispatch. +type IDatatypelistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDatatypelistContext differentiates from other interfaces. + IsDatatypelistContext() +} + +type DatatypelistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatatypelistContext() *DatatypelistContext { + var p = new(DatatypelistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datatypelist + return p +} + +func InitEmptyDatatypelistContext(p *DatatypelistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_datatypelist +} + +func (*DatatypelistContext) IsDatatypelistContext() {} + +func NewDatatypelistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DatatypelistContext { + var p = new(DatatypelistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_datatypelist + + return p +} + +func (s *DatatypelistContext) GetParser() antlr.Parser { return s.parser } + +func (s *DatatypelistContext) 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 *DatatypelistContext) 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 *DatatypelistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *DatatypelistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *DatatypelistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DatatypelistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DatatypelistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDatatypelist(s) + } +} + +func (s *DatatypelistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatatypelist(s) + } +} + +func (s *DatatypelistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatatypelist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Datatypelist() (localctx IDatatypelistContext) { + localctx = NewDatatypelistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1208, RedshiftParserRULE_datatypelist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10842) + p.Datatype() + } + p.SetState(10847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10843) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10844) + p.Datatype() + } + + p.SetState(10849) + 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 +} + +// IDatatypeContext is an interface to support dynamic dispatch. +type IDatatypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Typename() ITypenameContext + AllColid() []IColidContext + Colid(i int) IColidContext + + // 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 = RedshiftParserRULE_datatype + return p +} + +func InitEmptyDatatypeContext(p *DatatypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_datatype + + return p +} + +func (s *DatatypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DatatypeContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *DatatypeContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *DatatypeContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *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.(RedshiftParserListener); ok { + listenerT.EnterDatatype(s) + } +} + +func (s *DatatypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDatatype(s) + } +} + +func (s *DatatypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDatatype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Datatype() (localctx IDatatypeContext) { + localctx = NewDatatypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1210, RedshiftParserRULE_datatype) + p.SetState(10857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 912, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10850) + p.Typename() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10851) + p.Colid() + } + { + p.SetState(10852) + p.Typename() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10854) + p.Colid() + } + { + p.SetState(10855) + p.Colid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreaterlspolicystmtContext is an interface to support dynamic dispatch. +type ICreaterlspolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + RLS() antlr.TerminalNode + POLICY() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + USING() antlr.TerminalNode + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + A_expr() IA_exprContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + Inputcolumnlist() IInputcolumnlistContext + AS() antlr.TerminalNode + + // IsCreaterlspolicystmtContext differentiates from other interfaces. + IsCreaterlspolicystmtContext() +} + +type CreaterlspolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreaterlspolicystmtContext() *CreaterlspolicystmtContext { + var p = new(CreaterlspolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createrlspolicystmt + return p +} + +func InitEmptyCreaterlspolicystmtContext(p *CreaterlspolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createrlspolicystmt +} + +func (*CreaterlspolicystmtContext) IsCreaterlspolicystmtContext() {} + +func NewCreaterlspolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreaterlspolicystmtContext { + var p = new(CreaterlspolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createrlspolicystmt + + return p +} + +func (s *CreaterlspolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreaterlspolicystmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreaterlspolicystmtContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *CreaterlspolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *CreaterlspolicystmtContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *CreaterlspolicystmtContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CreaterlspolicystmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *CreaterlspolicystmtContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *CreaterlspolicystmtContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *CreaterlspolicystmtContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *CreaterlspolicystmtContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *CreaterlspolicystmtContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *CreaterlspolicystmtContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *CreaterlspolicystmtContext) Inputcolumnlist() IInputcolumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInputcolumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInputcolumnlistContext) +} + +func (s *CreaterlspolicystmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *CreaterlspolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreaterlspolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreaterlspolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreaterlspolicystmt(s) + } +} + +func (s *CreaterlspolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreaterlspolicystmt(s) + } +} + +func (s *CreaterlspolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreaterlspolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createrlspolicystmt() (localctx ICreaterlspolicystmtContext) { + localctx = NewCreaterlspolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1212, RedshiftParserRULE_createrlspolicystmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10859) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10860) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10861) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10862) + p.Colid() + } + p.SetState(10871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(10863) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10864) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10865) + p.Inputcolumnlist() + } + { + p.SetState(10866) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(10867) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10868) + p.Colid() + } + + } + + } + { + p.SetState(10873) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10874) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10875) + p.A_expr() + } + { + p.SetState(10876) + p.Match(RedshiftParserCLOSE_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 +} + +// IDescidentityproviderstmtContext is an interface to support dynamic dispatch. +type IDescidentityproviderstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTITY_P() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + Colid() IColidContext + DESC() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + + // IsDescidentityproviderstmtContext differentiates from other interfaces. + IsDescidentityproviderstmtContext() +} + +type DescidentityproviderstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescidentityproviderstmtContext() *DescidentityproviderstmtContext { + var p = new(DescidentityproviderstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_descidentityproviderstmt + return p +} + +func InitEmptyDescidentityproviderstmtContext(p *DescidentityproviderstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_descidentityproviderstmt +} + +func (*DescidentityproviderstmtContext) IsDescidentityproviderstmtContext() {} + +func NewDescidentityproviderstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DescidentityproviderstmtContext { + var p = new(DescidentityproviderstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_descidentityproviderstmt + + return p +} + +func (s *DescidentityproviderstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DescidentityproviderstmtContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *DescidentityproviderstmtContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER, 0) +} + +func (s *DescidentityproviderstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DescidentityproviderstmtContext) DESC() antlr.TerminalNode { + return s.GetToken(RedshiftParserDESC, 0) +} + +func (s *DescidentityproviderstmtContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDESCRIBE, 0) +} + +func (s *DescidentityproviderstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescidentityproviderstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DescidentityproviderstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDescidentityproviderstmt(s) + } +} + +func (s *DescidentityproviderstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDescidentityproviderstmt(s) + } +} + +func (s *DescidentityproviderstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDescidentityproviderstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Descidentityproviderstmt() (localctx IDescidentityproviderstmtContext) { + localctx = NewDescidentityproviderstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1214, RedshiftParserRULE_descidentityproviderstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10878) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserDESC || _la == RedshiftParserDESCRIBE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10879) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10880) + p.Match(RedshiftParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10881) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDetachmaskingpolicystmtContext is an interface to support dynamic dispatch. +type IDetachmaskingpolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DETACH() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Colid() IColidContext + ON() antlr.TerminalNode + Qualified_name() IQualified_nameContext + OPEN_PAREN() antlr.TerminalNode + Attachpolicycollist() IAttachpolicycollistContext + CLOSE_PAREN() antlr.TerminalNode + FROM() antlr.TerminalNode + Attachpolicytargets() IAttachpolicytargetsContext + + // IsDetachmaskingpolicystmtContext differentiates from other interfaces. + IsDetachmaskingpolicystmtContext() +} + +type DetachmaskingpolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDetachmaskingpolicystmtContext() *DetachmaskingpolicystmtContext { + var p = new(DetachmaskingpolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_detachmaskingpolicystmt + return p +} + +func InitEmptyDetachmaskingpolicystmtContext(p *DetachmaskingpolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_detachmaskingpolicystmt +} + +func (*DetachmaskingpolicystmtContext) IsDetachmaskingpolicystmtContext() {} + +func NewDetachmaskingpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DetachmaskingpolicystmtContext { + var p = new(DetachmaskingpolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_detachmaskingpolicystmt + + return p +} + +func (s *DetachmaskingpolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DetachmaskingpolicystmtContext) DETACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserDETACH, 0) +} + +func (s *DetachmaskingpolicystmtContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *DetachmaskingpolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *DetachmaskingpolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DetachmaskingpolicystmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *DetachmaskingpolicystmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *DetachmaskingpolicystmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *DetachmaskingpolicystmtContext) Attachpolicycollist() IAttachpolicycollistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachpolicycollistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttachpolicycollistContext) +} + +func (s *DetachmaskingpolicystmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *DetachmaskingpolicystmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *DetachmaskingpolicystmtContext) Attachpolicytargets() IAttachpolicytargetsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttachpolicytargetsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttachpolicytargetsContext) +} + +func (s *DetachmaskingpolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DetachmaskingpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DetachmaskingpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDetachmaskingpolicystmt(s) + } +} + +func (s *DetachmaskingpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDetachmaskingpolicystmt(s) + } +} + +func (s *DetachmaskingpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDetachmaskingpolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Detachmaskingpolicystmt() (localctx IDetachmaskingpolicystmtContext) { + localctx = NewDetachmaskingpolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1216, RedshiftParserRULE_detachmaskingpolicystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10883) + p.Match(RedshiftParserDETACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10884) + p.Match(RedshiftParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10885) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10886) + p.Colid() + } + { + p.SetState(10887) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10888) + p.Qualified_name() + } + { + p.SetState(10889) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10890) + p.Attachpolicycollist() + } + { + p.SetState(10891) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10892) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10893) + p.Attachpolicytargets() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDetachrlspolicystmtContext is an interface to support dynamic dispatch. +type IDetachrlspolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DETACH() antlr.TerminalNode + RLS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Rlspolicyname() IRlspolicynameContext + ON() antlr.TerminalNode + Table_name_list() ITable_name_listContext + FROM() antlr.TerminalNode + Role_or_user_or_public_list() IRole_or_user_or_public_listContext + TABLE() antlr.TerminalNode + + // IsDetachrlspolicystmtContext differentiates from other interfaces. + IsDetachrlspolicystmtContext() +} + +type DetachrlspolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDetachrlspolicystmtContext() *DetachrlspolicystmtContext { + var p = new(DetachrlspolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_detachrlspolicystmt + return p +} + +func InitEmptyDetachrlspolicystmtContext(p *DetachrlspolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_detachrlspolicystmt +} + +func (*DetachrlspolicystmtContext) IsDetachrlspolicystmtContext() {} + +func NewDetachrlspolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DetachrlspolicystmtContext { + var p = new(DetachrlspolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_detachrlspolicystmt + + return p +} + +func (s *DetachrlspolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DetachrlspolicystmtContext) DETACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserDETACH, 0) +} + +func (s *DetachrlspolicystmtContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *DetachrlspolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *DetachrlspolicystmtContext) Rlspolicyname() IRlspolicynameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRlspolicynameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRlspolicynameContext) +} + +func (s *DetachrlspolicystmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *DetachrlspolicystmtContext) Table_name_list() ITable_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_name_listContext) +} + +func (s *DetachrlspolicystmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *DetachrlspolicystmtContext) Role_or_user_or_public_list() IRole_or_user_or_public_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_or_user_or_public_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_or_user_or_public_listContext) +} + +func (s *DetachrlspolicystmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *DetachrlspolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DetachrlspolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DetachrlspolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDetachrlspolicystmt(s) + } +} + +func (s *DetachrlspolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDetachrlspolicystmt(s) + } +} + +func (s *DetachrlspolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDetachrlspolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Detachrlspolicystmt() (localctx IDetachrlspolicystmtContext) { + localctx = NewDetachrlspolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1218, RedshiftParserRULE_detachrlspolicystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10895) + p.Match(RedshiftParserDETACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10896) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10897) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10898) + p.Rlspolicyname() + } + { + p.SetState(10899) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10901) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 915, p.GetParserRuleContext()) == 1 { + { + p.SetState(10900) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10903) + p.Table_name_list() + } + { + p.SetState(10904) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10905) + p.Role_or_user_or_public_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 +} + +// IRole_or_user_or_public_listContext is an interface to support dynamic dispatch. +type IRole_or_user_or_public_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRole_or_user_or_public() []IRole_or_user_or_publicContext + Role_or_user_or_public(i int) IRole_or_user_or_publicContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRole_or_user_or_public_listContext differentiates from other interfaces. + IsRole_or_user_or_public_listContext() +} + +type Role_or_user_or_public_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_or_user_or_public_listContext() *Role_or_user_or_public_listContext { + var p = new(Role_or_user_or_public_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_role_or_user_or_public_list + return p +} + +func InitEmptyRole_or_user_or_public_listContext(p *Role_or_user_or_public_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_role_or_user_or_public_list +} + +func (*Role_or_user_or_public_listContext) IsRole_or_user_or_public_listContext() {} + +func NewRole_or_user_or_public_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_or_user_or_public_listContext { + var p = new(Role_or_user_or_public_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_role_or_user_or_public_list + + return p +} + +func (s *Role_or_user_or_public_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_or_user_or_public_listContext) AllRole_or_user_or_public() []IRole_or_user_or_publicContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_or_user_or_publicContext); ok { + len++ + } + } + + tst := make([]IRole_or_user_or_publicContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_or_user_or_publicContext); ok { + tst[i] = t.(IRole_or_user_or_publicContext) + i++ + } + } + + return tst +} + +func (s *Role_or_user_or_public_listContext) Role_or_user_or_public(i int) IRole_or_user_or_publicContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_or_user_or_publicContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_or_user_or_publicContext) +} + +func (s *Role_or_user_or_public_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Role_or_user_or_public_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Role_or_user_or_public_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_or_user_or_public_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_or_user_or_public_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRole_or_user_or_public_list(s) + } +} + +func (s *Role_or_user_or_public_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRole_or_user_or_public_list(s) + } +} + +func (s *Role_or_user_or_public_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRole_or_user_or_public_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Role_or_user_or_public_list() (localctx IRole_or_user_or_public_listContext) { + localctx = NewRole_or_user_or_public_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1220, RedshiftParserRULE_role_or_user_or_public_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10907) + p.Role_or_user_or_public() + } + p.SetState(10912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(10908) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10909) + p.Role_or_user_or_public() + } + + p.SetState(10914) + 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 +} + +// IRole_or_user_or_publicContext is an interface to support dynamic dispatch. +type IRole_or_user_or_publicContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rolespec() IRolespecContext + ROLE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + + // IsRole_or_user_or_publicContext differentiates from other interfaces. + IsRole_or_user_or_publicContext() +} + +type Role_or_user_or_publicContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_or_user_or_publicContext() *Role_or_user_or_publicContext { + var p = new(Role_or_user_or_publicContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_role_or_user_or_public + return p +} + +func InitEmptyRole_or_user_or_publicContext(p *Role_or_user_or_publicContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_role_or_user_or_public +} + +func (*Role_or_user_or_publicContext) IsRole_or_user_or_publicContext() {} + +func NewRole_or_user_or_publicContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_or_user_or_publicContext { + var p = new(Role_or_user_or_publicContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_role_or_user_or_public + + return p +} + +func (s *Role_or_user_or_publicContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_or_user_or_publicContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Role_or_user_or_publicContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Role_or_user_or_publicContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLIC, 0) +} + +func (s *Role_or_user_or_publicContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_or_user_or_publicContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_or_user_or_publicContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRole_or_user_or_public(s) + } +} + +func (s *Role_or_user_or_publicContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRole_or_user_or_public(s) + } +} + +func (s *Role_or_user_or_publicContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRole_or_user_or_public(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Role_or_user_or_public() (localctx IRole_or_user_or_publicContext) { + localctx = NewRole_or_user_or_publicContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1222, RedshiftParserRULE_role_or_user_or_public) + p.SetState(10919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 917, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10915) + p.Rolespec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10916) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10917) + p.Rolespec() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10918) + p.Match(RedshiftParserPUBLIC) + 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 +} + +// IRlspolicynameContext is an interface to support dynamic dispatch. +type IRlspolicynameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + + // IsRlspolicynameContext differentiates from other interfaces. + IsRlspolicynameContext() +} + +type RlspolicynameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRlspolicynameContext() *RlspolicynameContext { + var p = new(RlspolicynameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rlspolicyname + return p +} + +func InitEmptyRlspolicynameContext(p *RlspolicynameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rlspolicyname +} + +func (*RlspolicynameContext) IsRlspolicynameContext() {} + +func NewRlspolicynameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RlspolicynameContext { + var p = new(RlspolicynameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rlspolicyname + + return p +} + +func (s *RlspolicynameContext) GetParser() antlr.Parser { return s.parser } + +func (s *RlspolicynameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *RlspolicynameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RlspolicynameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RlspolicynameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRlspolicyname(s) + } +} + +func (s *RlspolicynameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRlspolicyname(s) + } +} + +func (s *RlspolicynameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRlspolicyname(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rlspolicyname() (localctx IRlspolicynameContext) { + localctx = NewRlspolicynameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1224, RedshiftParserRULE_rlspolicyname) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10921) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropidentityproviderstmtContext is an interface to support dynamic dispatch. +type IDropidentityproviderstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + Colid() IColidContext + Opt_if_exists() IOpt_if_existsContext + CASCADE() antlr.TerminalNode + + // IsDropidentityproviderstmtContext differentiates from other interfaces. + IsDropidentityproviderstmtContext() +} + +type DropidentityproviderstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropidentityproviderstmtContext() *DropidentityproviderstmtContext { + var p = new(DropidentityproviderstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropidentityproviderstmt + return p +} + +func InitEmptyDropidentityproviderstmtContext(p *DropidentityproviderstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropidentityproviderstmt +} + +func (*DropidentityproviderstmtContext) IsDropidentityproviderstmtContext() {} + +func NewDropidentityproviderstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropidentityproviderstmtContext { + var p = new(DropidentityproviderstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropidentityproviderstmt + + return p +} + +func (s *DropidentityproviderstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropidentityproviderstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropidentityproviderstmtContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *DropidentityproviderstmtContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER, 0) +} + +func (s *DropidentityproviderstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DropidentityproviderstmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropidentityproviderstmtContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *DropidentityproviderstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropidentityproviderstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropidentityproviderstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropidentityproviderstmt(s) + } +} + +func (s *DropidentityproviderstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropidentityproviderstmt(s) + } +} + +func (s *DropidentityproviderstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropidentityproviderstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropidentityproviderstmt() (localctx IDropidentityproviderstmtContext) { + localctx = NewDropidentityproviderstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1226, RedshiftParserRULE_dropidentityproviderstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10923) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10924) + p.Match(RedshiftParserIDENTITY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10925) + p.Match(RedshiftParserPROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10927) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 918, p.GetParserRuleContext()) == 1 { + { + p.SetState(10926) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10929) + p.Colid() + } + p.SetState(10931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE { + { + p.SetState(10930) + p.Match(RedshiftParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDroplibrarystmtContext is an interface to support dynamic dispatch. +type IDroplibrarystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Colid() IColidContext + Opt_if_exists() IOpt_if_existsContext + + // IsDroplibrarystmtContext differentiates from other interfaces. + IsDroplibrarystmtContext() +} + +type DroplibrarystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDroplibrarystmtContext() *DroplibrarystmtContext { + var p = new(DroplibrarystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droplibrarystmt + return p +} + +func InitEmptyDroplibrarystmtContext(p *DroplibrarystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droplibrarystmt +} + +func (*DroplibrarystmtContext) IsDroplibrarystmtContext() {} + +func NewDroplibrarystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroplibrarystmtContext { + var p = new(DroplibrarystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_droplibrarystmt + + return p +} + +func (s *DroplibrarystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DroplibrarystmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DroplibrarystmtContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIBRARY, 0) +} + +func (s *DroplibrarystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DroplibrarystmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DroplibrarystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DroplibrarystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DroplibrarystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDroplibrarystmt(s) + } +} + +func (s *DroplibrarystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDroplibrarystmt(s) + } +} + +func (s *DroplibrarystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDroplibrarystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Droplibrarystmt() (localctx IDroplibrarystmtContext) { + localctx = NewDroplibrarystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1228, RedshiftParserRULE_droplibrarystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10933) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10934) + p.Match(RedshiftParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10936) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 920, p.GetParserRuleContext()) == 1 { + { + p.SetState(10935) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10938) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropmaskingpolicystmtContext is an interface to support dynamic dispatch. +type IDropmaskingpolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Colid() IColidContext + Opt_if_exists() IOpt_if_existsContext + + // IsDropmaskingpolicystmtContext differentiates from other interfaces. + IsDropmaskingpolicystmtContext() +} + +type DropmaskingpolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropmaskingpolicystmtContext() *DropmaskingpolicystmtContext { + var p = new(DropmaskingpolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropmaskingpolicystmt + return p +} + +func InitEmptyDropmaskingpolicystmtContext(p *DropmaskingpolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropmaskingpolicystmt +} + +func (*DropmaskingpolicystmtContext) IsDropmaskingpolicystmtContext() {} + +func NewDropmaskingpolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropmaskingpolicystmtContext { + var p = new(DropmaskingpolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropmaskingpolicystmt + + return p +} + +func (s *DropmaskingpolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropmaskingpolicystmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropmaskingpolicystmtContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *DropmaskingpolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *DropmaskingpolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DropmaskingpolicystmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropmaskingpolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropmaskingpolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropmaskingpolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropmaskingpolicystmt(s) + } +} + +func (s *DropmaskingpolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropmaskingpolicystmt(s) + } +} + +func (s *DropmaskingpolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropmaskingpolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropmaskingpolicystmt() (localctx IDropmaskingpolicystmtContext) { + localctx = NewDropmaskingpolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1230, RedshiftParserRULE_dropmaskingpolicystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10940) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10941) + p.Match(RedshiftParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10942) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10944) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 921, p.GetParserRuleContext()) == 1 { + { + p.SetState(10943) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10946) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropmodelstmtContext is an interface to support dynamic dispatch. +type IDropmodelstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MODEL() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_if_exists() IOpt_if_existsContext + + // IsDropmodelstmtContext differentiates from other interfaces. + IsDropmodelstmtContext() +} + +type DropmodelstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropmodelstmtContext() *DropmodelstmtContext { + var p = new(DropmodelstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropmodelstmt + return p +} + +func InitEmptyDropmodelstmtContext(p *DropmodelstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropmodelstmt +} + +func (*DropmodelstmtContext) IsDropmodelstmtContext() {} + +func NewDropmodelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropmodelstmtContext { + var p = new(DropmodelstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropmodelstmt + + return p +} + +func (s *DropmodelstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropmodelstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropmodelstmtContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *DropmodelstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *DropmodelstmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DropmodelstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropmodelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropmodelstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropmodelstmt(s) + } +} + +func (s *DropmodelstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropmodelstmt(s) + } +} + +func (s *DropmodelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropmodelstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropmodelstmt() (localctx IDropmodelstmtContext) { + localctx = NewDropmodelstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1232, RedshiftParserRULE_dropmodelstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10948) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10949) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10951) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 922, p.GetParserRuleContext()) == 1 { + { + p.SetState(10950) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10953) + p.Qualified_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDroprlspolicystmtContext is an interface to support dynamic dispatch. +type IDroprlspolicystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + RLS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Colid() IColidContext + Opt_if_exists() IOpt_if_existsContext + CASCADE() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + + // IsDroprlspolicystmtContext differentiates from other interfaces. + IsDroprlspolicystmtContext() +} + +type DroprlspolicystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDroprlspolicystmtContext() *DroprlspolicystmtContext { + var p = new(DroprlspolicystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droprlspolicystmt + return p +} + +func InitEmptyDroprlspolicystmtContext(p *DroprlspolicystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_droprlspolicystmt +} + +func (*DroprlspolicystmtContext) IsDroprlspolicystmtContext() {} + +func NewDroprlspolicystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DroprlspolicystmtContext { + var p = new(DroprlspolicystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_droprlspolicystmt + + return p +} + +func (s *DroprlspolicystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DroprlspolicystmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DroprlspolicystmtContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *DroprlspolicystmtContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *DroprlspolicystmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *DroprlspolicystmtContext) Opt_if_exists() IOpt_if_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_if_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_if_existsContext) +} + +func (s *DroprlspolicystmtContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *DroprlspolicystmtContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *DroprlspolicystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DroprlspolicystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DroprlspolicystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDroprlspolicystmt(s) + } +} + +func (s *DroprlspolicystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDroprlspolicystmt(s) + } +} + +func (s *DroprlspolicystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDroprlspolicystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Droprlspolicystmt() (localctx IDroprlspolicystmtContext) { + localctx = NewDroprlspolicystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1234, RedshiftParserRULE_droprlspolicystmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10955) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10956) + p.Match(RedshiftParserRLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10957) + p.Match(RedshiftParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10959) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 923, p.GetParserRuleContext()) == 1 { + { + p.SetState(10958) + p.Opt_if_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10961) + p.Colid() + } + p.SetState(10963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(10962) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT) { + 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 +} + +// IAltertableappendstmtContext is an interface to support dynamic dispatch. +type IAltertableappendstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + APPEND() antlr.TerminalNode + FROM() antlr.TerminalNode + AllAppendoptions() []IAppendoptionsContext + Appendoptions(i int) IAppendoptionsContext + + // IsAltertableappendstmtContext differentiates from other interfaces. + IsAltertableappendstmtContext() +} + +type AltertableappendstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltertableappendstmtContext() *AltertableappendstmtContext { + var p = new(AltertableappendstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertableappendstmt + return p +} + +func InitEmptyAltertableappendstmtContext(p *AltertableappendstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertableappendstmt +} + +func (*AltertableappendstmtContext) IsAltertableappendstmtContext() {} + +func NewAltertableappendstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertableappendstmtContext { + var p = new(AltertableappendstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altertableappendstmt + + return p +} + +func (s *AltertableappendstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltertableappendstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltertableappendstmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *AltertableappendstmtContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *AltertableappendstmtContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AltertableappendstmtContext) APPEND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAPPEND, 0) +} + +func (s *AltertableappendstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *AltertableappendstmtContext) AllAppendoptions() []IAppendoptionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAppendoptionsContext); ok { + len++ + } + } + + tst := make([]IAppendoptionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAppendoptionsContext); ok { + tst[i] = t.(IAppendoptionsContext) + i++ + } + } + + return tst +} + +func (s *AltertableappendstmtContext) Appendoptions(i int) IAppendoptionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAppendoptionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAppendoptionsContext) +} + +func (s *AltertableappendstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltertableappendstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltertableappendstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltertableappendstmt(s) + } +} + +func (s *AltertableappendstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltertableappendstmt(s) + } +} + +func (s *AltertableappendstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltertableappendstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altertableappendstmt() (localctx IAltertableappendstmtContext) { + localctx = NewAltertableappendstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1236, RedshiftParserRULE_altertableappendstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10965) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10966) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10967) + p.Qualified_name() + } + { + p.SetState(10968) + p.Match(RedshiftParserAPPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10969) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10970) + p.Qualified_name() + } + p.SetState(10974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserFILLTARGET || _la == RedshiftParserIGNOREEXTRA { + { + p.SetState(10971) + p.Appendoptions() + } + + p.SetState(10976) + 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 +} + +// IAppendoptionsContext is an interface to support dynamic dispatch. +type IAppendoptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILLTARGET() antlr.TerminalNode + IGNOREEXTRA() antlr.TerminalNode + + // IsAppendoptionsContext differentiates from other interfaces. + IsAppendoptionsContext() +} + +type AppendoptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAppendoptionsContext() *AppendoptionsContext { + var p = new(AppendoptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_appendoptions + return p +} + +func InitEmptyAppendoptionsContext(p *AppendoptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_appendoptions +} + +func (*AppendoptionsContext) IsAppendoptionsContext() {} + +func NewAppendoptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AppendoptionsContext { + var p = new(AppendoptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_appendoptions + + return p +} + +func (s *AppendoptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AppendoptionsContext) FILLTARGET() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILLTARGET, 0) +} + +func (s *AppendoptionsContext) IGNOREEXTRA() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNOREEXTRA, 0) +} + +func (s *AppendoptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AppendoptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AppendoptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAppendoptions(s) + } +} + +func (s *AppendoptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAppendoptions(s) + } +} + +func (s *AppendoptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAppendoptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Appendoptions() (localctx IAppendoptionsContext) { + localctx = NewAppendoptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1238, RedshiftParserRULE_appendoptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10977) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFILLTARGET || _la == RedshiftParserIGNOREEXTRA) { + 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 +} + +// IAlteruserstmtContext is an interface to support dynamic dispatch. +type IAlteruserstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + USER() antlr.TerminalNode + Rolespec() IRolespecContext + WITH() antlr.TerminalNode + AllAlteruseropts() []IAlteruseroptsContext + Alteruseropts(i int) IAlteruseroptsContext + + // IsAlteruserstmtContext differentiates from other interfaces. + IsAlteruserstmtContext() +} + +type AlteruserstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlteruserstmtContext() *AlteruserstmtContext { + var p = new(AlteruserstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteruserstmt + return p +} + +func InitEmptyAlteruserstmtContext(p *AlteruserstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteruserstmt +} + +func (*AlteruserstmtContext) IsAlteruserstmtContext() {} + +func NewAlteruserstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteruserstmtContext { + var p = new(AlteruserstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteruserstmt + + return p +} + +func (s *AlteruserstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteruserstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlteruserstmtContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *AlteruserstmtContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *AlteruserstmtContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *AlteruserstmtContext) AllAlteruseropts() []IAlteruseroptsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlteruseroptsContext); ok { + len++ + } + } + + tst := make([]IAlteruseroptsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlteruseroptsContext); ok { + tst[i] = t.(IAlteruseroptsContext) + i++ + } + } + + return tst +} + +func (s *AlteruserstmtContext) Alteruseropts(i int) IAlteruseroptsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlteruseroptsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlteruseroptsContext) +} + +func (s *AlteruserstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteruserstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteruserstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteruserstmt(s) + } +} + +func (s *AlteruserstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteruserstmt(s) + } +} + +func (s *AlteruserstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteruserstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteruserstmt() (localctx IAlteruserstmtContext) { + localctx = NewAlteruserstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1240, RedshiftParserRULE_alteruserstmt) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10979) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10980) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10981) + p.Rolespec() + } + p.SetState(10983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(10982) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10986) + 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(10985) + p.Alteruseropts() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10988) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 927, 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 +} + +// IAlteruseroptsContext is an interface to support dynamic dispatch. +type IAlteruseroptsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATEDB() antlr.TerminalNode + NOCREATEDB() antlr.TerminalNode + CREATEUSER() antlr.TerminalNode + NOCREATEUSER() antlr.TerminalNode + SYSLOG() antlr.TerminalNode + ACCESS() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + UNRESTRICTED() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + Sconst() ISconstContext + DISABLE_P() antlr.TerminalNode + VALID() antlr.TerminalNode + UNTIL() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Colid() IColidContext + CONNECTION() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Iconst() IIconstContext + UNLIMITED() antlr.TerminalNode + SESSION() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + RESET() antlr.TerminalNode + SET() antlr.TerminalNode + A_expr() IA_exprContext + EXTERNALID() antlr.TerminalNode + + // IsAlteruseroptsContext differentiates from other interfaces. + IsAlteruseroptsContext() +} + +type AlteruseroptsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlteruseroptsContext() *AlteruseroptsContext { + var p = new(AlteruseroptsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteruseropts + return p +} + +func InitEmptyAlteruseroptsContext(p *AlteruseroptsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alteruseropts +} + +func (*AlteruseroptsContext) IsAlteruseroptsContext() {} + +func NewAlteruseroptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlteruseroptsContext { + var p = new(AlteruseroptsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alteruseropts + + return p +} + +func (s *AlteruseroptsContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlteruseroptsContext) CREATEDB() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATEDB, 0) +} + +func (s *AlteruseroptsContext) NOCREATEDB() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOCREATEDB, 0) +} + +func (s *AlteruseroptsContext) CREATEUSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATEUSER, 0) +} + +func (s *AlteruseroptsContext) NOCREATEUSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOCREATEUSER, 0) +} + +func (s *AlteruseroptsContext) SYSLOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSLOG, 0) +} + +func (s *AlteruseroptsContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *AlteruseroptsContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICTED, 0) +} + +func (s *AlteruseroptsContext) UNRESTRICTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNRESTRICTED, 0) +} + +func (s *AlteruseroptsContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(RedshiftParserPASSWORD, 0) +} + +func (s *AlteruseroptsContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *AlteruseroptsContext) DISABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISABLE_P, 0) +} + +func (s *AlteruseroptsContext) VALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALID, 0) +} + +func (s *AlteruseroptsContext) UNTIL() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNTIL, 0) +} + +func (s *AlteruseroptsContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *AlteruseroptsContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *AlteruseroptsContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *AlteruseroptsContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECTION, 0) +} + +func (s *AlteruseroptsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *AlteruseroptsContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *AlteruseroptsContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLIMITED, 0) +} + +func (s *AlteruseroptsContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *AlteruseroptsContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMEOUT, 0) +} + +func (s *AlteruseroptsContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *AlteruseroptsContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlteruseroptsContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *AlteruseroptsContext) EXTERNALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNALID, 0) +} + +func (s *AlteruseroptsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlteruseroptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlteruseroptsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlteruseropts(s) + } +} + +func (s *AlteruseroptsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlteruseropts(s) + } +} + +func (s *AlteruseroptsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlteruseropts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alteruseropts() (localctx IAlteruseroptsContext) { + localctx = NewAlteruseroptsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1242, RedshiftParserRULE_alteruseropts) + var _la int + + p.SetState(11029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 930, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10990) + p.Match(RedshiftParserCREATEDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10991) + p.Match(RedshiftParserNOCREATEDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10992) + p.Match(RedshiftParserCREATEUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10993) + p.Match(RedshiftParserNOCREATEUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10994) + p.Match(RedshiftParserSYSLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10995) + p.Match(RedshiftParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10996) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserRESTRICTED || _la == RedshiftParserUNRESTRICTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10997) + p.Match(RedshiftParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(10998) + p.Sconst() + } + + case RedshiftParserDISABLE_P: + { + p.SetState(10999) + p.Match(RedshiftParserDISABLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11002) + p.Match(RedshiftParserVALID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11003) + p.Match(RedshiftParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11004) + p.Sconst() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11005) + p.Match(RedshiftParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11006) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11007) + p.Colid() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(11008) + p.Match(RedshiftParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11009) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + { + p.SetState(11010) + p.Iconst() + } + + case RedshiftParserUNLIMITED: + { + p.SetState(11011) + p.Match(RedshiftParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(11014) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11015) + p.Match(RedshiftParserTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11016) + p.Iconst() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(11017) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11018) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11019) + p.Match(RedshiftParserTIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(11020) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11021) + p.Colid() + } + { + p.SetState(11022) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11023) + p.A_expr() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(11025) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11026) + p.Colid() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(11027) + p.Match(RedshiftParserEXTERNALID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11028) + p.Colid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnalyzecompressionstmtContext is an interface to support dynamic dispatch. +type IAnalyzecompressionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPRESSION() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + ANALYSE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + COMPROWS() antlr.TerminalNode + Iconst() IIconstContext + OPEN_PAREN() antlr.TerminalNode + Name_list() IName_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsAnalyzecompressionstmtContext differentiates from other interfaces. + IsAnalyzecompressionstmtContext() +} + +type AnalyzecompressionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnalyzecompressionstmtContext() *AnalyzecompressionstmtContext { + var p = new(AnalyzecompressionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_analyzecompressionstmt + return p +} + +func InitEmptyAnalyzecompressionstmtContext(p *AnalyzecompressionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_analyzecompressionstmt +} + +func (*AnalyzecompressionstmtContext) IsAnalyzecompressionstmtContext() {} + +func NewAnalyzecompressionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzecompressionstmtContext { + var p = new(AnalyzecompressionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_analyzecompressionstmt + + return p +} + +func (s *AnalyzecompressionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnalyzecompressionstmtContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPRESSION, 0) +} + +func (s *AnalyzecompressionstmtContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserANALYZE, 0) +} + +func (s *AnalyzecompressionstmtContext) ANALYSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserANALYSE, 0) +} + +func (s *AnalyzecompressionstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AnalyzecompressionstmtContext) COMPROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPROWS, 0) +} + +func (s *AnalyzecompressionstmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *AnalyzecompressionstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AnalyzecompressionstmtContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *AnalyzecompressionstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AnalyzecompressionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzecompressionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnalyzecompressionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAnalyzecompressionstmt(s) + } +} + +func (s *AnalyzecompressionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAnalyzecompressionstmt(s) + } +} + +func (s *AnalyzecompressionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAnalyzecompressionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Analyzecompressionstmt() (localctx IAnalyzecompressionstmtContext) { + localctx = NewAnalyzecompressionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1244, RedshiftParserRULE_analyzecompressionstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11031) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserANALYSE || _la == RedshiftParserANALYZE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11032) + p.Match(RedshiftParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11040) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 932, p.GetParserRuleContext()) == 1 { + { + p.SetState(11033) + p.Qualified_name() + } + p.SetState(11038) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 931, p.GetParserRuleContext()) == 1 { + { + p.SetState(11034) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11035) + p.Name_list() + } + { + p.SetState(11036) + p.Match(RedshiftParserCLOSE_PAREN) + 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(11044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMPROWS { + { + p.SetState(11042) + p.Match(RedshiftParserCOMPROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11043) + p.Iconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICancelstmtContext is an interface to support dynamic dispatch. +type ICancelstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CANCEL() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + Iconst() IIconstContext + + // IsCancelstmtContext differentiates from other interfaces. + IsCancelstmtContext() +} + +type CancelstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCancelstmtContext() *CancelstmtContext { + var p = new(CancelstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cancelstmt + return p +} + +func InitEmptyCancelstmtContext(p *CancelstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cancelstmt +} + +func (*CancelstmtContext) IsCancelstmtContext() {} + +func NewCancelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CancelstmtContext { + var p = new(CancelstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cancelstmt + + return p +} + +func (s *CancelstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CancelstmtContext) CANCEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCANCEL, 0) +} + +func (s *CancelstmtContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *CancelstmtContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CancelstmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *CancelstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CancelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CancelstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCancelstmt(s) + } +} + +func (s *CancelstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCancelstmt(s) + } +} + +func (s *CancelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCancelstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cancelstmt() (localctx ICancelstmtContext) { + localctx = NewCancelstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1246, RedshiftParserRULE_cancelstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11046) + p.Match(RedshiftParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(11047) + p.Sconst() + } + + case RedshiftParserIntegral: + { + p.SetState(11048) + p.Iconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-862)) & ^0x3f) == 0 && ((int64(1)<<(_la-862))&67108885) != 0 { + { + p.SetState(11051) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClosestmtContext is an interface to support dynamic dispatch. +type IClosestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCursorname returns the cursorname rule contexts. + GetCursorname() IColidContext + + // SetCursorname sets the cursorname rule contexts. + SetCursorname(IColidContext) + + // Getter signatures + CLOSE() antlr.TerminalNode + Colid() IColidContext + + // IsClosestmtContext differentiates from other interfaces. + IsClosestmtContext() +} + +type ClosestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cursorname IColidContext +} + +func NewEmptyClosestmtContext() *ClosestmtContext { + var p = new(ClosestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_closestmt + return p +} + +func InitEmptyClosestmtContext(p *ClosestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_closestmt +} + +func (*ClosestmtContext) IsClosestmtContext() {} + +func NewClosestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClosestmtContext { + var p = new(ClosestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_closestmt + + return p +} + +func (s *ClosestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClosestmtContext) GetCursorname() IColidContext { return s.cursorname } + +func (s *ClosestmtContext) SetCursorname(v IColidContext) { s.cursorname = v } + +func (s *ClosestmtContext) CLOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE, 0) +} + +func (s *ClosestmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ClosestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClosestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClosestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterClosestmt(s) + } +} + +func (s *ClosestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitClosestmt(s) + } +} + +func (s *ClosestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitClosestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Closestmt() (localctx IClosestmtContext) { + localctx = NewClosestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1248, RedshiftParserRULE_closestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11054) + p.Match(RedshiftParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11055) + + var _x = p.Colid() + + localctx.(*ClosestmtContext).cursorname = _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 +} + +// IInsertexternaltablestmtContext is an interface to support dynamic dispatch. +type IInsertexternaltablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + INTO() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Select_or_values() ISelect_or_valuesContext + + // IsInsertexternaltablestmtContext differentiates from other interfaces. + IsInsertexternaltablestmtContext() +} + +type InsertexternaltablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsertexternaltablestmtContext() *InsertexternaltablestmtContext { + var p = new(InsertexternaltablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insertexternaltablestmt + return p +} + +func InitEmptyInsertexternaltablestmtContext(p *InsertexternaltablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insertexternaltablestmt +} + +func (*InsertexternaltablestmtContext) IsInsertexternaltablestmtContext() {} + +func NewInsertexternaltablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertexternaltablestmtContext { + var p = new(InsertexternaltablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_insertexternaltablestmt + + return p +} + +func (s *InsertexternaltablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *InsertexternaltablestmtContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *InsertexternaltablestmtContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *InsertexternaltablestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *InsertexternaltablestmtContext) Select_or_values() ISelect_or_valuesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_or_valuesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_or_valuesContext) +} + +func (s *InsertexternaltablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertexternaltablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InsertexternaltablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInsertexternaltablestmt(s) + } +} + +func (s *InsertexternaltablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInsertexternaltablestmt(s) + } +} + +func (s *InsertexternaltablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInsertexternaltablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Insertexternaltablestmt() (localctx IInsertexternaltablestmtContext) { + localctx = NewInsertexternaltablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1250, RedshiftParserRULE_insertexternaltablestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11057) + p.Match(RedshiftParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11058) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11059) + p.Qualified_name() + } + { + p.SetState(11060) + p.Select_or_values() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_or_valuesContext is an interface to support dynamic dispatch. +type ISelect_or_valuesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Selectstmt() ISelectstmtContext + Values_clause() IValues_clauseContext + + // IsSelect_or_valuesContext differentiates from other interfaces. + IsSelect_or_valuesContext() +} + +type Select_or_valuesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_or_valuesContext() *Select_or_valuesContext { + var p = new(Select_or_valuesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_or_values + return p +} + +func InitEmptySelect_or_valuesContext(p *Select_or_valuesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_or_values +} + +func (*Select_or_valuesContext) IsSelect_or_valuesContext() {} + +func NewSelect_or_valuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_or_valuesContext { + var p = new(Select_or_valuesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_or_values + + return p +} + +func (s *Select_or_valuesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_or_valuesContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *Select_or_valuesContext) 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 *Select_or_valuesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_or_valuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_or_valuesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_or_values(s) + } +} + +func (s *Select_or_valuesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_or_values(s) + } +} + +func (s *Select_or_valuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_or_values(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_or_values() (localctx ISelect_or_valuesContext) { + localctx = NewSelect_or_valuesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1252, RedshiftParserRULE_select_or_values) + p.SetState(11064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 936, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11062) + p.Selectstmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11063) + p.Values_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 +} + +// ISelectintostmtContext is an interface to support dynamic dispatch. +type ISelectintostmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + Opt_target_list() IOpt_target_listContext + INTO() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_all_clause() IOpt_all_clauseContext + From_clause() IFrom_clauseContext + + // IsSelectintostmtContext differentiates from other interfaces. + IsSelectintostmtContext() +} + +type SelectintostmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectintostmtContext() *SelectintostmtContext { + var p = new(SelectintostmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_selectintostmt + return p +} + +func InitEmptySelectintostmtContext(p *SelectintostmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_selectintostmt +} + +func (*SelectintostmtContext) IsSelectintostmtContext() {} + +func NewSelectintostmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectintostmtContext { + var p = new(SelectintostmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_selectintostmt + + return p +} + +func (s *SelectintostmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectintostmtContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *SelectintostmtContext) Opt_target_list() IOpt_target_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_target_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_target_listContext) +} + +func (s *SelectintostmtContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *SelectintostmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *SelectintostmtContext) Opt_all_clause() IOpt_all_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_all_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_all_clauseContext) +} + +func (s *SelectintostmtContext) 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 *SelectintostmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectintostmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectintostmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelectintostmt(s) + } +} + +func (s *SelectintostmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelectintostmt(s) + } +} + +func (s *SelectintostmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelectintostmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Selectintostmt() (localctx ISelectintostmtContext) { + localctx = NewSelectintostmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1254, RedshiftParserRULE_selectintostmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11066) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserALL { + { + p.SetState(11067) + p.Opt_all_clause() + } + + } + { + p.SetState(11070) + p.Opt_target_list() + } + { + p.SetState(11071) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11072) + p.Qualified_name() + } + p.SetState(11074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(11073) + p.From_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 +} + +// ISetsessionauthorizationstmtContext is an interface to support dynamic dispatch. +type ISetsessionauthorizationstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + SESSION() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + Colid() IColidContext + DEFAULT() antlr.TerminalNode + RESET() antlr.TerminalNode + + // IsSetsessionauthorizationstmtContext differentiates from other interfaces. + IsSetsessionauthorizationstmtContext() +} + +type SetsessionauthorizationstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetsessionauthorizationstmtContext() *SetsessionauthorizationstmtContext { + var p = new(SetsessionauthorizationstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setsessionauthorizationstmt + return p +} + +func InitEmptySetsessionauthorizationstmtContext(p *SetsessionauthorizationstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setsessionauthorizationstmt +} + +func (*SetsessionauthorizationstmtContext) IsSetsessionauthorizationstmtContext() {} + +func NewSetsessionauthorizationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetsessionauthorizationstmtContext { + var p = new(SetsessionauthorizationstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_setsessionauthorizationstmt + + return p +} + +func (s *SetsessionauthorizationstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetsessionauthorizationstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *SetsessionauthorizationstmtContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *SetsessionauthorizationstmtContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHORIZATION, 0) +} + +func (s *SetsessionauthorizationstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *SetsessionauthorizationstmtContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *SetsessionauthorizationstmtContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *SetsessionauthorizationstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetsessionauthorizationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetsessionauthorizationstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSetsessionauthorizationstmt(s) + } +} + +func (s *SetsessionauthorizationstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSetsessionauthorizationstmt(s) + } +} + +func (s *SetsessionauthorizationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSetsessionauthorizationstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Setsessionauthorizationstmt() (localctx ISetsessionauthorizationstmtContext) { + localctx = NewSetsessionauthorizationstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1256, RedshiftParserRULE_setsessionauthorizationstmt) + p.SetState(11087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 939, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11076) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11077) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11078) + p.Match(RedshiftParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11079) + p.Colid() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11080) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11081) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11082) + p.Match(RedshiftParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11083) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11084) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11085) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11086) + p.Match(RedshiftParserAUTHORIZATION) + 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 +} + +// ISetsessioncharacteristicsstmtContext is an interface to support dynamic dispatch. +type ISetsessioncharacteristicsstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + SESSION() antlr.TerminalNode + CHARACTERISTICS() antlr.TerminalNode + AS() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + Transaction_mode_list() ITransaction_mode_listContext + + // IsSetsessioncharacteristicsstmtContext differentiates from other interfaces. + IsSetsessioncharacteristicsstmtContext() +} + +type SetsessioncharacteristicsstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetsessioncharacteristicsstmtContext() *SetsessioncharacteristicsstmtContext { + var p = new(SetsessioncharacteristicsstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setsessioncharacteristicsstmt + return p +} + +func InitEmptySetsessioncharacteristicsstmtContext(p *SetsessioncharacteristicsstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_setsessioncharacteristicsstmt +} + +func (*SetsessioncharacteristicsstmtContext) IsSetsessioncharacteristicsstmtContext() {} + +func NewSetsessioncharacteristicsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetsessioncharacteristicsstmtContext { + var p = new(SetsessioncharacteristicsstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_setsessioncharacteristicsstmt + + return p +} + +func (s *SetsessioncharacteristicsstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetsessioncharacteristicsstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *SetsessioncharacteristicsstmtContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *SetsessioncharacteristicsstmtContext) CHARACTERISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHARACTERISTICS, 0) +} + +func (s *SetsessioncharacteristicsstmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *SetsessioncharacteristicsstmtContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *SetsessioncharacteristicsstmtContext) Transaction_mode_list() ITransaction_mode_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_mode_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_mode_listContext) +} + +func (s *SetsessioncharacteristicsstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetsessioncharacteristicsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetsessioncharacteristicsstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSetsessioncharacteristicsstmt(s) + } +} + +func (s *SetsessioncharacteristicsstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSetsessioncharacteristicsstmt(s) + } +} + +func (s *SetsessioncharacteristicsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSetsessioncharacteristicsstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Setsessioncharacteristicsstmt() (localctx ISetsessioncharacteristicsstmtContext) { + localctx = NewSetsessioncharacteristicsstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1258, RedshiftParserRULE_setsessioncharacteristicsstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11089) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11090) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11091) + p.Match(RedshiftParserCHARACTERISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11092) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11093) + p.Match(RedshiftParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11094) + p.Transaction_mode_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 +} + +// IShowcolumnsstmtContext is an interface to support dynamic dispatch. +type IShowcolumnsstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + FROM() antlr.TerminalNode + Qualified_name() IQualified_nameContext + TABLE() antlr.TerminalNode + LIKE() antlr.TerminalNode + Sconst() ISconstContext + LIMIT() antlr.TerminalNode + Iconst() IIconstContext + + // IsShowcolumnsstmtContext differentiates from other interfaces. + IsShowcolumnsstmtContext() +} + +type ShowcolumnsstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowcolumnsstmtContext() *ShowcolumnsstmtContext { + var p = new(ShowcolumnsstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showcolumnsstmt + return p +} + +func InitEmptyShowcolumnsstmtContext(p *ShowcolumnsstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showcolumnsstmt +} + +func (*ShowcolumnsstmtContext) IsShowcolumnsstmtContext() {} + +func NewShowcolumnsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowcolumnsstmtContext { + var p = new(ShowcolumnsstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showcolumnsstmt + + return p +} + +func (s *ShowcolumnsstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowcolumnsstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowcolumnsstmtContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMNS, 0) +} + +func (s *ShowcolumnsstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *ShowcolumnsstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ShowcolumnsstmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *ShowcolumnsstmtContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *ShowcolumnsstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ShowcolumnsstmtContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *ShowcolumnsstmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *ShowcolumnsstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowcolumnsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowcolumnsstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowcolumnsstmt(s) + } +} + +func (s *ShowcolumnsstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowcolumnsstmt(s) + } +} + +func (s *ShowcolumnsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowcolumnsstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showcolumnsstmt() (localctx IShowcolumnsstmtContext) { + localctx = NewShowcolumnsstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1260, RedshiftParserRULE_showcolumnsstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11096) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11097) + p.Match(RedshiftParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11098) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11100) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 940, p.GetParserRuleContext()) == 1 { + { + p.SetState(11099) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11102) + p.Qualified_name() + } + p.SetState(11105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIKE { + { + p.SetState(11103) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11104) + p.Sconst() + } + + } + p.SetState(11109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIMIT { + { + p.SetState(11107) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11108) + p.Iconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowdatabasesstmtContext is an interface to support dynamic dispatch. +type IShowdatabasesstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + DATABASES() antlr.TerminalNode + FROM() antlr.TerminalNode + DATA_P() antlr.TerminalNode + CATALOG() antlr.TerminalNode + AllShowdbsopts() []IShowdbsoptsContext + Showdbsopts(i int) IShowdbsoptsContext + + // IsShowdatabasesstmtContext differentiates from other interfaces. + IsShowdatabasesstmtContext() +} + +type ShowdatabasesstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowdatabasesstmtContext() *ShowdatabasesstmtContext { + var p = new(ShowdatabasesstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showdatabasesstmt + return p +} + +func InitEmptyShowdatabasesstmtContext(p *ShowdatabasesstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showdatabasesstmt +} + +func (*ShowdatabasesstmtContext) IsShowdatabasesstmtContext() {} + +func NewShowdatabasesstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowdatabasesstmtContext { + var p = new(ShowdatabasesstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showdatabasesstmt + + return p +} + +func (s *ShowdatabasesstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowdatabasesstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowdatabasesstmtContext) DATABASES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASES, 0) +} + +func (s *ShowdatabasesstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *ShowdatabasesstmtContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *ShowdatabasesstmtContext) CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG, 0) +} + +func (s *ShowdatabasesstmtContext) AllShowdbsopts() []IShowdbsoptsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShowdbsoptsContext); ok { + len++ + } + } + + tst := make([]IShowdbsoptsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShowdbsoptsContext); ok { + tst[i] = t.(IShowdbsoptsContext) + i++ + } + } + + return tst +} + +func (s *ShowdatabasesstmtContext) Showdbsopts(i int) IShowdbsoptsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShowdbsoptsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShowdbsoptsContext) +} + +func (s *ShowdatabasesstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowdatabasesstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowdatabasesstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowdatabasesstmt(s) + } +} + +func (s *ShowdatabasesstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowdatabasesstmt(s) + } +} + +func (s *ShowdatabasesstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowdatabasesstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showdatabasesstmt() (localctx IShowdatabasesstmtContext) { + localctx = NewShowdatabasesstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1262, RedshiftParserRULE_showdatabasesstmt) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11111) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11112) + p.Match(RedshiftParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(11113) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11114) + p.Match(RedshiftParserDATA_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11115) + p.Match(RedshiftParserCATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 944, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11118) + p.Showdbsopts() + } + + } + p.SetState(11123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 944, 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 +} + +// IShowdbsoptsContext is an interface to support dynamic dispatch. +type IShowdbsoptsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + WITH() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Iconst() IIconstContext + ACCOUNT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + SESSION() antlr.TerminalNode + + // IsShowdbsoptsContext differentiates from other interfaces. + IsShowdbsoptsContext() +} + +type ShowdbsoptsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowdbsoptsContext() *ShowdbsoptsContext { + var p = new(ShowdbsoptsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showdbsopts + return p +} + +func InitEmptyShowdbsoptsContext(p *ShowdbsoptsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showdbsopts +} + +func (*ShowdbsoptsContext) IsShowdbsoptsContext() {} + +func NewShowdbsoptsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowdbsoptsContext { + var p = new(ShowdbsoptsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showdbsopts + + return p +} + +func (s *ShowdbsoptsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowdbsoptsContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *ShowdbsoptsContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *ShowdbsoptsContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ShowdbsoptsContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *ShowdbsoptsContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *ShowdbsoptsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *ShowdbsoptsContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *ShowdbsoptsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCOUNT, 0) +} + +func (s *ShowdbsoptsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *ShowdbsoptsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *ShowdbsoptsContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *ShowdbsoptsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *ShowdbsoptsContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *ShowdbsoptsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowdbsoptsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowdbsoptsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowdbsopts(s) + } +} + +func (s *ShowdbsoptsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowdbsopts(s) + } +} + +func (s *ShowdbsoptsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowdbsopts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showdbsopts() (localctx IShowdbsoptsContext) { + localctx = NewShowdbsoptsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1264, RedshiftParserRULE_showdbsopts) + var _la int + + p.SetState(11146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserLIKE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11124) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11125) + p.Sconst() + } + + case RedshiftParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11126) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11127) + p.Match(RedshiftParserDATASHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11128) + p.Sconst() + } + + case RedshiftParserLIMIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11129) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11130) + p.Iconst() + } + + case RedshiftParserACCOUNT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11131) + p.Match(RedshiftParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11132) + p.Sconst() + } + p.SetState(11137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(11133) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11134) + p.Sconst() + } + + p.SetState(11139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserIAM_ROLE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11140) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + { + p.SetState(11141) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSESSION: + { + p.SetState(11142) + p.Match(RedshiftParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(11143) + p.Sconst() + } + + 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 +} + +// IShowdatasharesstmtContext is an interface to support dynamic dispatch. +type IShowdatasharesstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + DATASHARES() antlr.TerminalNode + LIKE() antlr.TerminalNode + Sconst() ISconstContext + + // IsShowdatasharesstmtContext differentiates from other interfaces. + IsShowdatasharesstmtContext() +} + +type ShowdatasharesstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowdatasharesstmtContext() *ShowdatasharesstmtContext { + var p = new(ShowdatasharesstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showdatasharesstmt + return p +} + +func InitEmptyShowdatasharesstmtContext(p *ShowdatasharesstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showdatasharesstmt +} + +func (*ShowdatasharesstmtContext) IsShowdatasharesstmtContext() {} + +func NewShowdatasharesstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowdatasharesstmtContext { + var p = new(ShowdatasharesstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showdatasharesstmt + + return p +} + +func (s *ShowdatasharesstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowdatasharesstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowdatasharesstmtContext) DATASHARES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARES, 0) +} + +func (s *ShowdatasharesstmtContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *ShowdatasharesstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ShowdatasharesstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowdatasharesstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowdatasharesstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowdatasharesstmt(s) + } +} + +func (s *ShowdatasharesstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowdatasharesstmt(s) + } +} + +func (s *ShowdatasharesstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowdatasharesstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showdatasharesstmt() (localctx IShowdatasharesstmtContext) { + localctx = NewShowdatasharesstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1266, RedshiftParserRULE_showdatasharesstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11148) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11149) + p.Match(RedshiftParserDATASHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIKE { + { + p.SetState(11150) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11151) + p.Sconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowexternaltablestmtContext is an interface to support dynamic dispatch. +type IShowexternaltablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + PARTITION() antlr.TerminalNode + + // IsShowexternaltablestmtContext differentiates from other interfaces. + IsShowexternaltablestmtContext() +} + +type ShowexternaltablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowexternaltablestmtContext() *ShowexternaltablestmtContext { + var p = new(ShowexternaltablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showexternaltablestmt + return p +} + +func InitEmptyShowexternaltablestmtContext(p *ShowexternaltablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showexternaltablestmt +} + +func (*ShowexternaltablestmtContext) IsShowexternaltablestmtContext() {} + +func NewShowexternaltablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowexternaltablestmtContext { + var p = new(ShowexternaltablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showexternaltablestmt + + return p +} + +func (s *ShowexternaltablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowexternaltablestmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowexternaltablestmtContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *ShowexternaltablestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *ShowexternaltablestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ShowexternaltablestmtContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *ShowexternaltablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowexternaltablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowexternaltablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowexternaltablestmt(s) + } +} + +func (s *ShowexternaltablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowexternaltablestmt(s) + } +} + +func (s *ShowexternaltablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowexternaltablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showexternaltablestmt() (localctx IShowexternaltablestmtContext) { + localctx = NewShowexternaltablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1268, RedshiftParserRULE_showexternaltablestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11154) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11155) + p.Match(RedshiftParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11156) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11157) + p.Qualified_name() + } + p.SetState(11159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPARTITION { + { + p.SetState(11158) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowgrantsstmtContext is an interface to support dynamic dispatch. +type IShowgrantsstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + GRANTS() antlr.TerminalNode + ON() antlr.TerminalNode + Grantobject() IGrantobjectContext + FOR() antlr.TerminalNode + Grantprincipal() IGrantprincipalContext + LIMIT() antlr.TerminalNode + Iconst() IIconstContext + + // IsShowgrantsstmtContext differentiates from other interfaces. + IsShowgrantsstmtContext() +} + +type ShowgrantsstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowgrantsstmtContext() *ShowgrantsstmtContext { + var p = new(ShowgrantsstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showgrantsstmt + return p +} + +func InitEmptyShowgrantsstmtContext(p *ShowgrantsstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showgrantsstmt +} + +func (*ShowgrantsstmtContext) IsShowgrantsstmtContext() {} + +func NewShowgrantsstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowgrantsstmtContext { + var p = new(ShowgrantsstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showgrantsstmt + + return p +} + +func (s *ShowgrantsstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowgrantsstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowgrantsstmtContext) GRANTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANTS, 0) +} + +func (s *ShowgrantsstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *ShowgrantsstmtContext) Grantobject() IGrantobjectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantobjectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantobjectContext) +} + +func (s *ShowgrantsstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *ShowgrantsstmtContext) Grantprincipal() IGrantprincipalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantprincipalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrantprincipalContext) +} + +func (s *ShowgrantsstmtContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *ShowgrantsstmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *ShowgrantsstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowgrantsstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowgrantsstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowgrantsstmt(s) + } +} + +func (s *ShowgrantsstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowgrantsstmt(s) + } +} + +func (s *ShowgrantsstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowgrantsstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showgrantsstmt() (localctx IShowgrantsstmtContext) { + localctx = NewShowgrantsstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1270, RedshiftParserRULE_showgrantsstmt) + var _la int + + p.SetState(11184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 954, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11161) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11162) + p.Match(RedshiftParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserON { + { + p.SetState(11163) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11164) + p.Grantobject() + } + + } + p.SetState(11169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(11167) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11168) + p.Grantprincipal() + } + + } + p.SetState(11173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIMIT { + { + p.SetState(11171) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11172) + p.Iconst() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11175) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11176) + p.Match(RedshiftParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(11177) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11178) + p.Grantprincipal() + } + + p.SetState(11182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIMIT { + { + p.SetState(11180) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11181) + p.Iconst() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantobjectContext is an interface to support dynamic dispatch. +type IGrantobjectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATABASE() antlr.TerminalNode + Colid() IColidContext + SCHEMA() antlr.TerminalNode + Qualified_name() IQualified_nameContext + TABLE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Datatypelist() IDatatypelistContext + + // IsGrantobjectContext differentiates from other interfaces. + IsGrantobjectContext() +} + +type GrantobjectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantobjectContext() *GrantobjectContext { + var p = new(GrantobjectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantobject + return p +} + +func InitEmptyGrantobjectContext(p *GrantobjectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantobject +} + +func (*GrantobjectContext) IsGrantobjectContext() {} + +func NewGrantobjectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantobjectContext { + var p = new(GrantobjectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantobject + + return p +} + +func (s *GrantobjectContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantobjectContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *GrantobjectContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *GrantobjectContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *GrantobjectContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *GrantobjectContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *GrantobjectContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *GrantobjectContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *GrantobjectContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *GrantobjectContext) Datatypelist() IDatatypelistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypelistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypelistContext) +} + +func (s *GrantobjectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantobjectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantobjectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantobject(s) + } +} + +func (s *GrantobjectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantobject(s) + } +} + +func (s *GrantobjectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantobject(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantobject() (localctx IGrantobjectContext) { + localctx = NewGrantobjectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1272, RedshiftParserRULE_grantobject) + var _la int + + p.SetState(11203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 958, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11186) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11187) + p.Colid() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11188) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11189) + p.Qualified_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(11191) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 955, p.GetParserRuleContext()) == 1 { + { + p.SetState(11190) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11193) + p.Qualified_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11194) + p.Match(RedshiftParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11195) + p.Qualified_name() + } + p.SetState(11201) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 957, p.GetParserRuleContext()) == 1 { + { + p.SetState(11196) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-107)) & ^0x3f) == 0 && ((int64(1)<<(_la-107))&-5) != 0) || ((int64((_la-171)) & ^0x3f) == 0 && ((int64(1)<<(_la-171))&-129) != 0) || ((int64((_la-235)) & ^0x3f) == 0 && ((int64(1)<<(_la-235))&-4503599632089089) != 0) || ((int64((_la-299)) & ^0x3f) == 0 && ((int64(1)<<(_la-299))&-1) != 0) || ((int64((_la-363)) & ^0x3f) == 0 && ((int64(1)<<(_la-363))&-1237319681) != 0) || ((int64((_la-427)) & ^0x3f) == 0 && ((int64(1)<<(_la-427))&-1) != 0) || ((int64((_la-491)) & ^0x3f) == 0 && ((int64(1)<<(_la-491))&-1) != 0) || ((int64((_la-555)) & ^0x3f) == 0 && ((int64(1)<<(_la-555))&72057594037927935) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372036854759423) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(11197) + p.Datatypelist() + } + + } + { + p.SetState(11200) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantprincipalContext is an interface to support dynamic dispatch. +type IGrantprincipalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + ROLE() antlr.TerminalNode + + // IsGrantprincipalContext differentiates from other interfaces. + IsGrantprincipalContext() +} + +type GrantprincipalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantprincipalContext() *GrantprincipalContext { + var p = new(GrantprincipalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantprincipal + return p +} + +func InitEmptyGrantprincipalContext(p *GrantprincipalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grantprincipal +} + +func (*GrantprincipalContext) IsGrantprincipalContext() {} + +func NewGrantprincipalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GrantprincipalContext { + var p = new(GrantprincipalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_grantprincipal + + return p +} + +func (s *GrantprincipalContext) GetParser() antlr.Parser { return s.parser } + +func (s *GrantprincipalContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *GrantprincipalContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *GrantprincipalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GrantprincipalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GrantprincipalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrantprincipal(s) + } +} + +func (s *GrantprincipalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrantprincipal(s) + } +} + +func (s *GrantprincipalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrantprincipal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grantprincipal() (localctx IGrantprincipalContext) { + localctx = NewGrantprincipalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1274, RedshiftParserRULE_grantprincipal) + p.SetState(11208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 959, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11205) + p.Colid() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11206) + p.Match(RedshiftParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11207) + p.Colid() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowmodelstmtContext is an interface to support dynamic dispatch. +type IShowmodelstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + MODEL() antlr.TerminalNode + Qualified_name() IQualified_nameContext + ALL() antlr.TerminalNode + + // IsShowmodelstmtContext differentiates from other interfaces. + IsShowmodelstmtContext() +} + +type ShowmodelstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowmodelstmtContext() *ShowmodelstmtContext { + var p = new(ShowmodelstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showmodelstmt + return p +} + +func InitEmptyShowmodelstmtContext(p *ShowmodelstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showmodelstmt +} + +func (*ShowmodelstmtContext) IsShowmodelstmtContext() {} + +func NewShowmodelstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowmodelstmtContext { + var p = new(ShowmodelstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showmodelstmt + + return p +} + +func (s *ShowmodelstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowmodelstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowmodelstmtContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *ShowmodelstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ShowmodelstmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *ShowmodelstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowmodelstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowmodelstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowmodelstmt(s) + } +} + +func (s *ShowmodelstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowmodelstmt(s) + } +} + +func (s *ShowmodelstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowmodelstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showmodelstmt() (localctx IShowmodelstmtContext) { + localctx = NewShowmodelstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1276, RedshiftParserRULE_showmodelstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11210) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11211) + p.Match(RedshiftParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(11212) + p.Qualified_name() + } + + case RedshiftParserALL: + { + p.SetState(11213) + p.Match(RedshiftParserALL) + 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 +} + +// IShowprocedurestmtContext is an interface to support dynamic dispatch. +type IShowprocedurestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Func_args() IFunc_argsContext + + // IsShowprocedurestmtContext differentiates from other interfaces. + IsShowprocedurestmtContext() +} + +type ShowprocedurestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowprocedurestmtContext() *ShowprocedurestmtContext { + var p = new(ShowprocedurestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showprocedurestmt + return p +} + +func InitEmptyShowprocedurestmtContext(p *ShowprocedurestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showprocedurestmt +} + +func (*ShowprocedurestmtContext) IsShowprocedurestmtContext() {} + +func NewShowprocedurestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowprocedurestmtContext { + var p = new(ShowprocedurestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showprocedurestmt + + return p +} + +func (s *ShowprocedurestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowprocedurestmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowprocedurestmtContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *ShowprocedurestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ShowprocedurestmtContext) Func_args() IFunc_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_argsContext) +} + +func (s *ShowprocedurestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowprocedurestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowprocedurestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowprocedurestmt(s) + } +} + +func (s *ShowprocedurestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowprocedurestmt(s) + } +} + +func (s *ShowprocedurestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowprocedurestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showprocedurestmt() (localctx IShowprocedurestmtContext) { + localctx = NewShowprocedurestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1278, RedshiftParserRULE_showprocedurestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11216) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11217) + p.Match(RedshiftParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11218) + p.Qualified_name() + } + p.SetState(11220) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 961, p.GetParserRuleContext()) == 1 { + { + p.SetState(11219) + p.Func_args() + } + + } 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 +} + +// IShowschemasstmtContext is an interface to support dynamic dispatch. +type IShowschemasstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + FROM() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Colid() IColidContext + LIKE() antlr.TerminalNode + Sconst() ISconstContext + LIMIT() antlr.TerminalNode + Iconst() IIconstContext + + // IsShowschemasstmtContext differentiates from other interfaces. + IsShowschemasstmtContext() +} + +type ShowschemasstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowschemasstmtContext() *ShowschemasstmtContext { + var p = new(ShowschemasstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showschemasstmt + return p +} + +func InitEmptyShowschemasstmtContext(p *ShowschemasstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showschemasstmt +} + +func (*ShowschemasstmtContext) IsShowschemasstmtContext() {} + +func NewShowschemasstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowschemasstmtContext { + var p = new(ShowschemasstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showschemasstmt + + return p +} + +func (s *ShowschemasstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowschemasstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowschemasstmtContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMAS, 0) +} + +func (s *ShowschemasstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *ShowschemasstmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *ShowschemasstmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ShowschemasstmtContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *ShowschemasstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ShowschemasstmtContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *ShowschemasstmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *ShowschemasstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowschemasstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowschemasstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowschemasstmt(s) + } +} + +func (s *ShowschemasstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowschemasstmt(s) + } +} + +func (s *ShowschemasstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowschemasstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showschemasstmt() (localctx IShowschemasstmtContext) { + localctx = NewShowschemasstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1280, RedshiftParserRULE_showschemasstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11222) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11223) + p.Match(RedshiftParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(11224) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11225) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11226) + p.Colid() + } + + } + p.SetState(11231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIKE { + { + p.SetState(11229) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11230) + p.Sconst() + } + + } + p.SetState(11235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIMIT { + { + p.SetState(11233) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11234) + p.Iconst() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowtablestmtContext is an interface to support dynamic dispatch. +type IShowtablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + TABLE() antlr.TerminalNode + Qualified_name() IQualified_nameContext + + // IsShowtablestmtContext differentiates from other interfaces. + IsShowtablestmtContext() +} + +type ShowtablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowtablestmtContext() *ShowtablestmtContext { + var p = new(ShowtablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showtablestmt + return p +} + +func InitEmptyShowtablestmtContext(p *ShowtablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showtablestmt +} + +func (*ShowtablestmtContext) IsShowtablestmtContext() {} + +func NewShowtablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowtablestmtContext { + var p = new(ShowtablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showtablestmt + + return p +} + +func (s *ShowtablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowtablestmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowtablestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *ShowtablestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ShowtablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowtablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowtablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowtablestmt(s) + } +} + +func (s *ShowtablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowtablestmt(s) + } +} + +func (s *ShowtablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowtablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showtablestmt() (localctx IShowtablestmtContext) { + localctx = NewShowtablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1282, RedshiftParserRULE_showtablestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11237) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11238) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11239) + p.Qualified_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShowtablesstmtContext is an interface to support dynamic dispatch. +type IShowtablesstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IColidContext + + // GetSchema_name returns the schema_name rule contexts. + GetSchema_name() IColidContext + + // GetPattern returns the pattern rule contexts. + GetPattern() ISconstContext + + // GetLimit_value returns the limit_value rule contexts. + GetLimit_value() IIconstContext + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IColidContext) + + // SetSchema_name sets the schema_name rule contexts. + SetSchema_name(IColidContext) + + // SetPattern sets the pattern rule contexts. + SetPattern(ISconstContext) + + // SetLimit_value sets the limit_value rule contexts. + SetLimit_value(IIconstContext) + + // Getter signatures + SHOW() antlr.TerminalNode + TABLES() antlr.TerminalNode + FROM() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + DOT() antlr.TerminalNode + AllColid() []IColidContext + Colid(i int) IColidContext + LIKE() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Sconst() ISconstContext + Iconst() IIconstContext + + // IsShowtablesstmtContext differentiates from other interfaces. + IsShowtablesstmtContext() +} + +type ShowtablesstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IColidContext + schema_name IColidContext + pattern ISconstContext + limit_value IIconstContext +} + +func NewEmptyShowtablesstmtContext() *ShowtablesstmtContext { + var p = new(ShowtablesstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showtablesstmt + return p +} + +func InitEmptyShowtablesstmtContext(p *ShowtablesstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showtablesstmt +} + +func (*ShowtablesstmtContext) IsShowtablesstmtContext() {} + +func NewShowtablesstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowtablesstmtContext { + var p = new(ShowtablesstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showtablesstmt + + return p +} + +func (s *ShowtablesstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowtablesstmtContext) GetDatabase_name() IColidContext { return s.database_name } + +func (s *ShowtablesstmtContext) GetSchema_name() IColidContext { return s.schema_name } + +func (s *ShowtablesstmtContext) GetPattern() ISconstContext { return s.pattern } + +func (s *ShowtablesstmtContext) GetLimit_value() IIconstContext { return s.limit_value } + +func (s *ShowtablesstmtContext) SetDatabase_name(v IColidContext) { s.database_name = v } + +func (s *ShowtablesstmtContext) SetSchema_name(v IColidContext) { s.schema_name = v } + +func (s *ShowtablesstmtContext) SetPattern(v ISconstContext) { s.pattern = v } + +func (s *ShowtablesstmtContext) SetLimit_value(v IIconstContext) { s.limit_value = v } + +func (s *ShowtablesstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowtablesstmtContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *ShowtablesstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *ShowtablesstmtContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *ShowtablesstmtContext) DOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, 0) +} + +func (s *ShowtablesstmtContext) AllColid() []IColidContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColidContext); ok { + len++ + } + } + + tst := make([]IColidContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColidContext); ok { + tst[i] = t.(IColidContext) + i++ + } + } + + return tst +} + +func (s *ShowtablesstmtContext) Colid(i int) IColidContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ShowtablesstmtContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *ShowtablesstmtContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *ShowtablesstmtContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ShowtablesstmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *ShowtablesstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowtablesstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowtablesstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowtablesstmt(s) + } +} + +func (s *ShowtablesstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowtablesstmt(s) + } +} + +func (s *ShowtablesstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowtablesstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showtablesstmt() (localctx IShowtablesstmtContext) { + localctx = NewShowtablesstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1284, RedshiftParserRULE_showtablesstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11241) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11242) + p.Match(RedshiftParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11243) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11244) + p.Match(RedshiftParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11245) + + var _x = p.Colid() + + localctx.(*ShowtablesstmtContext).database_name = _x + } + { + p.SetState(11246) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11247) + + var _x = p.Colid() + + localctx.(*ShowtablesstmtContext).schema_name = _x + } + p.SetState(11250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIKE { + { + p.SetState(11248) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11249) + + var _x = p.Sconst() + + localctx.(*ShowtablesstmtContext).pattern = _x + } + + } + p.SetState(11254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLIMIT { + { + p.SetState(11252) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11253) + + var _x = p.Iconst() + + localctx.(*ShowtablesstmtContext).limit_value = _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 +} + +// IShowviewstmtContext is an interface to support dynamic dispatch. +type IShowviewstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + VIEW() antlr.TerminalNode + Qualified_name() IQualified_nameContext + + // IsShowviewstmtContext differentiates from other interfaces. + IsShowviewstmtContext() +} + +type ShowviewstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShowviewstmtContext() *ShowviewstmtContext { + var p = new(ShowviewstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showviewstmt + return p +} + +func InitEmptyShowviewstmtContext(p *ShowviewstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_showviewstmt +} + +func (*ShowviewstmtContext) IsShowviewstmtContext() {} + +func NewShowviewstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShowviewstmtContext { + var p = new(ShowviewstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_showviewstmt + + return p +} + +func (s *ShowviewstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ShowviewstmtContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *ShowviewstmtContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *ShowviewstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ShowviewstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ShowviewstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ShowviewstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterShowviewstmt(s) + } +} + +func (s *ShowviewstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitShowviewstmt(s) + } +} + +func (s *ShowviewstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitShowviewstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Showviewstmt() (localctx IShowviewstmtContext) { + localctx = NewShowviewstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1286, RedshiftParserRULE_showviewstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11256) + p.Match(RedshiftParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11257) + p.Match(RedshiftParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11258) + p.Qualified_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnloadstmtContext is an interface to support dynamic dispatch. +type IUnloadstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNLOAD() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + CLOSE_PAREN() antlr.TerminalNode + TO() antlr.TerminalNode + Iamroleclause() IIamroleclauseContext + AllUnloadoptions() []IUnloadoptionsContext + Unloadoptions(i int) IUnloadoptionsContext + + // IsUnloadstmtContext differentiates from other interfaces. + IsUnloadstmtContext() +} + +type UnloadstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnloadstmtContext() *UnloadstmtContext { + var p = new(UnloadstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unloadstmt + return p +} + +func InitEmptyUnloadstmtContext(p *UnloadstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unloadstmt +} + +func (*UnloadstmtContext) IsUnloadstmtContext() {} + +func NewUnloadstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnloadstmtContext { + var p = new(UnloadstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_unloadstmt + + return p +} + +func (s *UnloadstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnloadstmtContext) UNLOAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLOAD, 0) +} + +func (s *UnloadstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *UnloadstmtContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *UnloadstmtContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *UnloadstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *UnloadstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *UnloadstmtContext) Iamroleclause() IIamroleclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIamroleclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIamroleclauseContext) +} + +func (s *UnloadstmtContext) AllUnloadoptions() []IUnloadoptionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnloadoptionsContext); ok { + len++ + } + } + + tst := make([]IUnloadoptionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnloadoptionsContext); ok { + tst[i] = t.(IUnloadoptionsContext) + i++ + } + } + + return tst +} + +func (s *UnloadstmtContext) Unloadoptions(i int) IUnloadoptionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnloadoptionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnloadoptionsContext) +} + +func (s *UnloadstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnloadstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnloadstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUnloadstmt(s) + } +} + +func (s *UnloadstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUnloadstmt(s) + } +} + +func (s *UnloadstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUnloadstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Unloadstmt() (localctx IUnloadstmtContext) { + localctx = NewUnloadstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1288, RedshiftParserRULE_unloadstmt) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11260) + p.Match(RedshiftParserUNLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11261) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11262) + p.Sconst() + } + { + p.SetState(11263) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11264) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11265) + p.Sconst() + } + { + p.SetState(11266) + p.Iamroleclause() + } + p.SetState(11270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 967, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11267) + p.Unloadoptions() + } + + } + p.SetState(11272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 967, 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 +} + +// IIamroleclauseContext is an interface to support dynamic dispatch. +type IIamroleclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IAM_ROLE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Sconst() ISconstContext + + // IsIamroleclauseContext differentiates from other interfaces. + IsIamroleclauseContext() +} + +type IamroleclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIamroleclauseContext() *IamroleclauseContext { + var p = new(IamroleclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamroleclause + return p +} + +func InitEmptyIamroleclauseContext(p *IamroleclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iamroleclause +} + +func (*IamroleclauseContext) IsIamroleclauseContext() {} + +func NewIamroleclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IamroleclauseContext { + var p = new(IamroleclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_iamroleclause + + return p +} + +func (s *IamroleclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *IamroleclauseContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *IamroleclauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *IamroleclauseContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *IamroleclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IamroleclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IamroleclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIamroleclause(s) + } +} + +func (s *IamroleclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIamroleclause(s) + } +} + +func (s *IamroleclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIamroleclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Iamroleclause() (localctx IIamroleclauseContext) { + localctx = NewIamroleclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1290, RedshiftParserRULE_iamroleclause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11273) + p.Match(RedshiftParserIAM_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDEFAULT: + { + p.SetState(11274) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(11275) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnloadoptionsContext is an interface to support dynamic dispatch. +type IUnloadoptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Formatoption() IFormatoptionContext + Partitionbyoption() IPartitionbyoptionContext + Manifestoption() IManifestoptionContext + Headeroption() IHeaderoptionContext + Delimiteroption() IDelimiteroptionContext + Fixedwidthoption() IFixedwidthoptionContext + Encryptedoption() IEncryptedoptionContext + Kmskeyoption() IKmskeyoptionContext + Compressionoption() ICompressionoptionContext + Addquotesoption() IAddquotesoptionContext + Nullasoption() INullasoptionContext + Escapeoption() IEscapeoptionContext + Allowoverwriteoption() IAllowoverwriteoptionContext + Cleanpathoption() ICleanpathoptionContext + Paralleloption() IParalleloptionContext + Maxfilesizeoption() IMaxfilesizeoptionContext + Rowgroupsizeoption() IRowgroupsizeoptionContext + Regionoption() IRegionoptionContext + Extensionoption() IExtensionoptionContext + + // IsUnloadoptionsContext differentiates from other interfaces. + IsUnloadoptionsContext() +} + +type UnloadoptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnloadoptionsContext() *UnloadoptionsContext { + var p = new(UnloadoptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unloadoptions + return p +} + +func InitEmptyUnloadoptionsContext(p *UnloadoptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unloadoptions +} + +func (*UnloadoptionsContext) IsUnloadoptionsContext() {} + +func NewUnloadoptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnloadoptionsContext { + var p = new(UnloadoptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_unloadoptions + + return p +} + +func (s *UnloadoptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnloadoptionsContext) Formatoption() IFormatoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormatoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFormatoptionContext) +} + +func (s *UnloadoptionsContext) Partitionbyoption() IPartitionbyoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitionbyoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitionbyoptionContext) +} + +func (s *UnloadoptionsContext) Manifestoption() IManifestoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IManifestoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IManifestoptionContext) +} + +func (s *UnloadoptionsContext) Headeroption() IHeaderoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHeaderoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHeaderoptionContext) +} + +func (s *UnloadoptionsContext) Delimiteroption() IDelimiteroptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelimiteroptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelimiteroptionContext) +} + +func (s *UnloadoptionsContext) Fixedwidthoption() IFixedwidthoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFixedwidthoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFixedwidthoptionContext) +} + +func (s *UnloadoptionsContext) Encryptedoption() IEncryptedoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryptedoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryptedoptionContext) +} + +func (s *UnloadoptionsContext) Kmskeyoption() IKmskeyoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKmskeyoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKmskeyoptionContext) +} + +func (s *UnloadoptionsContext) Compressionoption() ICompressionoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompressionoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompressionoptionContext) +} + +func (s *UnloadoptionsContext) Addquotesoption() IAddquotesoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAddquotesoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAddquotesoptionContext) +} + +func (s *UnloadoptionsContext) Nullasoption() INullasoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INullasoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INullasoptionContext) +} + +func (s *UnloadoptionsContext) Escapeoption() IEscapeoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEscapeoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEscapeoptionContext) +} + +func (s *UnloadoptionsContext) Allowoverwriteoption() IAllowoverwriteoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllowoverwriteoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllowoverwriteoptionContext) +} + +func (s *UnloadoptionsContext) Cleanpathoption() ICleanpathoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICleanpathoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICleanpathoptionContext) +} + +func (s *UnloadoptionsContext) Paralleloption() IParalleloptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParalleloptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParalleloptionContext) +} + +func (s *UnloadoptionsContext) Maxfilesizeoption() IMaxfilesizeoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaxfilesizeoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaxfilesizeoptionContext) +} + +func (s *UnloadoptionsContext) Rowgroupsizeoption() IRowgroupsizeoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowgroupsizeoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowgroupsizeoptionContext) +} + +func (s *UnloadoptionsContext) Regionoption() IRegionoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegionoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegionoptionContext) +} + +func (s *UnloadoptionsContext) Extensionoption() IExtensionoptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtensionoptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtensionoptionContext) +} + +func (s *UnloadoptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnloadoptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnloadoptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUnloadoptions(s) + } +} + +func (s *UnloadoptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUnloadoptions(s) + } +} + +func (s *UnloadoptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUnloadoptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Unloadoptions() (localctx IUnloadoptionsContext) { + localctx = NewUnloadoptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1292, RedshiftParserRULE_unloadoptions) + p.SetState(11297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 969, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11278) + p.Formatoption() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11279) + p.Partitionbyoption() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11280) + p.Manifestoption() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11281) + p.Headeroption() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11282) + p.Delimiteroption() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11283) + p.Fixedwidthoption() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11284) + p.Encryptedoption() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11285) + p.Kmskeyoption() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(11286) + p.Compressionoption() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(11287) + p.Addquotesoption() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(11288) + p.Nullasoption() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(11289) + p.Escapeoption() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(11290) + p.Allowoverwriteoption() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(11291) + p.Cleanpathoption() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(11292) + p.Paralleloption() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(11293) + p.Maxfilesizeoption() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(11294) + p.Rowgroupsizeoption() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(11295) + p.Regionoption() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(11296) + p.Extensionoption() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFormatoptionContext is an interface to support dynamic dispatch. +type IFormatoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORMAT() antlr.TerminalNode + CSV() antlr.TerminalNode + PARQUET() antlr.TerminalNode + JSON() antlr.TerminalNode + + // IsFormatoptionContext differentiates from other interfaces. + IsFormatoptionContext() +} + +type FormatoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFormatoptionContext() *FormatoptionContext { + var p = new(FormatoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_formatoption + return p +} + +func InitEmptyFormatoptionContext(p *FormatoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_formatoption +} + +func (*FormatoptionContext) IsFormatoptionContext() {} + +func NewFormatoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FormatoptionContext { + var p = new(FormatoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_formatoption + + return p +} + +func (s *FormatoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *FormatoptionContext) FORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORMAT, 0) +} + +func (s *FormatoptionContext) CSV() antlr.TerminalNode { + return s.GetToken(RedshiftParserCSV, 0) +} + +func (s *FormatoptionContext) PARQUET() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARQUET, 0) +} + +func (s *FormatoptionContext) JSON() antlr.TerminalNode { + return s.GetToken(RedshiftParserJSON, 0) +} + +func (s *FormatoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FormatoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FormatoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFormatoption(s) + } +} + +func (s *FormatoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFormatoption(s) + } +} + +func (s *FormatoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFormatoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Formatoption() (localctx IFormatoptionContext) { + localctx = NewFormatoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1294, RedshiftParserRULE_formatoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11299) + p.Match(RedshiftParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11300) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCSV || _la == RedshiftParserJSON || _la == RedshiftParserPARQUET) { + 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 +} + +// IPartitionbyoptionContext is an interface to support dynamic dispatch. +type IPartitionbyoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + INCLUDE() antlr.TerminalNode + + // IsPartitionbyoptionContext differentiates from other interfaces. + IsPartitionbyoptionContext() +} + +type PartitionbyoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitionbyoptionContext() *PartitionbyoptionContext { + var p = new(PartitionbyoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partitionbyoption + return p +} + +func InitEmptyPartitionbyoptionContext(p *PartitionbyoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_partitionbyoption +} + +func (*PartitionbyoptionContext) IsPartitionbyoptionContext() {} + +func NewPartitionbyoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PartitionbyoptionContext { + var p = new(PartitionbyoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_partitionbyoption + + return p +} + +func (s *PartitionbyoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *PartitionbyoptionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *PartitionbyoptionContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *PartitionbyoptionContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *PartitionbyoptionContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *PartitionbyoptionContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *PartitionbyoptionContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDE, 0) +} + +func (s *PartitionbyoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PartitionbyoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PartitionbyoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPartitionbyoption(s) + } +} + +func (s *PartitionbyoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPartitionbyoption(s) + } +} + +func (s *PartitionbyoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPartitionbyoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Partitionbyoption() (localctx IPartitionbyoptionContext) { + localctx = NewPartitionbyoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1296, RedshiftParserRULE_partitionbyoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11302) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11303) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11304) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11305) + p.Columnlist() + } + { + p.SetState(11306) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11308) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 970, p.GetParserRuleContext()) == 1 { + { + p.SetState(11307) + p.Match(RedshiftParserINCLUDE) + 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 +} + +// IManifestoptionContext is an interface to support dynamic dispatch. +type IManifestoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MANIFEST() antlr.TerminalNode + VERBOSE() antlr.TerminalNode + + // IsManifestoptionContext differentiates from other interfaces. + IsManifestoptionContext() +} + +type ManifestoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyManifestoptionContext() *ManifestoptionContext { + var p = new(ManifestoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_manifestoption + return p +} + +func InitEmptyManifestoptionContext(p *ManifestoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_manifestoption +} + +func (*ManifestoptionContext) IsManifestoptionContext() {} + +func NewManifestoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ManifestoptionContext { + var p = new(ManifestoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_manifestoption + + return p +} + +func (s *ManifestoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ManifestoptionContext) MANIFEST() antlr.TerminalNode { + return s.GetToken(RedshiftParserMANIFEST, 0) +} + +func (s *ManifestoptionContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERBOSE, 0) +} + +func (s *ManifestoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ManifestoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ManifestoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterManifestoption(s) + } +} + +func (s *ManifestoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitManifestoption(s) + } +} + +func (s *ManifestoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitManifestoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Manifestoption() (localctx IManifestoptionContext) { + localctx = NewManifestoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1298, RedshiftParserRULE_manifestoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11310) + p.Match(RedshiftParserMANIFEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERBOSE { + { + p.SetState(11311) + p.Match(RedshiftParserVERBOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHeaderoptionContext is an interface to support dynamic dispatch. +type IHeaderoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HEADER_P() antlr.TerminalNode + + // IsHeaderoptionContext differentiates from other interfaces. + IsHeaderoptionContext() +} + +type HeaderoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHeaderoptionContext() *HeaderoptionContext { + var p = new(HeaderoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_headeroption + return p +} + +func InitEmptyHeaderoptionContext(p *HeaderoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_headeroption +} + +func (*HeaderoptionContext) IsHeaderoptionContext() {} + +func NewHeaderoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HeaderoptionContext { + var p = new(HeaderoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_headeroption + + return p +} + +func (s *HeaderoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *HeaderoptionContext) HEADER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserHEADER_P, 0) +} + +func (s *HeaderoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *HeaderoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *HeaderoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHeaderoption(s) + } +} + +func (s *HeaderoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHeaderoption(s) + } +} + +func (s *HeaderoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHeaderoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Headeroption() (localctx IHeaderoptionContext) { + localctx = NewHeaderoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1300, RedshiftParserRULE_headeroption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11314) + p.Match(RedshiftParserHEADER_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelimiteroptionContext is an interface to support dynamic dispatch. +type IDelimiteroptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITER() antlr.TerminalNode + Sconst() ISconstContext + AS() antlr.TerminalNode + + // IsDelimiteroptionContext differentiates from other interfaces. + IsDelimiteroptionContext() +} + +type DelimiteroptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelimiteroptionContext() *DelimiteroptionContext { + var p = new(DelimiteroptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_delimiteroption + return p +} + +func InitEmptyDelimiteroptionContext(p *DelimiteroptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_delimiteroption +} + +func (*DelimiteroptionContext) IsDelimiteroptionContext() {} + +func NewDelimiteroptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DelimiteroptionContext { + var p = new(DelimiteroptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_delimiteroption + + return p +} + +func (s *DelimiteroptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *DelimiteroptionContext) DELIMITER() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELIMITER, 0) +} + +func (s *DelimiteroptionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *DelimiteroptionContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *DelimiteroptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DelimiteroptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DelimiteroptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDelimiteroption(s) + } +} + +func (s *DelimiteroptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDelimiteroption(s) + } +} + +func (s *DelimiteroptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDelimiteroption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Delimiteroption() (localctx IDelimiteroptionContext) { + localctx = NewDelimiteroptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1302, RedshiftParserRULE_delimiteroption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11316) + p.Match(RedshiftParserDELIMITER) + 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 == RedshiftParserAS { + { + p.SetState(11317) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11320) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFixedwidthoptionContext is an interface to support dynamic dispatch. +type IFixedwidthoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FIXEDWIDTH() antlr.TerminalNode + Sconst() ISconstContext + + // IsFixedwidthoptionContext differentiates from other interfaces. + IsFixedwidthoptionContext() +} + +type FixedwidthoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFixedwidthoptionContext() *FixedwidthoptionContext { + var p = new(FixedwidthoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fixedwidthoption + return p +} + +func InitEmptyFixedwidthoptionContext(p *FixedwidthoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fixedwidthoption +} + +func (*FixedwidthoptionContext) IsFixedwidthoptionContext() {} + +func NewFixedwidthoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FixedwidthoptionContext { + var p = new(FixedwidthoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fixedwidthoption + + return p +} + +func (s *FixedwidthoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *FixedwidthoptionContext) FIXEDWIDTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIXEDWIDTH, 0) +} + +func (s *FixedwidthoptionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *FixedwidthoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FixedwidthoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FixedwidthoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFixedwidthoption(s) + } +} + +func (s *FixedwidthoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFixedwidthoption(s) + } +} + +func (s *FixedwidthoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFixedwidthoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fixedwidthoption() (localctx IFixedwidthoptionContext) { + localctx = NewFixedwidthoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1304, RedshiftParserRULE_fixedwidthoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11322) + p.Match(RedshiftParserFIXEDWIDTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11323) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEncryptedoptionContext is an interface to support dynamic dispatch. +type IEncryptedoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTED() antlr.TerminalNode + AUTO() antlr.TerminalNode + + // IsEncryptedoptionContext differentiates from other interfaces. + IsEncryptedoptionContext() +} + +type EncryptedoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEncryptedoptionContext() *EncryptedoptionContext { + var p = new(EncryptedoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_encryptedoption + return p +} + +func InitEmptyEncryptedoptionContext(p *EncryptedoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_encryptedoption +} + +func (*EncryptedoptionContext) IsEncryptedoptionContext() {} + +func NewEncryptedoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EncryptedoptionContext { + var p = new(EncryptedoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_encryptedoption + + return p +} + +func (s *EncryptedoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *EncryptedoptionContext) ENCRYPTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCRYPTED, 0) +} + +func (s *EncryptedoptionContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *EncryptedoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EncryptedoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EncryptedoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEncryptedoption(s) + } +} + +func (s *EncryptedoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEncryptedoption(s) + } +} + +func (s *EncryptedoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEncryptedoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Encryptedoption() (localctx IEncryptedoptionContext) { + localctx = NewEncryptedoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1306, RedshiftParserRULE_encryptedoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11325) + p.Match(RedshiftParserENCRYPTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11327) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 973, p.GetParserRuleContext()) == 1 { + { + p.SetState(11326) + p.Match(RedshiftParserAUTO) + 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 +} + +// IKmskeyoptionContext is an interface to support dynamic dispatch. +type IKmskeyoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KMS_KEY_ID() antlr.TerminalNode + Sconst() ISconstContext + + // IsKmskeyoptionContext differentiates from other interfaces. + IsKmskeyoptionContext() +} + +type KmskeyoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKmskeyoptionContext() *KmskeyoptionContext { + var p = new(KmskeyoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_kmskeyoption + return p +} + +func InitEmptyKmskeyoptionContext(p *KmskeyoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_kmskeyoption +} + +func (*KmskeyoptionContext) IsKmskeyoptionContext() {} + +func NewKmskeyoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KmskeyoptionContext { + var p = new(KmskeyoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_kmskeyoption + + return p +} + +func (s *KmskeyoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *KmskeyoptionContext) KMS_KEY_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserKMS_KEY_ID, 0) +} + +func (s *KmskeyoptionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *KmskeyoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KmskeyoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KmskeyoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterKmskeyoption(s) + } +} + +func (s *KmskeyoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitKmskeyoption(s) + } +} + +func (s *KmskeyoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitKmskeyoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Kmskeyoption() (localctx IKmskeyoptionContext) { + localctx = NewKmskeyoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1308, RedshiftParserRULE_kmskeyoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11329) + p.Match(RedshiftParserKMS_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11330) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompressionoptionContext is an interface to support dynamic dispatch. +type ICompressionoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BZIP2() antlr.TerminalNode + GZIP() antlr.TerminalNode + ZSTD() antlr.TerminalNode + + // IsCompressionoptionContext differentiates from other interfaces. + IsCompressionoptionContext() +} + +type CompressionoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompressionoptionContext() *CompressionoptionContext { + var p = new(CompressionoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_compressionoption + return p +} + +func InitEmptyCompressionoptionContext(p *CompressionoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_compressionoption +} + +func (*CompressionoptionContext) IsCompressionoptionContext() {} + +func NewCompressionoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompressionoptionContext { + var p = new(CompressionoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_compressionoption + + return p +} + +func (s *CompressionoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CompressionoptionContext) BZIP2() antlr.TerminalNode { + return s.GetToken(RedshiftParserBZIP2, 0) +} + +func (s *CompressionoptionContext) GZIP() antlr.TerminalNode { + return s.GetToken(RedshiftParserGZIP, 0) +} + +func (s *CompressionoptionContext) ZSTD() antlr.TerminalNode { + return s.GetToken(RedshiftParserZSTD, 0) +} + +func (s *CompressionoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CompressionoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CompressionoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCompressionoption(s) + } +} + +func (s *CompressionoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCompressionoption(s) + } +} + +func (s *CompressionoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCompressionoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Compressionoption() (localctx ICompressionoptionContext) { + localctx = NewCompressionoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1310, RedshiftParserRULE_compressionoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11332) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-451)) & ^0x3f) == 0 && ((int64(1)<<(_la-451))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAddquotesoptionContext is an interface to support dynamic dispatch. +type IAddquotesoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADDQUOTES() antlr.TerminalNode + + // IsAddquotesoptionContext differentiates from other interfaces. + IsAddquotesoptionContext() +} + +type AddquotesoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAddquotesoptionContext() *AddquotesoptionContext { + var p = new(AddquotesoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_addquotesoption + return p +} + +func InitEmptyAddquotesoptionContext(p *AddquotesoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_addquotesoption +} + +func (*AddquotesoptionContext) IsAddquotesoptionContext() {} + +func NewAddquotesoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AddquotesoptionContext { + var p = new(AddquotesoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_addquotesoption + + return p +} + +func (s *AddquotesoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AddquotesoptionContext) ADDQUOTES() antlr.TerminalNode { + return s.GetToken(RedshiftParserADDQUOTES, 0) +} + +func (s *AddquotesoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AddquotesoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AddquotesoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAddquotesoption(s) + } +} + +func (s *AddquotesoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAddquotesoption(s) + } +} + +func (s *AddquotesoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAddquotesoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Addquotesoption() (localctx IAddquotesoptionContext) { + localctx = NewAddquotesoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1312, RedshiftParserRULE_addquotesoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11334) + p.Match(RedshiftParserADDQUOTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INullasoptionContext is an interface to support dynamic dispatch. +type INullasoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_P() antlr.TerminalNode + AS() antlr.TerminalNode + Sconst() ISconstContext + + // IsNullasoptionContext differentiates from other interfaces. + IsNullasoptionContext() +} + +type NullasoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNullasoptionContext() *NullasoptionContext { + var p = new(NullasoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_nullasoption + return p +} + +func InitEmptyNullasoptionContext(p *NullasoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_nullasoption +} + +func (*NullasoptionContext) IsNullasoptionContext() {} + +func NewNullasoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NullasoptionContext { + var p = new(NullasoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_nullasoption + + return p +} + +func (s *NullasoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *NullasoptionContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *NullasoptionContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *NullasoptionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *NullasoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NullasoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NullasoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNullasoption(s) + } +} + +func (s *NullasoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNullasoption(s) + } +} + +func (s *NullasoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNullasoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Nullasoption() (localctx INullasoptionContext) { + localctx = NewNullasoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1314, RedshiftParserRULE_nullasoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11336) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11337) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11338) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEscapeoptionContext is an interface to support dynamic dispatch. +type IEscapeoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ESCAPE() antlr.TerminalNode + + // IsEscapeoptionContext differentiates from other interfaces. + IsEscapeoptionContext() +} + +type EscapeoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEscapeoptionContext() *EscapeoptionContext { + var p = new(EscapeoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_escapeoption + return p +} + +func InitEmptyEscapeoptionContext(p *EscapeoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_escapeoption +} + +func (*EscapeoptionContext) IsEscapeoptionContext() {} + +func NewEscapeoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EscapeoptionContext { + var p = new(EscapeoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_escapeoption + + return p +} + +func (s *EscapeoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *EscapeoptionContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserESCAPE, 0) +} + +func (s *EscapeoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EscapeoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EscapeoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEscapeoption(s) + } +} + +func (s *EscapeoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEscapeoption(s) + } +} + +func (s *EscapeoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEscapeoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Escapeoption() (localctx IEscapeoptionContext) { + localctx = NewEscapeoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1316, RedshiftParserRULE_escapeoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11340) + p.Match(RedshiftParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAllowoverwriteoptionContext is an interface to support dynamic dispatch. +type IAllowoverwriteoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALLOWOVERWRITE() antlr.TerminalNode + + // IsAllowoverwriteoptionContext differentiates from other interfaces. + IsAllowoverwriteoptionContext() +} + +type AllowoverwriteoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAllowoverwriteoptionContext() *AllowoverwriteoptionContext { + var p = new(AllowoverwriteoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_allowoverwriteoption + return p +} + +func InitEmptyAllowoverwriteoptionContext(p *AllowoverwriteoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_allowoverwriteoption +} + +func (*AllowoverwriteoptionContext) IsAllowoverwriteoptionContext() {} + +func NewAllowoverwriteoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AllowoverwriteoptionContext { + var p = new(AllowoverwriteoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_allowoverwriteoption + + return p +} + +func (s *AllowoverwriteoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *AllowoverwriteoptionContext) ALLOWOVERWRITE() antlr.TerminalNode { + return s.GetToken(RedshiftParserALLOWOVERWRITE, 0) +} + +func (s *AllowoverwriteoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AllowoverwriteoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AllowoverwriteoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAllowoverwriteoption(s) + } +} + +func (s *AllowoverwriteoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAllowoverwriteoption(s) + } +} + +func (s *AllowoverwriteoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAllowoverwriteoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Allowoverwriteoption() (localctx IAllowoverwriteoptionContext) { + localctx = NewAllowoverwriteoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1318, RedshiftParserRULE_allowoverwriteoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11342) + p.Match(RedshiftParserALLOWOVERWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICleanpathoptionContext is an interface to support dynamic dispatch. +type ICleanpathoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLEANPATH() antlr.TerminalNode + + // IsCleanpathoptionContext differentiates from other interfaces. + IsCleanpathoptionContext() +} + +type CleanpathoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCleanpathoptionContext() *CleanpathoptionContext { + var p = new(CleanpathoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cleanpathoption + return p +} + +func InitEmptyCleanpathoptionContext(p *CleanpathoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cleanpathoption +} + +func (*CleanpathoptionContext) IsCleanpathoptionContext() {} + +func NewCleanpathoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CleanpathoptionContext { + var p = new(CleanpathoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cleanpathoption + + return p +} + +func (s *CleanpathoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CleanpathoptionContext) CLEANPATH() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLEANPATH, 0) +} + +func (s *CleanpathoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CleanpathoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CleanpathoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCleanpathoption(s) + } +} + +func (s *CleanpathoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCleanpathoption(s) + } +} + +func (s *CleanpathoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCleanpathoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cleanpathoption() (localctx ICleanpathoptionContext) { + localctx = NewCleanpathoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1320, RedshiftParserRULE_cleanpathoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11344) + p.Match(RedshiftParserCLEANPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParalleloptionContext is an interface to support dynamic dispatch. +type IParalleloptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARALLEL() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsParalleloptionContext differentiates from other interfaces. + IsParalleloptionContext() +} + +type ParalleloptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParalleloptionContext() *ParalleloptionContext { + var p = new(ParalleloptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_paralleloption + return p +} + +func InitEmptyParalleloptionContext(p *ParalleloptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_paralleloption +} + +func (*ParalleloptionContext) IsParalleloptionContext() {} + +func NewParalleloptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParalleloptionContext { + var p = new(ParalleloptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_paralleloption + + return p +} + +func (s *ParalleloptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParalleloptionContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARALLEL, 0) +} + +func (s *ParalleloptionContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *ParalleloptionContext) OFF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFF, 0) +} + +func (s *ParalleloptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParalleloptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParalleloptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterParalleloption(s) + } +} + +func (s *ParalleloptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitParalleloption(s) + } +} + +func (s *ParalleloptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitParalleloption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Paralleloption() (localctx IParalleloptionContext) { + localctx = NewParalleloptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1322, RedshiftParserRULE_paralleloption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11346) + p.Match(RedshiftParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11347) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserON || _la == RedshiftParserOFF) { + 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 +} + +// IMaxfilesizeoptionContext is an interface to support dynamic dispatch. +type IMaxfilesizeoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAXFILESIZE() antlr.TerminalNode + Iconst() IIconstContext + AS() antlr.TerminalNode + Sizeunit() ISizeunitContext + + // IsMaxfilesizeoptionContext differentiates from other interfaces. + IsMaxfilesizeoptionContext() +} + +type MaxfilesizeoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaxfilesizeoptionContext() *MaxfilesizeoptionContext { + var p = new(MaxfilesizeoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_maxfilesizeoption + return p +} + +func InitEmptyMaxfilesizeoptionContext(p *MaxfilesizeoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_maxfilesizeoption +} + +func (*MaxfilesizeoptionContext) IsMaxfilesizeoptionContext() {} + +func NewMaxfilesizeoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MaxfilesizeoptionContext { + var p = new(MaxfilesizeoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_maxfilesizeoption + + return p +} + +func (s *MaxfilesizeoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *MaxfilesizeoptionContext) MAXFILESIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAXFILESIZE, 0) +} + +func (s *MaxfilesizeoptionContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *MaxfilesizeoptionContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *MaxfilesizeoptionContext) Sizeunit() ISizeunitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISizeunitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISizeunitContext) +} + +func (s *MaxfilesizeoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MaxfilesizeoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MaxfilesizeoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMaxfilesizeoption(s) + } +} + +func (s *MaxfilesizeoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMaxfilesizeoption(s) + } +} + +func (s *MaxfilesizeoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMaxfilesizeoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Maxfilesizeoption() (localctx IMaxfilesizeoptionContext) { + localctx = NewMaxfilesizeoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1324, RedshiftParserRULE_maxfilesizeoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11349) + p.Match(RedshiftParserMAXFILESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(11350) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11353) + p.Iconst() + } + p.SetState(11355) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 975, p.GetParserRuleContext()) == 1 { + { + p.SetState(11354) + p.Sizeunit() + } + + } 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 +} + +// IRowgroupsizeoptionContext is an interface to support dynamic dispatch. +type IRowgroupsizeoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROWGROUPSIZE() antlr.TerminalNode + Iconst() IIconstContext + AS() antlr.TerminalNode + Sizeunit() ISizeunitContext + + // IsRowgroupsizeoptionContext differentiates from other interfaces. + IsRowgroupsizeoptionContext() +} + +type RowgroupsizeoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowgroupsizeoptionContext() *RowgroupsizeoptionContext { + var p = new(RowgroupsizeoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowgroupsizeoption + return p +} + +func InitEmptyRowgroupsizeoptionContext(p *RowgroupsizeoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowgroupsizeoption +} + +func (*RowgroupsizeoptionContext) IsRowgroupsizeoptionContext() {} + +func NewRowgroupsizeoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowgroupsizeoptionContext { + var p = new(RowgroupsizeoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowgroupsizeoption + + return p +} + +func (s *RowgroupsizeoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowgroupsizeoptionContext) ROWGROUPSIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWGROUPSIZE, 0) +} + +func (s *RowgroupsizeoptionContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *RowgroupsizeoptionContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *RowgroupsizeoptionContext) Sizeunit() ISizeunitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISizeunitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISizeunitContext) +} + +func (s *RowgroupsizeoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowgroupsizeoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowgroupsizeoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowgroupsizeoption(s) + } +} + +func (s *RowgroupsizeoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowgroupsizeoption(s) + } +} + +func (s *RowgroupsizeoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowgroupsizeoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowgroupsizeoption() (localctx IRowgroupsizeoptionContext) { + localctx = NewRowgroupsizeoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1326, RedshiftParserRULE_rowgroupsizeoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11357) + p.Match(RedshiftParserROWGROUPSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(11358) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11361) + p.Iconst() + } + p.SetState(11363) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 977, p.GetParserRuleContext()) == 1 { + { + p.SetState(11362) + p.Sizeunit() + } + + } 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 +} + +// ISizeunitContext is an interface to support dynamic dispatch. +type ISizeunitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MB() antlr.TerminalNode + GB() antlr.TerminalNode + + // IsSizeunitContext differentiates from other interfaces. + IsSizeunitContext() +} + +type SizeunitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySizeunitContext() *SizeunitContext { + var p = new(SizeunitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sizeunit + return p +} + +func InitEmptySizeunitContext(p *SizeunitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sizeunit +} + +func (*SizeunitContext) IsSizeunitContext() {} + +func NewSizeunitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SizeunitContext { + var p = new(SizeunitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sizeunit + + return p +} + +func (s *SizeunitContext) GetParser() antlr.Parser { return s.parser } + +func (s *SizeunitContext) MB() antlr.TerminalNode { + return s.GetToken(RedshiftParserMB, 0) +} + +func (s *SizeunitContext) GB() antlr.TerminalNode { + return s.GetToken(RedshiftParserGB, 0) +} + +func (s *SizeunitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SizeunitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SizeunitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSizeunit(s) + } +} + +func (s *SizeunitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSizeunit(s) + } +} + +func (s *SizeunitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSizeunit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sizeunit() (localctx ISizeunitContext) { + localctx = NewSizeunitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1328, RedshiftParserRULE_sizeunit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11365) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserMB || _la == RedshiftParserGB) { + 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 +} + +// IRegionoptionContext is an interface to support dynamic dispatch. +type IRegionoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Sconst() ISconstContext + AS() antlr.TerminalNode + + // IsRegionoptionContext differentiates from other interfaces. + IsRegionoptionContext() +} + +type RegionoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRegionoptionContext() *RegionoptionContext { + var p = new(RegionoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_regionoption + return p +} + +func InitEmptyRegionoptionContext(p *RegionoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_regionoption +} + +func (*RegionoptionContext) IsRegionoptionContext() {} + +func NewRegionoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RegionoptionContext { + var p = new(RegionoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_regionoption + + return p +} + +func (s *RegionoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *RegionoptionContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *RegionoptionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *RegionoptionContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *RegionoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RegionoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RegionoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRegionoption(s) + } +} + +func (s *RegionoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRegionoption(s) + } +} + +func (s *RegionoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRegionoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Regionoption() (localctx IRegionoptionContext) { + localctx = NewRegionoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1330, RedshiftParserRULE_regionoption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11367) + p.Colid() + } + p.SetState(11369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(11368) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11371) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtensionoptionContext is an interface to support dynamic dispatch. +type IExtensionoptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTENSION() antlr.TerminalNode + Sconst() ISconstContext + + // IsExtensionoptionContext differentiates from other interfaces. + IsExtensionoptionContext() +} + +type ExtensionoptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtensionoptionContext() *ExtensionoptionContext { + var p = new(ExtensionoptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extensionoption + return p +} + +func InitEmptyExtensionoptionContext(p *ExtensionoptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extensionoption +} + +func (*ExtensionoptionContext) IsExtensionoptionContext() {} + +func NewExtensionoptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExtensionoptionContext { + var p = new(ExtensionoptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_extensionoption + + return p +} + +func (s *ExtensionoptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExtensionoptionContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *ExtensionoptionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *ExtensionoptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExtensionoptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExtensionoptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExtensionoption(s) + } +} + +func (s *ExtensionoptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExtensionoption(s) + } +} + +func (s *ExtensionoptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExtensionoption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Extensionoption() (localctx IExtensionoptionContext) { + localctx = NewExtensionoptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1332, RedshiftParserRULE_extensionoption) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11373) + p.Match(RedshiftParserEXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11374) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsestmtContext is an interface to support dynamic dispatch. +type IUsestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatabase_name returns the database_name rule contexts. + GetDatabase_name() IColidContext + + // SetDatabase_name sets the database_name rule contexts. + SetDatabase_name(IColidContext) + + // Getter signatures + USE() antlr.TerminalNode + Colid() IColidContext + + // IsUsestmtContext differentiates from other interfaces. + IsUsestmtContext() +} + +type UsestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + database_name IColidContext +} + +func NewEmptyUsestmtContext() *UsestmtContext { + var p = new(UsestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_usestmt + return p +} + +func InitEmptyUsestmtContext(p *UsestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_usestmt +} + +func (*UsestmtContext) IsUsestmtContext() {} + +func NewUsestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UsestmtContext { + var p = new(UsestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_usestmt + + return p +} + +func (s *UsestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *UsestmtContext) GetDatabase_name() IColidContext { return s.database_name } + +func (s *UsestmtContext) SetDatabase_name(v IColidContext) { s.database_name = v } + +func (s *UsestmtContext) USE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSE, 0) +} + +func (s *UsestmtContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *UsestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UsestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UsestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUsestmt(s) + } +} + +func (s *UsestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUsestmt(s) + } +} + +func (s *UsestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUsestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Usestmt() (localctx IUsestmtContext) { + localctx = NewUsestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1334, RedshiftParserRULE_usestmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11376) + p.Match(RedshiftParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11377) + + var _x = p.Colid() + + localctx.(*UsestmtContext).database_name = _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 +} + +// ICreatedbstmtContext is an interface to support dynamic dispatch. +type ICreatedbstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Name() INameContext + Opt_with() IOpt_withContext + Createdb_opt_list() ICreatedb_opt_listContext + + // IsCreatedbstmtContext differentiates from other interfaces. + IsCreatedbstmtContext() +} + +type CreatedbstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedbstmtContext() *CreatedbstmtContext { + var p = new(CreatedbstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdbstmt + return p +} + +func InitEmptyCreatedbstmtContext(p *CreatedbstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdbstmt +} + +func (*CreatedbstmtContext) IsCreatedbstmtContext() {} + +func NewCreatedbstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedbstmtContext { + var p = new(CreatedbstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdbstmt + + return p +} + +func (s *CreatedbstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatedbstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatedbstmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *CreatedbstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *CreatedbstmtContext) Opt_with() IOpt_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_withContext) +} + +func (s *CreatedbstmtContext) Createdb_opt_list() ICreatedb_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedb_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedb_opt_listContext) +} + +func (s *CreatedbstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatedbstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatedbstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedbstmt(s) + } +} + +func (s *CreatedbstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedbstmt(s) + } +} + +func (s *CreatedbstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedbstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdbstmt() (localctx ICreatedbstmtContext) { + localctx = NewCreatedbstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1336, RedshiftParserRULE_createdbstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11379) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11380) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11381) + p.Name() + } + p.SetState(11383) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 979, p.GetParserRuleContext()) == 1 { + { + p.SetState(11382) + p.Opt_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11386) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) == 1 { + { + p.SetState(11385) + p.Createdb_opt_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 +} + +// ICreatedb_opt_listContext is an interface to support dynamic dispatch. +type ICreatedb_opt_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Createdb_opt_items() ICreatedb_opt_itemsContext + + // IsCreatedb_opt_listContext differentiates from other interfaces. + IsCreatedb_opt_listContext() +} + +type Createdb_opt_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedb_opt_listContext() *Createdb_opt_listContext { + var p = new(Createdb_opt_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_list + return p +} + +func InitEmptyCreatedb_opt_listContext(p *Createdb_opt_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_list +} + +func (*Createdb_opt_listContext) IsCreatedb_opt_listContext() {} + +func NewCreatedb_opt_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_listContext { + var p = new(Createdb_opt_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdb_opt_list + + return p +} + +func (s *Createdb_opt_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Createdb_opt_listContext) Createdb_opt_items() ICreatedb_opt_itemsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedb_opt_itemsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedb_opt_itemsContext) +} + +func (s *Createdb_opt_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Createdb_opt_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Createdb_opt_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedb_opt_list(s) + } +} + +func (s *Createdb_opt_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedb_opt_list(s) + } +} + +func (s *Createdb_opt_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedb_opt_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdb_opt_list() (localctx ICreatedb_opt_listContext) { + localctx = NewCreatedb_opt_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1338, RedshiftParserRULE_createdb_opt_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11388) + p.Createdb_opt_items() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatedb_opt_itemsContext is an interface to support dynamic dispatch. +type ICreatedb_opt_itemsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCreatedb_opt_item() []ICreatedb_opt_itemContext + Createdb_opt_item(i int) ICreatedb_opt_itemContext + + // IsCreatedb_opt_itemsContext differentiates from other interfaces. + IsCreatedb_opt_itemsContext() +} + +type Createdb_opt_itemsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedb_opt_itemsContext() *Createdb_opt_itemsContext { + var p = new(Createdb_opt_itemsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_items + return p +} + +func InitEmptyCreatedb_opt_itemsContext(p *Createdb_opt_itemsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_items +} + +func (*Createdb_opt_itemsContext) IsCreatedb_opt_itemsContext() {} + +func NewCreatedb_opt_itemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_itemsContext { + var p = new(Createdb_opt_itemsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdb_opt_items + + return p +} + +func (s *Createdb_opt_itemsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Createdb_opt_itemsContext) AllCreatedb_opt_item() []ICreatedb_opt_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICreatedb_opt_itemContext); ok { + len++ + } + } + + tst := make([]ICreatedb_opt_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICreatedb_opt_itemContext); ok { + tst[i] = t.(ICreatedb_opt_itemContext) + i++ + } + } + + return tst +} + +func (s *Createdb_opt_itemsContext) Createdb_opt_item(i int) ICreatedb_opt_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedb_opt_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICreatedb_opt_itemContext) +} + +func (s *Createdb_opt_itemsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Createdb_opt_itemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Createdb_opt_itemsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedb_opt_items(s) + } +} + +func (s *Createdb_opt_itemsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedb_opt_items(s) + } +} + +func (s *Createdb_opt_itemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedb_opt_items(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdb_opt_items() (localctx ICreatedb_opt_itemsContext) { + localctx = NewCreatedb_opt_itemsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1340, RedshiftParserRULE_createdb_opt_items) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11391) + 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(11390) + p.Createdb_opt_item() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11393) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 981, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatedb_opt_itemContext is an interface to support dynamic dispatch. +type ICreatedb_opt_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Createdb_opt_name() ICreatedb_opt_nameContext + Signediconst() ISignediconstContext + Opt_boolean_or_string() IOpt_boolean_or_stringContext + DEFAULT() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + Opt_equal() IOpt_equalContext + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + COLLATE() antlr.TerminalNode + CASE_SENSITIVE() antlr.TerminalNode + CASE_INSENSITIVE() antlr.TerminalNode + CI() antlr.TerminalNode + CS() antlr.TerminalNode + + // IsCreatedb_opt_itemContext differentiates from other interfaces. + IsCreatedb_opt_itemContext() +} + +type Createdb_opt_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedb_opt_itemContext() *Createdb_opt_itemContext { + var p = new(Createdb_opt_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_item + return p +} + +func InitEmptyCreatedb_opt_itemContext(p *Createdb_opt_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_item +} + +func (*Createdb_opt_itemContext) IsCreatedb_opt_itemContext() {} + +func NewCreatedb_opt_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_itemContext { + var p = new(Createdb_opt_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdb_opt_item + + return p +} + +func (s *Createdb_opt_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Createdb_opt_itemContext) Createdb_opt_name() ICreatedb_opt_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedb_opt_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedb_opt_nameContext) +} + +func (s *Createdb_opt_itemContext) Signediconst() ISignediconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignediconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignediconstContext) +} + +func (s *Createdb_opt_itemContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_boolean_or_stringContext) +} + +func (s *Createdb_opt_itemContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Createdb_opt_itemContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLIMITED, 0) +} + +func (s *Createdb_opt_itemContext) Opt_equal() IOpt_equalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_equalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_equalContext) +} + +func (s *Createdb_opt_itemContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserISOLATION, 0) +} + +func (s *Createdb_opt_itemContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *Createdb_opt_itemContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERIALIZABLE, 0) +} + +func (s *Createdb_opt_itemContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSNAPSHOT, 0) +} + +func (s *Createdb_opt_itemContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Createdb_opt_itemContext) CASE_SENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_SENSITIVE, 0) +} + +func (s *Createdb_opt_itemContext) CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_INSENSITIVE, 0) +} + +func (s *Createdb_opt_itemContext) CI() antlr.TerminalNode { + return s.GetToken(RedshiftParserCI, 0) +} + +func (s *Createdb_opt_itemContext) CS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCS, 0) +} + +func (s *Createdb_opt_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Createdb_opt_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Createdb_opt_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedb_opt_item(s) + } +} + +func (s *Createdb_opt_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedb_opt_item(s) + } +} + +func (s *Createdb_opt_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedb_opt_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdb_opt_item() (localctx ICreatedb_opt_itemContext) { + localctx = NewCreatedb_opt_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1342, RedshiftParserRULE_createdb_opt_item) + var _la int + + p.SetState(11410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 984, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11395) + p.Createdb_opt_name() + } + p.SetState(11397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEQUAL { + { + p.SetState(11396) + p.Opt_equal() + } + + } + p.SetState(11403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 983, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11399) + p.Signediconst() + } + + case 2: + { + p.SetState(11400) + p.Opt_boolean_or_string() + } + + case 3: + { + p.SetState(11401) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(11402) + p.Match(RedshiftParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11405) + p.Match(RedshiftParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11406) + p.Match(RedshiftParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11407) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserSERIALIZABLE || _la == RedshiftParserSNAPSHOT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11408) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11409) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCI || _la == RedshiftParserCS || _la == RedshiftParserCASE_SENSITIVE || _la == RedshiftParserCASE_INSENSITIVE) { + 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 +} + +// ICreatedb_opt_nameContext is an interface to support dynamic dispatch. +type ICreatedb_opt_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + CONNECTION() antlr.TerminalNode + LIMIT() antlr.TerminalNode + ENCODING() antlr.TerminalNode + LOCATION() antlr.TerminalNode + OWNER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + + // IsCreatedb_opt_nameContext differentiates from other interfaces. + IsCreatedb_opt_nameContext() +} + +type Createdb_opt_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedb_opt_nameContext() *Createdb_opt_nameContext { + var p = new(Createdb_opt_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_name + return p +} + +func InitEmptyCreatedb_opt_nameContext(p *Createdb_opt_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdb_opt_name +} + +func (*Createdb_opt_nameContext) IsCreatedb_opt_nameContext() {} + +func NewCreatedb_opt_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Createdb_opt_nameContext { + var p = new(Createdb_opt_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdb_opt_name + + return p +} + +func (s *Createdb_opt_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Createdb_opt_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Createdb_opt_nameContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECTION, 0) +} + +func (s *Createdb_opt_nameContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *Createdb_opt_nameContext) ENCODING() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODING, 0) +} + +func (s *Createdb_opt_nameContext) LOCATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCATION, 0) +} + +func (s *Createdb_opt_nameContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *Createdb_opt_nameContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *Createdb_opt_nameContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPLATE, 0) +} + +func (s *Createdb_opt_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Createdb_opt_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Createdb_opt_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedb_opt_name(s) + } +} + +func (s *Createdb_opt_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedb_opt_name(s) + } +} + +func (s *Createdb_opt_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedb_opt_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdb_opt_name() (localctx ICreatedb_opt_nameContext) { + localctx = NewCreatedb_opt_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1344, RedshiftParserRULE_createdb_opt_name) + p.SetState(11420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserOUTER_P, RedshiftParserABSOLUTE_P, RedshiftParserBACKWARD, RedshiftParserCHAIN, RedshiftParserCLOSE, RedshiftParserCOMMIT, RedshiftParserCONTINUE_P, RedshiftParserCURSOR, RedshiftParserFIRST_P, RedshiftParserFORWARD, RedshiftParserINSERT, RedshiftParserLAST_P, RedshiftParserMOVE, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserOPTION, RedshiftParserPRIOR, RedshiftParserRELATIVE_P, RedshiftParserRESET, RedshiftParserROLLBACK, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSET, RedshiftParserTYPE_P, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserROWTYPE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11412) + p.Identifier() + } + + case RedshiftParserCONNECTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11413) + p.Match(RedshiftParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11414) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserENCODING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11415) + p.Match(RedshiftParserENCODING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserLOCATION: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11416) + p.Match(RedshiftParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserOWNER: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11417) + p.Match(RedshiftParserOWNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserTABLESPACE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11418) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserTEMPLATE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11419) + p.Match(RedshiftParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_equalContext is an interface to support dynamic dispatch. +type IOpt_equalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL() antlr.TerminalNode + + // IsOpt_equalContext differentiates from other interfaces. + IsOpt_equalContext() +} + +type Opt_equalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_equalContext() *Opt_equalContext { + var p = new(Opt_equalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_equal + return p +} + +func InitEmptyOpt_equalContext(p *Opt_equalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_equal +} + +func (*Opt_equalContext) IsOpt_equalContext() {} + +func NewOpt_equalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_equalContext { + var p = new(Opt_equalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_equal + + return p +} + +func (s *Opt_equalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_equalContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Opt_equalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_equalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_equalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_equal(s) + } +} + +func (s *Opt_equalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_equal(s) + } +} + +func (s *Opt_equalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_equal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_equal() (localctx IOpt_equalContext) { + localctx = NewOpt_equalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1346, RedshiftParserRULE_opt_equal) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11422) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterdatabasestmtContext is an interface to support dynamic dispatch. +type IAlterdatabasestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllName() []INameContext + Name(i int) INameContext + WITH() antlr.TerminalNode + SET() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + REFRESH() antlr.TerminalNode + COLLATION() antlr.TerminalNode + VERSION_P() antlr.TerminalNode + COLLATE() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + LIMIT() antlr.TerminalNode + CASE_SENSITIVE() antlr.TerminalNode + CASE_INSENSITIVE() antlr.TerminalNode + Iconst() IIconstContext + UNLIMITED() antlr.TerminalNode + Createdb_opt_list() ICreatedb_opt_listContext + + // IsAlterdatabasestmtContext differentiates from other interfaces. + IsAlterdatabasestmtContext() +} + +type AlterdatabasestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdatabasestmtContext() *AlterdatabasestmtContext { + var p = new(AlterdatabasestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatabasestmt + return p +} + +func InitEmptyAlterdatabasestmtContext(p *AlterdatabasestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatabasestmt +} + +func (*AlterdatabasestmtContext) IsAlterdatabasestmtContext() {} + +func NewAlterdatabasestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdatabasestmtContext { + var p = new(AlterdatabasestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdatabasestmt + + return p +} + +func (s *AlterdatabasestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterdatabasestmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterdatabasestmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *AlterdatabasestmtContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *AlterdatabasestmtContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterdatabasestmtContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *AlterdatabasestmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlterdatabasestmtContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *AlterdatabasestmtContext) REFRESH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFRESH, 0) +} + +func (s *AlterdatabasestmtContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *AlterdatabasestmtContext) VERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERSION_P, 0) +} + +func (s *AlterdatabasestmtContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *AlterdatabasestmtContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECTION, 0) +} + +func (s *AlterdatabasestmtContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *AlterdatabasestmtContext) CASE_SENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_SENSITIVE, 0) +} + +func (s *AlterdatabasestmtContext) CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE_INSENSITIVE, 0) +} + +func (s *AlterdatabasestmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *AlterdatabasestmtContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLIMITED, 0) +} + +func (s *AlterdatabasestmtContext) Createdb_opt_list() ICreatedb_opt_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatedb_opt_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatedb_opt_listContext) +} + +func (s *AlterdatabasestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterdatabasestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterdatabasestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdatabasestmt(s) + } +} + +func (s *AlterdatabasestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdatabasestmt(s) + } +} + +func (s *AlterdatabasestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdatabasestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdatabasestmt() (localctx IAlterdatabasestmtContext) { + localctx = NewAlterdatabasestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1348, RedshiftParserRULE_alterdatabasestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11424) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11425) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11426) + p.Name() + } + p.SetState(11448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 989, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11427) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11429) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 986, p.GetParserRuleContext()) == 1 { + { + p.SetState(11428) + p.Createdb_opt_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(11432) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 987, p.GetParserRuleContext()) == 1 { + { + p.SetState(11431) + p.Createdb_opt_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(11434) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11435) + p.Match(RedshiftParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11436) + p.Name() + } + + case 4: + { + p.SetState(11437) + p.Match(RedshiftParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11438) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11439) + p.Match(RedshiftParserVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(11440) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11441) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCASE_SENSITIVE || _la == RedshiftParserCASE_INSENSITIVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 6: + { + p.SetState(11442) + p.Match(RedshiftParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11443) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + { + p.SetState(11444) + p.Iconst() + } + + case RedshiftParserUNLIMITED: + { + p.SetState(11445) + p.Match(RedshiftParserUNLIMITED) + 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 +} + +// IAlterdatabasesetstmtContext is an interface to support dynamic dispatch. +type IAlterdatabasesetstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Name() INameContext + Setresetclause() ISetresetclauseContext + + // IsAlterdatabasesetstmtContext differentiates from other interfaces. + IsAlterdatabasesetstmtContext() +} + +type AlterdatabasesetstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdatabasesetstmtContext() *AlterdatabasesetstmtContext { + var p = new(AlterdatabasesetstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatabasesetstmt + return p +} + +func InitEmptyAlterdatabasesetstmtContext(p *AlterdatabasesetstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdatabasesetstmt +} + +func (*AlterdatabasesetstmtContext) IsAlterdatabasesetstmtContext() {} + +func NewAlterdatabasesetstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdatabasesetstmtContext { + var p = new(AlterdatabasesetstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdatabasesetstmt + + return p +} + +func (s *AlterdatabasesetstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterdatabasesetstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterdatabasesetstmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *AlterdatabasesetstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterdatabasesetstmtContext) Setresetclause() ISetresetclauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetresetclauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetresetclauseContext) +} + +func (s *AlterdatabasesetstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterdatabasesetstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterdatabasesetstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdatabasesetstmt(s) + } +} + +func (s *AlterdatabasesetstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdatabasesetstmt(s) + } +} + +func (s *AlterdatabasesetstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdatabasesetstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdatabasesetstmt() (localctx IAlterdatabasesetstmtContext) { + localctx = NewAlterdatabasesetstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1350, RedshiftParserRULE_alterdatabasesetstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11450) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11451) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11452) + p.Name() + } + { + p.SetState(11453) + p.Setresetclause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDropdbstmtContext is an interface to support dynamic dispatch. +type IDropdbstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Name() INameContext + + // IsDropdbstmtContext differentiates from other interfaces. + IsDropdbstmtContext() +} + +type DropdbstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDropdbstmtContext() *DropdbstmtContext { + var p = new(DropdbstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropdbstmt + return p +} + +func InitEmptyDropdbstmtContext(p *DropdbstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_dropdbstmt +} + +func (*DropdbstmtContext) IsDropdbstmtContext() {} + +func NewDropdbstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DropdbstmtContext { + var p = new(DropdbstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_dropdbstmt + + return p +} + +func (s *DropdbstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DropdbstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *DropdbstmtContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *DropdbstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DropdbstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DropdbstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DropdbstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDropdbstmt(s) + } +} + +func (s *DropdbstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDropdbstmt(s) + } +} + +func (s *DropdbstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDropdbstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Dropdbstmt() (localctx IDropdbstmtContext) { + localctx = NewDropdbstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1352, RedshiftParserRULE_dropdbstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11455) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11456) + p.Match(RedshiftParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11457) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_option_listContext is an interface to support dynamic dispatch. +type IDrop_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDrop_option() []IDrop_optionContext + Drop_option(i int) IDrop_optionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_option_listContext differentiates from other interfaces. + IsDrop_option_listContext() +} + +type Drop_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_option_listContext() *Drop_option_listContext { + var p = new(Drop_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_drop_option_list + return p +} + +func InitEmptyDrop_option_listContext(p *Drop_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_drop_option_list +} + +func (*Drop_option_listContext) IsDrop_option_listContext() {} + +func NewDrop_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_option_listContext { + var p = new(Drop_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_drop_option_list + + return p +} + +func (s *Drop_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_option_listContext) AllDrop_option() []IDrop_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_optionContext); ok { + len++ + } + } + + tst := make([]IDrop_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_optionContext); ok { + tst[i] = t.(IDrop_optionContext) + i++ + } + } + + return tst +} + +func (s *Drop_option_listContext) Drop_option(i int) IDrop_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_optionContext) +} + +func (s *Drop_option_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Drop_option_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Drop_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDrop_option_list(s) + } +} + +func (s *Drop_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDrop_option_list(s) + } +} + +func (s *Drop_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDrop_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Drop_option_list() (localctx IDrop_option_listContext) { + localctx = NewDrop_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1354, RedshiftParserRULE_drop_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11459) + p.Drop_option() + } + p.SetState(11464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(11460) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11461) + p.Drop_option() + } + + p.SetState(11466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_optionContext is an interface to support dynamic dispatch. +type IDrop_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORCE() antlr.TerminalNode + + // IsDrop_optionContext differentiates from other interfaces. + IsDrop_optionContext() +} + +type Drop_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_optionContext() *Drop_optionContext { + var p = new(Drop_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_drop_option + return p +} + +func InitEmptyDrop_optionContext(p *Drop_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_drop_option +} + +func (*Drop_optionContext) IsDrop_optionContext() {} + +func NewDrop_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_optionContext { + var p = new(Drop_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_drop_option + + return p +} + +func (s *Drop_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_optionContext) FORCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORCE, 0) +} + +func (s *Drop_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDrop_option(s) + } +} + +func (s *Drop_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDrop_option(s) + } +} + +func (s *Drop_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDrop_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Drop_option() (localctx IDrop_optionContext) { + localctx = NewDrop_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1356, RedshiftParserRULE_drop_option) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11467) + p.Match(RedshiftParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltercollationstmtContext is an interface to support dynamic dispatch. +type IAltercollationstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + COLLATION() antlr.TerminalNode + Any_name() IAny_nameContext + REFRESH() antlr.TerminalNode + VERSION_P() antlr.TerminalNode + + // IsAltercollationstmtContext differentiates from other interfaces. + IsAltercollationstmtContext() +} + +type AltercollationstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltercollationstmtContext() *AltercollationstmtContext { + var p = new(AltercollationstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altercollationstmt + return p +} + +func InitEmptyAltercollationstmtContext(p *AltercollationstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altercollationstmt +} + +func (*AltercollationstmtContext) IsAltercollationstmtContext() {} + +func NewAltercollationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltercollationstmtContext { + var p = new(AltercollationstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altercollationstmt + + return p +} + +func (s *AltercollationstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltercollationstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltercollationstmtContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *AltercollationstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AltercollationstmtContext) REFRESH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFRESH, 0) +} + +func (s *AltercollationstmtContext) VERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERSION_P, 0) +} + +func (s *AltercollationstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltercollationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltercollationstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltercollationstmt(s) + } +} + +func (s *AltercollationstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltercollationstmt(s) + } +} + +func (s *AltercollationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltercollationstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altercollationstmt() (localctx IAltercollationstmtContext) { + localctx = NewAltercollationstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1358, RedshiftParserRULE_altercollationstmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11469) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11470) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11471) + p.Any_name() + } + { + p.SetState(11472) + p.Match(RedshiftParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11473) + p.Match(RedshiftParserVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltersystemstmtContext is an interface to support dynamic dispatch. +type IAltersystemstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SYSTEM_P() antlr.TerminalNode + Generic_set() IGeneric_setContext + SET() antlr.TerminalNode + RESET() antlr.TerminalNode + + // IsAltersystemstmtContext differentiates from other interfaces. + IsAltersystemstmtContext() +} + +type AltersystemstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltersystemstmtContext() *AltersystemstmtContext { + var p = new(AltersystemstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altersystemstmt + return p +} + +func InitEmptyAltersystemstmtContext(p *AltersystemstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altersystemstmt +} + +func (*AltersystemstmtContext) IsAltersystemstmtContext() {} + +func NewAltersystemstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltersystemstmtContext { + var p = new(AltersystemstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altersystemstmt + + return p +} + +func (s *AltersystemstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltersystemstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltersystemstmtContext) SYSTEM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSTEM_P, 0) +} + +func (s *AltersystemstmtContext) Generic_set() IGeneric_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneric_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneric_setContext) +} + +func (s *AltersystemstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AltersystemstmtContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *AltersystemstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltersystemstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltersystemstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltersystemstmt(s) + } +} + +func (s *AltersystemstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltersystemstmt(s) + } +} + +func (s *AltersystemstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltersystemstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altersystemstmt() (localctx IAltersystemstmtContext) { + localctx = NewAltersystemstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1360, RedshiftParserRULE_altersystemstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11475) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11476) + p.Match(RedshiftParserSYSTEM_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11477) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserRESET || _la == RedshiftParserSET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11478) + p.Generic_set() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreatedomainstmtContext is an interface to support dynamic dispatch. +type ICreatedomainstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DOMAIN_P() antlr.TerminalNode + Any_name() IAny_nameContext + Typename() ITypenameContext + Colquallist() IColquallistContext + Opt_as() IOpt_asContext + + // IsCreatedomainstmtContext differentiates from other interfaces. + IsCreatedomainstmtContext() +} + +type CreatedomainstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreatedomainstmtContext() *CreatedomainstmtContext { + var p = new(CreatedomainstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdomainstmt + return p +} + +func InitEmptyCreatedomainstmtContext(p *CreatedomainstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createdomainstmt +} + +func (*CreatedomainstmtContext) IsCreatedomainstmtContext() {} + +func NewCreatedomainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreatedomainstmtContext { + var p = new(CreatedomainstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createdomainstmt + + return p +} + +func (s *CreatedomainstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreatedomainstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreatedomainstmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *CreatedomainstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *CreatedomainstmtContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *CreatedomainstmtContext) Colquallist() IColquallistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColquallistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColquallistContext) +} + +func (s *CreatedomainstmtContext) Opt_as() IOpt_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_asContext) +} + +func (s *CreatedomainstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreatedomainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreatedomainstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreatedomainstmt(s) + } +} + +func (s *CreatedomainstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreatedomainstmt(s) + } +} + +func (s *CreatedomainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreatedomainstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createdomainstmt() (localctx ICreatedomainstmtContext) { + localctx = NewCreatedomainstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1362, RedshiftParserRULE_createdomainstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11480) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11481) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11482) + p.Any_name() + } + p.SetState(11484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(11483) + p.Opt_as() + } + + } + { + p.SetState(11486) + p.Typename() + } + { + p.SetState(11487) + p.Colquallist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlterdomainstmtContext is an interface to support dynamic dispatch. +type IAlterdomainstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DOMAIN_P() antlr.TerminalNode + Any_name() IAny_nameContext + Alter_column_default() IAlter_column_defaultContext + DROP() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_P() antlr.TerminalNode + SET() antlr.TerminalNode + ADD_P() antlr.TerminalNode + Tableconstraint() ITableconstraintContext + CONSTRAINT() antlr.TerminalNode + Name() INameContext + VALIDATE() antlr.TerminalNode + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + Opt_drop_behavior() IOpt_drop_behaviorContext + + // IsAlterdomainstmtContext differentiates from other interfaces. + IsAlterdomainstmtContext() +} + +type AlterdomainstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlterdomainstmtContext() *AlterdomainstmtContext { + var p = new(AlterdomainstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdomainstmt + return p +} + +func InitEmptyAlterdomainstmtContext(p *AlterdomainstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alterdomainstmt +} + +func (*AlterdomainstmtContext) IsAlterdomainstmtContext() {} + +func NewAlterdomainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AlterdomainstmtContext { + var p = new(AlterdomainstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alterdomainstmt + + return p +} + +func (s *AlterdomainstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AlterdomainstmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AlterdomainstmtContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *AlterdomainstmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AlterdomainstmtContext) Alter_column_default() IAlter_column_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_column_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_column_defaultContext) +} + +func (s *AlterdomainstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *AlterdomainstmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *AlterdomainstmtContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *AlterdomainstmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *AlterdomainstmtContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *AlterdomainstmtContext) Tableconstraint() ITableconstraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableconstraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableconstraintContext) +} + +func (s *AlterdomainstmtContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *AlterdomainstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *AlterdomainstmtContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALIDATE, 0) +} + +func (s *AlterdomainstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *AlterdomainstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *AlterdomainstmtContext) Opt_drop_behavior() IOpt_drop_behaviorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_drop_behaviorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_drop_behaviorContext) +} + +func (s *AlterdomainstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AlterdomainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AlterdomainstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlterdomainstmt(s) + } +} + +func (s *AlterdomainstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlterdomainstmt(s) + } +} + +func (s *AlterdomainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlterdomainstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alterdomainstmt() (localctx IAlterdomainstmtContext) { + localctx = NewAlterdomainstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1364, RedshiftParserRULE_alterdomainstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11489) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11490) + p.Match(RedshiftParserDOMAIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11491) + p.Any_name() + } + p.SetState(11514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 994, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11492) + p.Alter_column_default() + } + + case 2: + { + p.SetState(11493) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11494) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11495) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(11496) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11497) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11498) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(11499) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11500) + p.Tableconstraint() + } + + case 5: + { + p.SetState(11501) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11502) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11505) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 992, p.GetParserRuleContext()) == 1 { + { + p.SetState(11503) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11504) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11507) + p.Name() + } + p.SetState(11509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCASCADE || _la == RedshiftParserRESTRICT { + { + p.SetState(11508) + p.Opt_drop_behavior() + } + + } + + case 6: + { + p.SetState(11511) + p.Match(RedshiftParserVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11512) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11513) + p.Name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_asContext is an interface to support dynamic dispatch. +type IOpt_asContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + + // IsOpt_asContext differentiates from other interfaces. + IsOpt_asContext() +} + +type Opt_asContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_asContext() *Opt_asContext { + var p = new(Opt_asContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_as + return p +} + +func InitEmptyOpt_asContext(p *Opt_asContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_as +} + +func (*Opt_asContext) IsOpt_asContext() {} + +func NewOpt_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_asContext { + var p = new(Opt_asContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_as + + return p +} + +func (s *Opt_asContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_asContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Opt_asContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_asContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_as(s) + } +} + +func (s *Opt_asContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_as(s) + } +} + +func (s *Opt_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_as(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_as() (localctx IOpt_asContext) { + localctx = NewOpt_asContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1366, RedshiftParserRULE_opt_as) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11516) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltertsdictionarystmtContext is an interface to support dynamic dispatch. +type IAltertsdictionarystmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TEXT_P() antlr.TerminalNode + SEARCH() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + Any_name() IAny_nameContext + Definition() IDefinitionContext + + // IsAltertsdictionarystmtContext differentiates from other interfaces. + IsAltertsdictionarystmtContext() +} + +type AltertsdictionarystmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltertsdictionarystmtContext() *AltertsdictionarystmtContext { + var p = new(AltertsdictionarystmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertsdictionarystmt + return p +} + +func InitEmptyAltertsdictionarystmtContext(p *AltertsdictionarystmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertsdictionarystmt +} + +func (*AltertsdictionarystmtContext) IsAltertsdictionarystmtContext() {} + +func NewAltertsdictionarystmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertsdictionarystmtContext { + var p = new(AltertsdictionarystmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altertsdictionarystmt + + return p +} + +func (s *AltertsdictionarystmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltertsdictionarystmtContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *AltertsdictionarystmtContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *AltertsdictionarystmtContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *AltertsdictionarystmtContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDICTIONARY, 0) +} + +func (s *AltertsdictionarystmtContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AltertsdictionarystmtContext) Definition() IDefinitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefinitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefinitionContext) +} + +func (s *AltertsdictionarystmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltertsdictionarystmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltertsdictionarystmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltertsdictionarystmt(s) + } +} + +func (s *AltertsdictionarystmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltertsdictionarystmt(s) + } +} + +func (s *AltertsdictionarystmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltertsdictionarystmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altertsdictionarystmt() (localctx IAltertsdictionarystmtContext) { + localctx = NewAltertsdictionarystmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1368, RedshiftParserRULE_altertsdictionarystmt) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11518) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11519) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11520) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11521) + p.Match(RedshiftParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11522) + p.Any_name() + } + { + p.SetState(11523) + p.Definition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAltertsconfigurationstmtContext is an interface to support dynamic dispatch. +type IAltertsconfigurationstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllALTER() []antlr.TerminalNode + ALTER(i int) antlr.TerminalNode + TEXT_P() antlr.TerminalNode + SEARCH() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + AllAny_name() []IAny_nameContext + Any_name(i int) IAny_nameContext + ADD_P() antlr.TerminalNode + MAPPING() antlr.TerminalNode + FOR() antlr.TerminalNode + Name_list() IName_listContext + Any_with() IAny_withContext + Any_name_list() IAny_name_listContext + REPLACE() antlr.TerminalNode + DROP() antlr.TerminalNode + IF_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsAltertsconfigurationstmtContext differentiates from other interfaces. + IsAltertsconfigurationstmtContext() +} + +type AltertsconfigurationstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAltertsconfigurationstmtContext() *AltertsconfigurationstmtContext { + var p = new(AltertsconfigurationstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertsconfigurationstmt + return p +} + +func InitEmptyAltertsconfigurationstmtContext(p *AltertsconfigurationstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_altertsconfigurationstmt +} + +func (*AltertsconfigurationstmtContext) IsAltertsconfigurationstmtContext() {} + +func NewAltertsconfigurationstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AltertsconfigurationstmtContext { + var p = new(AltertsconfigurationstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_altertsconfigurationstmt + + return p +} + +func (s *AltertsconfigurationstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AltertsconfigurationstmtContext) AllALTER() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserALTER) +} + +func (s *AltertsconfigurationstmtContext) ALTER(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, i) +} + +func (s *AltertsconfigurationstmtContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *AltertsconfigurationstmtContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *AltertsconfigurationstmtContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFIGURATION, 0) +} + +func (s *AltertsconfigurationstmtContext) AllAny_name() []IAny_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAny_nameContext); ok { + len++ + } + } + + tst := make([]IAny_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAny_nameContext); ok { + tst[i] = t.(IAny_nameContext) + i++ + } + } + + return tst +} + +func (s *AltertsconfigurationstmtContext) Any_name(i int) IAny_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *AltertsconfigurationstmtContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *AltertsconfigurationstmtContext) MAPPING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAPPING, 0) +} + +func (s *AltertsconfigurationstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *AltertsconfigurationstmtContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *AltertsconfigurationstmtContext) Any_with() IAny_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_withContext) +} + +func (s *AltertsconfigurationstmtContext) Any_name_list() IAny_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_name_listContext) +} + +func (s *AltertsconfigurationstmtContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *AltertsconfigurationstmtContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *AltertsconfigurationstmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *AltertsconfigurationstmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *AltertsconfigurationstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AltertsconfigurationstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AltertsconfigurationstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAltertsconfigurationstmt(s) + } +} + +func (s *AltertsconfigurationstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAltertsconfigurationstmt(s) + } +} + +func (s *AltertsconfigurationstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAltertsconfigurationstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Altertsconfigurationstmt() (localctx IAltertsconfigurationstmtContext) { + localctx = NewAltertsconfigurationstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1370, RedshiftParserRULE_altertsconfigurationstmt) + p.SetState(11597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 995, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11525) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11526) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11527) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11528) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11529) + p.Any_name() + } + { + p.SetState(11530) + p.Match(RedshiftParserADD_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11531) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11532) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11533) + p.Name_list() + } + { + p.SetState(11534) + p.Any_with() + } + { + p.SetState(11535) + p.Any_name_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11537) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11538) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11539) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11540) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11541) + p.Any_name() + } + { + p.SetState(11542) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11543) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11544) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11545) + p.Name_list() + } + { + p.SetState(11546) + p.Any_with() + } + { + p.SetState(11547) + p.Any_name_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11549) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11550) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11551) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11552) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11553) + p.Any_name() + } + { + p.SetState(11554) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11555) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11556) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11557) + p.Any_name() + } + { + p.SetState(11558) + p.Any_with() + } + { + p.SetState(11559) + p.Any_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11561) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11562) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11563) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11564) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11565) + p.Any_name() + } + { + p.SetState(11566) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11567) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11568) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11569) + p.Name_list() + } + { + p.SetState(11570) + p.Match(RedshiftParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11571) + p.Any_name() + } + { + p.SetState(11572) + p.Any_with() + } + { + p.SetState(11573) + p.Any_name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11575) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11576) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11577) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11578) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11579) + p.Any_name() + } + { + p.SetState(11580) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11581) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11582) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11583) + p.Name_list() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11585) + p.Match(RedshiftParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11586) + p.Match(RedshiftParserTEXT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11587) + p.Match(RedshiftParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11588) + p.Match(RedshiftParserCONFIGURATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11589) + p.Any_name() + } + { + p.SetState(11590) + p.Match(RedshiftParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11591) + p.Match(RedshiftParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11592) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11593) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11594) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11595) + p.Name_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAny_withContext is an interface to support dynamic dispatch. +type IAny_withContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + + // IsAny_withContext differentiates from other interfaces. + IsAny_withContext() +} + +type Any_withContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAny_withContext() *Any_withContext { + var p = new(Any_withContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_with + return p +} + +func InitEmptyAny_withContext(p *Any_withContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_with +} + +func (*Any_withContext) IsAny_withContext() {} + +func NewAny_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_withContext { + var p = new(Any_withContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_any_with + + return p +} + +func (s *Any_withContext) GetParser() antlr.Parser { return s.parser } + +func (s *Any_withContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Any_withContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Any_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Any_withContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAny_with(s) + } +} + +func (s *Any_withContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAny_with(s) + } +} + +func (s *Any_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAny_with(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Any_with() (localctx IAny_withContext) { + localctx = NewAny_withContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1372, RedshiftParserRULE_any_with) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11599) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreateconversionstmtContext is an interface to support dynamic dispatch. +type ICreateconversionstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CONVERSION_P() antlr.TerminalNode + AllAny_name() []IAny_nameContext + Any_name(i int) IAny_nameContext + FOR() antlr.TerminalNode + AllSconst() []ISconstContext + Sconst(i int) ISconstContext + TO() antlr.TerminalNode + FROM() antlr.TerminalNode + Opt_default() IOpt_defaultContext + + // IsCreateconversionstmtContext differentiates from other interfaces. + IsCreateconversionstmtContext() +} + +type CreateconversionstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreateconversionstmtContext() *CreateconversionstmtContext { + var p = new(CreateconversionstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createconversionstmt + return p +} + +func InitEmptyCreateconversionstmtContext(p *CreateconversionstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_createconversionstmt +} + +func (*CreateconversionstmtContext) IsCreateconversionstmtContext() {} + +func NewCreateconversionstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CreateconversionstmtContext { + var p = new(CreateconversionstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_createconversionstmt + + return p +} + +func (s *CreateconversionstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *CreateconversionstmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *CreateconversionstmtContext) CONVERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONVERSION_P, 0) +} + +func (s *CreateconversionstmtContext) AllAny_name() []IAny_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAny_nameContext); ok { + len++ + } + } + + tst := make([]IAny_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAny_nameContext); ok { + tst[i] = t.(IAny_nameContext) + i++ + } + } + + return tst +} + +func (s *CreateconversionstmtContext) Any_name(i int) IAny_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *CreateconversionstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *CreateconversionstmtContext) AllSconst() []ISconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISconstContext); ok { + len++ + } + } + + tst := make([]ISconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISconstContext); ok { + tst[i] = t.(ISconstContext) + i++ + } + } + + return tst +} + +func (s *CreateconversionstmtContext) Sconst(i int) ISconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *CreateconversionstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *CreateconversionstmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *CreateconversionstmtContext) Opt_default() IOpt_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_defaultContext) +} + +func (s *CreateconversionstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CreateconversionstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CreateconversionstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCreateconversionstmt(s) + } +} + +func (s *CreateconversionstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCreateconversionstmt(s) + } +} + +func (s *CreateconversionstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCreateconversionstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Createconversionstmt() (localctx ICreateconversionstmtContext) { + localctx = NewCreateconversionstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1374, RedshiftParserRULE_createconversionstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11601) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDEFAULT { + { + p.SetState(11602) + p.Opt_default() + } + + } + { + p.SetState(11605) + p.Match(RedshiftParserCONVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11606) + p.Any_name() + } + { + p.SetState(11607) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11608) + p.Sconst() + } + { + p.SetState(11609) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11610) + p.Sconst() + } + { + p.SetState(11611) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11612) + p.Any_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClusterstmtContext is an interface to support dynamic dispatch. +type IClusterstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTER() antlr.TerminalNode + Qualified_name() IQualified_nameContext + Opt_verbose() IOpt_verboseContext + Cluster_index_specification() ICluster_index_specificationContext + Name() INameContext + ON() antlr.TerminalNode + + // IsClusterstmtContext differentiates from other interfaces. + IsClusterstmtContext() +} + +type ClusterstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClusterstmtContext() *ClusterstmtContext { + var p = new(ClusterstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_clusterstmt + return p +} + +func InitEmptyClusterstmtContext(p *ClusterstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_clusterstmt +} + +func (*ClusterstmtContext) IsClusterstmtContext() {} + +func NewClusterstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ClusterstmtContext { + var p = new(ClusterstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_clusterstmt + + return p +} + +func (s *ClusterstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ClusterstmtContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLUSTER, 0) +} + +func (s *ClusterstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *ClusterstmtContext) Opt_verbose() IOpt_verboseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_verboseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_verboseContext) +} + +func (s *ClusterstmtContext) Cluster_index_specification() ICluster_index_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_index_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_index_specificationContext) +} + +func (s *ClusterstmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *ClusterstmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *ClusterstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ClusterstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ClusterstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterClusterstmt(s) + } +} + +func (s *ClusterstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitClusterstmt(s) + } +} + +func (s *ClusterstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitClusterstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Clusterstmt() (localctx IClusterstmtContext) { + localctx = NewClusterstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1376, RedshiftParserRULE_clusterstmt) + var _la int + + p.SetState(11634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1001, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11614) + p.Match(RedshiftParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERBOSE { + { + p.SetState(11615) + p.Opt_verbose() + } + + } + { + p.SetState(11618) + p.Qualified_name() + } + p.SetState(11620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(11619) + p.Cluster_index_specification() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11622) + p.Match(RedshiftParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERBOSE { + { + p.SetState(11623) + p.Opt_verbose() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11626) + p.Match(RedshiftParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERBOSE { + { + p.SetState(11627) + p.Opt_verbose() + } + + } + { + p.SetState(11630) + p.Name() + } + { + p.SetState(11631) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11632) + p.Qualified_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICluster_index_specificationContext is an interface to support dynamic dispatch. +type ICluster_index_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Name() INameContext + + // IsCluster_index_specificationContext differentiates from other interfaces. + IsCluster_index_specificationContext() +} + +type Cluster_index_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_index_specificationContext() *Cluster_index_specificationContext { + var p = new(Cluster_index_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cluster_index_specification + return p +} + +func InitEmptyCluster_index_specificationContext(p *Cluster_index_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cluster_index_specification +} + +func (*Cluster_index_specificationContext) IsCluster_index_specificationContext() {} + +func NewCluster_index_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_index_specificationContext { + var p = new(Cluster_index_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cluster_index_specification + + return p +} + +func (s *Cluster_index_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_index_specificationContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Cluster_index_specificationContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Cluster_index_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_index_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_index_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCluster_index_specification(s) + } +} + +func (s *Cluster_index_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCluster_index_specification(s) + } +} + +func (s *Cluster_index_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCluster_index_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cluster_index_specification() (localctx ICluster_index_specificationContext) { + localctx = NewCluster_index_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1378, RedshiftParserRULE_cluster_index_specification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11636) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11637) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVacuumstmtContext is an interface to support dynamic dispatch. +type IVacuumstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VACUUM() antlr.TerminalNode + Opt_full() IOpt_fullContext + Opt_freeze() IOpt_freezeContext + Opt_verbose() IOpt_verboseContext + Opt_analyze() IOpt_analyzeContext + Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext + OPEN_PAREN() antlr.TerminalNode + Vac_analyze_option_list() IVac_analyze_option_listContext + CLOSE_PAREN() antlr.TerminalNode + Vacuum_option() IVacuum_optionContext + Qualified_name() IQualified_nameContext + TO() antlr.TerminalNode + Iconst() IIconstContext + PERCENT_WORD() antlr.TerminalNode + BOOST() antlr.TerminalNode + + // IsVacuumstmtContext differentiates from other interfaces. + IsVacuumstmtContext() +} + +type VacuumstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVacuumstmtContext() *VacuumstmtContext { + var p = new(VacuumstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuumstmt + return p +} + +func InitEmptyVacuumstmtContext(p *VacuumstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuumstmt +} + +func (*VacuumstmtContext) IsVacuumstmtContext() {} + +func NewVacuumstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VacuumstmtContext { + var p = new(VacuumstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vacuumstmt + + return p +} + +func (s *VacuumstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *VacuumstmtContext) VACUUM() antlr.TerminalNode { + return s.GetToken(RedshiftParserVACUUM, 0) +} + +func (s *VacuumstmtContext) Opt_full() IOpt_fullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_fullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_fullContext) +} + +func (s *VacuumstmtContext) Opt_freeze() IOpt_freezeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_freezeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_freezeContext) +} + +func (s *VacuumstmtContext) Opt_verbose() IOpt_verboseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_verboseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_verboseContext) +} + +func (s *VacuumstmtContext) Opt_analyze() IOpt_analyzeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_analyzeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_analyzeContext) +} + +func (s *VacuumstmtContext) Opt_vacuum_relation_list() IOpt_vacuum_relation_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_vacuum_relation_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_vacuum_relation_listContext) +} + +func (s *VacuumstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *VacuumstmtContext) Vac_analyze_option_list() IVac_analyze_option_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVac_analyze_option_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVac_analyze_option_listContext) +} + +func (s *VacuumstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *VacuumstmtContext) Vacuum_option() IVacuum_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVacuum_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVacuum_optionContext) +} + +func (s *VacuumstmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *VacuumstmtContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *VacuumstmtContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *VacuumstmtContext) PERCENT_WORD() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENT_WORD, 0) +} + +func (s *VacuumstmtContext) BOOST() antlr.TerminalNode { + return s.GetToken(RedshiftParserBOOST, 0) +} + +func (s *VacuumstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VacuumstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VacuumstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVacuumstmt(s) + } +} + +func (s *VacuumstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVacuumstmt(s) + } +} + +func (s *VacuumstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVacuumstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vacuumstmt() (localctx IVacuumstmtContext) { + localctx = NewVacuumstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1380, RedshiftParserRULE_vacuumstmt) + var _la int + + p.SetState(11678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1012, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11639) + p.Match(RedshiftParserVACUUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFULL { + { + p.SetState(11640) + p.Opt_full() + } + + } + p.SetState(11644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFREEZE { + { + p.SetState(11643) + p.Opt_freeze() + } + + } + p.SetState(11647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERBOSE { + { + p.SetState(11646) + p.Opt_verbose() + } + + } + p.SetState(11650) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1005, p.GetParserRuleContext()) == 1 { + { + p.SetState(11649) + p.Opt_analyze() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11653) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1006, p.GetParserRuleContext()) == 1 { + { + p.SetState(11652) + p.Opt_vacuum_relation_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11655) + p.Match(RedshiftParserVACUUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11656) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11657) + p.Vac_analyze_option_list() + } + { + p.SetState(11658) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11660) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1007, p.GetParserRuleContext()) == 1 { + { + p.SetState(11659) + p.Opt_vacuum_relation_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11662) + p.Match(RedshiftParserVACUUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11664) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1008, p.GetParserRuleContext()) == 1 { + { + p.SetState(11663) + p.Vacuum_option() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11667) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1009, p.GetParserRuleContext()) == 1 { + { + p.SetState(11666) + p.Qualified_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTO { + { + p.SetState(11669) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11670) + p.Iconst() + } + { + p.SetState(11671) + p.Match(RedshiftParserPERCENT_WORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserBOOST { + { + p.SetState(11675) + p.Match(RedshiftParserBOOST) + 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 +} + +// IVacuum_optionContext is an interface to support dynamic dispatch. +type IVacuum_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FULL() antlr.TerminalNode + SORT() antlr.TerminalNode + ONLY() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + REINDEX() antlr.TerminalNode + RECLUSTER() antlr.TerminalNode + + // IsVacuum_optionContext differentiates from other interfaces. + IsVacuum_optionContext() +} + +type Vacuum_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVacuum_optionContext() *Vacuum_optionContext { + var p = new(Vacuum_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuum_option + return p +} + +func InitEmptyVacuum_optionContext(p *Vacuum_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuum_option +} + +func (*Vacuum_optionContext) IsVacuum_optionContext() {} + +func NewVacuum_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_optionContext { + var p = new(Vacuum_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vacuum_option + + return p +} + +func (s *Vacuum_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Vacuum_optionContext) FULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserFULL, 0) +} + +func (s *Vacuum_optionContext) SORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSORT, 0) +} + +func (s *Vacuum_optionContext) ONLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserONLY, 0) +} + +func (s *Vacuum_optionContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *Vacuum_optionContext) REINDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserREINDEX, 0) +} + +func (s *Vacuum_optionContext) RECLUSTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserRECLUSTER, 0) +} + +func (s *Vacuum_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Vacuum_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Vacuum_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVacuum_option(s) + } +} + +func (s *Vacuum_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVacuum_option(s) + } +} + +func (s *Vacuum_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVacuum_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vacuum_option() (localctx IVacuum_optionContext) { + localctx = NewVacuum_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1382, RedshiftParserRULE_vacuum_option) + p.SetState(11687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserFULL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11680) + p.Match(RedshiftParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSORT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11681) + p.Match(RedshiftParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11682) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDELETE_P: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11683) + p.Match(RedshiftParserDELETE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11684) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserREINDEX: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11685) + p.Match(RedshiftParserREINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserRECLUSTER: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11686) + p.Match(RedshiftParserRECLUSTER) + 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 +} + +// IAnalyzestmtContext is an interface to support dynamic dispatch. +type IAnalyzestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Analyze_keyword() IAnalyze_keywordContext + Opt_verbose() IOpt_verboseContext + Qualified_name() IQualified_nameContext + PREDICATE() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + ALL() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsAnalyzestmtContext differentiates from other interfaces. + IsAnalyzestmtContext() +} + +type AnalyzestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnalyzestmtContext() *AnalyzestmtContext { + var p = new(AnalyzestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_analyzestmt + return p +} + +func InitEmptyAnalyzestmtContext(p *AnalyzestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_analyzestmt +} + +func (*AnalyzestmtContext) IsAnalyzestmtContext() {} + +func NewAnalyzestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzestmtContext { + var p = new(AnalyzestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_analyzestmt + + return p +} + +func (s *AnalyzestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnalyzestmtContext) Analyze_keyword() IAnalyze_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyze_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyze_keywordContext) +} + +func (s *AnalyzestmtContext) Opt_verbose() IOpt_verboseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_verboseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_verboseContext) +} + +func (s *AnalyzestmtContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *AnalyzestmtContext) PREDICATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREDICATE, 0) +} + +func (s *AnalyzestmtContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMNS, 0) +} + +func (s *AnalyzestmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *AnalyzestmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AnalyzestmtContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *AnalyzestmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AnalyzestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnalyzestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAnalyzestmt(s) + } +} + +func (s *AnalyzestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAnalyzestmt(s) + } +} + +func (s *AnalyzestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAnalyzestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Analyzestmt() (localctx IAnalyzestmtContext) { + localctx = NewAnalyzestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1384, RedshiftParserRULE_analyzestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11689) + p.Analyze_keyword() + } + p.SetState(11691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERBOSE { + { + p.SetState(11690) + p.Opt_verbose() + } + + } + p.SetState(11700) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1016, p.GetParserRuleContext()) == 1 { + { + p.SetState(11693) + p.Qualified_name() + } + p.SetState(11698) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1015, p.GetParserRuleContext()) == 1 { + { + p.SetState(11694) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11695) + p.Columnlist() + } + { + p.SetState(11696) + p.Match(RedshiftParserCLOSE_PAREN) + 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(11706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case RedshiftParserPREDICATE: + { + p.SetState(11702) + p.Match(RedshiftParserPREDICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11703) + p.Match(RedshiftParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserALL: + { + p.SetState(11704) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11705) + p.Match(RedshiftParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEOF, RedshiftParserOPEN_PAREN, RedshiftParserSEMI, RedshiftParserANALYSE, RedshiftParserANALYZE, RedshiftParserCREATE, RedshiftParserDESC, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserGRANT, RedshiftParserINTO, RedshiftParserSELECT, RedshiftParserTABLE, RedshiftParserWITH, RedshiftParserABORT_P, RedshiftParserALTER, RedshiftParserBEGIN_P, RedshiftParserCHECKPOINT, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMIT, RedshiftParserCOPY, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDELETE_P, RedshiftParserDISCARD, RedshiftParserDROP, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserINSERT, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCK_P, RedshiftParserMERGE, RedshiftParserNOTIFY, RedshiftParserPREPARE, RedshiftParserREASSIGN, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELEASE, RedshiftParserRESET, RedshiftParserREVOKE, RedshiftParserROLLBACK, RedshiftParserSAVEPOINT, RedshiftParserSECURITY, RedshiftParserSET, RedshiftParserSHOW, RedshiftParserSTART, RedshiftParserTRUNCATE, RedshiftParserUNLISTEN, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserUNLOAD, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserDESCRIBE, RedshiftParserVALUES, RedshiftParserCALL, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserIMPORT_P, RedshiftParserEND_P, RedshiftParserMetaCommand: + + 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 +} + +// IVac_analyze_option_listContext is an interface to support dynamic dispatch. +type IVac_analyze_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllVac_analyze_option_elem() []IVac_analyze_option_elemContext + Vac_analyze_option_elem(i int) IVac_analyze_option_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsVac_analyze_option_listContext differentiates from other interfaces. + IsVac_analyze_option_listContext() +} + +type Vac_analyze_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVac_analyze_option_listContext() *Vac_analyze_option_listContext { + var p = new(Vac_analyze_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_list + return p +} + +func InitEmptyVac_analyze_option_listContext(p *Vac_analyze_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_list +} + +func (*Vac_analyze_option_listContext) IsVac_analyze_option_listContext() {} + +func NewVac_analyze_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_listContext { + var p = new(Vac_analyze_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_list + + return p +} + +func (s *Vac_analyze_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Vac_analyze_option_listContext) AllVac_analyze_option_elem() []IVac_analyze_option_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVac_analyze_option_elemContext); ok { + len++ + } + } + + tst := make([]IVac_analyze_option_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVac_analyze_option_elemContext); ok { + tst[i] = t.(IVac_analyze_option_elemContext) + i++ + } + } + + return tst +} + +func (s *Vac_analyze_option_listContext) Vac_analyze_option_elem(i int) IVac_analyze_option_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVac_analyze_option_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVac_analyze_option_elemContext) +} + +func (s *Vac_analyze_option_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Vac_analyze_option_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Vac_analyze_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Vac_analyze_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Vac_analyze_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVac_analyze_option_list(s) + } +} + +func (s *Vac_analyze_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVac_analyze_option_list(s) + } +} + +func (s *Vac_analyze_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVac_analyze_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vac_analyze_option_list() (localctx IVac_analyze_option_listContext) { + localctx = NewVac_analyze_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1386, RedshiftParserRULE_vac_analyze_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11708) + p.Vac_analyze_option_elem() + } + p.SetState(11713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(11709) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11710) + p.Vac_analyze_option_elem() + } + + p.SetState(11715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAnalyze_keywordContext is an interface to support dynamic dispatch. +type IAnalyze_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANALYZE() antlr.TerminalNode + ANALYSE() antlr.TerminalNode + + // IsAnalyze_keywordContext differentiates from other interfaces. + IsAnalyze_keywordContext() +} + +type Analyze_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnalyze_keywordContext() *Analyze_keywordContext { + var p = new(Analyze_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_analyze_keyword + return p +} + +func InitEmptyAnalyze_keywordContext(p *Analyze_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_analyze_keyword +} + +func (*Analyze_keywordContext) IsAnalyze_keywordContext() {} + +func NewAnalyze_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Analyze_keywordContext { + var p = new(Analyze_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_analyze_keyword + + return p +} + +func (s *Analyze_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Analyze_keywordContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserANALYZE, 0) +} + +func (s *Analyze_keywordContext) ANALYSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserANALYSE, 0) +} + +func (s *Analyze_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Analyze_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Analyze_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAnalyze_keyword(s) + } +} + +func (s *Analyze_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAnalyze_keyword(s) + } +} + +func (s *Analyze_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAnalyze_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Analyze_keyword() (localctx IAnalyze_keywordContext) { + localctx = NewAnalyze_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1388, RedshiftParserRULE_analyze_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11716) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserANALYSE || _la == RedshiftParserANALYZE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVac_analyze_option_elemContext is an interface to support dynamic dispatch. +type IVac_analyze_option_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Vac_analyze_option_name() IVac_analyze_option_nameContext + Vac_analyze_option_arg() IVac_analyze_option_argContext + + // IsVac_analyze_option_elemContext differentiates from other interfaces. + IsVac_analyze_option_elemContext() +} + +type Vac_analyze_option_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVac_analyze_option_elemContext() *Vac_analyze_option_elemContext { + var p = new(Vac_analyze_option_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_elem + return p +} + +func InitEmptyVac_analyze_option_elemContext(p *Vac_analyze_option_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_elem +} + +func (*Vac_analyze_option_elemContext) IsVac_analyze_option_elemContext() {} + +func NewVac_analyze_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_elemContext { + var p = new(Vac_analyze_option_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_elem + + return p +} + +func (s *Vac_analyze_option_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Vac_analyze_option_elemContext) Vac_analyze_option_name() IVac_analyze_option_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVac_analyze_option_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVac_analyze_option_nameContext) +} + +func (s *Vac_analyze_option_elemContext) Vac_analyze_option_arg() IVac_analyze_option_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVac_analyze_option_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVac_analyze_option_argContext) +} + +func (s *Vac_analyze_option_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Vac_analyze_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Vac_analyze_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVac_analyze_option_elem(s) + } +} + +func (s *Vac_analyze_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVac_analyze_option_elem(s) + } +} + +func (s *Vac_analyze_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVac_analyze_option_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vac_analyze_option_elem() (localctx IVac_analyze_option_elemContext) { + localctx = NewVac_analyze_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1390, RedshiftParserRULE_vac_analyze_option_elem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11718) + p.Vac_analyze_option_name() + } + p.SetState(11720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3616452116379348992) != 0) || ((int64((_la-79)) & ^0x3f) == 0 && ((int64(1)<<(_la-79))&-567349341831037) != 0) || ((int64((_la-143)) & ^0x3f) == 0 && ((int64(1)<<(_la-143))&-34359738369) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&-1266637395197953) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&-65537) != 0) || ((int64((_la-335)) & ^0x3f) == 0 && ((int64(1)<<(_la-335))&-359162070282797057) != 0) || ((int64((_la-399)) & ^0x3f) == 0 && ((int64(1)<<(_la-399))&-1) != 0) || ((int64((_la-463)) & ^0x3f) == 0 && ((int64(1)<<(_la-463))&-1) != 0) || ((int64((_la-527)) & ^0x3f) == 0 && ((int64(1)<<(_la-527))&-1) != 0) || ((int64((_la-591)) & ^0x3f) == 0 && ((int64(1)<<(_la-591))&-4611967493403049985) != 0) || ((int64((_la-655)) & ^0x3f) == 0 && ((int64(1)<<(_la-655))&9222668349412999167) != 0) || ((int64((_la-719)) & ^0x3f) == 0 && ((int64(1)<<(_la-719))&-1) != 0) || ((int64((_la-783)) & ^0x3f) == 0 && ((int64(1)<<(_la-783))&4503599627370495) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137925535881) != 0) { + { + p.SetState(11719) + p.Vac_analyze_option_arg() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVac_analyze_option_nameContext is an interface to support dynamic dispatch. +type IVac_analyze_option_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Nonreservedword() INonreservedwordContext + Analyze_keyword() IAnalyze_keywordContext + + // IsVac_analyze_option_nameContext differentiates from other interfaces. + IsVac_analyze_option_nameContext() +} + +type Vac_analyze_option_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVac_analyze_option_nameContext() *Vac_analyze_option_nameContext { + var p = new(Vac_analyze_option_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_name + return p +} + +func InitEmptyVac_analyze_option_nameContext(p *Vac_analyze_option_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_name +} + +func (*Vac_analyze_option_nameContext) IsVac_analyze_option_nameContext() {} + +func NewVac_analyze_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_nameContext { + var p = new(Vac_analyze_option_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_name + + return p +} + +func (s *Vac_analyze_option_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Vac_analyze_option_nameContext) Nonreservedword() INonreservedwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedwordContext) +} + +func (s *Vac_analyze_option_nameContext) Analyze_keyword() IAnalyze_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyze_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyze_keywordContext) +} + +func (s *Vac_analyze_option_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Vac_analyze_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Vac_analyze_option_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVac_analyze_option_name(s) + } +} + +func (s *Vac_analyze_option_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVac_analyze_option_name(s) + } +} + +func (s *Vac_analyze_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVac_analyze_option_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vac_analyze_option_name() (localctx IVac_analyze_option_nameContext) { + localctx = NewVac_analyze_option_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1392, RedshiftParserRULE_vac_analyze_option_name) + p.SetState(11724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11722) + p.Nonreservedword() + } + + case RedshiftParserANALYSE, RedshiftParserANALYZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11723) + p.Analyze_keyword() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVac_analyze_option_argContext is an interface to support dynamic dispatch. +type IVac_analyze_option_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_boolean_or_string() IOpt_boolean_or_stringContext + Numericonly() INumericonlyContext + + // IsVac_analyze_option_argContext differentiates from other interfaces. + IsVac_analyze_option_argContext() +} + +type Vac_analyze_option_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVac_analyze_option_argContext() *Vac_analyze_option_argContext { + var p = new(Vac_analyze_option_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_arg + return p +} + +func InitEmptyVac_analyze_option_argContext(p *Vac_analyze_option_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_arg +} + +func (*Vac_analyze_option_argContext) IsVac_analyze_option_argContext() {} + +func NewVac_analyze_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vac_analyze_option_argContext { + var p = new(Vac_analyze_option_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vac_analyze_option_arg + + return p +} + +func (s *Vac_analyze_option_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Vac_analyze_option_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_boolean_or_stringContext) +} + +func (s *Vac_analyze_option_argContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Vac_analyze_option_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Vac_analyze_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Vac_analyze_option_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVac_analyze_option_arg(s) + } +} + +func (s *Vac_analyze_option_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVac_analyze_option_arg(s) + } +} + +func (s *Vac_analyze_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVac_analyze_option_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vac_analyze_option_arg() (localctx IVac_analyze_option_argContext) { + localctx = NewVac_analyze_option_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1394, RedshiftParserRULE_vac_analyze_option_arg) + p.SetState(11728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11726) + p.Opt_boolean_or_string() + } + + case RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserIntegral, RedshiftParserNumeric: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11727) + p.Numericonly() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_analyzeContext is an interface to support dynamic dispatch. +type IOpt_analyzeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Analyze_keyword() IAnalyze_keywordContext + + // IsOpt_analyzeContext differentiates from other interfaces. + IsOpt_analyzeContext() +} + +type Opt_analyzeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_analyzeContext() *Opt_analyzeContext { + var p = new(Opt_analyzeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_analyze + return p +} + +func InitEmptyOpt_analyzeContext(p *Opt_analyzeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_analyze +} + +func (*Opt_analyzeContext) IsOpt_analyzeContext() {} + +func NewOpt_analyzeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_analyzeContext { + var p = new(Opt_analyzeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_analyze + + return p +} + +func (s *Opt_analyzeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_analyzeContext) Analyze_keyword() IAnalyze_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyze_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyze_keywordContext) +} + +func (s *Opt_analyzeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_analyzeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_analyzeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_analyze(s) + } +} + +func (s *Opt_analyzeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_analyze(s) + } +} + +func (s *Opt_analyzeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_analyze(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_analyze() (localctx IOpt_analyzeContext) { + localctx = NewOpt_analyzeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1396, RedshiftParserRULE_opt_analyze) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11730) + p.Analyze_keyword() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_verboseContext is an interface to support dynamic dispatch. +type IOpt_verboseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERBOSE() antlr.TerminalNode + + // IsOpt_verboseContext differentiates from other interfaces. + IsOpt_verboseContext() +} + +type Opt_verboseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_verboseContext() *Opt_verboseContext { + var p = new(Opt_verboseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_verbose + return p +} + +func InitEmptyOpt_verboseContext(p *Opt_verboseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_verbose +} + +func (*Opt_verboseContext) IsOpt_verboseContext() {} + +func NewOpt_verboseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_verboseContext { + var p = new(Opt_verboseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_verbose + + return p +} + +func (s *Opt_verboseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_verboseContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERBOSE, 0) +} + +func (s *Opt_verboseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_verboseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_verboseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_verbose(s) + } +} + +func (s *Opt_verboseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_verbose(s) + } +} + +func (s *Opt_verboseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_verbose(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_verbose() (localctx IOpt_verboseContext) { + localctx = NewOpt_verboseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1398, RedshiftParserRULE_opt_verbose) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11732) + p.Match(RedshiftParserVERBOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_fullContext is an interface to support dynamic dispatch. +type IOpt_fullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FULL() antlr.TerminalNode + + // IsOpt_fullContext differentiates from other interfaces. + IsOpt_fullContext() +} + +type Opt_fullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_fullContext() *Opt_fullContext { + var p = new(Opt_fullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_full + return p +} + +func InitEmptyOpt_fullContext(p *Opt_fullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_full +} + +func (*Opt_fullContext) IsOpt_fullContext() {} + +func NewOpt_fullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fullContext { + var p = new(Opt_fullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_full + + return p +} + +func (s *Opt_fullContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_fullContext) FULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserFULL, 0) +} + +func (s *Opt_fullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_fullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_fullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_full(s) + } +} + +func (s *Opt_fullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_full(s) + } +} + +func (s *Opt_fullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_full(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_full() (localctx IOpt_fullContext) { + localctx = NewOpt_fullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1400, RedshiftParserRULE_opt_full) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11734) + p.Match(RedshiftParserFULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_freezeContext is an interface to support dynamic dispatch. +type IOpt_freezeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FREEZE() antlr.TerminalNode + + // IsOpt_freezeContext differentiates from other interfaces. + IsOpt_freezeContext() +} + +type Opt_freezeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_freezeContext() *Opt_freezeContext { + var p = new(Opt_freezeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_freeze + return p +} + +func InitEmptyOpt_freezeContext(p *Opt_freezeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_freeze +} + +func (*Opt_freezeContext) IsOpt_freezeContext() {} + +func NewOpt_freezeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_freezeContext { + var p = new(Opt_freezeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_freeze + + return p +} + +func (s *Opt_freezeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_freezeContext) FREEZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFREEZE, 0) +} + +func (s *Opt_freezeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_freezeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_freezeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_freeze(s) + } +} + +func (s *Opt_freezeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_freeze(s) + } +} + +func (s *Opt_freezeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_freeze(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_freeze() (localctx IOpt_freezeContext) { + localctx = NewOpt_freezeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1402, RedshiftParserRULE_opt_freeze) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11736) + p.Match(RedshiftParserFREEZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_name_listContext is an interface to support dynamic dispatch. +type IOpt_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Name_list() IName_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_name_listContext differentiates from other interfaces. + IsOpt_name_listContext() +} + +type Opt_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_name_listContext() *Opt_name_listContext { + var p = new(Opt_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_name_list + return p +} + +func InitEmptyOpt_name_listContext(p *Opt_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_name_list +} + +func (*Opt_name_listContext) IsOpt_name_listContext() {} + +func NewOpt_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_name_listContext { + var p = new(Opt_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_name_list + + return p +} + +func (s *Opt_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_name_listContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_name_listContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *Opt_name_listContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_name_list(s) + } +} + +func (s *Opt_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_name_list(s) + } +} + +func (s *Opt_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_name_list() (localctx IOpt_name_listContext) { + localctx = NewOpt_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1404, RedshiftParserRULE_opt_name_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11738) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11739) + p.Name_list() + } + { + p.SetState(11740) + p.Match(RedshiftParserCLOSE_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 +} + +// IVacuum_relationContext is an interface to support dynamic dispatch. +type IVacuum_relationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name() IQualified_nameContext + Opt_name_list() IOpt_name_listContext + + // IsVacuum_relationContext differentiates from other interfaces. + IsVacuum_relationContext() +} + +type Vacuum_relationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVacuum_relationContext() *Vacuum_relationContext { + var p = new(Vacuum_relationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuum_relation + return p +} + +func InitEmptyVacuum_relationContext(p *Vacuum_relationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuum_relation +} + +func (*Vacuum_relationContext) IsVacuum_relationContext() {} + +func NewVacuum_relationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_relationContext { + var p = new(Vacuum_relationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vacuum_relation + + return p +} + +func (s *Vacuum_relationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Vacuum_relationContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Vacuum_relationContext) Opt_name_list() IOpt_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_name_listContext) +} + +func (s *Vacuum_relationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Vacuum_relationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Vacuum_relationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVacuum_relation(s) + } +} + +func (s *Vacuum_relationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVacuum_relation(s) + } +} + +func (s *Vacuum_relationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVacuum_relation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vacuum_relation() (localctx IVacuum_relationContext) { + localctx = NewVacuum_relationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1406, RedshiftParserRULE_vacuum_relation) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11742) + p.Qualified_name() + } + p.SetState(11744) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1022, p.GetParserRuleContext()) == 1 { + { + p.SetState(11743) + p.Opt_name_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 +} + +// IVacuum_relation_listContext is an interface to support dynamic dispatch. +type IVacuum_relation_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllVacuum_relation() []IVacuum_relationContext + Vacuum_relation(i int) IVacuum_relationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsVacuum_relation_listContext differentiates from other interfaces. + IsVacuum_relation_listContext() +} + +type Vacuum_relation_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVacuum_relation_listContext() *Vacuum_relation_listContext { + var p = new(Vacuum_relation_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuum_relation_list + return p +} + +func InitEmptyVacuum_relation_listContext(p *Vacuum_relation_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_vacuum_relation_list +} + +func (*Vacuum_relation_listContext) IsVacuum_relation_listContext() {} + +func NewVacuum_relation_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Vacuum_relation_listContext { + var p = new(Vacuum_relation_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_vacuum_relation_list + + return p +} + +func (s *Vacuum_relation_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Vacuum_relation_listContext) AllVacuum_relation() []IVacuum_relationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVacuum_relationContext); ok { + len++ + } + } + + tst := make([]IVacuum_relationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVacuum_relationContext); ok { + tst[i] = t.(IVacuum_relationContext) + i++ + } + } + + return tst +} + +func (s *Vacuum_relation_listContext) Vacuum_relation(i int) IVacuum_relationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVacuum_relationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVacuum_relationContext) +} + +func (s *Vacuum_relation_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Vacuum_relation_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Vacuum_relation_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Vacuum_relation_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Vacuum_relation_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVacuum_relation_list(s) + } +} + +func (s *Vacuum_relation_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVacuum_relation_list(s) + } +} + +func (s *Vacuum_relation_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVacuum_relation_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Vacuum_relation_list() (localctx IVacuum_relation_listContext) { + localctx = NewVacuum_relation_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1408, RedshiftParserRULE_vacuum_relation_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11746) + p.Vacuum_relation() + } + p.SetState(11751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(11747) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11748) + p.Vacuum_relation() + } + + p.SetState(11753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_vacuum_relation_listContext is an interface to support dynamic dispatch. +type IOpt_vacuum_relation_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Vacuum_relation_list() IVacuum_relation_listContext + + // IsOpt_vacuum_relation_listContext differentiates from other interfaces. + IsOpt_vacuum_relation_listContext() +} + +type Opt_vacuum_relation_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_vacuum_relation_listContext() *Opt_vacuum_relation_listContext { + var p = new(Opt_vacuum_relation_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_vacuum_relation_list + return p +} + +func InitEmptyOpt_vacuum_relation_listContext(p *Opt_vacuum_relation_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_vacuum_relation_list +} + +func (*Opt_vacuum_relation_listContext) IsOpt_vacuum_relation_listContext() {} + +func NewOpt_vacuum_relation_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_vacuum_relation_listContext { + var p = new(Opt_vacuum_relation_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_vacuum_relation_list + + return p +} + +func (s *Opt_vacuum_relation_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_vacuum_relation_listContext) Vacuum_relation_list() IVacuum_relation_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVacuum_relation_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVacuum_relation_listContext) +} + +func (s *Opt_vacuum_relation_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_vacuum_relation_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_vacuum_relation_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_vacuum_relation_list(s) + } +} + +func (s *Opt_vacuum_relation_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_vacuum_relation_list(s) + } +} + +func (s *Opt_vacuum_relation_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_vacuum_relation_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_vacuum_relation_list() (localctx IOpt_vacuum_relation_listContext) { + localctx = NewOpt_vacuum_relation_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1410, RedshiftParserRULE_opt_vacuum_relation_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11754) + p.Vacuum_relation_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 +} + +// IExplainstmtContext is an interface to support dynamic dispatch. +type IExplainstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPLAIN() antlr.TerminalNode + Explainablestmt() IExplainablestmtContext + Analyze_keyword() IAnalyze_keywordContext + Opt_verbose() IOpt_verboseContext + VERBOSE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Explain_option_list() IExplain_option_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsExplainstmtContext differentiates from other interfaces. + IsExplainstmtContext() +} + +type ExplainstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplainstmtContext() *ExplainstmtContext { + var p = new(ExplainstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explainstmt + return p +} + +func InitEmptyExplainstmtContext(p *ExplainstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explainstmt +} + +func (*ExplainstmtContext) IsExplainstmtContext() {} + +func NewExplainstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainstmtContext { + var p = new(ExplainstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_explainstmt + + return p +} + +func (s *ExplainstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExplainstmtContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPLAIN, 0) +} + +func (s *ExplainstmtContext) Explainablestmt() IExplainablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainablestmtContext) +} + +func (s *ExplainstmtContext) Analyze_keyword() IAnalyze_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyze_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyze_keywordContext) +} + +func (s *ExplainstmtContext) Opt_verbose() IOpt_verboseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_verboseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_verboseContext) +} + +func (s *ExplainstmtContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERBOSE, 0) +} + +func (s *ExplainstmtContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ExplainstmtContext) Explain_option_list() IExplain_option_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplain_option_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplain_option_listContext) +} + +func (s *ExplainstmtContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ExplainstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExplainstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExplainstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExplainstmt(s) + } +} + +func (s *ExplainstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExplainstmt(s) + } +} + +func (s *ExplainstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExplainstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Explainstmt() (localctx IExplainstmtContext) { + localctx = NewExplainstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1412, RedshiftParserRULE_explainstmt) + var _la int + + p.SetState(11774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1025, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11756) + p.Match(RedshiftParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11757) + p.Explainablestmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11758) + p.Match(RedshiftParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11759) + p.Analyze_keyword() + } + p.SetState(11761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVERBOSE { + { + p.SetState(11760) + p.Opt_verbose() + } + + } + { + p.SetState(11763) + p.Explainablestmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11765) + p.Match(RedshiftParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11766) + p.Match(RedshiftParserVERBOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11767) + p.Explainablestmt() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11768) + p.Match(RedshiftParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11769) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11770) + p.Explain_option_list() + } + { + p.SetState(11771) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11772) + p.Explainablestmt() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplainablestmtContext is an interface to support dynamic dispatch. +type IExplainablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Selectstmt() ISelectstmtContext + Insertstmt() IInsertstmtContext + Updatestmt() IUpdatestmtContext + Deletestmt() IDeletestmtContext + Declarecursorstmt() IDeclarecursorstmtContext + Createasstmt() ICreateasstmtContext + Creatematviewstmt() ICreatematviewstmtContext + Refreshmatviewstmt() IRefreshmatviewstmtContext + Executestmt() IExecutestmtContext + + // IsExplainablestmtContext differentiates from other interfaces. + IsExplainablestmtContext() +} + +type ExplainablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplainablestmtContext() *ExplainablestmtContext { + var p = new(ExplainablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explainablestmt + return p +} + +func InitEmptyExplainablestmtContext(p *ExplainablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explainablestmt +} + +func (*ExplainablestmtContext) IsExplainablestmtContext() {} + +func NewExplainablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainablestmtContext { + var p = new(ExplainablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_explainablestmt + + return p +} + +func (s *ExplainablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExplainablestmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *ExplainablestmtContext) Insertstmt() IInsertstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertstmtContext) +} + +func (s *ExplainablestmtContext) Updatestmt() IUpdatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdatestmtContext) +} + +func (s *ExplainablestmtContext) Deletestmt() IDeletestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeletestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeletestmtContext) +} + +func (s *ExplainablestmtContext) Declarecursorstmt() IDeclarecursorstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclarecursorstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeclarecursorstmtContext) +} + +func (s *ExplainablestmtContext) Createasstmt() ICreateasstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreateasstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreateasstmtContext) +} + +func (s *ExplainablestmtContext) Creatematviewstmt() ICreatematviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreatematviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreatematviewstmtContext) +} + +func (s *ExplainablestmtContext) Refreshmatviewstmt() IRefreshmatviewstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefreshmatviewstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefreshmatviewstmtContext) +} + +func (s *ExplainablestmtContext) Executestmt() IExecutestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecutestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecutestmtContext) +} + +func (s *ExplainablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExplainablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExplainablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExplainablestmt(s) + } +} + +func (s *ExplainablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExplainablestmt(s) + } +} + +func (s *ExplainablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExplainablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Explainablestmt() (localctx IExplainablestmtContext) { + localctx = NewExplainablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1414, RedshiftParserRULE_explainablestmt) + p.SetState(11785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1026, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11776) + p.Selectstmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11777) + p.Insertstmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11778) + p.Updatestmt() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11779) + p.Deletestmt() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11780) + p.Declarecursorstmt() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11781) + p.Createasstmt() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11782) + p.Creatematviewstmt() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11783) + p.Refreshmatviewstmt() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(11784) + p.Executestmt() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplain_option_listContext is an interface to support dynamic dispatch. +type IExplain_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExplain_option_elem() []IExplain_option_elemContext + Explain_option_elem(i int) IExplain_option_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExplain_option_listContext differentiates from other interfaces. + IsExplain_option_listContext() +} + +type Explain_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplain_option_listContext() *Explain_option_listContext { + var p = new(Explain_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_list + return p +} + +func InitEmptyExplain_option_listContext(p *Explain_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_list +} + +func (*Explain_option_listContext) IsExplain_option_listContext() {} + +func NewExplain_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_listContext { + var p = new(Explain_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_explain_option_list + + return p +} + +func (s *Explain_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explain_option_listContext) AllExplain_option_elem() []IExplain_option_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExplain_option_elemContext); ok { + len++ + } + } + + tst := make([]IExplain_option_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExplain_option_elemContext); ok { + tst[i] = t.(IExplain_option_elemContext) + i++ + } + } + + return tst +} + +func (s *Explain_option_listContext) Explain_option_elem(i int) IExplain_option_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplain_option_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExplain_option_elemContext) +} + +func (s *Explain_option_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Explain_option_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Explain_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explain_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explain_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExplain_option_list(s) + } +} + +func (s *Explain_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExplain_option_list(s) + } +} + +func (s *Explain_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExplain_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Explain_option_list() (localctx IExplain_option_listContext) { + localctx = NewExplain_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1416, RedshiftParserRULE_explain_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11787) + p.Explain_option_elem() + } + p.SetState(11792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(11788) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11789) + p.Explain_option_elem() + } + + p.SetState(11794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplain_option_elemContext is an interface to support dynamic dispatch. +type IExplain_option_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Explain_option_name() IExplain_option_nameContext + Explain_option_arg() IExplain_option_argContext + + // IsExplain_option_elemContext differentiates from other interfaces. + IsExplain_option_elemContext() +} + +type Explain_option_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplain_option_elemContext() *Explain_option_elemContext { + var p = new(Explain_option_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_elem + return p +} + +func InitEmptyExplain_option_elemContext(p *Explain_option_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_elem +} + +func (*Explain_option_elemContext) IsExplain_option_elemContext() {} + +func NewExplain_option_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_elemContext { + var p = new(Explain_option_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_explain_option_elem + + return p +} + +func (s *Explain_option_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explain_option_elemContext) Explain_option_name() IExplain_option_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplain_option_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplain_option_nameContext) +} + +func (s *Explain_option_elemContext) Explain_option_arg() IExplain_option_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplain_option_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplain_option_argContext) +} + +func (s *Explain_option_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explain_option_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explain_option_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExplain_option_elem(s) + } +} + +func (s *Explain_option_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExplain_option_elem(s) + } +} + +func (s *Explain_option_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExplain_option_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Explain_option_elem() (localctx IExplain_option_elemContext) { + localctx = NewExplain_option_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1418, RedshiftParserRULE_explain_option_elem) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11795) + p.Explain_option_name() + } + p.SetState(11797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3616452116379348992) != 0) || ((int64((_la-79)) & ^0x3f) == 0 && ((int64(1)<<(_la-79))&-567349341831037) != 0) || ((int64((_la-143)) & ^0x3f) == 0 && ((int64(1)<<(_la-143))&-34359738369) != 0) || ((int64((_la-207)) & ^0x3f) == 0 && ((int64(1)<<(_la-207))&-1266637395197953) != 0) || ((int64((_la-271)) & ^0x3f) == 0 && ((int64(1)<<(_la-271))&-65537) != 0) || ((int64((_la-335)) & ^0x3f) == 0 && ((int64(1)<<(_la-335))&-359162070282797057) != 0) || ((int64((_la-399)) & ^0x3f) == 0 && ((int64(1)<<(_la-399))&-1) != 0) || ((int64((_la-463)) & ^0x3f) == 0 && ((int64(1)<<(_la-463))&-1) != 0) || ((int64((_la-527)) & ^0x3f) == 0 && ((int64(1)<<(_la-527))&-1) != 0) || ((int64((_la-591)) & ^0x3f) == 0 && ((int64(1)<<(_la-591))&-4611967493403049985) != 0) || ((int64((_la-655)) & ^0x3f) == 0 && ((int64(1)<<(_la-655))&9222668349412999167) != 0) || ((int64((_la-719)) & ^0x3f) == 0 && ((int64(1)<<(_la-719))&-1) != 0) || ((int64((_la-783)) & ^0x3f) == 0 && ((int64(1)<<(_la-783))&4503599627370495) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137925535881) != 0) { + { + p.SetState(11796) + p.Explain_option_arg() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplain_option_nameContext is an interface to support dynamic dispatch. +type IExplain_option_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Nonreservedword() INonreservedwordContext + Analyze_keyword() IAnalyze_keywordContext + + // IsExplain_option_nameContext differentiates from other interfaces. + IsExplain_option_nameContext() +} + +type Explain_option_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplain_option_nameContext() *Explain_option_nameContext { + var p = new(Explain_option_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_name + return p +} + +func InitEmptyExplain_option_nameContext(p *Explain_option_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_name +} + +func (*Explain_option_nameContext) IsExplain_option_nameContext() {} + +func NewExplain_option_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_nameContext { + var p = new(Explain_option_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_explain_option_name + + return p +} + +func (s *Explain_option_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explain_option_nameContext) Nonreservedword() INonreservedwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedwordContext) +} + +func (s *Explain_option_nameContext) Analyze_keyword() IAnalyze_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyze_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyze_keywordContext) +} + +func (s *Explain_option_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explain_option_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explain_option_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExplain_option_name(s) + } +} + +func (s *Explain_option_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExplain_option_name(s) + } +} + +func (s *Explain_option_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExplain_option_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Explain_option_name() (localctx IExplain_option_nameContext) { + localctx = NewExplain_option_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1420, RedshiftParserRULE_explain_option_name) + p.SetState(11801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11799) + p.Nonreservedword() + } + + case RedshiftParserANALYSE, RedshiftParserANALYZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11800) + p.Analyze_keyword() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplain_option_argContext is an interface to support dynamic dispatch. +type IExplain_option_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_boolean_or_string() IOpt_boolean_or_stringContext + Numericonly() INumericonlyContext + + // IsExplain_option_argContext differentiates from other interfaces. + IsExplain_option_argContext() +} + +type Explain_option_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplain_option_argContext() *Explain_option_argContext { + var p = new(Explain_option_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_arg + return p +} + +func InitEmptyExplain_option_argContext(p *Explain_option_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explain_option_arg +} + +func (*Explain_option_argContext) IsExplain_option_argContext() {} + +func NewExplain_option_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_option_argContext { + var p = new(Explain_option_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_explain_option_arg + + return p +} + +func (s *Explain_option_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explain_option_argContext) Opt_boolean_or_string() IOpt_boolean_or_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_boolean_or_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_boolean_or_stringContext) +} + +func (s *Explain_option_argContext) Numericonly() INumericonlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericonlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericonlyContext) +} + +func (s *Explain_option_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explain_option_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explain_option_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExplain_option_arg(s) + } +} + +func (s *Explain_option_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExplain_option_arg(s) + } +} + +func (s *Explain_option_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExplain_option_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Explain_option_arg() (localctx IExplain_option_argContext) { + localctx = NewExplain_option_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1422, RedshiftParserRULE_explain_option_arg) + p.SetState(11805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11803) + p.Opt_boolean_or_string() + } + + case RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserIntegral, RedshiftParserNumeric: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11804) + p.Numericonly() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPreparestmtContext is an interface to support dynamic dispatch. +type IPreparestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PREPARE() antlr.TerminalNode + Name() INameContext + AS() antlr.TerminalNode + Preparablestmt() IPreparablestmtContext + Prep_type_clause() IPrep_type_clauseContext + + // IsPreparestmtContext differentiates from other interfaces. + IsPreparestmtContext() +} + +type PreparestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPreparestmtContext() *PreparestmtContext { + var p = new(PreparestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_preparestmt + return p +} + +func InitEmptyPreparestmtContext(p *PreparestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_preparestmt +} + +func (*PreparestmtContext) IsPreparestmtContext() {} + +func NewPreparestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparestmtContext { + var p = new(PreparestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_preparestmt + + return p +} + +func (s *PreparestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *PreparestmtContext) PREPARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPARE, 0) +} + +func (s *PreparestmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *PreparestmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *PreparestmtContext) Preparablestmt() IPreparablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPreparablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPreparablestmtContext) +} + +func (s *PreparestmtContext) Prep_type_clause() IPrep_type_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrep_type_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrep_type_clauseContext) +} + +func (s *PreparestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PreparestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PreparestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPreparestmt(s) + } +} + +func (s *PreparestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPreparestmt(s) + } +} + +func (s *PreparestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPreparestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Preparestmt() (localctx IPreparestmtContext) { + localctx = NewPreparestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1424, RedshiftParserRULE_preparestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11807) + p.Match(RedshiftParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11808) + p.Name() + } + p.SetState(11810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(11809) + p.Prep_type_clause() + } + + } + { + p.SetState(11812) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11813) + p.Preparablestmt() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPrep_type_clauseContext is an interface to support dynamic dispatch. +type IPrep_type_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Type_list() IType_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsPrep_type_clauseContext differentiates from other interfaces. + IsPrep_type_clauseContext() +} + +type Prep_type_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrep_type_clauseContext() *Prep_type_clauseContext { + var p = new(Prep_type_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_prep_type_clause + return p +} + +func InitEmptyPrep_type_clauseContext(p *Prep_type_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_prep_type_clause +} + +func (*Prep_type_clauseContext) IsPrep_type_clauseContext() {} + +func NewPrep_type_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Prep_type_clauseContext { + var p = new(Prep_type_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_prep_type_clause + + return p +} + +func (s *Prep_type_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Prep_type_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Prep_type_clauseContext) Type_list() IType_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_listContext) +} + +func (s *Prep_type_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Prep_type_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Prep_type_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Prep_type_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPrep_type_clause(s) + } +} + +func (s *Prep_type_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPrep_type_clause(s) + } +} + +func (s *Prep_type_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPrep_type_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Prep_type_clause() (localctx IPrep_type_clauseContext) { + localctx = NewPrep_type_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1426, RedshiftParserRULE_prep_type_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11815) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11816) + p.Type_list() + } + { + p.SetState(11817) + p.Match(RedshiftParserCLOSE_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 +} + +// IPreparablestmtContext is an interface to support dynamic dispatch. +type IPreparablestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Selectstmt() ISelectstmtContext + Insertstmt() IInsertstmtContext + Updatestmt() IUpdatestmtContext + Deletestmt() IDeletestmtContext + Mergestmt() IMergestmtContext + + // IsPreparablestmtContext differentiates from other interfaces. + IsPreparablestmtContext() +} + +type PreparablestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPreparablestmtContext() *PreparablestmtContext { + var p = new(PreparablestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_preparablestmt + return p +} + +func InitEmptyPreparablestmtContext(p *PreparablestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_preparablestmt +} + +func (*PreparablestmtContext) IsPreparablestmtContext() {} + +func NewPreparablestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PreparablestmtContext { + var p = new(PreparablestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_preparablestmt + + return p +} + +func (s *PreparablestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *PreparablestmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *PreparablestmtContext) Insertstmt() IInsertstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsertstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsertstmtContext) +} + +func (s *PreparablestmtContext) Updatestmt() IUpdatestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdatestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdatestmtContext) +} + +func (s *PreparablestmtContext) Deletestmt() IDeletestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeletestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeletestmtContext) +} + +func (s *PreparablestmtContext) Mergestmt() IMergestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMergestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMergestmtContext) +} + +func (s *PreparablestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PreparablestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PreparablestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPreparablestmt(s) + } +} + +func (s *PreparablestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPreparablestmt(s) + } +} + +func (s *PreparablestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPreparablestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Preparablestmt() (localctx IPreparablestmtContext) { + localctx = NewPreparablestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1428, RedshiftParserRULE_preparablestmt) + p.SetState(11824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1032, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11819) + p.Selectstmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11820) + p.Insertstmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11821) + p.Updatestmt() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11822) + p.Deletestmt() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11823) + p.Mergestmt() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExecutestmtContext is an interface to support dynamic dispatch. +type IExecutestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + Name() INameContext + Execute_param_clause() IExecute_param_clauseContext + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + Create_as_target() ICreate_as_targetContext + AS() antlr.TerminalNode + Opttemp() IOpttempContext + Opt_with_data() IOpt_with_dataContext + IF_P() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsExecutestmtContext differentiates from other interfaces. + IsExecutestmtContext() +} + +type ExecutestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecutestmtContext() *ExecutestmtContext { + var p = new(ExecutestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_executestmt + return p +} + +func InitEmptyExecutestmtContext(p *ExecutestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_executestmt +} + +func (*ExecutestmtContext) IsExecutestmtContext() {} + +func NewExecutestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExecutestmtContext { + var p = new(ExecutestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_executestmt + + return p +} + +func (s *ExecutestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExecutestmtContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *ExecutestmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *ExecutestmtContext) Execute_param_clause() IExecute_param_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_param_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_param_clauseContext) +} + +func (s *ExecutestmtContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *ExecutestmtContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *ExecutestmtContext) Create_as_target() ICreate_as_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_as_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_as_targetContext) +} + +func (s *ExecutestmtContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *ExecutestmtContext) Opttemp() IOpttempContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttempContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttempContext) +} + +func (s *ExecutestmtContext) Opt_with_data() IOpt_with_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_dataContext) +} + +func (s *ExecutestmtContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *ExecutestmtContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *ExecutestmtContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *ExecutestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExecutestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExecutestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExecutestmt(s) + } +} + +func (s *ExecutestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExecutestmt(s) + } +} + +func (s *ExecutestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExecutestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Executestmt() (localctx IExecutestmtContext) { + localctx = NewExecutestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1430, RedshiftParserRULE_executestmt) + var _la int + + p.SetState(11864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1040, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11826) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11827) + p.Name() + } + p.SetState(11829) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1033, p.GetParserRuleContext()) == 1 { + { + p.SetState(11828) + p.Execute_param_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11831) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLOCAL || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY { + { + p.SetState(11832) + p.Opttemp() + } + + } + { + p.SetState(11835) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11836) + p.Create_as_target() + } + { + p.SetState(11837) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11838) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11839) + p.Name() + } + p.SetState(11841) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1035, p.GetParserRuleContext()) == 1 { + { + p.SetState(11840) + p.Execute_param_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11844) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1036, p.GetParserRuleContext()) == 1 { + { + p.SetState(11843) + p.Opt_with_data() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11846) + p.Match(RedshiftParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLOCAL || _la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY { + { + p.SetState(11847) + p.Opttemp() + } + + } + { + p.SetState(11850) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11851) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11852) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11853) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11854) + p.Create_as_target() + } + { + p.SetState(11855) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11856) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11857) + p.Name() + } + p.SetState(11859) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1038, p.GetParserRuleContext()) == 1 { + { + p.SetState(11858) + p.Execute_param_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11862) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1039, p.GetParserRuleContext()) == 1 { + { + p.SetState(11861) + p.Opt_with_data() + } + + } 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 +} + +// IExecute_param_clauseContext is an interface to support dynamic dispatch. +type IExecute_param_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsExecute_param_clauseContext differentiates from other interfaces. + IsExecute_param_clauseContext() +} + +type Execute_param_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_param_clauseContext() *Execute_param_clauseContext { + var p = new(Execute_param_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_execute_param_clause + return p +} + +func InitEmptyExecute_param_clauseContext(p *Execute_param_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_execute_param_clause +} + +func (*Execute_param_clauseContext) IsExecute_param_clauseContext() {} + +func NewExecute_param_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_param_clauseContext { + var p = new(Execute_param_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_execute_param_clause + + return p +} + +func (s *Execute_param_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_param_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Execute_param_clauseContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Execute_param_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Execute_param_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_param_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_param_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExecute_param_clause(s) + } +} + +func (s *Execute_param_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExecute_param_clause(s) + } +} + +func (s *Execute_param_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExecute_param_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Execute_param_clause() (localctx IExecute_param_clauseContext) { + localctx = NewExecute_param_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1432, RedshiftParserRULE_execute_param_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11866) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11867) + p.Expr_list() + } + { + p.SetState(11868) + p.Match(RedshiftParserCLOSE_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 +} + +// IDeallocatestmtContext is an interface to support dynamic dispatch. +type IDeallocatestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEALLOCATE() antlr.TerminalNode + Name() INameContext + PREPARE() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsDeallocatestmtContext differentiates from other interfaces. + IsDeallocatestmtContext() +} + +type DeallocatestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeallocatestmtContext() *DeallocatestmtContext { + var p = new(DeallocatestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_deallocatestmt + return p +} + +func InitEmptyDeallocatestmtContext(p *DeallocatestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_deallocatestmt +} + +func (*DeallocatestmtContext) IsDeallocatestmtContext() {} + +func NewDeallocatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeallocatestmtContext { + var p = new(DeallocatestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_deallocatestmt + + return p +} + +func (s *DeallocatestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeallocatestmtContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEALLOCATE, 0) +} + +func (s *DeallocatestmtContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *DeallocatestmtContext) PREPARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPARE, 0) +} + +func (s *DeallocatestmtContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *DeallocatestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeallocatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeallocatestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDeallocatestmt(s) + } +} + +func (s *DeallocatestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDeallocatestmt(s) + } +} + +func (s *DeallocatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDeallocatestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Deallocatestmt() (localctx IDeallocatestmtContext) { + localctx = NewDeallocatestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1434, RedshiftParserRULE_deallocatestmt) + p.SetState(11880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1041, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11870) + p.Match(RedshiftParserDEALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11871) + p.Name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11872) + p.Match(RedshiftParserDEALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11873) + p.Match(RedshiftParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11874) + p.Name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11875) + p.Match(RedshiftParserDEALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11876) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11877) + p.Match(RedshiftParserDEALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11878) + p.Match(RedshiftParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11879) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsertstmtContext is an interface to support dynamic dispatch. +type IInsertstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + INTO() antlr.TerminalNode + Insert_target() IInsert_targetContext + Insert_rest() IInsert_restContext + Opt_with_clause() IOpt_with_clauseContext + Opt_on_conflict() IOpt_on_conflictContext + Returning_clause() IReturning_clauseContext + + // IsInsertstmtContext differentiates from other interfaces. + IsInsertstmtContext() +} + +type InsertstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsertstmtContext() *InsertstmtContext { + var p = new(InsertstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insertstmt + return p +} + +func InitEmptyInsertstmtContext(p *InsertstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insertstmt +} + +func (*InsertstmtContext) IsInsertstmtContext() {} + +func NewInsertstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InsertstmtContext { + var p = new(InsertstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_insertstmt + + return p +} + +func (s *InsertstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *InsertstmtContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *InsertstmtContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *InsertstmtContext) Insert_target() IInsert_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_targetContext) +} + +func (s *InsertstmtContext) Insert_rest() IInsert_restContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_restContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_restContext) +} + +func (s *InsertstmtContext) Opt_with_clause() IOpt_with_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_clauseContext) +} + +func (s *InsertstmtContext) Opt_on_conflict() IOpt_on_conflictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_on_conflictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_on_conflictContext) +} + +func (s *InsertstmtContext) Returning_clause() IReturning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturning_clauseContext) +} + +func (s *InsertstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *InsertstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *InsertstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInsertstmt(s) + } +} + +func (s *InsertstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInsertstmt(s) + } +} + +func (s *InsertstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInsertstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Insertstmt() (localctx IInsertstmtContext) { + localctx = NewInsertstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1436, RedshiftParserRULE_insertstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(11882) + p.Opt_with_clause() + } + + } + { + p.SetState(11885) + p.Match(RedshiftParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11886) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11887) + p.Insert_target() + } + { + p.SetState(11888) + p.Insert_rest() + } + p.SetState(11890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserON { + { + p.SetState(11889) + p.Opt_on_conflict() + } + + } + p.SetState(11893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRETURNING { + { + p.SetState(11892) + p.Returning_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_targetContext is an interface to support dynamic dispatch. +type IInsert_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name() IQualified_nameContext + AS() antlr.TerminalNode + Colid() IColidContext + + // IsInsert_targetContext differentiates from other interfaces. + IsInsert_targetContext() +} + +type Insert_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_targetContext() *Insert_targetContext { + var p = new(Insert_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_target + return p +} + +func InitEmptyInsert_targetContext(p *Insert_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_target +} + +func (*Insert_targetContext) IsInsert_targetContext() {} + +func NewInsert_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_targetContext { + var p = new(Insert_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_insert_target + + return p +} + +func (s *Insert_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_targetContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Insert_targetContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Insert_targetContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Insert_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInsert_target(s) + } +} + +func (s *Insert_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInsert_target(s) + } +} + +func (s *Insert_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInsert_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Insert_target() (localctx IInsert_targetContext) { + localctx = NewInsert_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1438, RedshiftParserRULE_insert_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11895) + p.Qualified_name() + } + p.SetState(11898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(11896) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11897) + p.Colid() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_restContext is an interface to support dynamic dispatch. +type IInsert_restContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Selectstmt() ISelectstmtContext + OVERRIDING() antlr.TerminalNode + Override_kind() IOverride_kindContext + VALUE_P() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Insert_column_list() IInsert_column_listContext + CLOSE_PAREN() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + VALUES() antlr.TerminalNode + + // IsInsert_restContext differentiates from other interfaces. + IsInsert_restContext() +} + +type Insert_restContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_restContext() *Insert_restContext { + var p = new(Insert_restContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_rest + return p +} + +func InitEmptyInsert_restContext(p *Insert_restContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_rest +} + +func (*Insert_restContext) IsInsert_restContext() {} + +func NewInsert_restContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_restContext { + var p = new(Insert_restContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_insert_rest + + return p +} + +func (s *Insert_restContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_restContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *Insert_restContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVERRIDING, 0) +} + +func (s *Insert_restContext) Override_kind() IOverride_kindContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverride_kindContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverride_kindContext) +} + +func (s *Insert_restContext) VALUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUE_P, 0) +} + +func (s *Insert_restContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Insert_restContext) Insert_column_list() IInsert_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_column_listContext) +} + +func (s *Insert_restContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Insert_restContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Insert_restContext) VALUES() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUES, 0) +} + +func (s *Insert_restContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_restContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_restContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInsert_rest(s) + } +} + +func (s *Insert_restContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInsert_rest(s) + } +} + +func (s *Insert_restContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInsert_rest(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Insert_rest() (localctx IInsert_restContext) { + localctx = NewInsert_restContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1440, RedshiftParserRULE_insert_rest) + var _la int + + p.SetState(11919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1047, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11900) + p.Selectstmt() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11901) + p.Match(RedshiftParserOVERRIDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11902) + p.Override_kind() + } + { + p.SetState(11903) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11904) + p.Selectstmt() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11906) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11907) + p.Insert_column_list() + } + { + p.SetState(11908) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOVERRIDING { + { + p.SetState(11909) + p.Match(RedshiftParserOVERRIDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11910) + p.Override_kind() + } + { + p.SetState(11911) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11915) + p.Selectstmt() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11917) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11918) + p.Match(RedshiftParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverride_kindContext is an interface to support dynamic dispatch. +type IOverride_kindContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USER() antlr.TerminalNode + SYSTEM_P() antlr.TerminalNode + + // IsOverride_kindContext differentiates from other interfaces. + IsOverride_kindContext() +} + +type Override_kindContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverride_kindContext() *Override_kindContext { + var p = new(Override_kindContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_override_kind + return p +} + +func InitEmptyOverride_kindContext(p *Override_kindContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_override_kind +} + +func (*Override_kindContext) IsOverride_kindContext() {} + +func NewOverride_kindContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Override_kindContext { + var p = new(Override_kindContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_override_kind + + return p +} + +func (s *Override_kindContext) GetParser() antlr.Parser { return s.parser } + +func (s *Override_kindContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *Override_kindContext) SYSTEM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSTEM_P, 0) +} + +func (s *Override_kindContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Override_kindContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Override_kindContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOverride_kind(s) + } +} + +func (s *Override_kindContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOverride_kind(s) + } +} + +func (s *Override_kindContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOverride_kind(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Override_kind() (localctx IOverride_kindContext) { + localctx = NewOverride_kindContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1442, RedshiftParserRULE_override_kind) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11921) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserUSER || _la == RedshiftParserSYSTEM_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_column_listContext is an interface to support dynamic dispatch. +type IInsert_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllInsert_column_item() []IInsert_column_itemContext + Insert_column_item(i int) IInsert_column_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsInsert_column_listContext differentiates from other interfaces. + IsInsert_column_listContext() +} + +type Insert_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_column_listContext() *Insert_column_listContext { + var p = new(Insert_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_column_list + return p +} + +func InitEmptyInsert_column_listContext(p *Insert_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_column_list +} + +func (*Insert_column_listContext) IsInsert_column_listContext() {} + +func NewInsert_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_listContext { + var p = new(Insert_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_insert_column_list + + return p +} + +func (s *Insert_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_column_listContext) AllInsert_column_item() []IInsert_column_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInsert_column_itemContext); ok { + len++ + } + } + + tst := make([]IInsert_column_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInsert_column_itemContext); ok { + tst[i] = t.(IInsert_column_itemContext) + i++ + } + } + + return tst +} + +func (s *Insert_column_listContext) Insert_column_item(i int) IInsert_column_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_column_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInsert_column_itemContext) +} + +func (s *Insert_column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Insert_column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Insert_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInsert_column_list(s) + } +} + +func (s *Insert_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInsert_column_list(s) + } +} + +func (s *Insert_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInsert_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Insert_column_list() (localctx IInsert_column_listContext) { + localctx = NewInsert_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1444, RedshiftParserRULE_insert_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11923) + p.Insert_column_item() + } + p.SetState(11928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(11924) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11925) + p.Insert_column_item() + } + + p.SetState(11930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_column_itemContext is an interface to support dynamic dispatch. +type IInsert_column_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Opt_indirection() IOpt_indirectionContext + + // IsInsert_column_itemContext differentiates from other interfaces. + IsInsert_column_itemContext() +} + +type Insert_column_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_column_itemContext() *Insert_column_itemContext { + var p = new(Insert_column_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_column_item + return p +} + +func InitEmptyInsert_column_itemContext(p *Insert_column_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_insert_column_item +} + +func (*Insert_column_itemContext) IsInsert_column_itemContext() {} + +func NewInsert_column_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_column_itemContext { + var p = new(Insert_column_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_insert_column_item + + return p +} + +func (s *Insert_column_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_column_itemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Insert_column_itemContext) Opt_indirection() IOpt_indirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_indirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_indirectionContext) +} + +func (s *Insert_column_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_column_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_column_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInsert_column_item(s) + } +} + +func (s *Insert_column_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInsert_column_item(s) + } +} + +func (s *Insert_column_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInsert_column_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Insert_column_item() (localctx IInsert_column_itemContext) { + localctx = NewInsert_column_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1446, RedshiftParserRULE_insert_column_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11931) + p.Colid() + } + { + p.SetState(11932) + p.Opt_indirection() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_on_conflictContext is an interface to support dynamic dispatch. +type IOpt_on_conflictContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + CONFLICT() antlr.TerminalNode + DO() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + Set_clause_list() ISet_clause_listContext + NOTHING() antlr.TerminalNode + Opt_conf_expr() IOpt_conf_exprContext + Where_clause() IWhere_clauseContext + + // IsOpt_on_conflictContext differentiates from other interfaces. + IsOpt_on_conflictContext() +} + +type Opt_on_conflictContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_on_conflictContext() *Opt_on_conflictContext { + var p = new(Opt_on_conflictContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_on_conflict + return p +} + +func InitEmptyOpt_on_conflictContext(p *Opt_on_conflictContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_on_conflict +} + +func (*Opt_on_conflictContext) IsOpt_on_conflictContext() {} + +func NewOpt_on_conflictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_on_conflictContext { + var p = new(Opt_on_conflictContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_on_conflict + + return p +} + +func (s *Opt_on_conflictContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_on_conflictContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Opt_on_conflictContext) CONFLICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFLICT, 0) +} + +func (s *Opt_on_conflictContext) DO() antlr.TerminalNode { + return s.GetToken(RedshiftParserDO, 0) +} + +func (s *Opt_on_conflictContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Opt_on_conflictContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Opt_on_conflictContext) Set_clause_list() ISet_clause_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_clause_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_clause_listContext) +} + +func (s *Opt_on_conflictContext) NOTHING() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTHING, 0) +} + +func (s *Opt_on_conflictContext) Opt_conf_expr() IOpt_conf_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_conf_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_conf_exprContext) +} + +func (s *Opt_on_conflictContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Opt_on_conflictContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_on_conflictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_on_conflictContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_on_conflict(s) + } +} + +func (s *Opt_on_conflictContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_on_conflict(s) + } +} + +func (s *Opt_on_conflictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_on_conflict(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_on_conflict() (localctx IOpt_on_conflictContext) { + localctx = NewOpt_on_conflictContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1448, RedshiftParserRULE_opt_on_conflict) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11934) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11935) + p.Match(RedshiftParserCONFLICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN || _la == RedshiftParserON { + { + p.SetState(11936) + p.Opt_conf_expr() + } + + } + { + p.SetState(11939) + p.Match(RedshiftParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserUPDATE: + { + p.SetState(11940) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11941) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11942) + p.Set_clause_list() + } + p.SetState(11944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(11943) + p.Where_clause() + } + + } + + case RedshiftParserNOTHING: + { + p.SetState(11946) + p.Match(RedshiftParserNOTHING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_conf_exprContext is an interface to support dynamic dispatch. +type IOpt_conf_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Index_params() IIndex_paramsContext + CLOSE_PAREN() antlr.TerminalNode + Where_clause() IWhere_clauseContext + ON() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Name() INameContext + + // IsOpt_conf_exprContext differentiates from other interfaces. + IsOpt_conf_exprContext() +} + +type Opt_conf_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_conf_exprContext() *Opt_conf_exprContext { + var p = new(Opt_conf_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_conf_expr + return p +} + +func InitEmptyOpt_conf_exprContext(p *Opt_conf_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_conf_expr +} + +func (*Opt_conf_exprContext) IsOpt_conf_exprContext() {} + +func NewOpt_conf_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_conf_exprContext { + var p = new(Opt_conf_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_conf_expr + + return p +} + +func (s *Opt_conf_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_conf_exprContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_conf_exprContext) Index_params() IIndex_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_paramsContext) +} + +func (s *Opt_conf_exprContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_conf_exprContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Opt_conf_exprContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Opt_conf_exprContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *Opt_conf_exprContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Opt_conf_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_conf_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_conf_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_conf_expr(s) + } +} + +func (s *Opt_conf_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_conf_expr(s) + } +} + +func (s *Opt_conf_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_conf_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_conf_expr() (localctx IOpt_conf_exprContext) { + localctx = NewOpt_conf_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1450, RedshiftParserRULE_opt_conf_expr) + var _la int + + p.SetState(11958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11949) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11950) + p.Index_params() + } + { + p.SetState(11951) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(11952) + p.Where_clause() + } + + } + + case RedshiftParserON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11955) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11956) + p.Match(RedshiftParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11957) + p.Name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReturning_clauseContext is an interface to support dynamic dispatch. +type IReturning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNING() antlr.TerminalNode + Target_list() ITarget_listContext + + // IsReturning_clauseContext differentiates from other interfaces. + IsReturning_clauseContext() +} + +type Returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturning_clauseContext() *Returning_clauseContext { + var p = new(Returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_returning_clause + return p +} + +func InitEmptyReturning_clauseContext(p *Returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_returning_clause +} + +func (*Returning_clauseContext) IsReturning_clauseContext() {} + +func NewReturning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Returning_clauseContext { + var p = new(Returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_returning_clause + + return p +} + +func (s *Returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Returning_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNING, 0) +} + +func (s *Returning_clauseContext) Target_list() ITarget_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITarget_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITarget_listContext) +} + +func (s *Returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReturning_clause(s) + } +} + +func (s *Returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReturning_clause(s) + } +} + +func (s *Returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReturning_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Returning_clause() (localctx IReturning_clauseContext) { + localctx = NewReturning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1452, RedshiftParserRULE_returning_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11960) + p.Match(RedshiftParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11961) + p.Target_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 +} + +// IMergestmtContext is an interface to support dynamic dispatch. +type IMergestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MERGE() antlr.TerminalNode + INTO() antlr.TerminalNode + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + USING() antlr.TerminalNode + ON() antlr.TerminalNode + A_expr() IA_exprContext + Select_with_parens() ISelect_with_parensContext + REMOVE() antlr.TerminalNode + DUPLICATES() antlr.TerminalNode + With_clause() IWith_clauseContext + ONLY() antlr.TerminalNode + AllAlias_clause() []IAlias_clauseContext + Alias_clause(i int) IAlias_clauseContext + AllMerge_when_clause() []IMerge_when_clauseContext + Merge_when_clause(i int) IMerge_when_clauseContext + + // IsMergestmtContext differentiates from other interfaces. + IsMergestmtContext() +} + +type MergestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMergestmtContext() *MergestmtContext { + var p = new(MergestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_mergestmt + return p +} + +func InitEmptyMergestmtContext(p *MergestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_mergestmt +} + +func (*MergestmtContext) IsMergestmtContext() {} + +func NewMergestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MergestmtContext { + var p = new(MergestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_mergestmt + + return p +} + +func (s *MergestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *MergestmtContext) MERGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMERGE, 0) +} + +func (s *MergestmtContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *MergestmtContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *MergestmtContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *MergestmtContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *MergestmtContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *MergestmtContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *MergestmtContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *MergestmtContext) REMOVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREMOVE, 0) +} + +func (s *MergestmtContext) DUPLICATES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDUPLICATES, 0) +} + +func (s *MergestmtContext) 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 *MergestmtContext) ONLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserONLY, 0) +} + +func (s *MergestmtContext) AllAlias_clause() []IAlias_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlias_clauseContext); ok { + len++ + } + } + + tst := make([]IAlias_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlias_clauseContext); ok { + tst[i] = t.(IAlias_clauseContext) + i++ + } + } + + return tst +} + +func (s *MergestmtContext) Alias_clause(i int) IAlias_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlias_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlias_clauseContext) +} + +func (s *MergestmtContext) AllMerge_when_clause() []IMerge_when_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMerge_when_clauseContext); ok { + len++ + } + } + + tst := make([]IMerge_when_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMerge_when_clauseContext); ok { + tst[i] = t.(IMerge_when_clauseContext) + i++ + } + } + + return tst +} + +func (s *MergestmtContext) Merge_when_clause(i int) IMerge_when_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_when_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMerge_when_clauseContext) +} + +func (s *MergestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MergestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MergestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMergestmt(s) + } +} + +func (s *MergestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMergestmt(s) + } +} + +func (s *MergestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMergestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Mergestmt() (localctx IMergestmtContext) { + localctx = NewMergestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1454, RedshiftParserRULE_mergestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(11963) + p.With_clause() + } + + } + { + p.SetState(11966) + p.Match(RedshiftParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11967) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserONLY { + { + p.SetState(11968) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11971) + p.Qualified_name() + } + p.SetState(11973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558349) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(11972) + p.Alias_clause() + } + + } + { + p.SetState(11975) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN: + { + p.SetState(11976) + p.Select_with_parens() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(11977) + p.Qualified_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11981) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558349) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(11980) + p.Alias_clause() + } + + } + { + p.SetState(11983) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11984) + p.A_expr() + } + p.SetState(11992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserWHEN: + p.SetState(11986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserWHEN { + { + p.SetState(11985) + p.Merge_when_clause() + } + + p.SetState(11988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case RedshiftParserREMOVE: + { + p.SetState(11990) + p.Match(RedshiftParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11991) + p.Match(RedshiftParserDUPLICATES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_when_clauseContext is an interface to support dynamic dispatch. +type IMerge_when_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Merge_insert_clause() IMerge_insert_clauseContext + Merge_update_clause() IMerge_update_clauseContext + Merge_delete_clause() IMerge_delete_clauseContext + + // IsMerge_when_clauseContext differentiates from other interfaces. + IsMerge_when_clauseContext() +} + +type Merge_when_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_when_clauseContext() *Merge_when_clauseContext { + var p = new(Merge_when_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_merge_when_clause + return p +} + +func InitEmptyMerge_when_clauseContext(p *Merge_when_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_merge_when_clause +} + +func (*Merge_when_clauseContext) IsMerge_when_clauseContext() {} + +func NewMerge_when_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_when_clauseContext { + var p = new(Merge_when_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_merge_when_clause + + return p +} + +func (s *Merge_when_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_when_clauseContext) 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_when_clauseContext) 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_when_clauseContext) Merge_delete_clause() IMerge_delete_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_delete_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_delete_clauseContext) +} + +func (s *Merge_when_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_when_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_when_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMerge_when_clause(s) + } +} + +func (s *Merge_when_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMerge_when_clause(s) + } +} + +func (s *Merge_when_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMerge_when_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Merge_when_clause() (localctx IMerge_when_clauseContext) { + localctx = NewMerge_when_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1456, RedshiftParserRULE_merge_when_clause) + p.SetState(11997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1061, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11994) + p.Merge_insert_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11995) + p.Merge_update_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11996) + p.Merge_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 +} + +// IMerge_insert_clauseContext is an interface to support dynamic dispatch. +type IMerge_insert_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + NOT() antlr.TerminalNode + MATCHED() antlr.TerminalNode + INSERT() antlr.TerminalNode + Values_clause() IValues_clauseContext + AND() antlr.TerminalNode + A_expr() IA_exprContext + THEN() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Insert_column_list() IInsert_column_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsMerge_insert_clauseContext differentiates from other interfaces. + IsMerge_insert_clauseContext() +} + +type Merge_insert_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_insert_clauseContext() *Merge_insert_clauseContext { + var p = new(Merge_insert_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_merge_insert_clause + return p +} + +func InitEmptyMerge_insert_clauseContext(p *Merge_insert_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_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(RedshiftParserWHEN, 0) +} + +func (s *Merge_insert_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Merge_insert_clauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATCHED, 0) +} + +func (s *Merge_insert_clauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *Merge_insert_clauseContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Merge_insert_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Merge_insert_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Merge_insert_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *Merge_insert_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Merge_insert_clauseContext) Insert_column_list() IInsert_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_column_listContext) +} + +func (s *Merge_insert_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Merge_insert_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_insert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_insert_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMerge_insert_clause(s) + } +} + +func (s *Merge_insert_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMerge_insert_clause(s) + } +} + +func (s *Merge_insert_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMerge_insert_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Merge_insert_clause() (localctx IMerge_insert_clauseContext) { + localctx = NewMerge_insert_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1458, RedshiftParserRULE_merge_insert_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11999) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12000) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12001) + p.Match(RedshiftParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(12002) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12003) + p.A_expr() + } + + } + p.SetState(12007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTHEN { + { + p.SetState(12006) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12009) + p.Match(RedshiftParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(12010) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12011) + p.Insert_column_list() + } + { + p.SetState(12012) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12016) + p.Values_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_update_clauseContext is an interface to support dynamic dispatch. +type IMerge_update_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + MATCHED() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + Set_clause_list() ISet_clause_listContext + AND() antlr.TerminalNode + A_expr() IA_exprContext + THEN() antlr.TerminalNode + + // IsMerge_update_clauseContext differentiates from other interfaces. + IsMerge_update_clauseContext() +} + +type Merge_update_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_update_clauseContext() *Merge_update_clauseContext { + var p = new(Merge_update_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_merge_update_clause + return p +} + +func InitEmptyMerge_update_clauseContext(p *Merge_update_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_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(RedshiftParserWHEN, 0) +} + +func (s *Merge_update_clauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATCHED, 0) +} + +func (s *Merge_update_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Merge_update_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Merge_update_clauseContext) Set_clause_list() ISet_clause_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_clause_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_clause_listContext) +} + +func (s *Merge_update_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Merge_update_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Merge_update_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *Merge_update_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_update_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_update_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMerge_update_clause(s) + } +} + +func (s *Merge_update_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMerge_update_clause(s) + } +} + +func (s *Merge_update_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMerge_update_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Merge_update_clause() (localctx IMerge_update_clauseContext) { + localctx = NewMerge_update_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1460, RedshiftParserRULE_merge_update_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12018) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12019) + p.Match(RedshiftParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(12020) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12021) + p.A_expr() + } + + } + p.SetState(12025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTHEN { + { + p.SetState(12024) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12027) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12028) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12029) + p.Set_clause_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_delete_clauseContext is an interface to support dynamic dispatch. +type IMerge_delete_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + MATCHED() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + AND() antlr.TerminalNode + A_expr() IA_exprContext + THEN() antlr.TerminalNode + + // IsMerge_delete_clauseContext differentiates from other interfaces. + IsMerge_delete_clauseContext() +} + +type Merge_delete_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_delete_clauseContext() *Merge_delete_clauseContext { + var p = new(Merge_delete_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_merge_delete_clause + return p +} + +func InitEmptyMerge_delete_clauseContext(p *Merge_delete_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_merge_delete_clause +} + +func (*Merge_delete_clauseContext) IsMerge_delete_clauseContext() {} + +func NewMerge_delete_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_delete_clauseContext { + var p = new(Merge_delete_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_merge_delete_clause + + return p +} + +func (s *Merge_delete_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_delete_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *Merge_delete_clauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATCHED, 0) +} + +func (s *Merge_delete_clauseContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *Merge_delete_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Merge_delete_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Merge_delete_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *Merge_delete_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_delete_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_delete_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMerge_delete_clause(s) + } +} + +func (s *Merge_delete_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMerge_delete_clause(s) + } +} + +func (s *Merge_delete_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMerge_delete_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Merge_delete_clause() (localctx IMerge_delete_clauseContext) { + localctx = NewMerge_delete_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1462, RedshiftParserRULE_merge_delete_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12031) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12032) + p.Match(RedshiftParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(12033) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12034) + p.A_expr() + } + + } + p.SetState(12038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTHEN { + { + p.SetState(12037) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12040) + p.Match(RedshiftParserDELETE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeletestmtContext is an interface to support dynamic dispatch. +type IDeletestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE_P() antlr.TerminalNode + Relation_expr_opt_alias() IRelation_expr_opt_aliasContext + Opt_with_clause() IOpt_with_clauseContext + FROM() antlr.TerminalNode + Using_clause() IUsing_clauseContext + Where_or_current_clause() IWhere_or_current_clauseContext + Returning_clause() IReturning_clauseContext + + // IsDeletestmtContext differentiates from other interfaces. + IsDeletestmtContext() +} + +type DeletestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeletestmtContext() *DeletestmtContext { + var p = new(DeletestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_deletestmt + return p +} + +func InitEmptyDeletestmtContext(p *DeletestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_deletestmt +} + +func (*DeletestmtContext) IsDeletestmtContext() {} + +func NewDeletestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeletestmtContext { + var p = new(DeletestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_deletestmt + + return p +} + +func (s *DeletestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeletestmtContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *DeletestmtContext) Relation_expr_opt_alias() IRelation_expr_opt_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_expr_opt_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_expr_opt_aliasContext) +} + +func (s *DeletestmtContext) Opt_with_clause() IOpt_with_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_clauseContext) +} + +func (s *DeletestmtContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *DeletestmtContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *DeletestmtContext) Where_or_current_clause() IWhere_or_current_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_or_current_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_or_current_clauseContext) +} + +func (s *DeletestmtContext) Returning_clause() IReturning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturning_clauseContext) +} + +func (s *DeletestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeletestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeletestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDeletestmt(s) + } +} + +func (s *DeletestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDeletestmt(s) + } +} + +func (s *DeletestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDeletestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Deletestmt() (localctx IDeletestmtContext) { + localctx = NewDeletestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1464, RedshiftParserRULE_deletestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(12042) + p.Opt_with_clause() + } + + } + { + p.SetState(12045) + p.Match(RedshiftParserDELETE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12047) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(12046) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12049) + p.Relation_expr_opt_alias() + } + p.SetState(12051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(12050) + p.Using_clause() + } + + } + p.SetState(12054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(12053) + p.Where_or_current_clause() + } + + } + p.SetState(12057) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRETURNING { + { + p.SetState(12056) + p.Returning_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_clauseContext is an interface to support dynamic dispatch. +type IUsing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + From_list() IFrom_listContext + + // IsUsing_clauseContext differentiates from other interfaces. + IsUsing_clauseContext() +} + +type Using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_clauseContext() *Using_clauseContext { + var p = new(Using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_using_clause + return p +} + +func InitEmptyUsing_clauseContext(p *Using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_using_clause + + return p +} + +func (s *Using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Using_clauseContext) From_list() IFrom_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_listContext) +} + +func (s *Using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUsing_clause(s) + } +} + +func (s *Using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUsing_clause(s) + } +} + +func (s *Using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUsing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Using_clause() (localctx IUsing_clauseContext) { + localctx = NewUsing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1466, RedshiftParserRULE_using_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12059) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12060) + p.From_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILockstmtContext is an interface to support dynamic dispatch. +type ILockstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCK_P() antlr.TerminalNode + Relation_expr_list() IRelation_expr_listContext + Opt_table() IOpt_tableContext + Opt_lock() IOpt_lockContext + Opt_nowait() IOpt_nowaitContext + + // IsLockstmtContext differentiates from other interfaces. + IsLockstmtContext() +} + +type LockstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockstmtContext() *LockstmtContext { + var p = new(LockstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_lockstmt + return p +} + +func InitEmptyLockstmtContext(p *LockstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_lockstmt +} + +func (*LockstmtContext) IsLockstmtContext() {} + +func NewLockstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LockstmtContext { + var p = new(LockstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_lockstmt + + return p +} + +func (s *LockstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *LockstmtContext) LOCK_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCK_P, 0) +} + +func (s *LockstmtContext) Relation_expr_list() IRelation_expr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_expr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_expr_listContext) +} + +func (s *LockstmtContext) Opt_table() IOpt_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_tableContext) +} + +func (s *LockstmtContext) Opt_lock() IOpt_lockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_lockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_lockContext) +} + +func (s *LockstmtContext) Opt_nowait() IOpt_nowaitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_nowaitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_nowaitContext) +} + +func (s *LockstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LockstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LockstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLockstmt(s) + } +} + +func (s *LockstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLockstmt(s) + } +} + +func (s *LockstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLockstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Lockstmt() (localctx ILockstmtContext) { + localctx = NewLockstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1468, RedshiftParserRULE_lockstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12062) + p.Match(RedshiftParserLOCK_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12064) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1074, p.GetParserRuleContext()) == 1 { + { + p.SetState(12063) + p.Opt_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12066) + p.Relation_expr_list() + } + p.SetState(12068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIN_P { + { + p.SetState(12067) + p.Opt_lock() + } + + } + p.SetState(12071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOWAIT { + { + p.SetState(12070) + p.Opt_nowait() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_lockContext is an interface to support dynamic dispatch. +type IOpt_lockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN_P() antlr.TerminalNode + Lock_type() ILock_typeContext + MODE() antlr.TerminalNode + + // IsOpt_lockContext differentiates from other interfaces. + IsOpt_lockContext() +} + +type Opt_lockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_lockContext() *Opt_lockContext { + var p = new(Opt_lockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_lock + return p +} + +func InitEmptyOpt_lockContext(p *Opt_lockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_lock +} + +func (*Opt_lockContext) IsOpt_lockContext() {} + +func NewOpt_lockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_lockContext { + var p = new(Opt_lockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_lock + + return p +} + +func (s *Opt_lockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_lockContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Opt_lockContext) Lock_type() ILock_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILock_typeContext) +} + +func (s *Opt_lockContext) MODE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODE, 0) +} + +func (s *Opt_lockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_lockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_lockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_lock(s) + } +} + +func (s *Opt_lockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_lock(s) + } +} + +func (s *Opt_lockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_lock(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_lock() (localctx IOpt_lockContext) { + localctx = NewOpt_lockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1470, RedshiftParserRULE_opt_lock) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12073) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12074) + p.Lock_type() + } + { + p.SetState(12075) + p.Match(RedshiftParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILock_typeContext is an interface to support dynamic dispatch. +type ILock_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACCESS() antlr.TerminalNode + SHARE() antlr.TerminalNode + EXCLUSIVE() antlr.TerminalNode + ROW() antlr.TerminalNode + UPDATE() antlr.TerminalNode + + // IsLock_typeContext differentiates from other interfaces. + IsLock_typeContext() +} + +type Lock_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLock_typeContext() *Lock_typeContext { + var p = new(Lock_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_lock_type + return p +} + +func InitEmptyLock_typeContext(p *Lock_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_lock_type +} + +func (*Lock_typeContext) IsLock_typeContext() {} + +func NewLock_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_typeContext { + var p = new(Lock_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_lock_type + + return p +} + +func (s *Lock_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_typeContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *Lock_typeContext) SHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHARE, 0) +} + +func (s *Lock_typeContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUSIVE, 0) +} + +func (s *Lock_typeContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Lock_typeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Lock_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLock_type(s) + } +} + +func (s *Lock_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLock_type(s) + } +} + +func (s *Lock_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLock_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Lock_type() (localctx ILock_typeContext) { + localctx = NewLock_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1472, RedshiftParserRULE_lock_type) + var _la int + + p.SetState(12089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserACCESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12077) + p.Match(RedshiftParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12078) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXCLUSIVE || _la == RedshiftParserSHARE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserROW: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12079) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12080) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXCLUSIVE || _la == RedshiftParserSHARE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case RedshiftParserSHARE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12081) + p.Match(RedshiftParserSHARE) + 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 RedshiftParserUPDATE: + { + p.SetState(12082) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12083) + p.Match(RedshiftParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserROW: + { + p.SetState(12084) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12085) + p.Match(RedshiftParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserMODE: + + default: + } + + case RedshiftParserEXCLUSIVE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12088) + p.Match(RedshiftParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_nowaitContext is an interface to support dynamic dispatch. +type IOpt_nowaitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOWAIT() antlr.TerminalNode + + // IsOpt_nowaitContext differentiates from other interfaces. + IsOpt_nowaitContext() +} + +type Opt_nowaitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_nowaitContext() *Opt_nowaitContext { + var p = new(Opt_nowaitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nowait + return p +} + +func InitEmptyOpt_nowaitContext(p *Opt_nowaitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nowait +} + +func (*Opt_nowaitContext) IsOpt_nowaitContext() {} + +func NewOpt_nowaitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nowaitContext { + var p = new(Opt_nowaitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_nowait + + return p +} + +func (s *Opt_nowaitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_nowaitContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOWAIT, 0) +} + +func (s *Opt_nowaitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_nowaitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_nowaitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_nowait(s) + } +} + +func (s *Opt_nowaitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_nowait(s) + } +} + +func (s *Opt_nowaitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_nowait(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_nowait() (localctx IOpt_nowaitContext) { + localctx = NewOpt_nowaitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1474, RedshiftParserRULE_opt_nowait) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12091) + p.Match(RedshiftParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_nowait_or_skipContext is an interface to support dynamic dispatch. +type IOpt_nowait_or_skipContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOWAIT() antlr.TerminalNode + SKIP_P() antlr.TerminalNode + LOCKED() antlr.TerminalNode + + // IsOpt_nowait_or_skipContext differentiates from other interfaces. + IsOpt_nowait_or_skipContext() +} + +type Opt_nowait_or_skipContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_nowait_or_skipContext() *Opt_nowait_or_skipContext { + var p = new(Opt_nowait_or_skipContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nowait_or_skip + return p +} + +func InitEmptyOpt_nowait_or_skipContext(p *Opt_nowait_or_skipContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_nowait_or_skip +} + +func (*Opt_nowait_or_skipContext) IsOpt_nowait_or_skipContext() {} + +func NewOpt_nowait_or_skipContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_nowait_or_skipContext { + var p = new(Opt_nowait_or_skipContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_nowait_or_skip + + return p +} + +func (s *Opt_nowait_or_skipContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_nowait_or_skipContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOWAIT, 0) +} + +func (s *Opt_nowait_or_skipContext) SKIP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSKIP_P, 0) +} + +func (s *Opt_nowait_or_skipContext) LOCKED() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCKED, 0) +} + +func (s *Opt_nowait_or_skipContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_nowait_or_skipContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_nowait_or_skipContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_nowait_or_skip(s) + } +} + +func (s *Opt_nowait_or_skipContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_nowait_or_skip(s) + } +} + +func (s *Opt_nowait_or_skipContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_nowait_or_skip(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_nowait_or_skip() (localctx IOpt_nowait_or_skipContext) { + localctx = NewOpt_nowait_or_skipContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1476, RedshiftParserRULE_opt_nowait_or_skip) + p.SetState(12096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNOWAIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12093) + p.Match(RedshiftParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSKIP_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12094) + p.Match(RedshiftParserSKIP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12095) + p.Match(RedshiftParserLOCKED) + 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 +} + +// IUpdatestmtContext is an interface to support dynamic dispatch. +type IUpdatestmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + Relation_expr_opt_alias() IRelation_expr_opt_aliasContext + SET() antlr.TerminalNode + Set_clause_list() ISet_clause_listContext + Opt_with_clause() IOpt_with_clauseContext + From_clause() IFrom_clauseContext + Where_or_current_clause() IWhere_or_current_clauseContext + Returning_clause() IReturning_clauseContext + + // IsUpdatestmtContext differentiates from other interfaces. + IsUpdatestmtContext() +} + +type UpdatestmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdatestmtContext() *UpdatestmtContext { + var p = new(UpdatestmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_updatestmt + return p +} + +func InitEmptyUpdatestmtContext(p *UpdatestmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_updatestmt +} + +func (*UpdatestmtContext) IsUpdatestmtContext() {} + +func NewUpdatestmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UpdatestmtContext { + var p = new(UpdatestmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_updatestmt + + return p +} + +func (s *UpdatestmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *UpdatestmtContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *UpdatestmtContext) Relation_expr_opt_alias() IRelation_expr_opt_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_expr_opt_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_expr_opt_aliasContext) +} + +func (s *UpdatestmtContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *UpdatestmtContext) Set_clause_list() ISet_clause_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_clause_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_clause_listContext) +} + +func (s *UpdatestmtContext) Opt_with_clause() IOpt_with_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_with_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_with_clauseContext) +} + +func (s *UpdatestmtContext) From_clause() IFrom_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clauseContext) +} + +func (s *UpdatestmtContext) Where_or_current_clause() IWhere_or_current_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_or_current_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_or_current_clauseContext) +} + +func (s *UpdatestmtContext) Returning_clause() IReturning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturning_clauseContext) +} + +func (s *UpdatestmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UpdatestmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UpdatestmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUpdatestmt(s) + } +} + +func (s *UpdatestmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUpdatestmt(s) + } +} + +func (s *UpdatestmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUpdatestmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Updatestmt() (localctx IUpdatestmtContext) { + localctx = NewUpdatestmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1478, RedshiftParserRULE_updatestmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH { + { + p.SetState(12098) + p.Opt_with_clause() + } + + } + { + p.SetState(12101) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12102) + p.Relation_expr_opt_alias() + } + { + p.SetState(12103) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12104) + p.Set_clause_list() + } + p.SetState(12106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(12105) + p.From_clause() + } + + } + p.SetState(12109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(12108) + p.Where_or_current_clause() + } + + } + p.SetState(12112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRETURNING { + { + p.SetState(12111) + p.Returning_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_clause_listContext is an interface to support dynamic dispatch. +type ISet_clause_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSet_clause() []ISet_clauseContext + Set_clause(i int) ISet_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSet_clause_listContext differentiates from other interfaces. + IsSet_clause_listContext() +} + +type Set_clause_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_clause_listContext() *Set_clause_listContext { + var p = new(Set_clause_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_clause_list + return p +} + +func InitEmptySet_clause_listContext(p *Set_clause_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_clause_list +} + +func (*Set_clause_listContext) IsSet_clause_listContext() {} + +func NewSet_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_clause_listContext { + var p = new(Set_clause_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_set_clause_list + + return p +} + +func (s *Set_clause_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_clause_listContext) AllSet_clause() []ISet_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISet_clauseContext); ok { + len++ + } + } + + tst := make([]ISet_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISet_clauseContext); ok { + tst[i] = t.(ISet_clauseContext) + i++ + } + } + + return tst +} + +func (s *Set_clause_listContext) Set_clause(i int) ISet_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISet_clauseContext) +} + +func (s *Set_clause_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Set_clause_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Set_clause_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_clause_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSet_clause_list(s) + } +} + +func (s *Set_clause_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSet_clause_list(s) + } +} + +func (s *Set_clause_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSet_clause_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Set_clause_list() (localctx ISet_clause_listContext) { + localctx = NewSet_clause_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1480, RedshiftParserRULE_set_clause_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12114) + p.Set_clause() + } + p.SetState(12119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12115) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12116) + p.Set_clause() + } + + p.SetState(12121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_clauseContext is an interface to support dynamic dispatch. +type ISet_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_target() ISet_targetContext + EQUAL() antlr.TerminalNode + A_expr() IA_exprContext + OPEN_PAREN() antlr.TerminalNode + Set_target_list() ISet_target_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsSet_clauseContext differentiates from other interfaces. + IsSet_clauseContext() +} + +type Set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_clauseContext() *Set_clauseContext { + var p = new(Set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_clause + return p +} + +func InitEmptySet_clauseContext(p *Set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_clause +} + +func (*Set_clauseContext) IsSet_clauseContext() {} + +func NewSet_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_clauseContext { + var p = new(Set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_set_clause + + return p +} + +func (s *Set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_clauseContext) Set_target() ISet_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_targetContext) +} + +func (s *Set_clauseContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Set_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Set_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Set_clauseContext) Set_target_list() ISet_target_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_target_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_target_listContext) +} + +func (s *Set_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSet_clause(s) + } +} + +func (s *Set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSet_clause(s) + } +} + +func (s *Set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSet_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Set_clause() (localctx ISet_clauseContext) { + localctx = NewSet_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1482, RedshiftParserRULE_set_clause) + p.SetState(12132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12122) + p.Set_target() + } + { + p.SetState(12123) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12124) + p.A_expr() + } + + case RedshiftParserOPEN_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12126) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12127) + p.Set_target_list() + } + { + p.SetState(12128) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12129) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12130) + p.A_expr() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_targetContext is an interface to support dynamic dispatch. +type ISet_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Opt_indirection() IOpt_indirectionContext + + // IsSet_targetContext differentiates from other interfaces. + IsSet_targetContext() +} + +type Set_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_targetContext() *Set_targetContext { + var p = new(Set_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_target + return p +} + +func InitEmptySet_targetContext(p *Set_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_target +} + +func (*Set_targetContext) IsSet_targetContext() {} + +func NewSet_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_targetContext { + var p = new(Set_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_set_target + + return p +} + +func (s *Set_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_targetContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Set_targetContext) Opt_indirection() IOpt_indirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_indirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_indirectionContext) +} + +func (s *Set_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSet_target(s) + } +} + +func (s *Set_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSet_target(s) + } +} + +func (s *Set_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSet_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Set_target() (localctx ISet_targetContext) { + localctx = NewSet_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1484, RedshiftParserRULE_set_target) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12134) + p.Colid() + } + { + p.SetState(12135) + p.Opt_indirection() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_target_listContext is an interface to support dynamic dispatch. +type ISet_target_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSet_target() []ISet_targetContext + Set_target(i int) ISet_targetContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSet_target_listContext differentiates from other interfaces. + IsSet_target_listContext() +} + +type Set_target_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_target_listContext() *Set_target_listContext { + var p = new(Set_target_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_target_list + return p +} + +func InitEmptySet_target_listContext(p *Set_target_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_set_target_list +} + +func (*Set_target_listContext) IsSet_target_listContext() {} + +func NewSet_target_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_target_listContext { + var p = new(Set_target_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_set_target_list + + return p +} + +func (s *Set_target_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_target_listContext) AllSet_target() []ISet_targetContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISet_targetContext); ok { + len++ + } + } + + tst := make([]ISet_targetContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISet_targetContext); ok { + tst[i] = t.(ISet_targetContext) + i++ + } + } + + return tst +} + +func (s *Set_target_listContext) Set_target(i int) ISet_targetContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_targetContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISet_targetContext) +} + +func (s *Set_target_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Set_target_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Set_target_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_target_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSet_target_list(s) + } +} + +func (s *Set_target_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSet_target_list(s) + } +} + +func (s *Set_target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSet_target_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Set_target_list() (localctx ISet_target_listContext) { + localctx = NewSet_target_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1486, RedshiftParserRULE_set_target_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12137) + p.Set_target() + } + p.SetState(12142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12138) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12139) + p.Set_target() + } + + p.SetState(12144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeclarecursorstmtContext is an interface to support dynamic dispatch. +type IDeclarecursorstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECLARE() antlr.TerminalNode + Cursor_name() ICursor_nameContext + Cursor_options() ICursor_optionsContext + CURSOR() antlr.TerminalNode + FOR() antlr.TerminalNode + Selectstmt() ISelectstmtContext + Opt_hold() IOpt_holdContext + + // IsDeclarecursorstmtContext differentiates from other interfaces. + IsDeclarecursorstmtContext() +} + +type DeclarecursorstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclarecursorstmtContext() *DeclarecursorstmtContext { + var p = new(DeclarecursorstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_declarecursorstmt + return p +} + +func InitEmptyDeclarecursorstmtContext(p *DeclarecursorstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_declarecursorstmt +} + +func (*DeclarecursorstmtContext) IsDeclarecursorstmtContext() {} + +func NewDeclarecursorstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DeclarecursorstmtContext { + var p = new(DeclarecursorstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_declarecursorstmt + + return p +} + +func (s *DeclarecursorstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *DeclarecursorstmtContext) DECLARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDECLARE, 0) +} + +func (s *DeclarecursorstmtContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *DeclarecursorstmtContext) Cursor_options() ICursor_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_optionsContext) +} + +func (s *DeclarecursorstmtContext) CURSOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURSOR, 0) +} + +func (s *DeclarecursorstmtContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *DeclarecursorstmtContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *DeclarecursorstmtContext) Opt_hold() IOpt_holdContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_holdContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_holdContext) +} + +func (s *DeclarecursorstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DeclarecursorstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DeclarecursorstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDeclarecursorstmt(s) + } +} + +func (s *DeclarecursorstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDeclarecursorstmt(s) + } +} + +func (s *DeclarecursorstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDeclarecursorstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Declarecursorstmt() (localctx IDeclarecursorstmtContext) { + localctx = NewDeclarecursorstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1488, RedshiftParserRULE_declarecursorstmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12145) + p.Match(RedshiftParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12146) + p.Cursor_name() + } + { + p.SetState(12147) + p.Cursor_options() + } + { + p.SetState(12148) + p.Match(RedshiftParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWITH || _la == RedshiftParserWITHOUT { + { + p.SetState(12149) + p.Opt_hold() + } + + } + { + p.SetState(12152) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12153) + p.Selectstmt() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_nameContext is an interface to support dynamic dispatch. +type ICursor_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + + // IsCursor_nameContext differentiates from other interfaces. + IsCursor_nameContext() +} + +type Cursor_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_nameContext() *Cursor_nameContext { + var p = new(Cursor_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cursor_name + return p +} + +func InitEmptyCursor_nameContext(p *Cursor_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_cursor_name + + return p +} + +func (s *Cursor_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_nameContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Cursor_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCursor_name(s) + } +} + +func (s *Cursor_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCursor_name(s) + } +} + +func (s *Cursor_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCursor_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cursor_name() (localctx ICursor_nameContext) { + localctx = NewCursor_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1490, RedshiftParserRULE_cursor_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12155) + p.Name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_optionsContext is an interface to support dynamic dispatch. +type ICursor_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllNO() []antlr.TerminalNode + NO(i int) antlr.TerminalNode + AllSCROLL() []antlr.TerminalNode + SCROLL(i int) antlr.TerminalNode + AllBINARY() []antlr.TerminalNode + BINARY(i int) antlr.TerminalNode + AllINSENSITIVE() []antlr.TerminalNode + INSENSITIVE(i int) antlr.TerminalNode + + // IsCursor_optionsContext differentiates from other interfaces. + IsCursor_optionsContext() +} + +type Cursor_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_optionsContext() *Cursor_optionsContext { + var p = new(Cursor_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cursor_options + return p +} + +func InitEmptyCursor_optionsContext(p *Cursor_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cursor_options +} + +func (*Cursor_optionsContext) IsCursor_optionsContext() {} + +func NewCursor_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_optionsContext { + var p = new(Cursor_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cursor_options + + return p +} + +func (s *Cursor_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_optionsContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserNO) +} + +func (s *Cursor_optionsContext) NO(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, i) +} + +func (s *Cursor_optionsContext) AllSCROLL() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserSCROLL) +} + +func (s *Cursor_optionsContext) SCROLL(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserSCROLL, i) +} + +func (s *Cursor_optionsContext) AllBINARY() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserBINARY) +} + +func (s *Cursor_optionsContext) BINARY(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserBINARY, i) +} + +func (s *Cursor_optionsContext) AllINSENSITIVE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserINSENSITIVE) +} + +func (s *Cursor_optionsContext) INSENSITIVE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserINSENSITIVE, i) +} + +func (s *Cursor_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCursor_options(s) + } +} + +func (s *Cursor_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCursor_options(s) + } +} + +func (s *Cursor_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCursor_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cursor_options() (localctx ICursor_optionsContext) { + localctx = NewCursor_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1492, RedshiftParserRULE_cursor_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserBINARY || _la == RedshiftParserINSENSITIVE || _la == RedshiftParserNO || _la == RedshiftParserSCROLL { + p.SetState(12162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNO: + { + p.SetState(12157) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12158) + p.Match(RedshiftParserSCROLL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSCROLL: + { + p.SetState(12159) + p.Match(RedshiftParserSCROLL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserBINARY: + { + p.SetState(12160) + p.Match(RedshiftParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserINSENSITIVE: + { + p.SetState(12161) + p.Match(RedshiftParserINSENSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_holdContext is an interface to support dynamic dispatch. +type IOpt_holdContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + HOLD() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsOpt_holdContext differentiates from other interfaces. + IsOpt_holdContext() +} + +type Opt_holdContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_holdContext() *Opt_holdContext { + var p = new(Opt_holdContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_hold + return p +} + +func InitEmptyOpt_holdContext(p *Opt_holdContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_hold +} + +func (*Opt_holdContext) IsOpt_holdContext() {} + +func NewOpt_holdContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_holdContext { + var p = new(Opt_holdContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_hold + + return p +} + +func (s *Opt_holdContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_holdContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_holdContext) HOLD() antlr.TerminalNode { + return s.GetToken(RedshiftParserHOLD, 0) +} + +func (s *Opt_holdContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHOUT, 0) +} + +func (s *Opt_holdContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_holdContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_holdContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_hold(s) + } +} + +func (s *Opt_holdContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_hold(s) + } +} + +func (s *Opt_holdContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_hold(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_hold() (localctx IOpt_holdContext) { + localctx = NewOpt_holdContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1494, RedshiftParserRULE_opt_hold) + p.SetState(12171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserWITH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12167) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12168) + p.Match(RedshiftParserHOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserWITHOUT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12169) + p.Match(RedshiftParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12170) + p.Match(RedshiftParserHOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelectstmtContext is an interface to support dynamic dispatch. +type ISelectstmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_no_parens() ISelect_no_parensContext + Select_with_parens() ISelect_with_parensContext + + // IsSelectstmtContext differentiates from other interfaces. + IsSelectstmtContext() +} + +type SelectstmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelectstmtContext() *SelectstmtContext { + var p = new(SelectstmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_selectstmt + return p +} + +func InitEmptySelectstmtContext(p *SelectstmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_selectstmt +} + +func (*SelectstmtContext) IsSelectstmtContext() {} + +func NewSelectstmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SelectstmtContext { + var p = new(SelectstmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_selectstmt + + return p +} + +func (s *SelectstmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *SelectstmtContext) Select_no_parens() ISelect_no_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_no_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_no_parensContext) +} + +func (s *SelectstmtContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *SelectstmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SelectstmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SelectstmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelectstmt(s) + } +} + +func (s *SelectstmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelectstmt(s) + } +} + +func (s *SelectstmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelectstmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Selectstmt() (localctx ISelectstmtContext) { + localctx = NewSelectstmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1496, RedshiftParserRULE_selectstmt) + p.SetState(12175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1091, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12173) + p.Select_no_parens() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12174) + p.Select_with_parens() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_with_parensContext is an interface to support dynamic dispatch. +type ISelect_with_parensContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Select_no_parens() ISelect_no_parensContext + CLOSE_PAREN() antlr.TerminalNode + Select_with_parens() ISelect_with_parensContext + + // IsSelect_with_parensContext differentiates from other interfaces. + IsSelect_with_parensContext() +} + +type Select_with_parensContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_with_parensContext() *Select_with_parensContext { + var p = new(Select_with_parensContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_with_parens + return p +} + +func InitEmptySelect_with_parensContext(p *Select_with_parensContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_with_parens +} + +func (*Select_with_parensContext) IsSelect_with_parensContext() {} + +func NewSelect_with_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_with_parensContext { + var p = new(Select_with_parensContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_with_parens + + return p +} + +func (s *Select_with_parensContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_with_parensContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Select_with_parensContext) Select_no_parens() ISelect_no_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_no_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_no_parensContext) +} + +func (s *Select_with_parensContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Select_with_parensContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *Select_with_parensContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_with_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_with_parensContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_with_parens(s) + } +} + +func (s *Select_with_parensContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_with_parens(s) + } +} + +func (s *Select_with_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_with_parens(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_with_parens() (localctx ISelect_with_parensContext) { + localctx = NewSelect_with_parensContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1498, RedshiftParserRULE_select_with_parens) + p.SetState(12185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1092, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12177) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12178) + p.Select_no_parens() + } + { + p.SetState(12179) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12181) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12182) + p.Select_with_parens() + } + { + p.SetState(12183) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_no_parensContext is an interface to support dynamic dispatch. +type ISelect_no_parensContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_clause() ISelect_clauseContext + Opt_sort_clause() IOpt_sort_clauseContext + For_locking_clause() IFor_locking_clauseContext + Select_limit() ISelect_limitContext + Opt_select_limit() IOpt_select_limitContext + Opt_for_locking_clause() IOpt_for_locking_clauseContext + With_clause() IWith_clauseContext + + // IsSelect_no_parensContext differentiates from other interfaces. + IsSelect_no_parensContext() +} + +type Select_no_parensContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_no_parensContext() *Select_no_parensContext { + var p = new(Select_no_parensContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_no_parens + return p +} + +func InitEmptySelect_no_parensContext(p *Select_no_parensContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_no_parens +} + +func (*Select_no_parensContext) IsSelect_no_parensContext() {} + +func NewSelect_no_parensContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_no_parensContext { + var p = new(Select_no_parensContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_no_parens + + return p +} + +func (s *Select_no_parensContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_no_parensContext) Select_clause() ISelect_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_clauseContext) +} + +func (s *Select_no_parensContext) Opt_sort_clause() IOpt_sort_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sort_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sort_clauseContext) +} + +func (s *Select_no_parensContext) For_locking_clause() IFor_locking_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_locking_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_locking_clauseContext) +} + +func (s *Select_no_parensContext) Select_limit() ISelect_limitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_limitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_limitContext) +} + +func (s *Select_no_parensContext) Opt_select_limit() IOpt_select_limitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_select_limitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_select_limitContext) +} + +func (s *Select_no_parensContext) Opt_for_locking_clause() IOpt_for_locking_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_for_locking_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_for_locking_clauseContext) +} + +func (s *Select_no_parensContext) With_clause() IWith_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_clauseContext) +} + +func (s *Select_no_parensContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_no_parensContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_no_parensContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_no_parens(s) + } +} + +func (s *Select_no_parensContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_no_parens(s) + } +} + +func (s *Select_no_parensContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_no_parens(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_no_parens() (localctx ISelect_no_parensContext) { + localctx = NewSelect_no_parensContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1500, RedshiftParserRULE_select_no_parens) + var _la int + + p.SetState(12216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserSELECT, RedshiftParserTABLE, RedshiftParserVALUES: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12187) + p.Select_clause() + } + p.SetState(12189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserORDER { + { + p.SetState(12188) + p.Opt_sort_clause() + } + + } + p.SetState(12199) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1096, p.GetParserRuleContext()) == 1 { + { + p.SetState(12191) + p.For_locking_clause() + } + p.SetState(12193) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1094, p.GetParserRuleContext()) == 1 { + { + p.SetState(12192) + p.Opt_select_limit() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1096, p.GetParserRuleContext()) == 2 { + { + p.SetState(12195) + p.Select_limit() + } + p.SetState(12197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(12196) + p.Opt_for_locking_clause() + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12201) + p.With_clause() + } + { + p.SetState(12202) + p.Select_clause() + } + p.SetState(12204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserORDER { + { + p.SetState(12203) + p.Opt_sort_clause() + } + + } + p.SetState(12214) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1100, p.GetParserRuleContext()) == 1 { + { + p.SetState(12206) + p.For_locking_clause() + } + p.SetState(12208) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1098, p.GetParserRuleContext()) == 1 { + { + p.SetState(12207) + p.Opt_select_limit() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1100, p.GetParserRuleContext()) == 2 { + { + p.SetState(12210) + p.Select_limit() + } + p.SetState(12212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(12211) + p.Opt_for_locking_clause() + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_clauseContext is an interface to support dynamic dispatch. +type ISelect_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSimple_select_intersect() []ISimple_select_intersectContext + Simple_select_intersect(i int) ISimple_select_intersectContext + AllUNION() []antlr.TerminalNode + UNION(i int) antlr.TerminalNode + AllEXCEPT() []antlr.TerminalNode + EXCEPT(i int) antlr.TerminalNode + AllAll_or_distinct() []IAll_or_distinctContext + All_or_distinct(i int) IAll_or_distinctContext + + // IsSelect_clauseContext differentiates from other interfaces. + IsSelect_clauseContext() +} + +type Select_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_clauseContext() *Select_clauseContext { + var p = new(Select_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_clause + return p +} + +func InitEmptySelect_clauseContext(p *Select_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_clause +} + +func (*Select_clauseContext) IsSelect_clauseContext() {} + +func NewSelect_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_clauseContext { + var p = new(Select_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_clause + + return p +} + +func (s *Select_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_clauseContext) AllSimple_select_intersect() []ISimple_select_intersectContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimple_select_intersectContext); ok { + len++ + } + } + + tst := make([]ISimple_select_intersectContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimple_select_intersectContext); ok { + tst[i] = t.(ISimple_select_intersectContext) + i++ + } + } + + return tst +} + +func (s *Select_clauseContext) Simple_select_intersect(i int) ISimple_select_intersectContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_select_intersectContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimple_select_intersectContext) +} + +func (s *Select_clauseContext) AllUNION() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserUNION) +} + +func (s *Select_clauseContext) UNION(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserUNION, i) +} + +func (s *Select_clauseContext) AllEXCEPT() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserEXCEPT) +} + +func (s *Select_clauseContext) EXCEPT(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCEPT, i) +} + +func (s *Select_clauseContext) AllAll_or_distinct() []IAll_or_distinctContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAll_or_distinctContext); ok { + len++ + } + } + + tst := make([]IAll_or_distinctContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAll_or_distinctContext); ok { + tst[i] = t.(IAll_or_distinctContext) + i++ + } + } + + return tst +} + +func (s *Select_clauseContext) All_or_distinct(i int) IAll_or_distinctContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_or_distinctContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAll_or_distinctContext) +} + +func (s *Select_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_clause(s) + } +} + +func (s *Select_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_clause(s) + } +} + +func (s *Select_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_clause() (localctx ISelect_clauseContext) { + localctx = NewSelect_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1502, RedshiftParserRULE_select_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12218) + p.Simple_select_intersect() + } + p.SetState(12226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserEXCEPT || _la == RedshiftParserUNION { + { + p.SetState(12219) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEXCEPT || _la == RedshiftParserUNION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserALL || _la == RedshiftParserDISTINCT { + { + p.SetState(12220) + p.All_or_distinct() + } + + } + { + p.SetState(12223) + p.Simple_select_intersect() + } + + p.SetState(12228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_select_intersectContext is an interface to support dynamic dispatch. +type ISimple_select_intersectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSimple_select_pramary() []ISimple_select_pramaryContext + Simple_select_pramary(i int) ISimple_select_pramaryContext + AllINTERSECT() []antlr.TerminalNode + INTERSECT(i int) antlr.TerminalNode + AllAll_or_distinct() []IAll_or_distinctContext + All_or_distinct(i int) IAll_or_distinctContext + + // IsSimple_select_intersectContext differentiates from other interfaces. + IsSimple_select_intersectContext() +} + +type Simple_select_intersectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimple_select_intersectContext() *Simple_select_intersectContext { + var p = new(Simple_select_intersectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_simple_select_intersect + return p +} + +func InitEmptySimple_select_intersectContext(p *Simple_select_intersectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_simple_select_intersect +} + +func (*Simple_select_intersectContext) IsSimple_select_intersectContext() {} + +func NewSimple_select_intersectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_intersectContext { + var p = new(Simple_select_intersectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_simple_select_intersect + + return p +} + +func (s *Simple_select_intersectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_select_intersectContext) AllSimple_select_pramary() []ISimple_select_pramaryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimple_select_pramaryContext); ok { + len++ + } + } + + tst := make([]ISimple_select_pramaryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimple_select_pramaryContext); ok { + tst[i] = t.(ISimple_select_pramaryContext) + i++ + } + } + + return tst +} + +func (s *Simple_select_intersectContext) Simple_select_pramary(i int) ISimple_select_pramaryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_select_pramaryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimple_select_pramaryContext) +} + +func (s *Simple_select_intersectContext) AllINTERSECT() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserINTERSECT) +} + +func (s *Simple_select_intersectContext) INTERSECT(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserINTERSECT, i) +} + +func (s *Simple_select_intersectContext) AllAll_or_distinct() []IAll_or_distinctContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAll_or_distinctContext); ok { + len++ + } + } + + tst := make([]IAll_or_distinctContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAll_or_distinctContext); ok { + tst[i] = t.(IAll_or_distinctContext) + i++ + } + } + + return tst +} + +func (s *Simple_select_intersectContext) All_or_distinct(i int) IAll_or_distinctContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_or_distinctContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAll_or_distinctContext) +} + +func (s *Simple_select_intersectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_select_intersectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_select_intersectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSimple_select_intersect(s) + } +} + +func (s *Simple_select_intersectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSimple_select_intersect(s) + } +} + +func (s *Simple_select_intersectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSimple_select_intersect(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Simple_select_intersect() (localctx ISimple_select_intersectContext) { + localctx = NewSimple_select_intersectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1504, RedshiftParserRULE_simple_select_intersect) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12229) + p.Simple_select_pramary() + } + p.SetState(12237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserINTERSECT { + { + p.SetState(12230) + p.Match(RedshiftParserINTERSECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserALL || _la == RedshiftParserDISTINCT { + { + p.SetState(12231) + p.All_or_distinct() + } + + } + { + p.SetState(12234) + p.Simple_select_pramary() + } + + p.SetState(12239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_select_pramaryContext is an interface to support dynamic dispatch. +type ISimple_select_pramaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + Target_list() ITarget_listContext + Distinct_clause() IDistinct_clauseContext + Exclude_clause() IExclude_clauseContext + AllInto_clause() []IInto_clauseContext + Into_clause(i int) IInto_clauseContext + From_clause() IFrom_clauseContext + Where_clause() IWhere_clauseContext + Start_with_clause() IStart_with_clauseContext + Group_clause() IGroup_clauseContext + Having_clause() IHaving_clauseContext + Qualify_clause() IQualify_clauseContext + Window_clause() IWindow_clauseContext + Opt_all_clause() IOpt_all_clauseContext + Opt_target_list() IOpt_target_listContext + Opt_top_clause() IOpt_top_clauseContext + Values_clause() IValues_clauseContext + TABLE() antlr.TerminalNode + Relation_expr() IRelation_exprContext + Select_with_parens() ISelect_with_parensContext + + // IsSimple_select_pramaryContext differentiates from other interfaces. + IsSimple_select_pramaryContext() +} + +type Simple_select_pramaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimple_select_pramaryContext() *Simple_select_pramaryContext { + var p = new(Simple_select_pramaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_simple_select_pramary + return p +} + +func InitEmptySimple_select_pramaryContext(p *Simple_select_pramaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_simple_select_pramary +} + +func (*Simple_select_pramaryContext) IsSimple_select_pramaryContext() {} + +func NewSimple_select_pramaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_select_pramaryContext { + var p = new(Simple_select_pramaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_simple_select_pramary + + return p +} + +func (s *Simple_select_pramaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_select_pramaryContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Simple_select_pramaryContext) Target_list() ITarget_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITarget_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITarget_listContext) +} + +func (s *Simple_select_pramaryContext) Distinct_clause() IDistinct_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDistinct_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDistinct_clauseContext) +} + +func (s *Simple_select_pramaryContext) Exclude_clause() IExclude_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExclude_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExclude_clauseContext) +} + +func (s *Simple_select_pramaryContext) AllInto_clause() []IInto_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInto_clauseContext); ok { + len++ + } + } + + tst := make([]IInto_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInto_clauseContext); ok { + tst[i] = t.(IInto_clauseContext) + i++ + } + } + + return tst +} + +func (s *Simple_select_pramaryContext) Into_clause(i int) IInto_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Simple_select_pramaryContext) From_clause() IFrom_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clauseContext) +} + +func (s *Simple_select_pramaryContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Simple_select_pramaryContext) Start_with_clause() IStart_with_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_with_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_with_clauseContext) +} + +func (s *Simple_select_pramaryContext) Group_clause() IGroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_clauseContext) +} + +func (s *Simple_select_pramaryContext) Having_clause() IHaving_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_clauseContext) +} + +func (s *Simple_select_pramaryContext) Qualify_clause() IQualify_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualify_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualify_clauseContext) +} + +func (s *Simple_select_pramaryContext) Window_clause() IWindow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_clauseContext) +} + +func (s *Simple_select_pramaryContext) Opt_all_clause() IOpt_all_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_all_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_all_clauseContext) +} + +func (s *Simple_select_pramaryContext) Opt_target_list() IOpt_target_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_target_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_target_listContext) +} + +func (s *Simple_select_pramaryContext) Opt_top_clause() IOpt_top_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_top_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_top_clauseContext) +} + +func (s *Simple_select_pramaryContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Simple_select_pramaryContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Simple_select_pramaryContext) Relation_expr() IRelation_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *Simple_select_pramaryContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *Simple_select_pramaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_select_pramaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_select_pramaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSimple_select_pramary(s) + } +} + +func (s *Simple_select_pramaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSimple_select_pramary(s) + } +} + +func (s *Simple_select_pramaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSimple_select_pramary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Simple_select_pramary() (localctx ISimple_select_pramaryContext) { + localctx = NewSimple_select_pramaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1506, RedshiftParserRULE_simple_select_pramary) + var _la int + + p.SetState(12293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSELECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12240) + p.Match(RedshiftParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1111, p.GetParserRuleContext()) { + case 1: + p.SetState(12242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserALL { + { + p.SetState(12241) + p.Opt_all_clause() + } + + } + p.SetState(12245) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1107, p.GetParserRuleContext()) == 1 { + { + p.SetState(12244) + p.Into_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12248) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1108, p.GetParserRuleContext()) == 1 { + { + p.SetState(12247) + p.Opt_target_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(12251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTOP { + { + p.SetState(12250) + p.Opt_top_clause() + } + + } + p.SetState(12254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINTO { + { + p.SetState(12253) + p.Into_clause() + } + + } + { + p.SetState(12256) + p.Target_list() + } + + case 3: + { + p.SetState(12257) + p.Distinct_clause() + } + { + p.SetState(12258) + p.Target_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(12263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCLUDE { + { + p.SetState(12262) + p.Exclude_clause() + } + + } + p.SetState(12266) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1113, p.GetParserRuleContext()) == 1 { + { + p.SetState(12265) + p.Into_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(12268) + p.From_clause() + } + + } + p.SetState(12272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(12271) + p.Where_clause() + } + + } + p.SetState(12275) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1116, p.GetParserRuleContext()) == 1 { + { + p.SetState(12274) + p.Start_with_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGROUP_P { + { + p.SetState(12277) + p.Group_clause() + } + + } + p.SetState(12281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserHAVING { + { + p.SetState(12280) + p.Having_clause() + } + + } + p.SetState(12284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserQUALIFY { + { + p.SetState(12283) + p.Qualify_clause() + } + + } + p.SetState(12287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWINDOW { + { + p.SetState(12286) + p.Window_clause() + } + + } + + case RedshiftParserVALUES: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12289) + p.Values_clause() + } + + case RedshiftParserTABLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12290) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12291) + p.Relation_expr() + } + + case RedshiftParserOPEN_PAREN: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12292) + p.Select_with_parens() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExclude_clauseContext is an interface to support dynamic dispatch. +type IExclude_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCLUDE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Columnlist() IColumnlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsExclude_clauseContext differentiates from other interfaces. + IsExclude_clauseContext() +} + +type Exclude_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExclude_clauseContext() *Exclude_clauseContext { + var p = new(Exclude_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclude_clause + return p +} + +func InitEmptyExclude_clauseContext(p *Exclude_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exclude_clause +} + +func (*Exclude_clauseContext) IsExclude_clauseContext() {} + +func NewExclude_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exclude_clauseContext { + var p = new(Exclude_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_exclude_clause + + return p +} + +func (s *Exclude_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exclude_clauseContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDE, 0) +} + +func (s *Exclude_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Exclude_clauseContext) Columnlist() IColumnlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnlistContext) +} + +func (s *Exclude_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Exclude_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exclude_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exclude_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExclude_clause(s) + } +} + +func (s *Exclude_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExclude_clause(s) + } +} + +func (s *Exclude_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExclude_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Exclude_clause() (localctx IExclude_clauseContext) { + localctx = NewExclude_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1508, RedshiftParserRULE_exclude_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12295) + p.Match(RedshiftParserEXCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12296) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12297) + p.Columnlist() + } + { + p.SetState(12298) + p.Match(RedshiftParserCLOSE_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 +} + +// IQualify_clauseContext is an interface to support dynamic dispatch. +type IQualify_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUALIFY() antlr.TerminalNode + A_expr() IA_exprContext + + // IsQualify_clauseContext differentiates from other interfaces. + IsQualify_clauseContext() +} + +type Qualify_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualify_clauseContext() *Qualify_clauseContext { + var p = new(Qualify_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qualify_clause + return p +} + +func InitEmptyQualify_clauseContext(p *Qualify_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qualify_clause +} + +func (*Qualify_clauseContext) IsQualify_clauseContext() {} + +func NewQualify_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualify_clauseContext { + var p = new(Qualify_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_qualify_clause + + return p +} + +func (s *Qualify_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualify_clauseContext) QUALIFY() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUALIFY, 0) +} + +func (s *Qualify_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Qualify_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualify_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualify_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterQualify_clause(s) + } +} + +func (s *Qualify_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitQualify_clause(s) + } +} + +func (s *Qualify_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitQualify_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Qualify_clause() (localctx IQualify_clauseContext) { + localctx = NewQualify_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1510, RedshiftParserRULE_qualify_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12300) + p.Match(RedshiftParserQUALIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12301) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_with_clauseContext is an interface to support dynamic dispatch. +type IStart_with_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONNECT() antlr.TerminalNode + BY() antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + START() antlr.TerminalNode + WITH() antlr.TerminalNode + + // IsStart_with_clauseContext differentiates from other interfaces. + IsStart_with_clauseContext() +} + +type Start_with_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_with_clauseContext() *Start_with_clauseContext { + var p = new(Start_with_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_start_with_clause + return p +} + +func InitEmptyStart_with_clauseContext(p *Start_with_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_start_with_clause +} + +func (*Start_with_clauseContext) IsStart_with_clauseContext() {} + +func NewStart_with_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_with_clauseContext { + var p = new(Start_with_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_start_with_clause + + return p +} + +func (s *Start_with_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_with_clauseContext) CONNECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECT, 0) +} + +func (s *Start_with_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Start_with_clauseContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Start_with_clauseContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Start_with_clauseContext) START() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTART, 0) +} + +func (s *Start_with_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Start_with_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_with_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_with_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStart_with_clause(s) + } +} + +func (s *Start_with_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStart_with_clause(s) + } +} + +func (s *Start_with_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStart_with_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Start_with_clause() (localctx IStart_with_clauseContext) { + localctx = NewStart_with_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1512, RedshiftParserRULE_start_with_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSTART { + { + p.SetState(12303) + p.Match(RedshiftParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12304) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12305) + p.A_expr() + } + + } + { + p.SetState(12308) + p.Match(RedshiftParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12309) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12310) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWith_clauseContext is an interface to support dynamic dispatch. +type IWith_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + Cte_list() ICte_listContext + RECURSIVE() antlr.TerminalNode + + // IsWith_clauseContext differentiates from other interfaces. + IsWith_clauseContext() +} + +type With_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_clauseContext() *With_clauseContext { + var p = new(With_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_with_clause + return p +} + +func InitEmptyWith_clauseContext(p *With_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_with_clause + + return p +} + +func (s *With_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *With_clauseContext) Cte_list() ICte_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICte_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICte_listContext) +} + +func (s *With_clauseContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRECURSIVE, 0) +} + +func (s *With_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWith_clause(s) + } +} + +func (s *With_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWith_clause(s) + } +} + +func (s *With_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWith_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) With_clause() (localctx IWith_clauseContext) { + localctx = NewWith_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1514, RedshiftParserRULE_with_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12312) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12314) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1123, p.GetParserRuleContext()) == 1 { + { + p.SetState(12313) + p.Match(RedshiftParserRECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12316) + p.Cte_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICte_listContext is an interface to support dynamic dispatch. +type ICte_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCommon_table_expr() []ICommon_table_exprContext + Common_table_expr(i int) ICommon_table_exprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCte_listContext differentiates from other interfaces. + IsCte_listContext() +} + +type Cte_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCte_listContext() *Cte_listContext { + var p = new(Cte_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cte_list + return p +} + +func InitEmptyCte_listContext(p *Cte_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cte_list +} + +func (*Cte_listContext) IsCte_listContext() {} + +func NewCte_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cte_listContext { + var p = new(Cte_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cte_list + + return p +} + +func (s *Cte_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cte_listContext) AllCommon_table_expr() []ICommon_table_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICommon_table_exprContext); ok { + len++ + } + } + + tst := make([]ICommon_table_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICommon_table_exprContext); ok { + tst[i] = t.(ICommon_table_exprContext) + i++ + } + } + + return tst +} + +func (s *Cte_listContext) Common_table_expr(i int) ICommon_table_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_table_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICommon_table_exprContext) +} + +func (s *Cte_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Cte_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Cte_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cte_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cte_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCte_list(s) + } +} + +func (s *Cte_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCte_list(s) + } +} + +func (s *Cte_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCte_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cte_list() (localctx ICte_listContext) { + localctx = NewCte_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1516, RedshiftParserRULE_cte_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12318) + p.Common_table_expr() + } + p.SetState(12323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12319) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12320) + p.Common_table_expr() + } + + p.SetState(12325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICommon_table_exprContext is an interface to support dynamic dispatch. +type ICommon_table_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Name() INameContext + AS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Preparablestmt() IPreparablestmtContext + CLOSE_PAREN() antlr.TerminalNode + Opt_name_list() IOpt_name_listContext + Opt_materialized() IOpt_materializedContext + + // IsCommon_table_exprContext differentiates from other interfaces. + IsCommon_table_exprContext() +} + +type Common_table_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommon_table_exprContext() *Common_table_exprContext { + var p = new(Common_table_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_table_expr + return p +} + +func InitEmptyCommon_table_exprContext(p *Common_table_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_common_table_expr +} + +func (*Common_table_exprContext) IsCommon_table_exprContext() {} + +func NewCommon_table_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_exprContext { + var p = new(Common_table_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_common_table_expr + + return p +} + +func (s *Common_table_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Common_table_exprContext) Name() INameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Common_table_exprContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Common_table_exprContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Common_table_exprContext) Preparablestmt() IPreparablestmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPreparablestmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPreparablestmtContext) +} + +func (s *Common_table_exprContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Common_table_exprContext) Opt_name_list() IOpt_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_name_listContext) +} + +func (s *Common_table_exprContext) Opt_materialized() IOpt_materializedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_materializedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_materializedContext) +} + +func (s *Common_table_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Common_table_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Common_table_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCommon_table_expr(s) + } +} + +func (s *Common_table_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCommon_table_expr(s) + } +} + +func (s *Common_table_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCommon_table_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Common_table_expr() (localctx ICommon_table_exprContext) { + localctx = NewCommon_table_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1518, RedshiftParserRULE_common_table_expr) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12326) + p.Name() + } + p.SetState(12328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(12327) + p.Opt_name_list() + } + + } + { + p.SetState(12330) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT || _la == RedshiftParserMATERIALIZED { + { + p.SetState(12331) + p.Opt_materialized() + } + + } + { + p.SetState(12334) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12335) + p.Preparablestmt() + } + { + p.SetState(12336) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_materializedContext is an interface to support dynamic dispatch. +type IOpt_materializedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATERIALIZED() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsOpt_materializedContext differentiates from other interfaces. + IsOpt_materializedContext() +} + +type Opt_materializedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_materializedContext() *Opt_materializedContext { + var p = new(Opt_materializedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_materialized + return p +} + +func InitEmptyOpt_materializedContext(p *Opt_materializedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_materialized +} + +func (*Opt_materializedContext) IsOpt_materializedContext() {} + +func NewOpt_materializedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_materializedContext { + var p = new(Opt_materializedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_materialized + + return p +} + +func (s *Opt_materializedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_materializedContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *Opt_materializedContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Opt_materializedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_materializedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_materializedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_materialized(s) + } +} + +func (s *Opt_materializedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_materialized(s) + } +} + +func (s *Opt_materializedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_materialized(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_materialized() (localctx IOpt_materializedContext) { + localctx = NewOpt_materializedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1520, RedshiftParserRULE_opt_materialized) + p.SetState(12341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserMATERIALIZED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12338) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNOT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12339) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12340) + p.Match(RedshiftParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_with_clauseContext is an interface to support dynamic dispatch. +type IOpt_with_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + With_clause() IWith_clauseContext + + // IsOpt_with_clauseContext differentiates from other interfaces. + IsOpt_with_clauseContext() +} + +type Opt_with_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_with_clauseContext() *Opt_with_clauseContext { + var p = new(Opt_with_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_clause + return p +} + +func InitEmptyOpt_with_clauseContext(p *Opt_with_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_with_clause +} + +func (*Opt_with_clauseContext) IsOpt_with_clauseContext() {} + +func NewOpt_with_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_with_clauseContext { + var p = new(Opt_with_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_with_clause + + return p +} + +func (s *Opt_with_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_with_clauseContext) With_clause() IWith_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_clauseContext) +} + +func (s *Opt_with_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_with_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_with_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_with_clause(s) + } +} + +func (s *Opt_with_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_with_clause(s) + } +} + +func (s *Opt_with_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_with_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_with_clause() (localctx IOpt_with_clauseContext) { + localctx = NewOpt_with_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1522, RedshiftParserRULE_opt_with_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12343) + p.With_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 +} + +// 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 + OpttempTableName() IOpttempTableNameContext + Into_target() IInto_targetContext + Opt_strict() IOpt_strictContext + + // 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 = RedshiftParserRULE_into_clause + return p +} + +func InitEmptyInto_clauseContext(p *Into_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_into_clause + + return p +} + +func (s *Into_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Into_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *Into_clauseContext) OpttempTableName() IOpttempTableNameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpttempTableNameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpttempTableNameContext) +} + +func (s *Into_clauseContext) Into_target() IInto_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_targetContext) +} + +func (s *Into_clauseContext) Opt_strict() IOpt_strictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_strictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_strictContext) +} + +func (s *Into_clauseContext) 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.(RedshiftParserListener); ok { + listenerT.EnterInto_clause(s) + } +} + +func (s *Into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInto_clause(s) + } +} + +func (s *Into_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInto_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Into_clause() (localctx IInto_clauseContext) { + localctx = NewInto_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1524, RedshiftParserRULE_into_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12345) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1129, p.GetParserRuleContext()) { + case 1: + p.SetState(12347) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1128, p.GetParserRuleContext()) == 1 { + { + p.SetState(12346) + p.Opt_strict() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12349) + p.OpttempTableName() + } + + case 2: + { + p.SetState(12350) + p.Into_target() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_top_clauseContext is an interface to support dynamic dispatch. +type IOpt_top_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TOP() antlr.TerminalNode + Iconst() IIconstContext + + // IsOpt_top_clauseContext differentiates from other interfaces. + IsOpt_top_clauseContext() +} + +type Opt_top_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_top_clauseContext() *Opt_top_clauseContext { + var p = new(Opt_top_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_top_clause + return p +} + +func InitEmptyOpt_top_clauseContext(p *Opt_top_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_top_clause +} + +func (*Opt_top_clauseContext) IsOpt_top_clauseContext() {} + +func NewOpt_top_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_top_clauseContext { + var p = new(Opt_top_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_top_clause + + return p +} + +func (s *Opt_top_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_top_clauseContext) TOP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTOP, 0) +} + +func (s *Opt_top_clauseContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Opt_top_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_top_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_top_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_top_clause(s) + } +} + +func (s *Opt_top_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_top_clause(s) + } +} + +func (s *Opt_top_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_top_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_top_clause() (localctx IOpt_top_clauseContext) { + localctx = NewOpt_top_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1526, RedshiftParserRULE_opt_top_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12353) + p.Match(RedshiftParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12354) + p.Iconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_strictContext is an interface to support dynamic dispatch. +type IOpt_strictContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRICT_P() antlr.TerminalNode + + // IsOpt_strictContext differentiates from other interfaces. + IsOpt_strictContext() +} + +type Opt_strictContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_strictContext() *Opt_strictContext { + var p = new(Opt_strictContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_strict + return p +} + +func InitEmptyOpt_strictContext(p *Opt_strictContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_strict +} + +func (*Opt_strictContext) IsOpt_strictContext() {} + +func NewOpt_strictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_strictContext { + var p = new(Opt_strictContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_strict + + return p +} + +func (s *Opt_strictContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_strictContext) STRICT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRICT_P, 0) +} + +func (s *Opt_strictContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_strictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_strictContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_strict(s) + } +} + +func (s *Opt_strictContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_strict(s) + } +} + +func (s *Opt_strictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_strict(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_strict() (localctx IOpt_strictContext) { + localctx = NewOpt_strictContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1528, RedshiftParserRULE_opt_strict) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12356) + p.Match(RedshiftParserSTRICT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpttempTableNameContext is an interface to support dynamic dispatch. +type IOpttempTableNameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name() IQualified_nameContext + TEMPORARY() antlr.TerminalNode + TEMP() antlr.TerminalNode + Opt_table() IOpt_tableContext + LOCAL() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + UNLOGGED() antlr.TerminalNode + TABLE() antlr.TerminalNode + + // IsOpttempTableNameContext differentiates from other interfaces. + IsOpttempTableNameContext() +} + +type OpttempTableNameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpttempTableNameContext() *OpttempTableNameContext { + var p = new(OpttempTableNameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttempTableName + return p +} + +func InitEmptyOpttempTableNameContext(p *OpttempTableNameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttempTableName +} + +func (*OpttempTableNameContext) IsOpttempTableNameContext() {} + +func NewOpttempTableNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttempTableNameContext { + var p = new(OpttempTableNameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opttempTableName + + return p +} + +func (s *OpttempTableNameContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpttempTableNameContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *OpttempTableNameContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPORARY, 0) +} + +func (s *OpttempTableNameContext) TEMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMP, 0) +} + +func (s *OpttempTableNameContext) Opt_table() IOpt_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_tableContext) +} + +func (s *OpttempTableNameContext) LOCAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCAL, 0) +} + +func (s *OpttempTableNameContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserGLOBAL, 0) +} + +func (s *OpttempTableNameContext) UNLOGGED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLOGGED, 0) +} + +func (s *OpttempTableNameContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *OpttempTableNameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpttempTableNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpttempTableNameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpttempTableName(s) + } +} + +func (s *OpttempTableNameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpttempTableName(s) + } +} + +func (s *OpttempTableNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpttempTableName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) OpttempTableName() (localctx IOpttempTableNameContext) { + localctx = NewOpttempTableNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1530, RedshiftParserRULE_opttempTableName) + var _la int + + p.SetState(12374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1133, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(12359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGLOBAL || _la == RedshiftParserLOCAL { + { + p.SetState(12358) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserGLOBAL || _la == RedshiftParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(12361) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTEMP || _la == RedshiftParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12363) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1131, p.GetParserRuleContext()) == 1 { + { + p.SetState(12362) + p.Opt_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12365) + p.Qualified_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12366) + p.Match(RedshiftParserUNLOGGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12368) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1132, p.GetParserRuleContext()) == 1 { + { + p.SetState(12367) + p.Opt_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12370) + p.Qualified_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12371) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12372) + p.Qualified_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12373) + p.Qualified_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_tableContext is an interface to support dynamic dispatch. +type IOpt_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + + // IsOpt_tableContext differentiates from other interfaces. + IsOpt_tableContext() +} + +type Opt_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_tableContext() *Opt_tableContext { + var p = new(Opt_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_table + return p +} + +func InitEmptyOpt_tableContext(p *Opt_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_table +} + +func (*Opt_tableContext) IsOpt_tableContext() {} + +func NewOpt_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_tableContext { + var p = new(Opt_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_table + + return p +} + +func (s *Opt_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Opt_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_table(s) + } +} + +func (s *Opt_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_table(s) + } +} + +func (s *Opt_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_table() (localctx IOpt_tableContext) { + localctx = NewOpt_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1532, RedshiftParserRULE_opt_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12376) + p.Match(RedshiftParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAll_or_distinctContext is an interface to support dynamic dispatch. +type IAll_or_distinctContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + + // IsAll_or_distinctContext differentiates from other interfaces. + IsAll_or_distinctContext() +} + +type All_or_distinctContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_or_distinctContext() *All_or_distinctContext { + var p = new(All_or_distinctContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_or_distinct + return p +} + +func InitEmptyAll_or_distinctContext(p *All_or_distinctContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_or_distinct +} + +func (*All_or_distinctContext) IsAll_or_distinctContext() {} + +func NewAll_or_distinctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_or_distinctContext { + var p = new(All_or_distinctContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_all_or_distinct + + return p +} + +func (s *All_or_distinctContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_or_distinctContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *All_or_distinctContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTINCT, 0) +} + +func (s *All_or_distinctContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_or_distinctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_or_distinctContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAll_or_distinct(s) + } +} + +func (s *All_or_distinctContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAll_or_distinct(s) + } +} + +func (s *All_or_distinctContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAll_or_distinct(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) All_or_distinct() (localctx IAll_or_distinctContext) { + localctx = NewAll_or_distinctContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1534, RedshiftParserRULE_all_or_distinct) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12378) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || _la == RedshiftParserDISTINCT) { + 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 +} + +// IDistinct_clauseContext is an interface to support dynamic dispatch. +type IDistinct_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISTINCT() antlr.TerminalNode + ON() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsDistinct_clauseContext differentiates from other interfaces. + IsDistinct_clauseContext() +} + +type Distinct_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDistinct_clauseContext() *Distinct_clauseContext { + var p = new(Distinct_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_distinct_clause + return p +} + +func InitEmptyDistinct_clauseContext(p *Distinct_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_distinct_clause +} + +func (*Distinct_clauseContext) IsDistinct_clauseContext() {} + +func NewDistinct_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Distinct_clauseContext { + var p = new(Distinct_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_distinct_clause + + return p +} + +func (s *Distinct_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Distinct_clauseContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTINCT, 0) +} + +func (s *Distinct_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Distinct_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Distinct_clauseContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Distinct_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Distinct_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Distinct_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Distinct_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDistinct_clause(s) + } +} + +func (s *Distinct_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDistinct_clause(s) + } +} + +func (s *Distinct_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDistinct_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Distinct_clause() (localctx IDistinct_clauseContext) { + localctx = NewDistinct_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1536, RedshiftParserRULE_distinct_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12380) + p.Match(RedshiftParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserON { + { + p.SetState(12381) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12382) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12383) + p.Expr_list() + } + { + p.SetState(12384) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_all_clauseContext is an interface to support dynamic dispatch. +type IOpt_all_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + + // IsOpt_all_clauseContext differentiates from other interfaces. + IsOpt_all_clauseContext() +} + +type Opt_all_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_all_clauseContext() *Opt_all_clauseContext { + var p = new(Opt_all_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_all_clause + return p +} + +func InitEmptyOpt_all_clauseContext(p *Opt_all_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_all_clause +} + +func (*Opt_all_clauseContext) IsOpt_all_clauseContext() {} + +func NewOpt_all_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_all_clauseContext { + var p = new(Opt_all_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_all_clause + + return p +} + +func (s *Opt_all_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_all_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Opt_all_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_all_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_all_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_all_clause(s) + } +} + +func (s *Opt_all_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_all_clause(s) + } +} + +func (s *Opt_all_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_all_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_all_clause() (localctx IOpt_all_clauseContext) { + localctx = NewOpt_all_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1538, RedshiftParserRULE_opt_all_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12388) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_sort_clauseContext is an interface to support dynamic dispatch. +type IOpt_sort_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sort_clause() ISort_clauseContext + + // IsOpt_sort_clauseContext differentiates from other interfaces. + IsOpt_sort_clauseContext() +} + +type Opt_sort_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_sort_clauseContext() *Opt_sort_clauseContext { + var p = new(Opt_sort_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_sort_clause + return p +} + +func InitEmptyOpt_sort_clauseContext(p *Opt_sort_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_sort_clause +} + +func (*Opt_sort_clauseContext) IsOpt_sort_clauseContext() {} + +func NewOpt_sort_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_sort_clauseContext { + var p = new(Opt_sort_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_sort_clause + + return p +} + +func (s *Opt_sort_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_sort_clauseContext) Sort_clause() ISort_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISort_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISort_clauseContext) +} + +func (s *Opt_sort_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_sort_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_sort_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_sort_clause(s) + } +} + +func (s *Opt_sort_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_sort_clause(s) + } +} + +func (s *Opt_sort_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_sort_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_sort_clause() (localctx IOpt_sort_clauseContext) { + localctx = NewOpt_sort_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1540, RedshiftParserRULE_opt_sort_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12390) + p.Sort_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 +} + +// ISort_clauseContext is an interface to support dynamic dispatch. +type ISort_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + Sortby_list() ISortby_listContext + + // IsSort_clauseContext differentiates from other interfaces. + IsSort_clauseContext() +} + +type Sort_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySort_clauseContext() *Sort_clauseContext { + var p = new(Sort_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sort_clause + return p +} + +func InitEmptySort_clauseContext(p *Sort_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sort_clause +} + +func (*Sort_clauseContext) IsSort_clauseContext() {} + +func NewSort_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sort_clauseContext { + var p = new(Sort_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sort_clause + + return p +} + +func (s *Sort_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sort_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserORDER, 0) +} + +func (s *Sort_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Sort_clauseContext) Sortby_list() ISortby_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortby_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISortby_listContext) +} + +func (s *Sort_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sort_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sort_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSort_clause(s) + } +} + +func (s *Sort_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSort_clause(s) + } +} + +func (s *Sort_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSort_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sort_clause() (localctx ISort_clauseContext) { + localctx = NewSort_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1542, RedshiftParserRULE_sort_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12392) + p.Match(RedshiftParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12393) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12394) + p.Sortby_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISortby_listContext is an interface to support dynamic dispatch. +type ISortby_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSortby() []ISortbyContext + Sortby(i int) ISortbyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSortby_listContext differentiates from other interfaces. + IsSortby_listContext() +} + +type Sortby_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySortby_listContext() *Sortby_listContext { + var p = new(Sortby_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortby_list + return p +} + +func InitEmptySortby_listContext(p *Sortby_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortby_list +} + +func (*Sortby_listContext) IsSortby_listContext() {} + +func NewSortby_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sortby_listContext { + var p = new(Sortby_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sortby_list + + return p +} + +func (s *Sortby_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sortby_listContext) AllSortby() []ISortbyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISortbyContext); ok { + len++ + } + } + + tst := make([]ISortbyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISortbyContext); ok { + tst[i] = t.(ISortbyContext) + i++ + } + } + + return tst +} + +func (s *Sortby_listContext) Sortby(i int) ISortbyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISortbyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISortbyContext) +} + +func (s *Sortby_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Sortby_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Sortby_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sortby_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sortby_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSortby_list(s) + } +} + +func (s *Sortby_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSortby_list(s) + } +} + +func (s *Sortby_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSortby_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sortby_list() (localctx ISortby_listContext) { + localctx = NewSortby_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1544, RedshiftParserRULE_sortby_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12396) + p.Sortby() + } + p.SetState(12401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12397) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12398) + p.Sortby() + } + + p.SetState(12403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISortbyContext is an interface to support dynamic dispatch. +type ISortbyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + USING() antlr.TerminalNode + Qual_all_op() IQual_all_opContext + Opt_nulls_order() IOpt_nulls_orderContext + Opt_asc_desc() IOpt_asc_descContext + + // IsSortbyContext differentiates from other interfaces. + IsSortbyContext() +} + +type SortbyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySortbyContext() *SortbyContext { + var p = new(SortbyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortby + return p +} + +func InitEmptySortbyContext(p *SortbyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sortby +} + +func (*SortbyContext) IsSortbyContext() {} + +func NewSortbyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortbyContext { + var p = new(SortbyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sortby + + return p +} + +func (s *SortbyContext) GetParser() antlr.Parser { return s.parser } + +func (s *SortbyContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *SortbyContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *SortbyContext) Qual_all_op() IQual_all_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQual_all_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQual_all_opContext) +} + +func (s *SortbyContext) Opt_nulls_order() IOpt_nulls_orderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_nulls_orderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_nulls_orderContext) +} + +func (s *SortbyContext) Opt_asc_desc() IOpt_asc_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_asc_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_asc_descContext) +} + +func (s *SortbyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SortbyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SortbyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSortby(s) + } +} + +func (s *SortbyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSortby(s) + } +} + +func (s *SortbyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSortby(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sortby() (localctx ISortbyContext) { + localctx = NewSortbyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1546, RedshiftParserRULE_sortby) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12404) + p.A_expr() + } + p.SetState(12410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserUSING: + { + p.SetState(12405) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12406) + p.Qual_all_op() + } + + case RedshiftParserEOF, RedshiftParserOPEN_PAREN, RedshiftParserCLOSE_PAREN, RedshiftParserCOMMA, RedshiftParserSEMI, RedshiftParserANALYSE, RedshiftParserANALYZE, RedshiftParserASC, RedshiftParserCREATE, RedshiftParserDESC, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserFOR, RedshiftParserGRANT, RedshiftParserINTO, RedshiftParserLIMIT, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserRETURNING, RedshiftParserSELECT, RedshiftParserTABLE, RedshiftParserWITH, RedshiftParserABORT_P, RedshiftParserALTER, RedshiftParserBEGIN_P, RedshiftParserCHECKPOINT, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMIT, RedshiftParserCOPY, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDELETE_P, RedshiftParserDISCARD, RedshiftParserDROP, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserINSERT, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCK_P, RedshiftParserMERGE, RedshiftParserNOTIFY, RedshiftParserNULLS_P, RedshiftParserPREPARE, RedshiftParserRANGE, RedshiftParserREASSIGN, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELEASE, RedshiftParserRESET, RedshiftParserREVOKE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserSAVEPOINT, RedshiftParserSECURITY, RedshiftParserSET, RedshiftParserSHOW, RedshiftParserSTART, RedshiftParserTRUNCATE, RedshiftParserUNLISTEN, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserUNLOAD, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserDESCRIBE, RedshiftParserVALUES, RedshiftParserCALL, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserIMPORT_P, RedshiftParserEND_P, RedshiftParserGROUPS, RedshiftParserLOOP, RedshiftParserMetaCommand: + p.SetState(12408) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1136, p.GetParserRuleContext()) == 1 { + { + p.SetState(12407) + p.Opt_asc_desc() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNULLS_P { + { + p.SetState(12412) + p.Opt_nulls_order() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_limitContext is an interface to support dynamic dispatch. +type ISelect_limitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Limit_clause() ILimit_clauseContext + Offset_clause() IOffset_clauseContext + + // IsSelect_limitContext differentiates from other interfaces. + IsSelect_limitContext() +} + +type Select_limitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_limitContext() *Select_limitContext { + var p = new(Select_limitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_limit + return p +} + +func InitEmptySelect_limitContext(p *Select_limitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_limit +} + +func (*Select_limitContext) IsSelect_limitContext() {} + +func NewSelect_limitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_limitContext { + var p = new(Select_limitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_limit + + return p +} + +func (s *Select_limitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_limitContext) Limit_clause() ILimit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_clauseContext) +} + +func (s *Select_limitContext) Offset_clause() IOffset_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOffset_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOffset_clauseContext) +} + +func (s *Select_limitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_limitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_limitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_limit(s) + } +} + +func (s *Select_limitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_limit(s) + } +} + +func (s *Select_limitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_limit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_limit() (localctx ISelect_limitContext) { + localctx = NewSelect_limitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1548, RedshiftParserRULE_select_limit) + var _la int + + p.SetState(12423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserFETCH, RedshiftParserLIMIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12415) + p.Limit_clause() + } + p.SetState(12417) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOFFSET { + { + p.SetState(12416) + p.Offset_clause() + } + + } + + case RedshiftParserOFFSET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12419) + p.Offset_clause() + } + p.SetState(12421) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1140, p.GetParserRuleContext()) == 1 { + { + p.SetState(12420) + p.Limit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_select_limitContext is an interface to support dynamic dispatch. +type IOpt_select_limitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_limit() ISelect_limitContext + + // IsOpt_select_limitContext differentiates from other interfaces. + IsOpt_select_limitContext() +} + +type Opt_select_limitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_select_limitContext() *Opt_select_limitContext { + var p = new(Opt_select_limitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_select_limit + return p +} + +func InitEmptyOpt_select_limitContext(p *Opt_select_limitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_select_limit +} + +func (*Opt_select_limitContext) IsOpt_select_limitContext() {} + +func NewOpt_select_limitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_select_limitContext { + var p = new(Opt_select_limitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_select_limit + + return p +} + +func (s *Opt_select_limitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_select_limitContext) Select_limit() ISelect_limitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_limitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_limitContext) +} + +func (s *Opt_select_limitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_select_limitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_select_limitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_select_limit(s) + } +} + +func (s *Opt_select_limitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_select_limit(s) + } +} + +func (s *Opt_select_limitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_select_limit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_select_limit() (localctx IOpt_select_limitContext) { + localctx = NewOpt_select_limitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1550, RedshiftParserRULE_opt_select_limit) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12425) + p.Select_limit() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILimit_clauseContext is an interface to support dynamic dispatch. +type ILimit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIMIT() antlr.TerminalNode + Select_limit_value() ISelect_limit_valueContext + COMMA() antlr.TerminalNode + Select_offset_value() ISelect_offset_valueContext + FETCH() antlr.TerminalNode + First_or_next() IFirst_or_nextContext + Select_fetch_first_value() ISelect_fetch_first_valueContext + Row_or_rows() IRow_or_rowsContext + ONLY() antlr.TerminalNode + WITH() antlr.TerminalNode + TIES() antlr.TerminalNode + + // IsLimit_clauseContext differentiates from other interfaces. + IsLimit_clauseContext() +} + +type Limit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLimit_clauseContext() *Limit_clauseContext { + var p = new(Limit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_limit_clause + return p +} + +func InitEmptyLimit_clauseContext(p *Limit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_limit_clause +} + +func (*Limit_clauseContext) IsLimit_clauseContext() {} + +func NewLimit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_clauseContext { + var p = new(Limit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_limit_clause + + return p +} + +func (s *Limit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Limit_clauseContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *Limit_clauseContext) Select_limit_value() ISelect_limit_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_limit_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_limit_valueContext) +} + +func (s *Limit_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Limit_clauseContext) Select_offset_value() ISelect_offset_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_offset_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_offset_valueContext) +} + +func (s *Limit_clauseContext) FETCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFETCH, 0) +} + +func (s *Limit_clauseContext) First_or_next() IFirst_or_nextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFirst_or_nextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFirst_or_nextContext) +} + +func (s *Limit_clauseContext) Select_fetch_first_value() ISelect_fetch_first_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_fetch_first_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_fetch_first_valueContext) +} + +func (s *Limit_clauseContext) Row_or_rows() IRow_or_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_or_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_or_rowsContext) +} + +func (s *Limit_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserONLY, 0) +} + +func (s *Limit_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Limit_clauseContext) TIES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIES, 0) +} + +func (s *Limit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Limit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Limit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLimit_clause(s) + } +} + +func (s *Limit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLimit_clause(s) + } +} + +func (s *Limit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLimit_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Limit_clause() (localctx ILimit_clauseContext) { + localctx = NewLimit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1552, RedshiftParserRULE_limit_clause) + var _la int + + p.SetState(12450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserLIMIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12427) + p.Match(RedshiftParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12428) + p.Select_limit_value() + } + p.SetState(12431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(12429) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12430) + p.Select_offset_value() + } + + } + + case RedshiftParserFETCH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12433) + p.Match(RedshiftParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12434) + p.First_or_next() + } + p.SetState(12448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1145, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12435) + p.Select_fetch_first_value() + } + { + p.SetState(12436) + p.Row_or_rows() + } + p.SetState(12440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserONLY: + { + p.SetState(12437) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserWITH: + { + p.SetState(12438) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12439) + p.Match(RedshiftParserTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + { + p.SetState(12442) + p.Row_or_rows() + } + p.SetState(12446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserONLY: + { + p.SetState(12443) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserWITH: + { + p.SetState(12444) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12445) + p.Match(RedshiftParserTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOffset_clauseContext is an interface to support dynamic dispatch. +type IOffset_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFSET() antlr.TerminalNode + Select_offset_value() ISelect_offset_valueContext + Select_fetch_first_value() ISelect_fetch_first_valueContext + Row_or_rows() IRow_or_rowsContext + + // IsOffset_clauseContext differentiates from other interfaces. + IsOffset_clauseContext() +} + +type Offset_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOffset_clauseContext() *Offset_clauseContext { + var p = new(Offset_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_offset_clause + return p +} + +func InitEmptyOffset_clauseContext(p *Offset_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_offset_clause + + return p +} + +func (s *Offset_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Offset_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFFSET, 0) +} + +func (s *Offset_clauseContext) Select_offset_value() ISelect_offset_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_offset_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_offset_valueContext) +} + +func (s *Offset_clauseContext) Select_fetch_first_value() ISelect_fetch_first_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_fetch_first_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_fetch_first_valueContext) +} + +func (s *Offset_clauseContext) Row_or_rows() IRow_or_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_or_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_or_rowsContext) +} + +func (s *Offset_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Offset_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Offset_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOffset_clause(s) + } +} + +func (s *Offset_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOffset_clause(s) + } +} + +func (s *Offset_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOffset_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Offset_clause() (localctx IOffset_clauseContext) { + localctx = NewOffset_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1554, RedshiftParserRULE_offset_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12452) + p.Match(RedshiftParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1147, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12453) + p.Select_offset_value() + } + + case 2: + { + p.SetState(12454) + p.Select_fetch_first_value() + } + { + p.SetState(12455) + p.Row_or_rows() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_limit_valueContext is an interface to support dynamic dispatch. +type ISelect_limit_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + ALL() antlr.TerminalNode + + // IsSelect_limit_valueContext differentiates from other interfaces. + IsSelect_limit_valueContext() +} + +type Select_limit_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_limit_valueContext() *Select_limit_valueContext { + var p = new(Select_limit_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_limit_value + return p +} + +func InitEmptySelect_limit_valueContext(p *Select_limit_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_limit_value +} + +func (*Select_limit_valueContext) IsSelect_limit_valueContext() {} + +func NewSelect_limit_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_limit_valueContext { + var p = new(Select_limit_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_limit_value + + return p +} + +func (s *Select_limit_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_limit_valueContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Select_limit_valueContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Select_limit_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_limit_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_limit_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_limit_value(s) + } +} + +func (s *Select_limit_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_limit_value(s) + } +} + +func (s *Select_limit_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_limit_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_limit_value() (localctx ISelect_limit_valueContext) { + localctx = NewSelect_limit_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1556, RedshiftParserRULE_select_limit_value) + p.SetState(12461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserPARAM, RedshiftParserOperator, RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserSESSION_USER, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserBinaryStringConstant, RedshiftParserHexadecimalStringConstant, RedshiftParserIntegral, RedshiftParserNumeric, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12459) + p.A_expr() + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12460) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_offset_valueContext is an interface to support dynamic dispatch. +type ISelect_offset_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + + // IsSelect_offset_valueContext differentiates from other interfaces. + IsSelect_offset_valueContext() +} + +type Select_offset_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_offset_valueContext() *Select_offset_valueContext { + var p = new(Select_offset_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_offset_value + return p +} + +func InitEmptySelect_offset_valueContext(p *Select_offset_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_offset_value +} + +func (*Select_offset_valueContext) IsSelect_offset_valueContext() {} + +func NewSelect_offset_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_offset_valueContext { + var p = new(Select_offset_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_offset_value + + return p +} + +func (s *Select_offset_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_offset_valueContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Select_offset_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_offset_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_offset_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_offset_value(s) + } +} + +func (s *Select_offset_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_offset_value(s) + } +} + +func (s *Select_offset_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_offset_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_offset_value() (localctx ISelect_offset_valueContext) { + localctx = NewSelect_offset_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1558, RedshiftParserRULE_select_offset_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12463) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISelect_fetch_first_valueContext is an interface to support dynamic dispatch. +type ISelect_fetch_first_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + C_expr() IC_exprContext + PLUS() antlr.TerminalNode + I_or_f_const() II_or_f_constContext + MINUS() antlr.TerminalNode + + // IsSelect_fetch_first_valueContext differentiates from other interfaces. + IsSelect_fetch_first_valueContext() +} + +type Select_fetch_first_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_fetch_first_valueContext() *Select_fetch_first_valueContext { + var p = new(Select_fetch_first_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_fetch_first_value + return p +} + +func InitEmptySelect_fetch_first_valueContext(p *Select_fetch_first_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_select_fetch_first_value +} + +func (*Select_fetch_first_valueContext) IsSelect_fetch_first_valueContext() {} + +func NewSelect_fetch_first_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_fetch_first_valueContext { + var p = new(Select_fetch_first_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_select_fetch_first_value + + return p +} + +func (s *Select_fetch_first_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_fetch_first_valueContext) C_expr() IC_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_exprContext) +} + +func (s *Select_fetch_first_valueContext) PLUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLUS, 0) +} + +func (s *Select_fetch_first_valueContext) I_or_f_const() II_or_f_constContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(II_or_f_constContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(II_or_f_constContext) +} + +func (s *Select_fetch_first_valueContext) MINUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUS, 0) +} + +func (s *Select_fetch_first_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_fetch_first_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_fetch_first_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSelect_fetch_first_value(s) + } +} + +func (s *Select_fetch_first_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSelect_fetch_first_value(s) + } +} + +func (s *Select_fetch_first_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSelect_fetch_first_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Select_fetch_first_value() (localctx ISelect_fetch_first_valueContext) { + localctx = NewSelect_fetch_first_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1560, RedshiftParserRULE_select_fetch_first_value) + p.SetState(12470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserPARAM, RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserSESSION_USER, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserBinaryStringConstant, RedshiftParserHexadecimalStringConstant, RedshiftParserIntegral, RedshiftParserNumeric, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12465) + p.C_expr() + } + + case RedshiftParserPLUS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12466) + p.Match(RedshiftParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12467) + p.I_or_f_const() + } + + case RedshiftParserMINUS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12468) + p.Match(RedshiftParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12469) + p.I_or_f_const() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// II_or_f_constContext is an interface to support dynamic dispatch. +type II_or_f_constContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Iconst() IIconstContext + Fconst() IFconstContext + + // IsI_or_f_constContext differentiates from other interfaces. + IsI_or_f_constContext() +} + +type I_or_f_constContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyI_or_f_constContext() *I_or_f_constContext { + var p = new(I_or_f_constContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_i_or_f_const + return p +} + +func InitEmptyI_or_f_constContext(p *I_or_f_constContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_i_or_f_const +} + +func (*I_or_f_constContext) IsI_or_f_constContext() {} + +func NewI_or_f_constContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *I_or_f_constContext { + var p = new(I_or_f_constContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_i_or_f_const + + return p +} + +func (s *I_or_f_constContext) GetParser() antlr.Parser { return s.parser } + +func (s *I_or_f_constContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *I_or_f_constContext) Fconst() IFconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFconstContext) +} + +func (s *I_or_f_constContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *I_or_f_constContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *I_or_f_constContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterI_or_f_const(s) + } +} + +func (s *I_or_f_constContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitI_or_f_const(s) + } +} + +func (s *I_or_f_constContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitI_or_f_const(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) I_or_f_const() (localctx II_or_f_constContext) { + localctx = NewI_or_f_constContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1562, RedshiftParserRULE_i_or_f_const) + p.SetState(12474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12472) + p.Iconst() + } + + case RedshiftParserNumeric: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12473) + p.Fconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRow_or_rowsContext is an interface to support dynamic dispatch. +type IRow_or_rowsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + ROWS() antlr.TerminalNode + + // IsRow_or_rowsContext differentiates from other interfaces. + IsRow_or_rowsContext() +} + +type Row_or_rowsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_or_rowsContext() *Row_or_rowsContext { + var p = new(Row_or_rowsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row_or_rows + return p +} + +func InitEmptyRow_or_rowsContext(p *Row_or_rowsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row_or_rows +} + +func (*Row_or_rowsContext) IsRow_or_rowsContext() {} + +func NewRow_or_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_or_rowsContext { + var p = new(Row_or_rowsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_row_or_rows + + return p +} + +func (s *Row_or_rowsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_or_rowsContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Row_or_rowsContext) ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWS, 0) +} + +func (s *Row_or_rowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_or_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_or_rowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRow_or_rows(s) + } +} + +func (s *Row_or_rowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRow_or_rows(s) + } +} + +func (s *Row_or_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRow_or_rows(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Row_or_rows() (localctx IRow_or_rowsContext) { + localctx = NewRow_or_rowsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1564, RedshiftParserRULE_row_or_rows) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12476) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserROWS || _la == RedshiftParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFirst_or_nextContext is an interface to support dynamic dispatch. +type IFirst_or_nextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FIRST_P() antlr.TerminalNode + NEXT() antlr.TerminalNode + + // IsFirst_or_nextContext differentiates from other interfaces. + IsFirst_or_nextContext() +} + +type First_or_nextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFirst_or_nextContext() *First_or_nextContext { + var p = new(First_or_nextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_first_or_next + return p +} + +func InitEmptyFirst_or_nextContext(p *First_or_nextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_first_or_next +} + +func (*First_or_nextContext) IsFirst_or_nextContext() {} + +func NewFirst_or_nextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *First_or_nextContext { + var p = new(First_or_nextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_first_or_next + + return p +} + +func (s *First_or_nextContext) GetParser() antlr.Parser { return s.parser } + +func (s *First_or_nextContext) FIRST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIRST_P, 0) +} + +func (s *First_or_nextContext) NEXT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEXT, 0) +} + +func (s *First_or_nextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *First_or_nextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *First_or_nextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFirst_or_next(s) + } +} + +func (s *First_or_nextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFirst_or_next(s) + } +} + +func (s *First_or_nextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFirst_or_next(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) First_or_next() (localctx IFirst_or_nextContext) { + localctx = NewFirst_or_nextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1566, RedshiftParserRULE_first_or_next) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12478) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFIRST_P || _la == RedshiftParserNEXT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGroup_clauseContext is an interface to support dynamic dispatch. +type IGroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP_P() antlr.TerminalNode + BY() antlr.TerminalNode + Group_by_list() IGroup_by_listContext + + // IsGroup_clauseContext differentiates from other interfaces. + IsGroup_clauseContext() +} + +type Group_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_clauseContext() *Group_clauseContext { + var p = new(Group_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_group_clause + return p +} + +func InitEmptyGroup_clauseContext(p *Group_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_group_clause +} + +func (*Group_clauseContext) IsGroup_clauseContext() {} + +func NewGroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_clauseContext { + var p = new(Group_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_group_clause + + return p +} + +func (s *Group_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_clauseContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *Group_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Group_clauseContext) Group_by_list() IGroup_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_listContext) +} + +func (s *Group_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGroup_clause(s) + } +} + +func (s *Group_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGroup_clause(s) + } +} + +func (s *Group_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGroup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Group_clause() (localctx IGroup_clauseContext) { + localctx = NewGroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1568, RedshiftParserRULE_group_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12480) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12481) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12482) + p.Group_by_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 +} + +// IGroup_by_listContext is an interface to support dynamic dispatch. +type IGroup_by_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGroup_by_item() []IGroup_by_itemContext + Group_by_item(i int) IGroup_by_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsGroup_by_listContext differentiates from other interfaces. + IsGroup_by_listContext() +} + +type Group_by_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_listContext() *Group_by_listContext { + var p = new(Group_by_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_group_by_list + return p +} + +func InitEmptyGroup_by_listContext(p *Group_by_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_group_by_list +} + +func (*Group_by_listContext) IsGroup_by_listContext() {} + +func NewGroup_by_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_listContext { + var p = new(Group_by_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_group_by_list + + return p +} + +func (s *Group_by_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_listContext) AllGroup_by_item() []IGroup_by_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_by_itemContext); ok { + len++ + } + } + + tst := make([]IGroup_by_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_by_itemContext); ok { + tst[i] = t.(IGroup_by_itemContext) + i++ + } + } + + return tst +} + +func (s *Group_by_listContext) Group_by_item(i int) IGroup_by_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_itemContext) +} + +func (s *Group_by_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Group_by_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Group_by_listContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Group_by_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGroup_by_list(s) + } +} + +func (s *Group_by_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGroup_by_list(s) + } +} + +func (s *Group_by_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGroup_by_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Group_by_list() (localctx IGroup_by_listContext) { + localctx = NewGroup_by_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1570, RedshiftParserRULE_group_by_list) + var _alt int + + p.SetState(12493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserPARAM, RedshiftParserOperator, RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserSESSION_USER, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserBinaryStringConstant, RedshiftParserHexadecimalStringConstant, RedshiftParserIntegral, RedshiftParserNumeric, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12484) + p.Group_by_item() + } + p.SetState(12489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1151, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(12485) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12486) + p.Group_by_item() + } + + } + p.SetState(12491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1151, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case RedshiftParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12492) + p.Match(RedshiftParserALL) + 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 +} + +// IGroup_by_itemContext is an interface to support dynamic dispatch. +type IGroup_by_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + Empty_grouping_set() IEmpty_grouping_setContext + Cube_clause() ICube_clauseContext + Rollup_clause() IRollup_clauseContext + Grouping_sets_clause() IGrouping_sets_clauseContext + + // IsGroup_by_itemContext differentiates from other interfaces. + IsGroup_by_itemContext() +} + +type Group_by_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_itemContext() *Group_by_itemContext { + var p = new(Group_by_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_group_by_item + return p +} + +func InitEmptyGroup_by_itemContext(p *Group_by_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_group_by_item +} + +func (*Group_by_itemContext) IsGroup_by_itemContext() {} + +func NewGroup_by_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_itemContext { + var p = new(Group_by_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_group_by_item + + return p +} + +func (s *Group_by_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_itemContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Group_by_itemContext) Empty_grouping_set() IEmpty_grouping_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEmpty_grouping_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEmpty_grouping_setContext) +} + +func (s *Group_by_itemContext) Cube_clause() ICube_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICube_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICube_clauseContext) +} + +func (s *Group_by_itemContext) Rollup_clause() IRollup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollup_clauseContext) +} + +func (s *Group_by_itemContext) Grouping_sets_clause() IGrouping_sets_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_clauseContext) +} + +func (s *Group_by_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGroup_by_item(s) + } +} + +func (s *Group_by_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGroup_by_item(s) + } +} + +func (s *Group_by_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGroup_by_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Group_by_item() (localctx IGroup_by_itemContext) { + localctx = NewGroup_by_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1572, RedshiftParserRULE_group_by_item) + p.SetState(12500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1153, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12495) + p.A_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12496) + p.Empty_grouping_set() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12497) + p.Cube_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12498) + p.Rollup_clause() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12499) + p.Grouping_sets_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 +} + +// IEmpty_grouping_setContext is an interface to support dynamic dispatch. +type IEmpty_grouping_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + + // IsEmpty_grouping_setContext differentiates from other interfaces. + IsEmpty_grouping_setContext() +} + +type Empty_grouping_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEmpty_grouping_setContext() *Empty_grouping_setContext { + var p = new(Empty_grouping_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_empty_grouping_set + return p +} + +func InitEmptyEmpty_grouping_setContext(p *Empty_grouping_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_empty_grouping_set +} + +func (*Empty_grouping_setContext) IsEmpty_grouping_setContext() {} + +func NewEmpty_grouping_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Empty_grouping_setContext { + var p = new(Empty_grouping_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_empty_grouping_set + + return p +} + +func (s *Empty_grouping_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Empty_grouping_setContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Empty_grouping_setContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Empty_grouping_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Empty_grouping_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Empty_grouping_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterEmpty_grouping_set(s) + } +} + +func (s *Empty_grouping_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitEmpty_grouping_set(s) + } +} + +func (s *Empty_grouping_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitEmpty_grouping_set(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Empty_grouping_set() (localctx IEmpty_grouping_setContext) { + localctx = NewEmpty_grouping_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1574, RedshiftParserRULE_empty_grouping_set) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12502) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12503) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollup_clauseContext is an interface to support dynamic dispatch. +type IRollup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLUP() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsRollup_clauseContext differentiates from other interfaces. + IsRollup_clauseContext() +} + +type Rollup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollup_clauseContext() *Rollup_clauseContext { + var p = new(Rollup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rollup_clause + return p +} + +func InitEmptyRollup_clauseContext(p *Rollup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rollup_clause +} + +func (*Rollup_clauseContext) IsRollup_clauseContext() {} + +func NewRollup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollup_clauseContext { + var p = new(Rollup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rollup_clause + + return p +} + +func (s *Rollup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollup_clauseContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLLUP, 0) +} + +func (s *Rollup_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Rollup_clauseContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Rollup_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Rollup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRollup_clause(s) + } +} + +func (s *Rollup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRollup_clause(s) + } +} + +func (s *Rollup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRollup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rollup_clause() (localctx IRollup_clauseContext) { + localctx = NewRollup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1576, RedshiftParserRULE_rollup_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12505) + p.Match(RedshiftParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12506) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12507) + p.Expr_list() + } + { + p.SetState(12508) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICube_clauseContext is an interface to support dynamic dispatch. +type ICube_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CUBE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsCube_clauseContext differentiates from other interfaces. + IsCube_clauseContext() +} + +type Cube_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCube_clauseContext() *Cube_clauseContext { + var p = new(Cube_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cube_clause + return p +} + +func InitEmptyCube_clauseContext(p *Cube_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cube_clause +} + +func (*Cube_clauseContext) IsCube_clauseContext() {} + +func NewCube_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cube_clauseContext { + var p = new(Cube_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cube_clause + + return p +} + +func (s *Cube_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cube_clauseContext) CUBE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCUBE, 0) +} + +func (s *Cube_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Cube_clauseContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Cube_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Cube_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cube_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cube_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCube_clause(s) + } +} + +func (s *Cube_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCube_clause(s) + } +} + +func (s *Cube_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCube_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cube_clause() (localctx ICube_clauseContext) { + localctx = NewCube_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1578, RedshiftParserRULE_cube_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12510) + p.Match(RedshiftParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12511) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12512) + p.Expr_list() + } + { + p.SetState(12513) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_sets_clauseContext is an interface to support dynamic dispatch. +type IGrouping_sets_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUPING() antlr.TerminalNode + SETS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Group_by_list() IGroup_by_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsGrouping_sets_clauseContext differentiates from other interfaces. + IsGrouping_sets_clauseContext() +} + +type Grouping_sets_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_sets_clauseContext() *Grouping_sets_clauseContext { + var p = new(Grouping_sets_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_grouping_sets_clause + return p +} + +func InitEmptyGrouping_sets_clauseContext(p *Grouping_sets_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_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(RedshiftParserGROUPING, 0) +} + +func (s *Grouping_sets_clauseContext) SETS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETS, 0) +} + +func (s *Grouping_sets_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Grouping_sets_clauseContext) Group_by_list() IGroup_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_listContext) +} + +func (s *Grouping_sets_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Grouping_sets_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_sets_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_sets_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGrouping_sets_clause(s) + } +} + +func (s *Grouping_sets_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGrouping_sets_clause(s) + } +} + +func (s *Grouping_sets_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGrouping_sets_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Grouping_sets_clause() (localctx IGrouping_sets_clauseContext) { + localctx = NewGrouping_sets_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1580, RedshiftParserRULE_grouping_sets_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12515) + p.Match(RedshiftParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12516) + p.Match(RedshiftParserSETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12517) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12518) + p.Group_by_list() + } + { + p.SetState(12519) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHaving_clauseContext is an interface to support dynamic dispatch. +type IHaving_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HAVING() antlr.TerminalNode + A_expr() IA_exprContext + + // IsHaving_clauseContext differentiates from other interfaces. + IsHaving_clauseContext() +} + +type Having_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHaving_clauseContext() *Having_clauseContext { + var p = new(Having_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_having_clause + return p +} + +func InitEmptyHaving_clauseContext(p *Having_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_having_clause + + return p +} + +func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Having_clauseContext) HAVING() antlr.TerminalNode { + return s.GetToken(RedshiftParserHAVING, 0) +} + +func (s *Having_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Having_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Having_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Having_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterHaving_clause(s) + } +} + +func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitHaving_clause(s) + } +} + +func (s *Having_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitHaving_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Having_clause() (localctx IHaving_clauseContext) { + localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1582, RedshiftParserRULE_having_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12521) + p.Match(RedshiftParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12522) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_locking_clauseContext is an interface to support dynamic dispatch. +type IFor_locking_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + For_locking_items() IFor_locking_itemsContext + FOR() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + + // IsFor_locking_clauseContext differentiates from other interfaces. + IsFor_locking_clauseContext() +} + +type For_locking_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_locking_clauseContext() *For_locking_clauseContext { + var p = new(For_locking_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_clause + return p +} + +func InitEmptyFor_locking_clauseContext(p *For_locking_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_clause +} + +func (*For_locking_clauseContext) IsFor_locking_clauseContext() {} + +func NewFor_locking_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_clauseContext { + var p = new(For_locking_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_for_locking_clause + + return p +} + +func (s *For_locking_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_locking_clauseContext) For_locking_items() IFor_locking_itemsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_locking_itemsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_locking_itemsContext) +} + +func (s *For_locking_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *For_locking_clauseContext) READ() antlr.TerminalNode { + return s.GetToken(RedshiftParserREAD, 0) +} + +func (s *For_locking_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserONLY, 0) +} + +func (s *For_locking_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_locking_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_locking_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFor_locking_clause(s) + } +} + +func (s *For_locking_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFor_locking_clause(s) + } +} + +func (s *For_locking_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFor_locking_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) For_locking_clause() (localctx IFor_locking_clauseContext) { + localctx = NewFor_locking_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1584, RedshiftParserRULE_for_locking_clause) + p.SetState(12528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1154, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12524) + p.For_locking_items() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12525) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12526) + p.Match(RedshiftParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12527) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_for_locking_clauseContext is an interface to support dynamic dispatch. +type IOpt_for_locking_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + For_locking_clause() IFor_locking_clauseContext + + // IsOpt_for_locking_clauseContext differentiates from other interfaces. + IsOpt_for_locking_clauseContext() +} + +type Opt_for_locking_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_for_locking_clauseContext() *Opt_for_locking_clauseContext { + var p = new(Opt_for_locking_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_for_locking_clause + return p +} + +func InitEmptyOpt_for_locking_clauseContext(p *Opt_for_locking_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_for_locking_clause +} + +func (*Opt_for_locking_clauseContext) IsOpt_for_locking_clauseContext() {} + +func NewOpt_for_locking_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_for_locking_clauseContext { + var p = new(Opt_for_locking_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_for_locking_clause + + return p +} + +func (s *Opt_for_locking_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_for_locking_clauseContext) For_locking_clause() IFor_locking_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_locking_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_locking_clauseContext) +} + +func (s *Opt_for_locking_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_for_locking_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_for_locking_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_for_locking_clause(s) + } +} + +func (s *Opt_for_locking_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_for_locking_clause(s) + } +} + +func (s *Opt_for_locking_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_for_locking_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_for_locking_clause() (localctx IOpt_for_locking_clauseContext) { + localctx = NewOpt_for_locking_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1586, RedshiftParserRULE_opt_for_locking_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12530) + p.For_locking_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 +} + +// IFor_locking_itemsContext is an interface to support dynamic dispatch. +type IFor_locking_itemsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFor_locking_item() []IFor_locking_itemContext + For_locking_item(i int) IFor_locking_itemContext + + // IsFor_locking_itemsContext differentiates from other interfaces. + IsFor_locking_itemsContext() +} + +type For_locking_itemsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_locking_itemsContext() *For_locking_itemsContext { + var p = new(For_locking_itemsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_items + return p +} + +func InitEmptyFor_locking_itemsContext(p *For_locking_itemsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_items +} + +func (*For_locking_itemsContext) IsFor_locking_itemsContext() {} + +func NewFor_locking_itemsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_itemsContext { + var p = new(For_locking_itemsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_for_locking_items + + return p +} + +func (s *For_locking_itemsContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_locking_itemsContext) AllFor_locking_item() []IFor_locking_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFor_locking_itemContext); ok { + len++ + } + } + + tst := make([]IFor_locking_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFor_locking_itemContext); ok { + tst[i] = t.(IFor_locking_itemContext) + i++ + } + } + + return tst +} + +func (s *For_locking_itemsContext) For_locking_item(i int) IFor_locking_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_locking_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFor_locking_itemContext) +} + +func (s *For_locking_itemsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_locking_itemsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_locking_itemsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFor_locking_items(s) + } +} + +func (s *For_locking_itemsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFor_locking_items(s) + } +} + +func (s *For_locking_itemsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFor_locking_items(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) For_locking_items() (localctx IFor_locking_itemsContext) { + localctx = NewFor_locking_itemsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1588, RedshiftParserRULE_for_locking_items) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserFOR { + { + p.SetState(12532) + p.For_locking_item() + } + + p.SetState(12535) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_locking_itemContext is an interface to support dynamic dispatch. +type IFor_locking_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + For_locking_strength() IFor_locking_strengthContext + Locked_rels_list() ILocked_rels_listContext + Opt_nowait_or_skip() IOpt_nowait_or_skipContext + + // IsFor_locking_itemContext differentiates from other interfaces. + IsFor_locking_itemContext() +} + +type For_locking_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_locking_itemContext() *For_locking_itemContext { + var p = new(For_locking_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_item + return p +} + +func InitEmptyFor_locking_itemContext(p *For_locking_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_item +} + +func (*For_locking_itemContext) IsFor_locking_itemContext() {} + +func NewFor_locking_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_itemContext { + var p = new(For_locking_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_for_locking_item + + return p +} + +func (s *For_locking_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_locking_itemContext) For_locking_strength() IFor_locking_strengthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_locking_strengthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_locking_strengthContext) +} + +func (s *For_locking_itemContext) Locked_rels_list() ILocked_rels_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocked_rels_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocked_rels_listContext) +} + +func (s *For_locking_itemContext) Opt_nowait_or_skip() IOpt_nowait_or_skipContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_nowait_or_skipContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_nowait_or_skipContext) +} + +func (s *For_locking_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_locking_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_locking_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFor_locking_item(s) + } +} + +func (s *For_locking_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFor_locking_item(s) + } +} + +func (s *For_locking_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFor_locking_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) For_locking_item() (localctx IFor_locking_itemContext) { + localctx = NewFor_locking_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1590, RedshiftParserRULE_for_locking_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12537) + p.For_locking_strength() + } + p.SetState(12539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOF { + { + p.SetState(12538) + p.Locked_rels_list() + } + + } + p.SetState(12542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOWAIT || _la == RedshiftParserSKIP_P { + { + p.SetState(12541) + p.Opt_nowait_or_skip() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_locking_strengthContext is an interface to support dynamic dispatch. +type IFor_locking_strengthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SHARE() antlr.TerminalNode + NO() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsFor_locking_strengthContext differentiates from other interfaces. + IsFor_locking_strengthContext() +} + +type For_locking_strengthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_locking_strengthContext() *For_locking_strengthContext { + var p = new(For_locking_strengthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_strength + return p +} + +func InitEmptyFor_locking_strengthContext(p *For_locking_strengthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_locking_strength +} + +func (*For_locking_strengthContext) IsFor_locking_strengthContext() {} + +func NewFor_locking_strengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_locking_strengthContext { + var p = new(For_locking_strengthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_for_locking_strength + + return p +} + +func (s *For_locking_strengthContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_locking_strengthContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *For_locking_strengthContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *For_locking_strengthContext) SHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHARE, 0) +} + +func (s *For_locking_strengthContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *For_locking_strengthContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *For_locking_strengthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_locking_strengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_locking_strengthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFor_locking_strength(s) + } +} + +func (s *For_locking_strengthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFor_locking_strength(s) + } +} + +func (s *For_locking_strengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFor_locking_strength(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) For_locking_strength() (localctx IFor_locking_strengthContext) { + localctx = NewFor_locking_strengthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1592, RedshiftParserRULE_for_locking_strength) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12544) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNO, RedshiftParserUPDATE: + p.SetState(12547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(12545) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12546) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12549) + p.Match(RedshiftParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserKEY, RedshiftParserSHARE: + p.SetState(12551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserKEY { + { + p.SetState(12550) + p.Match(RedshiftParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12553) + p.Match(RedshiftParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocked_rels_listContext is an interface to support dynamic dispatch. +type ILocked_rels_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + Qualified_name_list() IQualified_name_listContext + + // IsLocked_rels_listContext differentiates from other interfaces. + IsLocked_rels_listContext() +} + +type Locked_rels_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocked_rels_listContext() *Locked_rels_listContext { + var p = new(Locked_rels_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_locked_rels_list + return p +} + +func InitEmptyLocked_rels_listContext(p *Locked_rels_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_locked_rels_list +} + +func (*Locked_rels_listContext) IsLocked_rels_listContext() {} + +func NewLocked_rels_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Locked_rels_listContext { + var p = new(Locked_rels_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_locked_rels_list + + return p +} + +func (s *Locked_rels_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Locked_rels_listContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *Locked_rels_listContext) Qualified_name_list() IQualified_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_name_listContext) +} + +func (s *Locked_rels_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Locked_rels_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Locked_rels_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLocked_rels_list(s) + } +} + +func (s *Locked_rels_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLocked_rels_list(s) + } +} + +func (s *Locked_rels_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLocked_rels_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Locked_rels_list() (localctx ILocked_rels_listContext) { + localctx = NewLocked_rels_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1594, RedshiftParserRULE_locked_rels_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12556) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12557) + p.Qualified_name_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValues_clauseContext is an interface to support dynamic dispatch. +type IValues_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + AllExpr_list() []IExpr_listContext + Expr_list(i int) IExpr_listContext + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsValues_clauseContext differentiates from other interfaces. + IsValues_clauseContext() +} + +type Values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValues_clauseContext() *Values_clauseContext { + var p = new(Values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_values_clause + return p +} + +func InitEmptyValues_clauseContext(p *Values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_values_clause + + return p +} + +func (s *Values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUES, 0) +} + +func (s *Values_clauseContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *Values_clauseContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *Values_clauseContext) AllExpr_list() []IExpr_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpr_listContext); ok { + len++ + } + } + + tst := make([]IExpr_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpr_listContext); ok { + tst[i] = t.(IExpr_listContext) + i++ + } + } + + return tst +} + +func (s *Values_clauseContext) Expr_list(i int) IExpr_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Values_clauseContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *Values_clauseContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *Values_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Values_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterValues_clause(s) + } +} + +func (s *Values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitValues_clause(s) + } +} + +func (s *Values_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitValues_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Values_clause() (localctx IValues_clauseContext) { + localctx = NewValues_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1596, RedshiftParserRULE_values_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12559) + p.Match(RedshiftParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12560) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12561) + p.Expr_list() + } + { + p.SetState(12562) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12563) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12564) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12565) + p.Expr_list() + } + { + p.SetState(12566) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(12572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_clauseContext is an interface to support dynamic dispatch. +type IFrom_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + From_list() IFrom_listContext + + // IsFrom_clauseContext differentiates from other interfaces. + IsFrom_clauseContext() +} + +type From_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_clauseContext() *From_clauseContext { + var p = new(From_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_from_clause + return p +} + +func InitEmptyFrom_clauseContext(p *From_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_from_clause + + return p +} + +func (s *From_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *From_clauseContext) From_list() IFrom_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_listContext) +} + +func (s *From_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFrom_clause(s) + } +} + +func (s *From_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFrom_clause(s) + } +} + +func (s *From_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFrom_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) From_clause() (localctx IFrom_clauseContext) { + localctx = NewFrom_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1598, RedshiftParserRULE_from_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12573) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12574) + p.From_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrom_listContext is an interface to support dynamic dispatch. +type IFrom_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 + + // IsFrom_listContext differentiates from other interfaces. + IsFrom_listContext() +} + +type From_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_listContext() *From_listContext { + var p = new(From_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_from_list + return p +} + +func InitEmptyFrom_listContext(p *From_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_from_list +} + +func (*From_listContext) IsFrom_listContext() {} + +func NewFrom_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *From_listContext { + var p = new(From_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_from_list + + return p +} + +func (s *From_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_listContext) AllTable_ref() []ITable_refContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_refContext); ok { + len++ + } + } + + tst := make([]ITable_refContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_refContext); ok { + tst[i] = t.(ITable_refContext) + i++ + } + } + + return tst +} + +func (s *From_listContext) Table_ref(i int) ITable_refContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_refContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_refContext) +} + +func (s *From_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *From_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *From_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFrom_list(s) + } +} + +func (s *From_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFrom_list(s) + } +} + +func (s *From_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFrom_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) From_list() (localctx IFrom_listContext) { + localctx = NewFrom_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1600, RedshiftParserRULE_from_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12576) + p.Table_ref() + } + p.SetState(12581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1162, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(12577) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12578) + p.Table_ref() + } + + } + p.SetState(12583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1162, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_refContext is an interface to support dynamic dispatch. +type ITable_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Relation_expr() IRelation_exprContext + Func_table() IFunc_tableContext + Xmltable() IXmltableContext + Select_with_parens() ISelect_with_parensContext + LATERAL_P() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + AllTable_ref() []ITable_refContext + Table_ref(i int) ITable_refContext + CLOSE_PAREN() antlr.TerminalNode + AllJoined_table() []IJoined_tableContext + Joined_table(i int) IJoined_tableContext + Opt_alias_clause() IOpt_alias_clauseContext + Tablesample_clause() ITablesample_clauseContext + Func_alias_clause() IFunc_alias_clauseContext + CROSS() antlr.TerminalNode + JOIN() antlr.TerminalNode + NATURAL() antlr.TerminalNode + Join_qual() IJoin_qualContext + Join_type() IJoin_typeContext + + // IsTable_refContext differentiates from other interfaces. + IsTable_refContext() +} + +type Table_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_refContext() *Table_refContext { + var p = new(Table_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_ref + return p +} + +func InitEmptyTable_refContext(p *Table_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_table_ref + + return p +} + +func (s *Table_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_refContext) Relation_expr() IRelation_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *Table_refContext) Func_table() IFunc_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_tableContext) +} + +func (s *Table_refContext) Xmltable() IXmltableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltableContext) +} + +func (s *Table_refContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *Table_refContext) LATERAL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLATERAL_P, 0) +} + +func (s *Table_refContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Table_refContext) AllTable_ref() []ITable_refContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_refContext); ok { + len++ + } + } + + tst := make([]ITable_refContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_refContext); ok { + tst[i] = t.(ITable_refContext) + i++ + } + } + + return tst +} + +func (s *Table_refContext) Table_ref(i int) ITable_refContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_refContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_refContext) +} + +func (s *Table_refContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Table_refContext) AllJoined_table() []IJoined_tableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoined_tableContext); ok { + len++ + } + } + + tst := make([]IJoined_tableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoined_tableContext); ok { + tst[i] = t.(IJoined_tableContext) + i++ + } + } + + return tst +} + +func (s *Table_refContext) Joined_table(i int) IJoined_tableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoined_tableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoined_tableContext) +} + +func (s *Table_refContext) Opt_alias_clause() IOpt_alias_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_alias_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_alias_clauseContext) +} + +func (s *Table_refContext) Tablesample_clause() ITablesample_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablesample_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablesample_clauseContext) +} + +func (s *Table_refContext) Func_alias_clause() IFunc_alias_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_alias_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_alias_clauseContext) +} + +func (s *Table_refContext) CROSS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCROSS, 0) +} + +func (s *Table_refContext) JOIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserJOIN, 0) +} + +func (s *Table_refContext) NATURAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserNATURAL, 0) +} + +func (s *Table_refContext) Join_qual() IJoin_qualContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_qualContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_qualContext) +} + +func (s *Table_refContext) Join_type() IJoin_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_typeContext) +} + +func (s *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.(RedshiftParserListener); ok { + listenerT.EnterTable_ref(s) + } +} + +func (s *Table_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_ref(s) + } +} + +func (s *Table_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_ref(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_ref() (localctx ITable_refContext) { + localctx = NewTable_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1602, RedshiftParserRULE_table_ref) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1176, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12584) + p.Relation_expr() + } + p.SetState(12586) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1163, p.GetParserRuleContext()) == 1 { + { + p.SetState(12585) + p.Opt_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserTABLESAMPLE { + { + p.SetState(12588) + p.Tablesample_clause() + } + + } + + case 2: + { + p.SetState(12591) + p.Func_table() + } + p.SetState(12593) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1165, p.GetParserRuleContext()) == 1 { + { + p.SetState(12592) + p.Func_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(12595) + p.Xmltable() + } + p.SetState(12597) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1166, p.GetParserRuleContext()) == 1 { + { + p.SetState(12596) + p.Opt_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + { + p.SetState(12599) + p.Select_with_parens() + } + p.SetState(12601) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1167, p.GetParserRuleContext()) == 1 { + { + p.SetState(12600) + p.Opt_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + { + p.SetState(12603) + p.Match(RedshiftParserLATERAL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1171, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12604) + p.Xmltable() + } + p.SetState(12606) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1168, p.GetParserRuleContext()) == 1 { + { + p.SetState(12605) + p.Opt_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(12608) + p.Func_table() + } + p.SetState(12610) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1169, p.GetParserRuleContext()) == 1 { + { + p.SetState(12609) + p.Func_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(12612) + p.Select_with_parens() + } + p.SetState(12614) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1170, p.GetParserRuleContext()) == 1 { + { + p.SetState(12613) + p.Opt_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 6: + { + p.SetState(12618) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12619) + p.Table_ref() + } + p.SetState(12636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case RedshiftParserCROSS: + { + p.SetState(12620) + p.Match(RedshiftParserCROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12621) + p.Match(RedshiftParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12622) + p.Table_ref() + } + + case RedshiftParserNATURAL: + { + p.SetState(12623) + p.Match(RedshiftParserNATURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-115)) & ^0x3f) == 0 && ((int64(1)<<(_la-115))&8261) != 0 { + { + p.SetState(12624) + p.Join_type() + } + + } + { + p.SetState(12627) + p.Match(RedshiftParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12628) + p.Table_ref() + } + + case RedshiftParserFULL, RedshiftParserINNER_P, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserRIGHT: + p.SetState(12630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-115)) & ^0x3f) == 0 && ((int64(1)<<(_la-115))&8261) != 0 { + { + p.SetState(12629) + p.Join_type() + } + + } + { + p.SetState(12632) + p.Match(RedshiftParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12633) + p.Table_ref() + } + { + p.SetState(12634) + p.Join_qual() + } + + case RedshiftParserCLOSE_PAREN: + + default: + } + { + p.SetState(12638) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12640) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1175, p.GetParserRuleContext()) == 1 { + { + p.SetState(12639) + p.Opt_alias_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(12647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1177, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(12644) + p.Joined_table() + } + + } + p.SetState(12649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1177, 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 +} + +// IJoined_tableContext is an interface to support dynamic dispatch. +type IJoined_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JOIN() antlr.TerminalNode + Table_ref() ITable_refContext + Join_qual() IJoin_qualContext + Join_type() IJoin_typeContext + CROSS() antlr.TerminalNode + NATURAL() antlr.TerminalNode + + // IsJoined_tableContext differentiates from other interfaces. + IsJoined_tableContext() +} + +type Joined_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoined_tableContext() *Joined_tableContext { + var p = new(Joined_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_joined_table + return p +} + +func InitEmptyJoined_tableContext(p *Joined_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_joined_table +} + +func (*Joined_tableContext) IsJoined_tableContext() {} + +func NewJoined_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Joined_tableContext { + var p = new(Joined_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_joined_table + + return p +} + +func (s *Joined_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Joined_tableContext) JOIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserJOIN, 0) +} + +func (s *Joined_tableContext) 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 *Joined_tableContext) Join_qual() IJoin_qualContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_qualContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_qualContext) +} + +func (s *Joined_tableContext) Join_type() IJoin_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_typeContext) +} + +func (s *Joined_tableContext) CROSS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCROSS, 0) +} + +func (s *Joined_tableContext) NATURAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserNATURAL, 0) +} + +func (s *Joined_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Joined_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Joined_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterJoined_table(s) + } +} + +func (s *Joined_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitJoined_table(s) + } +} + +func (s *Joined_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitJoined_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Joined_table() (localctx IJoined_tableContext) { + localctx = NewJoined_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1604, RedshiftParserRULE_joined_table) + var _la int + + p.SetState(12666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserFULL, RedshiftParserINNER_P, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserRIGHT: + p.EnterOuterAlt(localctx, 1) + p.SetState(12651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-115)) & ^0x3f) == 0 && ((int64(1)<<(_la-115))&8261) != 0 { + { + p.SetState(12650) + p.Join_type() + } + + } + { + p.SetState(12653) + p.Match(RedshiftParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12654) + p.Table_ref() + } + { + p.SetState(12655) + p.Join_qual() + } + + case RedshiftParserCROSS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12657) + p.Match(RedshiftParserCROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12658) + p.Match(RedshiftParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12659) + p.Table_ref() + } + + case RedshiftParserNATURAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12660) + p.Match(RedshiftParserNATURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-115)) & ^0x3f) == 0 && ((int64(1)<<(_la-115))&8261) != 0 { + { + p.SetState(12661) + p.Join_type() + } + + } + { + p.SetState(12664) + p.Match(RedshiftParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12665) + p.Table_ref() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlias_clauseContext is an interface to support dynamic dispatch. +type IAlias_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + AS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Name_list() IName_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsAlias_clauseContext differentiates from other interfaces. + IsAlias_clauseContext() +} + +type Alias_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlias_clauseContext() *Alias_clauseContext { + var p = new(Alias_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alias_clause + return p +} + +func InitEmptyAlias_clauseContext(p *Alias_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_alias_clause +} + +func (*Alias_clauseContext) IsAlias_clauseContext() {} + +func NewAlias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alias_clauseContext { + var p = new(Alias_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_alias_clause + + return p +} + +func (s *Alias_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alias_clauseContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Alias_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Alias_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Alias_clauseContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *Alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Alias_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAlias_clause(s) + } +} + +func (s *Alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAlias_clause(s) + } +} + +func (s *Alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAlias_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Alias_clause() (localctx IAlias_clauseContext) { + localctx = NewAlias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1606, RedshiftParserRULE_alias_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(12668) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12671) + p.Colid() + } + p.SetState(12676) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1182, p.GetParserRuleContext()) == 1 { + { + p.SetState(12672) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12673) + p.Name_list() + } + { + p.SetState(12674) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_alias_clauseContext is an interface to support dynamic dispatch. +type IOpt_alias_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_alias_clause() ITable_alias_clauseContext + + // IsOpt_alias_clauseContext differentiates from other interfaces. + IsOpt_alias_clauseContext() +} + +type Opt_alias_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_alias_clauseContext() *Opt_alias_clauseContext { + var p = new(Opt_alias_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_alias_clause + return p +} + +func InitEmptyOpt_alias_clauseContext(p *Opt_alias_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_alias_clause +} + +func (*Opt_alias_clauseContext) IsOpt_alias_clauseContext() {} + +func NewOpt_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_alias_clauseContext { + var p = new(Opt_alias_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_alias_clause + + return p +} + +func (s *Opt_alias_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_alias_clauseContext) Table_alias_clause() ITable_alias_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_alias_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_alias_clauseContext) +} + +func (s *Opt_alias_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_alias_clause(s) + } +} + +func (s *Opt_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_alias_clause(s) + } +} + +func (s *Opt_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_alias_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_alias_clause() (localctx IOpt_alias_clauseContext) { + localctx = NewOpt_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1608, RedshiftParserRULE_opt_alias_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12678) + p.Table_alias_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 +} + +// ITable_alias_clauseContext is an interface to support dynamic dispatch. +type ITable_alias_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_alias() ITable_aliasContext + AS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Name_list() IName_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsTable_alias_clauseContext differentiates from other interfaces. + IsTable_alias_clauseContext() +} + +type Table_alias_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_alias_clauseContext() *Table_alias_clauseContext { + var p = new(Table_alias_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_alias_clause + return p +} + +func InitEmptyTable_alias_clauseContext(p *Table_alias_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_alias_clause +} + +func (*Table_alias_clauseContext) IsTable_alias_clauseContext() {} + +func NewTable_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_alias_clauseContext { + var p = new(Table_alias_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_table_alias_clause + + return p +} + +func (s *Table_alias_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_alias_clauseContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Table_alias_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Table_alias_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Table_alias_clauseContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *Table_alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Table_alias_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_alias_clause(s) + } +} + +func (s *Table_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_alias_clause(s) + } +} + +func (s *Table_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_alias_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_alias_clause() (localctx ITable_alias_clauseContext) { + localctx = NewTable_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1610, RedshiftParserRULE_table_alias_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(12680) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12683) + p.Table_alias() + } + p.SetState(12688) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1184, p.GetParserRuleContext()) == 1 { + { + p.SetState(12684) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12685) + p.Name_list() + } + { + p.SetState(12686) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_alias_clauseContext is an interface to support dynamic dispatch. +type IFunc_alias_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alias_clause() IAlias_clauseContext + OPEN_PAREN() antlr.TerminalNode + Tablefuncelementlist() ITablefuncelementlistContext + CLOSE_PAREN() antlr.TerminalNode + AS() antlr.TerminalNode + Colid() IColidContext + + // IsFunc_alias_clauseContext differentiates from other interfaces. + IsFunc_alias_clauseContext() +} + +type Func_alias_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_alias_clauseContext() *Func_alias_clauseContext { + var p = new(Func_alias_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_alias_clause + return p +} + +func InitEmptyFunc_alias_clauseContext(p *Func_alias_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_alias_clause +} + +func (*Func_alias_clauseContext) IsFunc_alias_clauseContext() {} + +func NewFunc_alias_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_alias_clauseContext { + var p = new(Func_alias_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_alias_clause + + return p +} + +func (s *Func_alias_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_alias_clauseContext) Alias_clause() IAlias_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlias_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlias_clauseContext) +} + +func (s *Func_alias_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Func_alias_clauseContext) Tablefuncelementlist() ITablefuncelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablefuncelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablefuncelementlistContext) +} + +func (s *Func_alias_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Func_alias_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Func_alias_clauseContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Func_alias_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_alias_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_alias_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_alias_clause(s) + } +} + +func (s *Func_alias_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_alias_clause(s) + } +} + +func (s *Func_alias_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_alias_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_alias_clause() (localctx IFunc_alias_clauseContext) { + localctx = NewFunc_alias_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1612, RedshiftParserRULE_func_alias_clause) + var _la int + + p.SetState(12702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1187, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12690) + p.Alias_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(12696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAS: + { + p.SetState(12691) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(12692) + p.Colid() + } + + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(12695) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12698) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12699) + p.Tablefuncelementlist() + } + { + p.SetState(12700) + p.Match(RedshiftParserCLOSE_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_typeContext is an interface to support dynamic dispatch. +type IJoin_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FULL() antlr.TerminalNode + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + INNER_P() antlr.TerminalNode + OUTER_P() antlr.TerminalNode + + // IsJoin_typeContext differentiates from other interfaces. + IsJoin_typeContext() +} + +type Join_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_typeContext() *Join_typeContext { + var p = new(Join_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_join_type + return p +} + +func InitEmptyJoin_typeContext(p *Join_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_join_type +} + +func (*Join_typeContext) IsJoin_typeContext() {} + +func NewJoin_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_typeContext { + var p = new(Join_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_join_type + + return p +} + +func (s *Join_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_typeContext) FULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserFULL, 0) +} + +func (s *Join_typeContext) LEFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEFT, 0) +} + +func (s *Join_typeContext) RIGHT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRIGHT, 0) +} + +func (s *Join_typeContext) INNER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINNER_P, 0) +} + +func (s *Join_typeContext) OUTER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOUTER_P, 0) +} + +func (s *Join_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterJoin_type(s) + } +} + +func (s *Join_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitJoin_type(s) + } +} + +func (s *Join_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitJoin_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Join_type() (localctx IJoin_typeContext) { + localctx = NewJoin_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1614, RedshiftParserRULE_join_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12704) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-115)) & ^0x3f) == 0 && ((int64(1)<<(_la-115))&8261) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12706) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOUTER_P { + { + p.SetState(12705) + p.Match(RedshiftParserOUTER_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJoin_qualContext is an interface to support dynamic dispatch. +type IJoin_qualContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Name_list() IName_listContext + CLOSE_PAREN() antlr.TerminalNode + ON() antlr.TerminalNode + A_expr() IA_exprContext + + // IsJoin_qualContext differentiates from other interfaces. + IsJoin_qualContext() +} + +type Join_qualContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_qualContext() *Join_qualContext { + var p = new(Join_qualContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_join_qual + return p +} + +func InitEmptyJoin_qualContext(p *Join_qualContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_join_qual +} + +func (*Join_qualContext) IsJoin_qualContext() {} + +func NewJoin_qualContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_qualContext { + var p = new(Join_qualContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_join_qual + + return p +} + +func (s *Join_qualContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_qualContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Join_qualContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Join_qualContext) Name_list() IName_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IName_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IName_listContext) +} + +func (s *Join_qualContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Join_qualContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Join_qualContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Join_qualContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_qualContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_qualContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterJoin_qual(s) + } +} + +func (s *Join_qualContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitJoin_qual(s) + } +} + +func (s *Join_qualContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitJoin_qual(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Join_qual() (localctx IJoin_qualContext) { + localctx = NewJoin_qualContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1616, RedshiftParserRULE_join_qual) + p.SetState(12715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserUSING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12708) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12709) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12710) + p.Name_list() + } + { + p.SetState(12711) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12713) + p.Match(RedshiftParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12714) + p.A_expr() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelation_exprContext is an interface to support dynamic dispatch. +type IRelation_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Qualified_name() IQualified_nameContext + STAR() antlr.TerminalNode + ONLY() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + + // IsRelation_exprContext differentiates from other interfaces. + IsRelation_exprContext() +} + +type Relation_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelation_exprContext() *Relation_exprContext { + var p = new(Relation_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_relation_expr + return p +} + +func InitEmptyRelation_exprContext(p *Relation_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_relation_expr +} + +func (*Relation_exprContext) IsRelation_exprContext() {} + +func NewRelation_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_exprContext { + var p = new(Relation_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_relation_expr + + return p +} + +func (s *Relation_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relation_exprContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Relation_exprContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *Relation_exprContext) ONLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserONLY, 0) +} + +func (s *Relation_exprContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Relation_exprContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Relation_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relation_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relation_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRelation_expr(s) + } +} + +func (s *Relation_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRelation_expr(s) + } +} + +func (s *Relation_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRelation_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Relation_expr() (localctx IRelation_exprContext) { + localctx = NewRelation_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1618, RedshiftParserRULE_relation_expr) + var _la int + + p.SetState(12729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12717) + p.Qualified_name() + } + p.SetState(12719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSTAR { + { + p.SetState(12718) + p.Match(RedshiftParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case RedshiftParserONLY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12721) + p.Match(RedshiftParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(12722) + p.Qualified_name() + } + + case RedshiftParserOPEN_PAREN: + { + p.SetState(12723) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12724) + p.Qualified_name() + } + { + p.SetState(12725) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelation_expr_listContext is an interface to support dynamic dispatch. +type IRelation_expr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRelation_expr() []IRelation_exprContext + Relation_expr(i int) IRelation_exprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRelation_expr_listContext differentiates from other interfaces. + IsRelation_expr_listContext() +} + +type Relation_expr_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelation_expr_listContext() *Relation_expr_listContext { + var p = new(Relation_expr_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_relation_expr_list + return p +} + +func InitEmptyRelation_expr_listContext(p *Relation_expr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_relation_expr_list +} + +func (*Relation_expr_listContext) IsRelation_expr_listContext() {} + +func NewRelation_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_expr_listContext { + var p = new(Relation_expr_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_relation_expr_list + + return p +} + +func (s *Relation_expr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relation_expr_listContext) AllRelation_expr() []IRelation_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelation_exprContext); ok { + len++ + } + } + + tst := make([]IRelation_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelation_exprContext); ok { + tst[i] = t.(IRelation_exprContext) + i++ + } + } + + return tst +} + +func (s *Relation_expr_listContext) Relation_expr(i int) IRelation_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *Relation_expr_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Relation_expr_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Relation_expr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relation_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relation_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRelation_expr_list(s) + } +} + +func (s *Relation_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRelation_expr_list(s) + } +} + +func (s *Relation_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRelation_expr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Relation_expr_list() (localctx IRelation_expr_listContext) { + localctx = NewRelation_expr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1620, RedshiftParserRULE_relation_expr_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12731) + p.Relation_expr() + } + p.SetState(12736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12732) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12733) + p.Relation_expr() + } + + p.SetState(12738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelation_expr_opt_aliasContext is an interface to support dynamic dispatch. +type IRelation_expr_opt_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Relation_expr() IRelation_exprContext + Colid() IColidContext + AS() antlr.TerminalNode + + // IsRelation_expr_opt_aliasContext differentiates from other interfaces. + IsRelation_expr_opt_aliasContext() +} + +type Relation_expr_opt_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelation_expr_opt_aliasContext() *Relation_expr_opt_aliasContext { + var p = new(Relation_expr_opt_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_relation_expr_opt_alias + return p +} + +func InitEmptyRelation_expr_opt_aliasContext(p *Relation_expr_opt_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_relation_expr_opt_alias +} + +func (*Relation_expr_opt_aliasContext) IsRelation_expr_opt_aliasContext() {} + +func NewRelation_expr_opt_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relation_expr_opt_aliasContext { + var p = new(Relation_expr_opt_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_relation_expr_opt_alias + + return p +} + +func (s *Relation_expr_opt_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relation_expr_opt_aliasContext) Relation_expr() IRelation_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelation_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelation_exprContext) +} + +func (s *Relation_expr_opt_aliasContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Relation_expr_opt_aliasContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Relation_expr_opt_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relation_expr_opt_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relation_expr_opt_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRelation_expr_opt_alias(s) + } +} + +func (s *Relation_expr_opt_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRelation_expr_opt_alias(s) + } +} + +func (s *Relation_expr_opt_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRelation_expr_opt_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Relation_expr_opt_alias() (localctx IRelation_expr_opt_aliasContext) { + localctx = NewRelation_expr_opt_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1622, RedshiftParserRULE_relation_expr_opt_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12739) + p.Relation_expr() + } + p.SetState(12744) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1195, p.GetParserRuleContext()) == 1 { + p.SetState(12741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(12740) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12743) + p.Colid() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablesample_clauseContext is an interface to support dynamic dispatch. +type ITablesample_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESAMPLE() antlr.TerminalNode + Func_name() IFunc_nameContext + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + CLOSE_PAREN() antlr.TerminalNode + Opt_repeatable_clause() IOpt_repeatable_clauseContext + + // IsTablesample_clauseContext differentiates from other interfaces. + IsTablesample_clauseContext() +} + +type Tablesample_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablesample_clauseContext() *Tablesample_clauseContext { + var p = new(Tablesample_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablesample_clause + return p +} + +func InitEmptyTablesample_clauseContext(p *Tablesample_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablesample_clause +} + +func (*Tablesample_clauseContext) IsTablesample_clauseContext() {} + +func NewTablesample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablesample_clauseContext { + var p = new(Tablesample_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tablesample_clause + + return p +} + +func (s *Tablesample_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablesample_clauseContext) TABLESAMPLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESAMPLE, 0) +} + +func (s *Tablesample_clauseContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *Tablesample_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Tablesample_clauseContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Tablesample_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Tablesample_clauseContext) Opt_repeatable_clause() IOpt_repeatable_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_repeatable_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_repeatable_clauseContext) +} + +func (s *Tablesample_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablesample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablesample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTablesample_clause(s) + } +} + +func (s *Tablesample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTablesample_clause(s) + } +} + +func (s *Tablesample_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTablesample_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tablesample_clause() (localctx ITablesample_clauseContext) { + localctx = NewTablesample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1624, RedshiftParserRULE_tablesample_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12746) + p.Match(RedshiftParserTABLESAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12747) + p.Func_name() + } + { + p.SetState(12748) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12749) + p.Expr_list() + } + { + p.SetState(12750) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserREPEATABLE { + { + p.SetState(12751) + p.Opt_repeatable_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_repeatable_clauseContext is an interface to support dynamic dispatch. +type IOpt_repeatable_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPEATABLE() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_repeatable_clauseContext differentiates from other interfaces. + IsOpt_repeatable_clauseContext() +} + +type Opt_repeatable_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_repeatable_clauseContext() *Opt_repeatable_clauseContext { + var p = new(Opt_repeatable_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_repeatable_clause + return p +} + +func InitEmptyOpt_repeatable_clauseContext(p *Opt_repeatable_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_repeatable_clause +} + +func (*Opt_repeatable_clauseContext) IsOpt_repeatable_clauseContext() {} + +func NewOpt_repeatable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_repeatable_clauseContext { + var p = new(Opt_repeatable_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_repeatable_clause + + return p +} + +func (s *Opt_repeatable_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_repeatable_clauseContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPEATABLE, 0) +} + +func (s *Opt_repeatable_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_repeatable_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_repeatable_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_repeatable_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_repeatable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_repeatable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_repeatable_clause(s) + } +} + +func (s *Opt_repeatable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_repeatable_clause(s) + } +} + +func (s *Opt_repeatable_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_repeatable_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_repeatable_clause() (localctx IOpt_repeatable_clauseContext) { + localctx = NewOpt_repeatable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1626, RedshiftParserRULE_opt_repeatable_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12754) + p.Match(RedshiftParserREPEATABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12755) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12756) + p.A_expr() + } + { + p.SetState(12757) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_tableContext is an interface to support dynamic dispatch. +type IFunc_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_expr_windowless() IFunc_expr_windowlessContext + Opt_ordinality() IOpt_ordinalityContext + ROWS() antlr.TerminalNode + FROM() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Rowsfrom_list() IRowsfrom_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsFunc_tableContext differentiates from other interfaces. + IsFunc_tableContext() +} + +type Func_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_tableContext() *Func_tableContext { + var p = new(Func_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_table + return p +} + +func InitEmptyFunc_tableContext(p *Func_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_table +} + +func (*Func_tableContext) IsFunc_tableContext() {} + +func NewFunc_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_tableContext { + var p = new(Func_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_table + + return p +} + +func (s *Func_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_tableContext) Func_expr_windowless() IFunc_expr_windowlessContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_expr_windowlessContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_expr_windowlessContext) +} + +func (s *Func_tableContext) Opt_ordinality() IOpt_ordinalityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_ordinalityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_ordinalityContext) +} + +func (s *Func_tableContext) ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWS, 0) +} + +func (s *Func_tableContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Func_tableContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Func_tableContext) Rowsfrom_list() IRowsfrom_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsfrom_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRowsfrom_listContext) +} + +func (s *Func_tableContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Func_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_table(s) + } +} + +func (s *Func_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_table(s) + } +} + +func (s *Func_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_table() (localctx IFunc_tableContext) { + localctx = NewFunc_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1628, RedshiftParserRULE_func_table) + p.SetState(12771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1199, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12759) + p.Func_expr_windowless() + } + p.SetState(12761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1197, p.GetParserRuleContext()) == 1 { + { + p.SetState(12760) + p.Opt_ordinality() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12763) + p.Match(RedshiftParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12764) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12765) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12766) + p.Rowsfrom_list() + } + { + p.SetState(12767) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12769) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1198, p.GetParserRuleContext()) == 1 { + { + p.SetState(12768) + p.Opt_ordinality() + } + + } 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 +} + +// IRowsfrom_itemContext is an interface to support dynamic dispatch. +type IRowsfrom_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_expr_windowless() IFunc_expr_windowlessContext + Opt_col_def_list() IOpt_col_def_listContext + + // IsRowsfrom_itemContext differentiates from other interfaces. + IsRowsfrom_itemContext() +} + +type Rowsfrom_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsfrom_itemContext() *Rowsfrom_itemContext { + var p = new(Rowsfrom_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsfrom_item + return p +} + +func InitEmptyRowsfrom_itemContext(p *Rowsfrom_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsfrom_item +} + +func (*Rowsfrom_itemContext) IsRowsfrom_itemContext() {} + +func NewRowsfrom_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowsfrom_itemContext { + var p = new(Rowsfrom_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsfrom_item + + return p +} + +func (s *Rowsfrom_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rowsfrom_itemContext) Func_expr_windowless() IFunc_expr_windowlessContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_expr_windowlessContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_expr_windowlessContext) +} + +func (s *Rowsfrom_itemContext) Opt_col_def_list() IOpt_col_def_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_col_def_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_col_def_listContext) +} + +func (s *Rowsfrom_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rowsfrom_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rowsfrom_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsfrom_item(s) + } +} + +func (s *Rowsfrom_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsfrom_item(s) + } +} + +func (s *Rowsfrom_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsfrom_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsfrom_item() (localctx IRowsfrom_itemContext) { + localctx = NewRowsfrom_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1630, RedshiftParserRULE_rowsfrom_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12773) + p.Func_expr_windowless() + } + p.SetState(12775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(12774) + p.Opt_col_def_list() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRowsfrom_listContext is an interface to support dynamic dispatch. +type IRowsfrom_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRowsfrom_item() []IRowsfrom_itemContext + Rowsfrom_item(i int) IRowsfrom_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRowsfrom_listContext differentiates from other interfaces. + IsRowsfrom_listContext() +} + +type Rowsfrom_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowsfrom_listContext() *Rowsfrom_listContext { + var p = new(Rowsfrom_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsfrom_list + return p +} + +func InitEmptyRowsfrom_listContext(p *Rowsfrom_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rowsfrom_list +} + +func (*Rowsfrom_listContext) IsRowsfrom_listContext() {} + +func NewRowsfrom_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rowsfrom_listContext { + var p = new(Rowsfrom_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rowsfrom_list + + return p +} + +func (s *Rowsfrom_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rowsfrom_listContext) AllRowsfrom_item() []IRowsfrom_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRowsfrom_itemContext); ok { + len++ + } + } + + tst := make([]IRowsfrom_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRowsfrom_itemContext); ok { + tst[i] = t.(IRowsfrom_itemContext) + i++ + } + } + + return tst +} + +func (s *Rowsfrom_listContext) Rowsfrom_item(i int) IRowsfrom_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowsfrom_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRowsfrom_itemContext) +} + +func (s *Rowsfrom_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Rowsfrom_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Rowsfrom_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rowsfrom_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rowsfrom_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRowsfrom_list(s) + } +} + +func (s *Rowsfrom_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRowsfrom_list(s) + } +} + +func (s *Rowsfrom_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRowsfrom_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rowsfrom_list() (localctx IRowsfrom_listContext) { + localctx = NewRowsfrom_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1632, RedshiftParserRULE_rowsfrom_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12777) + p.Rowsfrom_item() + } + p.SetState(12782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12778) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12779) + p.Rowsfrom_item() + } + + p.SetState(12784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_col_def_listContext is an interface to support dynamic dispatch. +type IOpt_col_def_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Tablefuncelementlist() ITablefuncelementlistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_col_def_listContext differentiates from other interfaces. + IsOpt_col_def_listContext() +} + +type Opt_col_def_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_col_def_listContext() *Opt_col_def_listContext { + var p = new(Opt_col_def_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_col_def_list + return p +} + +func InitEmptyOpt_col_def_listContext(p *Opt_col_def_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_col_def_list +} + +func (*Opt_col_def_listContext) IsOpt_col_def_listContext() {} + +func NewOpt_col_def_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_col_def_listContext { + var p = new(Opt_col_def_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_col_def_list + + return p +} + +func (s *Opt_col_def_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_col_def_listContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Opt_col_def_listContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_col_def_listContext) Tablefuncelementlist() ITablefuncelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablefuncelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablefuncelementlistContext) +} + +func (s *Opt_col_def_listContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_col_def_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_col_def_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_col_def_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_col_def_list(s) + } +} + +func (s *Opt_col_def_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_col_def_list(s) + } +} + +func (s *Opt_col_def_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_col_def_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_col_def_list() (localctx IOpt_col_def_listContext) { + localctx = NewOpt_col_def_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1634, RedshiftParserRULE_opt_col_def_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12785) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12786) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12787) + p.Tablefuncelementlist() + } + { + p.SetState(12788) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_ordinalityContext is an interface to support dynamic dispatch. +type IOpt_ordinalityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + + // IsOpt_ordinalityContext differentiates from other interfaces. + IsOpt_ordinalityContext() +} + +type Opt_ordinalityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_ordinalityContext() *Opt_ordinalityContext { + var p = new(Opt_ordinalityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_ordinality + return p +} + +func InitEmptyOpt_ordinalityContext(p *Opt_ordinalityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_ordinality +} + +func (*Opt_ordinalityContext) IsOpt_ordinalityContext() {} + +func NewOpt_ordinalityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_ordinalityContext { + var p = new(Opt_ordinalityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_ordinality + + return p +} + +func (s *Opt_ordinalityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_ordinalityContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_ordinalityContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserORDINALITY, 0) +} + +func (s *Opt_ordinalityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_ordinalityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_ordinalityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_ordinality(s) + } +} + +func (s *Opt_ordinalityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_ordinality(s) + } +} + +func (s *Opt_ordinalityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_ordinality(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_ordinality() (localctx IOpt_ordinalityContext) { + localctx = NewOpt_ordinalityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1636, RedshiftParserRULE_opt_ordinality) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12790) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12791) + p.Match(RedshiftParserORDINALITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhere_clauseContext is an interface to support dynamic dispatch. +type IWhere_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + A_expr() IA_exprContext + + // IsWhere_clauseContext differentiates from other interfaces. + IsWhere_clauseContext() +} + +type Where_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhere_clauseContext() *Where_clauseContext { + var p = new(Where_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_where_clause + return p +} + +func InitEmptyWhere_clauseContext(p *Where_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_where_clause + + return p +} + +func (s *Where_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Where_clauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHERE, 0) +} + +func (s *Where_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Where_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Where_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Where_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWhere_clause(s) + } +} + +func (s *Where_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWhere_clause(s) + } +} + +func (s *Where_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWhere_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Where_clause() (localctx IWhere_clauseContext) { + localctx = NewWhere_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1638, RedshiftParserRULE_where_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12793) + p.Match(RedshiftParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12794) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhere_or_current_clauseContext is an interface to support dynamic dispatch. +type IWhere_or_current_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHERE() antlr.TerminalNode + CURRENT_P() antlr.TerminalNode + OF() antlr.TerminalNode + Cursor_name() ICursor_nameContext + A_expr() IA_exprContext + + // IsWhere_or_current_clauseContext differentiates from other interfaces. + IsWhere_or_current_clauseContext() +} + +type Where_or_current_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhere_or_current_clauseContext() *Where_or_current_clauseContext { + var p = new(Where_or_current_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_where_or_current_clause + return p +} + +func InitEmptyWhere_or_current_clauseContext(p *Where_or_current_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_where_or_current_clause +} + +func (*Where_or_current_clauseContext) IsWhere_or_current_clauseContext() {} + +func NewWhere_or_current_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Where_or_current_clauseContext { + var p = new(Where_or_current_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_where_or_current_clause + + return p +} + +func (s *Where_or_current_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Where_or_current_clauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHERE, 0) +} + +func (s *Where_or_current_clauseContext) CURRENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_P, 0) +} + +func (s *Where_or_current_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *Where_or_current_clauseContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Where_or_current_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Where_or_current_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Where_or_current_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Where_or_current_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWhere_or_current_clause(s) + } +} + +func (s *Where_or_current_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWhere_or_current_clause(s) + } +} + +func (s *Where_or_current_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWhere_or_current_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Where_or_current_clause() (localctx IWhere_or_current_clauseContext) { + localctx = NewWhere_or_current_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1640, RedshiftParserRULE_where_or_current_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12796) + p.Match(RedshiftParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1202, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12797) + p.Match(RedshiftParserCURRENT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12798) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12799) + p.Cursor_name() + } + + case 2: + { + p.SetState(12800) + p.A_expr() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpttablefuncelementlistContext is an interface to support dynamic dispatch. +type IOpttablefuncelementlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tablefuncelementlist() ITablefuncelementlistContext + + // IsOpttablefuncelementlistContext differentiates from other interfaces. + IsOpttablefuncelementlistContext() +} + +type OpttablefuncelementlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpttablefuncelementlistContext() *OpttablefuncelementlistContext { + var p = new(OpttablefuncelementlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttablefuncelementlist + return p +} + +func InitEmptyOpttablefuncelementlistContext(p *OpttablefuncelementlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opttablefuncelementlist +} + +func (*OpttablefuncelementlistContext) IsOpttablefuncelementlistContext() {} + +func NewOpttablefuncelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *OpttablefuncelementlistContext { + var p = new(OpttablefuncelementlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opttablefuncelementlist + + return p +} + +func (s *OpttablefuncelementlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *OpttablefuncelementlistContext) Tablefuncelementlist() ITablefuncelementlistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablefuncelementlistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablefuncelementlistContext) +} + +func (s *OpttablefuncelementlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *OpttablefuncelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *OpttablefuncelementlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpttablefuncelementlist(s) + } +} + +func (s *OpttablefuncelementlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpttablefuncelementlist(s) + } +} + +func (s *OpttablefuncelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpttablefuncelementlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opttablefuncelementlist() (localctx IOpttablefuncelementlistContext) { + localctx = NewOpttablefuncelementlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1642, RedshiftParserRULE_opttablefuncelementlist) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12803) + p.Tablefuncelementlist() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablefuncelementlistContext is an interface to support dynamic dispatch. +type ITablefuncelementlistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTablefuncelement() []ITablefuncelementContext + Tablefuncelement(i int) ITablefuncelementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTablefuncelementlistContext differentiates from other interfaces. + IsTablefuncelementlistContext() +} + +type TablefuncelementlistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablefuncelementlistContext() *TablefuncelementlistContext { + var p = new(TablefuncelementlistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablefuncelementlist + return p +} + +func InitEmptyTablefuncelementlistContext(p *TablefuncelementlistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablefuncelementlist +} + +func (*TablefuncelementlistContext) IsTablefuncelementlistContext() {} + +func NewTablefuncelementlistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablefuncelementlistContext { + var p = new(TablefuncelementlistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tablefuncelementlist + + return p +} + +func (s *TablefuncelementlistContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablefuncelementlistContext) AllTablefuncelement() []ITablefuncelementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablefuncelementContext); ok { + len++ + } + } + + tst := make([]ITablefuncelementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablefuncelementContext); ok { + tst[i] = t.(ITablefuncelementContext) + i++ + } + } + + return tst +} + +func (s *TablefuncelementlistContext) Tablefuncelement(i int) ITablefuncelementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablefuncelementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablefuncelementContext) +} + +func (s *TablefuncelementlistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *TablefuncelementlistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *TablefuncelementlistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablefuncelementlistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablefuncelementlistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTablefuncelementlist(s) + } +} + +func (s *TablefuncelementlistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTablefuncelementlist(s) + } +} + +func (s *TablefuncelementlistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTablefuncelementlist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tablefuncelementlist() (localctx ITablefuncelementlistContext) { + localctx = NewTablefuncelementlistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1644, RedshiftParserRULE_tablefuncelementlist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12805) + p.Tablefuncelement() + } + p.SetState(12810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12806) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12807) + p.Tablefuncelement() + } + + p.SetState(12812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablefuncelementContext is an interface to support dynamic dispatch. +type ITablefuncelementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Typename() ITypenameContext + Opt_collate_clause() IOpt_collate_clauseContext + + // IsTablefuncelementContext differentiates from other interfaces. + IsTablefuncelementContext() +} + +type TablefuncelementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablefuncelementContext() *TablefuncelementContext { + var p = new(TablefuncelementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablefuncelement + return p +} + +func InitEmptyTablefuncelementContext(p *TablefuncelementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_tablefuncelement +} + +func (*TablefuncelementContext) IsTablefuncelementContext() {} + +func NewTablefuncelementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablefuncelementContext { + var p = new(TablefuncelementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_tablefuncelement + + return p +} + +func (s *TablefuncelementContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablefuncelementContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *TablefuncelementContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *TablefuncelementContext) Opt_collate_clause() IOpt_collate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_collate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_collate_clauseContext) +} + +func (s *TablefuncelementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablefuncelementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablefuncelementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTablefuncelement(s) + } +} + +func (s *TablefuncelementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTablefuncelement(s) + } +} + +func (s *TablefuncelementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTablefuncelement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Tablefuncelement() (localctx ITablefuncelementContext) { + localctx = NewTablefuncelementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1646, RedshiftParserRULE_tablefuncelement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12813) + p.Colid() + } + { + p.SetState(12814) + p.Typename() + } + p.SetState(12816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLLATE { + { + p.SetState(12815) + p.Opt_collate_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltableContext is an interface to support dynamic dispatch. +type IXmltableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLTABLE() antlr.TerminalNode + AllOPEN_PAREN() []antlr.TerminalNode + OPEN_PAREN(i int) antlr.TerminalNode + AllCLOSE_PAREN() []antlr.TerminalNode + CLOSE_PAREN(i int) antlr.TerminalNode + C_expr() IC_exprContext + Xmlexists_argument() IXmlexists_argumentContext + COLUMNS() antlr.TerminalNode + Xmltable_column_list() IXmltable_column_listContext + XMLNAMESPACES() antlr.TerminalNode + Xml_namespace_list() IXml_namespace_listContext + COMMA() antlr.TerminalNode + + // IsXmltableContext differentiates from other interfaces. + IsXmltableContext() +} + +type XmltableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltableContext() *XmltableContext { + var p = new(XmltableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable + return p +} + +func InitEmptyXmltableContext(p *XmltableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_xmltable + + return p +} + +func (s *XmltableContext) GetParser() antlr.Parser { return s.parser } + +func (s *XmltableContext) XMLTABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLTABLE, 0) +} + +func (s *XmltableContext) AllOPEN_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_PAREN) +} + +func (s *XmltableContext) OPEN_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, i) +} + +func (s *XmltableContext) AllCLOSE_PAREN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_PAREN) +} + +func (s *XmltableContext) CLOSE_PAREN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, i) +} + +func (s *XmltableContext) C_expr() IC_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_exprContext) +} + +func (s *XmltableContext) Xmlexists_argument() IXmlexists_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlexists_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlexists_argumentContext) +} + +func (s *XmltableContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMNS, 0) +} + +func (s *XmltableContext) Xmltable_column_list() IXmltable_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltable_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltable_column_listContext) +} + +func (s *XmltableContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLNAMESPACES, 0) +} + +func (s *XmltableContext) Xml_namespace_list() IXml_namespace_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_namespace_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_namespace_listContext) +} + +func (s *XmltableContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *XmltableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XmltableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XmltableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXmltable(s) + } +} + +func (s *XmltableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXmltable(s) + } +} + +func (s *XmltableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXmltable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xmltable() (localctx IXmltableContext) { + localctx = NewXmltableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1648, RedshiftParserRULE_xmltable) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12818) + p.Match(RedshiftParserXMLTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12819) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1205, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12820) + p.C_expr() + } + { + p.SetState(12821) + p.Xmlexists_argument() + } + { + p.SetState(12822) + p.Match(RedshiftParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12823) + p.Xmltable_column_list() + } + + case 2: + { + p.SetState(12825) + p.Match(RedshiftParserXMLNAMESPACES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12826) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12827) + p.Xml_namespace_list() + } + { + p.SetState(12828) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12829) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12830) + p.C_expr() + } + { + p.SetState(12831) + p.Xmlexists_argument() + } + { + p.SetState(12832) + p.Match(RedshiftParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12833) + p.Xmltable_column_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(12837) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltable_column_listContext is an interface to support dynamic dispatch. +type IXmltable_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllXmltable_column_el() []IXmltable_column_elContext + Xmltable_column_el(i int) IXmltable_column_elContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXmltable_column_listContext differentiates from other interfaces. + IsXmltable_column_listContext() +} + +type Xmltable_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltable_column_listContext() *Xmltable_column_listContext { + var p = new(Xmltable_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_list + return p +} + +func InitEmptyXmltable_column_listContext(p *Xmltable_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_list +} + +func (*Xmltable_column_listContext) IsXmltable_column_listContext() {} + +func NewXmltable_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_listContext { + var p = new(Xmltable_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xmltable_column_list + + return p +} + +func (s *Xmltable_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltable_column_listContext) AllXmltable_column_el() []IXmltable_column_elContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXmltable_column_elContext); ok { + len++ + } + } + + tst := make([]IXmltable_column_elContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXmltable_column_elContext); ok { + tst[i] = t.(IXmltable_column_elContext) + i++ + } + } + + return tst +} + +func (s *Xmltable_column_listContext) Xmltable_column_el(i int) IXmltable_column_elContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltable_column_elContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXmltable_column_elContext) +} + +func (s *Xmltable_column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Xmltable_column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Xmltable_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltable_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltable_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXmltable_column_list(s) + } +} + +func (s *Xmltable_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXmltable_column_list(s) + } +} + +func (s *Xmltable_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXmltable_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xmltable_column_list() (localctx IXmltable_column_listContext) { + localctx = NewXmltable_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1650, RedshiftParserRULE_xmltable_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12839) + p.Xmltable_column_el() + } + p.SetState(12844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12840) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12841) + p.Xmltable_column_el() + } + + p.SetState(12846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltable_column_elContext is an interface to support dynamic dispatch. +type IXmltable_column_elContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Typename() ITypenameContext + FOR() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + Xmltable_column_option_list() IXmltable_column_option_listContext + + // IsXmltable_column_elContext differentiates from other interfaces. + IsXmltable_column_elContext() +} + +type Xmltable_column_elContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltable_column_elContext() *Xmltable_column_elContext { + var p = new(Xmltable_column_elContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_el + return p +} + +func InitEmptyXmltable_column_elContext(p *Xmltable_column_elContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_el +} + +func (*Xmltable_column_elContext) IsXmltable_column_elContext() {} + +func NewXmltable_column_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_elContext { + var p = new(Xmltable_column_elContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xmltable_column_el + + return p +} + +func (s *Xmltable_column_elContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltable_column_elContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Xmltable_column_elContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Xmltable_column_elContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Xmltable_column_elContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserORDINALITY, 0) +} + +func (s *Xmltable_column_elContext) Xmltable_column_option_list() IXmltable_column_option_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltable_column_option_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltable_column_option_listContext) +} + +func (s *Xmltable_column_elContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltable_column_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltable_column_elContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXmltable_column_el(s) + } +} + +func (s *Xmltable_column_elContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXmltable_column_el(s) + } +} + +func (s *Xmltable_column_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXmltable_column_el(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xmltable_column_el() (localctx IXmltable_column_elContext) { + localctx = NewXmltable_column_elContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1652, RedshiftParserRULE_xmltable_column_el) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12847) + p.Colid() + } + p.SetState(12854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserVARBYTE, RedshiftParserVARBINARY, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(12848) + p.Typename() + } + p.SetState(12850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1152974281451248645) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&146404508992290945) != 0) || ((int64((_la-211)) & ^0x3f) == 0 && ((int64(1)<<(_la-211))&56295003965620233) != 0) || ((int64((_la-276)) & ^0x3f) == 0 && ((int64(1)<<(_la-276))&36136584055128065) != 0) || _la == RedshiftParserTYPE_P || _la == RedshiftParserCALL || _la == RedshiftParserCURRENT_P || ((int64((_la-676)) & ^0x3f) == 0 && ((int64(1)<<(_la-676))&13124950286337) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&402653321) != 0) { + { + p.SetState(12849) + p.Xmltable_column_option_list() + } + + } + + case RedshiftParserFOR: + { + p.SetState(12852) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12853) + p.Match(RedshiftParserORDINALITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltable_column_option_listContext is an interface to support dynamic dispatch. +type IXmltable_column_option_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllXmltable_column_option_el() []IXmltable_column_option_elContext + Xmltable_column_option_el(i int) IXmltable_column_option_elContext + + // IsXmltable_column_option_listContext differentiates from other interfaces. + IsXmltable_column_option_listContext() +} + +type Xmltable_column_option_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltable_column_option_listContext() *Xmltable_column_option_listContext { + var p = new(Xmltable_column_option_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_option_list + return p +} + +func InitEmptyXmltable_column_option_listContext(p *Xmltable_column_option_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_option_list +} + +func (*Xmltable_column_option_listContext) IsXmltable_column_option_listContext() {} + +func NewXmltable_column_option_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_option_listContext { + var p = new(Xmltable_column_option_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xmltable_column_option_list + + return p +} + +func (s *Xmltable_column_option_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltable_column_option_listContext) AllXmltable_column_option_el() []IXmltable_column_option_elContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXmltable_column_option_elContext); ok { + len++ + } + } + + tst := make([]IXmltable_column_option_elContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXmltable_column_option_elContext); ok { + tst[i] = t.(IXmltable_column_option_elContext) + i++ + } + } + + return tst +} + +func (s *Xmltable_column_option_listContext) Xmltable_column_option_el(i int) IXmltable_column_option_elContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltable_column_option_elContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXmltable_column_option_elContext) +} + +func (s *Xmltable_column_option_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltable_column_option_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltable_column_option_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXmltable_column_option_list(s) + } +} + +func (s *Xmltable_column_option_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXmltable_column_option_list(s) + } +} + +func (s *Xmltable_column_option_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXmltable_column_option_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xmltable_column_option_list() (localctx IXmltable_column_option_listContext) { + localctx = NewXmltable_column_option_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1654, RedshiftParserRULE_xmltable_column_option_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1152974281451248645) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&146404508992290945) != 0) || ((int64((_la-211)) & ^0x3f) == 0 && ((int64(1)<<(_la-211))&56295003965620233) != 0) || ((int64((_la-276)) & ^0x3f) == 0 && ((int64(1)<<(_la-276))&36136584055128065) != 0) || _la == RedshiftParserTYPE_P || _la == RedshiftParserCALL || _la == RedshiftParserCURRENT_P || ((int64((_la-676)) & ^0x3f) == 0 && ((int64(1)<<(_la-676))&13124950286337) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&402653321) != 0) { + { + p.SetState(12856) + p.Xmltable_column_option_el() + } + + p.SetState(12859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltable_column_option_elContext is an interface to support dynamic dispatch. +type IXmltable_column_option_elContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + A_expr() IA_exprContext + Identifier() IIdentifierContext + NOT() antlr.TerminalNode + NULL_P() antlr.TerminalNode + + // IsXmltable_column_option_elContext differentiates from other interfaces. + IsXmltable_column_option_elContext() +} + +type Xmltable_column_option_elContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltable_column_option_elContext() *Xmltable_column_option_elContext { + var p = new(Xmltable_column_option_elContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_option_el + return p +} + +func InitEmptyXmltable_column_option_elContext(p *Xmltable_column_option_elContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmltable_column_option_el +} + +func (*Xmltable_column_option_elContext) IsXmltable_column_option_elContext() {} + +func NewXmltable_column_option_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltable_column_option_elContext { + var p = new(Xmltable_column_option_elContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xmltable_column_option_el + + return p +} + +func (s *Xmltable_column_option_elContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltable_column_option_elContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Xmltable_column_option_elContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Xmltable_column_option_elContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Xmltable_column_option_elContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Xmltable_column_option_elContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Xmltable_column_option_elContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltable_column_option_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltable_column_option_elContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXmltable_column_option_el(s) + } +} + +func (s *Xmltable_column_option_elContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXmltable_column_option_el(s) + } +} + +func (s *Xmltable_column_option_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXmltable_column_option_el(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xmltable_column_option_el() (localctx IXmltable_column_option_elContext) { + localctx = NewXmltable_column_option_elContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1656, RedshiftParserRULE_xmltable_column_option_el) + p.SetState(12869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1210, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12861) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12862) + p.A_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12863) + p.Identifier() + } + { + p.SetState(12864) + p.A_expr() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12866) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12867) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12868) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_namespace_listContext is an interface to support dynamic dispatch. +type IXml_namespace_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllXml_namespace_el() []IXml_namespace_elContext + Xml_namespace_el(i int) IXml_namespace_elContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXml_namespace_listContext differentiates from other interfaces. + IsXml_namespace_listContext() +} + +type Xml_namespace_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_namespace_listContext() *Xml_namespace_listContext { + var p = new(Xml_namespace_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_namespace_list + return p +} + +func InitEmptyXml_namespace_listContext(p *Xml_namespace_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_namespace_list +} + +func (*Xml_namespace_listContext) IsXml_namespace_listContext() {} + +func NewXml_namespace_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespace_listContext { + var p = new(Xml_namespace_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_namespace_list + + return p +} + +func (s *Xml_namespace_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_namespace_listContext) AllXml_namespace_el() []IXml_namespace_elContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_namespace_elContext); ok { + len++ + } + } + + tst := make([]IXml_namespace_elContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_namespace_elContext); ok { + tst[i] = t.(IXml_namespace_elContext) + i++ + } + } + + return tst +} + +func (s *Xml_namespace_listContext) Xml_namespace_el(i int) IXml_namespace_elContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_namespace_elContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_namespace_elContext) +} + +func (s *Xml_namespace_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Xml_namespace_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Xml_namespace_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_namespace_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_namespace_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_namespace_list(s) + } +} + +func (s *Xml_namespace_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_namespace_list(s) + } +} + +func (s *Xml_namespace_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_namespace_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_namespace_list() (localctx IXml_namespace_listContext) { + localctx = NewXml_namespace_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1658, RedshiftParserRULE_xml_namespace_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12871) + p.Xml_namespace_el() + } + p.SetState(12876) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(12872) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12873) + p.Xml_namespace_el() + } + + p.SetState(12878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_namespace_elContext is an interface to support dynamic dispatch. +type IXml_namespace_elContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + B_expr() IB_exprContext + AS() antlr.TerminalNode + Collabel() ICollabelContext + DEFAULT() antlr.TerminalNode + + // IsXml_namespace_elContext differentiates from other interfaces. + IsXml_namespace_elContext() +} + +type Xml_namespace_elContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_namespace_elContext() *Xml_namespace_elContext { + var p = new(Xml_namespace_elContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_namespace_el + return p +} + +func InitEmptyXml_namespace_elContext(p *Xml_namespace_elContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_namespace_el +} + +func (*Xml_namespace_elContext) IsXml_namespace_elContext() {} + +func NewXml_namespace_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespace_elContext { + var p = new(Xml_namespace_elContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_namespace_el + + return p +} + +func (s *Xml_namespace_elContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_namespace_elContext) B_expr() IB_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IB_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IB_exprContext) +} + +func (s *Xml_namespace_elContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Xml_namespace_elContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Xml_namespace_elContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Xml_namespace_elContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_namespace_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_namespace_elContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_namespace_el(s) + } +} + +func (s *Xml_namespace_elContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_namespace_el(s) + } +} + +func (s *Xml_namespace_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_namespace_el(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_namespace_el() (localctx IXml_namespace_elContext) { + localctx = NewXml_namespace_elContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1660, RedshiftParserRULE_xml_namespace_el) + p.SetState(12885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1212, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12879) + p.b_expr(0) + } + { + p.SetState(12880) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12881) + p.Collabel() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12883) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12884) + p.b_expr(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITypenameContext is an interface to support dynamic dispatch. +type ITypenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Simpletypename() ISimpletypenameContext + ARRAY() antlr.TerminalNode + SETOF() antlr.TerminalNode + Opt_array_bounds() IOpt_array_boundsContext + OPEN_BRACKET() antlr.TerminalNode + Iconst() IIconstContext + CLOSE_BRACKET() antlr.TerminalNode + Qualified_name() IQualified_nameContext + PERCENT() antlr.TerminalNode + ROWTYPE() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + SUPER() antlr.TerminalNode + + // IsTypenameContext differentiates from other interfaces. + IsTypenameContext() +} + +type TypenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTypenameContext() *TypenameContext { + var p = new(TypenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_typename + return p +} + +func InitEmptyTypenameContext(p *TypenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_typename +} + +func (*TypenameContext) IsTypenameContext() {} + +func NewTypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TypenameContext { + var p = new(TypenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_typename + + return p +} + +func (s *TypenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *TypenameContext) Simpletypename() ISimpletypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpletypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpletypenameContext) +} + +func (s *TypenameContext) ARRAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserARRAY, 0) +} + +func (s *TypenameContext) SETOF() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETOF, 0) +} + +func (s *TypenameContext) Opt_array_bounds() IOpt_array_boundsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_array_boundsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_array_boundsContext) +} + +func (s *TypenameContext) OPEN_BRACKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_BRACKET, 0) +} + +func (s *TypenameContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *TypenameContext) CLOSE_BRACKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_BRACKET, 0) +} + +func (s *TypenameContext) Qualified_name() IQualified_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *TypenameContext) PERCENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENT, 0) +} + +func (s *TypenameContext) ROWTYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWTYPE, 0) +} + +func (s *TypenameContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *TypenameContext) SUPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUPER, 0) +} + +func (s *TypenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TypenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTypename(s) + } +} + +func (s *TypenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTypename(s) + } +} + +func (s *TypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTypename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Typename() (localctx ITypenameContext) { + localctx = NewTypenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1662, RedshiftParserRULE_typename) + var _la int + + p.SetState(12908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1217, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(12888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSETOF { + { + p.SetState(12887) + p.Match(RedshiftParserSETOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12890) + p.Simpletypename() + } + p.SetState(12901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1216, p.GetParserRuleContext()) { + case 1: + p.SetState(12892) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1214, p.GetParserRuleContext()) == 1 { + { + p.SetState(12891) + p.Opt_array_bounds() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(12894) + p.Match(RedshiftParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12899) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1215, p.GetParserRuleContext()) == 1 { + { + p.SetState(12895) + p.Match(RedshiftParserOPEN_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12896) + p.Iconst() + } + { + p.SetState(12897) + p.Match(RedshiftParserCLOSE_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12903) + p.Qualified_name() + } + { + p.SetState(12904) + p.Match(RedshiftParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12905) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTYPE_P || _la == RedshiftParserROWTYPE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12907) + p.Match(RedshiftParserSUPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_array_boundsContext is an interface to support dynamic dispatch. +type IOpt_array_boundsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOPEN_BRACKET() []antlr.TerminalNode + OPEN_BRACKET(i int) antlr.TerminalNode + AllCLOSE_BRACKET() []antlr.TerminalNode + CLOSE_BRACKET(i int) antlr.TerminalNode + AllIconst() []IIconstContext + Iconst(i int) IIconstContext + + // IsOpt_array_boundsContext differentiates from other interfaces. + IsOpt_array_boundsContext() +} + +type Opt_array_boundsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_array_boundsContext() *Opt_array_boundsContext { + var p = new(Opt_array_boundsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_array_bounds + return p +} + +func InitEmptyOpt_array_boundsContext(p *Opt_array_boundsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_array_bounds +} + +func (*Opt_array_boundsContext) IsOpt_array_boundsContext() {} + +func NewOpt_array_boundsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_array_boundsContext { + var p = new(Opt_array_boundsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_array_bounds + + return p +} + +func (s *Opt_array_boundsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_array_boundsContext) AllOPEN_BRACKET() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_BRACKET) +} + +func (s *Opt_array_boundsContext) OPEN_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_BRACKET, i) +} + +func (s *Opt_array_boundsContext) AllCLOSE_BRACKET() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_BRACKET) +} + +func (s *Opt_array_boundsContext) CLOSE_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_BRACKET, i) +} + +func (s *Opt_array_boundsContext) AllIconst() []IIconstContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIconstContext); ok { + len++ + } + } + + tst := make([]IIconstContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIconstContext); ok { + tst[i] = t.(IIconstContext) + i++ + } + } + + return tst +} + +func (s *Opt_array_boundsContext) Iconst(i int) IIconstContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Opt_array_boundsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_array_boundsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_array_boundsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_array_bounds(s) + } +} + +func (s *Opt_array_boundsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_array_bounds(s) + } +} + +func (s *Opt_array_boundsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_array_bounds(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_array_bounds() (localctx IOpt_array_boundsContext) { + localctx = NewOpt_array_boundsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1664, RedshiftParserRULE_opt_array_bounds) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12915) + 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(12910) + p.Match(RedshiftParserOPEN_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserIntegral { + { + p.SetState(12911) + p.Iconst() + } + + } + { + p.SetState(12914) + p.Match(RedshiftParserCLOSE_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12917) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1219, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimpletypenameContext is an interface to support dynamic dispatch. +type ISimpletypenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Generictype() IGenerictypeContext + Numeric() INumericContext + Bit() IBitContext + Character() ICharacterContext + Varbyte() IVarbyteContext + Constdatetime() IConstdatetimeContext + Constinterval() IConstintervalContext + OPEN_PAREN() antlr.TerminalNode + Iconst() IIconstContext + CLOSE_PAREN() antlr.TerminalNode + Opt_interval() IOpt_intervalContext + Json_type() IJson_typeContext + + // IsSimpletypenameContext differentiates from other interfaces. + IsSimpletypenameContext() +} + +type SimpletypenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimpletypenameContext() *SimpletypenameContext { + var p = new(SimpletypenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_simpletypename + return p +} + +func InitEmptySimpletypenameContext(p *SimpletypenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_simpletypename +} + +func (*SimpletypenameContext) IsSimpletypenameContext() {} + +func NewSimpletypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SimpletypenameContext { + var p = new(SimpletypenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_simpletypename + + return p +} + +func (s *SimpletypenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *SimpletypenameContext) Generictype() IGenerictypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGenerictypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGenerictypeContext) +} + +func (s *SimpletypenameContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *SimpletypenameContext) Bit() IBitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitContext) +} + +func (s *SimpletypenameContext) Character() ICharacterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharacterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharacterContext) +} + +func (s *SimpletypenameContext) Varbyte() IVarbyteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarbyteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarbyteContext) +} + +func (s *SimpletypenameContext) Constdatetime() IConstdatetimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstdatetimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstdatetimeContext) +} + +func (s *SimpletypenameContext) Constinterval() IConstintervalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstintervalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstintervalContext) +} + +func (s *SimpletypenameContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *SimpletypenameContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *SimpletypenameContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *SimpletypenameContext) Opt_interval() IOpt_intervalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_intervalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_intervalContext) +} + +func (s *SimpletypenameContext) Json_type() IJson_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_typeContext) +} + +func (s *SimpletypenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SimpletypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SimpletypenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSimpletypename(s) + } +} + +func (s *SimpletypenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSimpletypename(s) + } +} + +func (s *SimpletypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSimpletypename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Simpletypename() (localctx ISimpletypenameContext) { + localctx = NewSimpletypenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1666, RedshiftParserRULE_simpletypename) + p.SetState(12936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1222, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12919) + p.Generictype() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12920) + p.Numeric() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12921) + p.Bit() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12922) + p.Character() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12923) + p.Varbyte() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12924) + p.Constdatetime() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12925) + p.Constinterval() + } + p.SetState(12933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1221, p.GetParserRuleContext()) { + case 1: + p.SetState(12927) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1220, p.GetParserRuleContext()) == 1 { + { + p.SetState(12926) + p.Opt_interval() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(12929) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12930) + p.Iconst() + } + { + p.SetState(12931) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12935) + p.Json_type() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarbyteContext is an interface to support dynamic dispatch. +type IVarbyteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Iconst() IIconstContext + CLOSE_PAREN() antlr.TerminalNode + VARBYTE() antlr.TerminalNode + VARBINARY() antlr.TerminalNode + BINARY() antlr.TerminalNode + VARYING() antlr.TerminalNode + + // IsVarbyteContext differentiates from other interfaces. + IsVarbyteContext() +} + +type VarbyteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarbyteContext() *VarbyteContext { + var p = new(VarbyteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_varbyte + return p +} + +func InitEmptyVarbyteContext(p *VarbyteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_varbyte +} + +func (*VarbyteContext) IsVarbyteContext() {} + +func NewVarbyteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VarbyteContext { + var p = new(VarbyteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_varbyte + + return p +} + +func (s *VarbyteContext) GetParser() antlr.Parser { return s.parser } + +func (s *VarbyteContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *VarbyteContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *VarbyteContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *VarbyteContext) VARBYTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARBYTE, 0) +} + +func (s *VarbyteContext) VARBINARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARBINARY, 0) +} + +func (s *VarbyteContext) BINARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBINARY, 0) +} + +func (s *VarbyteContext) VARYING() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARYING, 0) +} + +func (s *VarbyteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VarbyteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VarbyteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterVarbyte(s) + } +} + +func (s *VarbyteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitVarbyte(s) + } +} + +func (s *VarbyteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitVarbyte(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Varbyte() (localctx IVarbyteContext) { + localctx = NewVarbyteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1668, RedshiftParserRULE_varbyte) + p.EnterOuterAlt(localctx, 1) + p.SetState(12942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserVARBYTE: + { + p.SetState(12938) + p.Match(RedshiftParserVARBYTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserVARBINARY: + { + p.SetState(12939) + p.Match(RedshiftParserVARBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserBINARY: + { + p.SetState(12940) + p.Match(RedshiftParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12941) + p.Match(RedshiftParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12944) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12945) + p.Iconst() + } + { + p.SetState(12946) + p.Match(RedshiftParserCLOSE_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_typeContext is an interface to support dynamic dispatch. +type IJson_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JSON() antlr.TerminalNode + + // IsJson_typeContext differentiates from other interfaces. + IsJson_typeContext() +} + +type Json_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_typeContext() *Json_typeContext { + var p = new(Json_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_json_type + return p +} + +func InitEmptyJson_typeContext(p *Json_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_json_type +} + +func (*Json_typeContext) IsJson_typeContext() {} + +func NewJson_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_typeContext { + var p = new(Json_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_json_type + + return p +} + +func (s *Json_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_typeContext) JSON() antlr.TerminalNode { + return s.GetToken(RedshiftParserJSON, 0) +} + +func (s *Json_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterJson_type(s) + } +} + +func (s *Json_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitJson_type(s) + } +} + +func (s *Json_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitJson_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Json_type() (localctx IJson_typeContext) { + localctx = NewJson_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1670, RedshiftParserRULE_json_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12948) + p.Match(RedshiftParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConsttypenameContext is an interface to support dynamic dispatch. +type IConsttypenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric() INumericContext + Constbit() IConstbitContext + Constcharacter() IConstcharacterContext + Constdatetime() IConstdatetimeContext + + // IsConsttypenameContext differentiates from other interfaces. + IsConsttypenameContext() +} + +type ConsttypenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConsttypenameContext() *ConsttypenameContext { + var p = new(ConsttypenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_consttypename + return p +} + +func InitEmptyConsttypenameContext(p *ConsttypenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_consttypename +} + +func (*ConsttypenameContext) IsConsttypenameContext() {} + +func NewConsttypenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConsttypenameContext { + var p = new(ConsttypenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_consttypename + + return p +} + +func (s *ConsttypenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConsttypenameContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *ConsttypenameContext) Constbit() IConstbitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstbitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstbitContext) +} + +func (s *ConsttypenameContext) Constcharacter() IConstcharacterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstcharacterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstcharacterContext) +} + +func (s *ConsttypenameContext) Constdatetime() IConstdatetimeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstdatetimeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstdatetimeContext) +} + +func (s *ConsttypenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConsttypenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConsttypenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConsttypename(s) + } +} + +func (s *ConsttypenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConsttypename(s) + } +} + +func (s *ConsttypenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConsttypename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Consttypename() (localctx IConsttypenameContext) { + localctx = NewConsttypenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1672, RedshiftParserRULE_consttypename) + p.SetState(12954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDOUBLE_P, RedshiftParserBIGINT, RedshiftParserBOOLEAN_P, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserFLOAT_P, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserNUMERIC, RedshiftParserREAL, RedshiftParserSMALLINT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12950) + p.Numeric() + } + + case RedshiftParserBIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12951) + p.Constbit() + } + + case RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserVARCHAR: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12952) + p.Constcharacter() + } + + case RedshiftParserTIME, RedshiftParserTIMESTAMP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12953) + p.Constdatetime() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGenerictypeContext is an interface to support dynamic dispatch. +type IGenerictypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Builtin_function_name() IBuiltin_function_nameContext + Type_function_name() IType_function_nameContext + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + Attrs() IAttrsContext + Opt_type_modifiers() IOpt_type_modifiersContext + + // IsGenerictypeContext differentiates from other interfaces. + IsGenerictypeContext() +} + +type GenerictypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGenerictypeContext() *GenerictypeContext { + var p = new(GenerictypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generictype + return p +} + +func InitEmptyGenerictypeContext(p *GenerictypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_generictype +} + +func (*GenerictypeContext) IsGenerictypeContext() {} + +func NewGenerictypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *GenerictypeContext { + var p = new(GenerictypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_generictype + + return p +} + +func (s *GenerictypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *GenerictypeContext) Builtin_function_name() IBuiltin_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuiltin_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuiltin_function_nameContext) +} + +func (s *GenerictypeContext) Type_function_name() IType_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_nameContext) +} + +func (s *GenerictypeContext) LEFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEFT, 0) +} + +func (s *GenerictypeContext) RIGHT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRIGHT, 0) +} + +func (s *GenerictypeContext) Attrs() IAttrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttrsContext) +} + +func (s *GenerictypeContext) Opt_type_modifiers() IOpt_type_modifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_type_modifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_type_modifiersContext) +} + +func (s *GenerictypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *GenerictypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *GenerictypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGenerictype(s) + } +} + +func (s *GenerictypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGenerictype(s) + } +} + +func (s *GenerictypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGenerictype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Generictype() (localctx IGenerictypeContext) { + localctx = NewGenerictypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1674, RedshiftParserRULE_generictype) + p.EnterOuterAlt(localctx, 1) + p.SetState(12960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCURRENT_USER, RedshiftParserREPLACE, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserREVERSE, RedshiftParserLOG, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER: + { + p.SetState(12956) + p.Builtin_function_name() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserPARAMETER, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserCOLUMNS, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(12957) + p.Type_function_name() + } + + case RedshiftParserLEFT: + { + p.SetState(12958) + p.Match(RedshiftParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserRIGHT: + { + p.SetState(12959) + p.Match(RedshiftParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12963) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1226, p.GetParserRuleContext()) == 1 { + { + p.SetState(12962) + p.Attrs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12966) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1227, p.GetParserRuleContext()) == 1 { + { + p.SetState(12965) + p.Opt_type_modifiers() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_type_modifiersContext is an interface to support dynamic dispatch. +type IOpt_type_modifiersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_type_modifiersContext differentiates from other interfaces. + IsOpt_type_modifiersContext() +} + +type Opt_type_modifiersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_type_modifiersContext() *Opt_type_modifiersContext { + var p = new(Opt_type_modifiersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_type_modifiers + return p +} + +func InitEmptyOpt_type_modifiersContext(p *Opt_type_modifiersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_type_modifiers +} + +func (*Opt_type_modifiersContext) IsOpt_type_modifiersContext() {} + +func NewOpt_type_modifiersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_type_modifiersContext { + var p = new(Opt_type_modifiersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_type_modifiers + + return p +} + +func (s *Opt_type_modifiersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_type_modifiersContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_type_modifiersContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Opt_type_modifiersContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_type_modifiersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_type_modifiersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_type_modifiersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_type_modifiers(s) + } +} + +func (s *Opt_type_modifiersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_type_modifiers(s) + } +} + +func (s *Opt_type_modifiersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_type_modifiers(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_type_modifiers() (localctx IOpt_type_modifiersContext) { + localctx = NewOpt_type_modifiersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1676, RedshiftParserRULE_opt_type_modifiers) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12968) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12969) + p.Expr_list() + } + { + p.SetState(12970) + p.Match(RedshiftParserCLOSE_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 +} + +// INumericContext is an interface to support dynamic dispatch. +type INumericContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INT_P() antlr.TerminalNode + INTEGER() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + BIGINT() antlr.TerminalNode + REAL() antlr.TerminalNode + FLOAT_P() antlr.TerminalNode + Opt_float() IOpt_floatContext + DOUBLE_P() antlr.TerminalNode + PRECISION() antlr.TerminalNode + DECIMAL_P() antlr.TerminalNode + Opt_type_modifiers() IOpt_type_modifiersContext + DEC() antlr.TerminalNode + NUMERIC() antlr.TerminalNode + BOOLEAN_P() antlr.TerminalNode + + // IsNumericContext differentiates from other interfaces. + IsNumericContext() +} + +type NumericContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumericContext() *NumericContext { + var p = new(NumericContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_numeric + return p +} + +func InitEmptyNumericContext(p *NumericContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_numeric + + return p +} + +func (s *NumericContext) GetParser() antlr.Parser { return s.parser } + +func (s *NumericContext) INT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINT_P, 0) +} + +func (s *NumericContext) INTEGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTEGER, 0) +} + +func (s *NumericContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSMALLINT, 0) +} + +func (s *NumericContext) BIGINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserBIGINT, 0) +} + +func (s *NumericContext) REAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserREAL, 0) +} + +func (s *NumericContext) FLOAT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFLOAT_P, 0) +} + +func (s *NumericContext) Opt_float() IOpt_floatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_floatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_floatContext) +} + +func (s *NumericContext) DOUBLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOUBLE_P, 0) +} + +func (s *NumericContext) PRECISION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRECISION, 0) +} + +func (s *NumericContext) DECIMAL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDECIMAL_P, 0) +} + +func (s *NumericContext) Opt_type_modifiers() IOpt_type_modifiersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_type_modifiersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_type_modifiersContext) +} + +func (s *NumericContext) DEC() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEC, 0) +} + +func (s *NumericContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserNUMERIC, 0) +} + +func (s *NumericContext) BOOLEAN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserBOOLEAN_P, 0) +} + +func (s *NumericContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumericContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NumericContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNumeric(s) + } +} + +func (s *NumericContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNumeric(s) + } +} + +func (s *NumericContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNumeric(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Numeric() (localctx INumericContext) { + localctx = NewNumericContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1678, RedshiftParserRULE_numeric) + p.SetState(12996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserINT_P: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12972) + p.Match(RedshiftParserINT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserINTEGER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12973) + p.Match(RedshiftParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSMALLINT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12974) + p.Match(RedshiftParserSMALLINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserBIGINT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12975) + p.Match(RedshiftParserBIGINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserREAL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12976) + p.Match(RedshiftParserREAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFLOAT_P: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12977) + p.Match(RedshiftParserFLOAT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12979) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1228, p.GetParserRuleContext()) == 1 { + { + p.SetState(12978) + p.Opt_float() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserDOUBLE_P: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12981) + p.Match(RedshiftParserDOUBLE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12982) + p.Match(RedshiftParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDECIMAL_P: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12983) + p.Match(RedshiftParserDECIMAL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12985) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1229, p.GetParserRuleContext()) == 1 { + { + p.SetState(12984) + p.Opt_type_modifiers() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserDEC: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12987) + p.Match(RedshiftParserDEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12989) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1230, p.GetParserRuleContext()) == 1 { + { + p.SetState(12988) + p.Opt_type_modifiers() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserNUMERIC: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(12991) + p.Match(RedshiftParserNUMERIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12993) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1231, p.GetParserRuleContext()) == 1 { + { + p.SetState(12992) + p.Opt_type_modifiers() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserBOOLEAN_P: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(12995) + p.Match(RedshiftParserBOOLEAN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_floatContext is an interface to support dynamic dispatch. +type IOpt_floatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Iconst() IIconstContext + CLOSE_PAREN() antlr.TerminalNode + + // IsOpt_floatContext differentiates from other interfaces. + IsOpt_floatContext() +} + +type Opt_floatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_floatContext() *Opt_floatContext { + var p = new(Opt_floatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_float + return p +} + +func InitEmptyOpt_floatContext(p *Opt_floatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_float +} + +func (*Opt_floatContext) IsOpt_floatContext() {} + +func NewOpt_floatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_floatContext { + var p = new(Opt_floatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_float + + return p +} + +func (s *Opt_floatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_floatContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_floatContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Opt_floatContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_floatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_floatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_floatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_float(s) + } +} + +func (s *Opt_floatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_float(s) + } +} + +func (s *Opt_floatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_float(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_float() (localctx IOpt_floatContext) { + localctx = NewOpt_floatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1680, RedshiftParserRULE_opt_float) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12998) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12999) + p.Iconst() + } + { + p.SetState(13000) + p.Match(RedshiftParserCLOSE_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 +} + +// IBitContext is an interface to support dynamic dispatch. +type IBitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Bitwithlength() IBitwithlengthContext + Bitwithoutlength() IBitwithoutlengthContext + + // IsBitContext differentiates from other interfaces. + IsBitContext() +} + +type BitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBitContext() *BitContext { + var p = new(BitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bit + return p +} + +func InitEmptyBitContext(p *BitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bit +} + +func (*BitContext) IsBitContext() {} + +func NewBitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitContext { + var p = new(BitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_bit + + return p +} + +func (s *BitContext) GetParser() antlr.Parser { return s.parser } + +func (s *BitContext) Bitwithlength() IBitwithlengthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitwithlengthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitwithlengthContext) +} + +func (s *BitContext) Bitwithoutlength() IBitwithoutlengthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitwithoutlengthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitwithoutlengthContext) +} + +func (s *BitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterBit(s) + } +} + +func (s *BitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitBit(s) + } +} + +func (s *BitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitBit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Bit() (localctx IBitContext) { + localctx = NewBitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1682, RedshiftParserRULE_bit) + p.SetState(13004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1233, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13002) + p.Bitwithlength() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13003) + p.Bitwithoutlength() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstbitContext is an interface to support dynamic dispatch. +type IConstbitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Bitwithlength() IBitwithlengthContext + Bitwithoutlength() IBitwithoutlengthContext + + // IsConstbitContext differentiates from other interfaces. + IsConstbitContext() +} + +type ConstbitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstbitContext() *ConstbitContext { + var p = new(ConstbitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constbit + return p +} + +func InitEmptyConstbitContext(p *ConstbitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constbit +} + +func (*ConstbitContext) IsConstbitContext() {} + +func NewConstbitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstbitContext { + var p = new(ConstbitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constbit + + return p +} + +func (s *ConstbitContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstbitContext) Bitwithlength() IBitwithlengthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitwithlengthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitwithlengthContext) +} + +func (s *ConstbitContext) Bitwithoutlength() IBitwithoutlengthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitwithoutlengthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitwithoutlengthContext) +} + +func (s *ConstbitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstbitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstbitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstbit(s) + } +} + +func (s *ConstbitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstbit(s) + } +} + +func (s *ConstbitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstbit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constbit() (localctx IConstbitContext) { + localctx = NewConstbitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1684, RedshiftParserRULE_constbit) + p.SetState(13008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1234, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13006) + p.Bitwithlength() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13007) + p.Bitwithoutlength() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBitwithlengthContext is an interface to support dynamic dispatch. +type IBitwithlengthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BIT() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + CLOSE_PAREN() antlr.TerminalNode + Opt_varying() IOpt_varyingContext + + // IsBitwithlengthContext differentiates from other interfaces. + IsBitwithlengthContext() +} + +type BitwithlengthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBitwithlengthContext() *BitwithlengthContext { + var p = new(BitwithlengthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bitwithlength + return p +} + +func InitEmptyBitwithlengthContext(p *BitwithlengthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bitwithlength +} + +func (*BitwithlengthContext) IsBitwithlengthContext() {} + +func NewBitwithlengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwithlengthContext { + var p = new(BitwithlengthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_bitwithlength + + return p +} + +func (s *BitwithlengthContext) GetParser() antlr.Parser { return s.parser } + +func (s *BitwithlengthContext) BIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserBIT, 0) +} + +func (s *BitwithlengthContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *BitwithlengthContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *BitwithlengthContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *BitwithlengthContext) Opt_varying() IOpt_varyingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_varyingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_varyingContext) +} + +func (s *BitwithlengthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BitwithlengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BitwithlengthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterBitwithlength(s) + } +} + +func (s *BitwithlengthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitBitwithlength(s) + } +} + +func (s *BitwithlengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitBitwithlength(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Bitwithlength() (localctx IBitwithlengthContext) { + localctx = NewBitwithlengthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1686, RedshiftParserRULE_bitwithlength) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13010) + p.Match(RedshiftParserBIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserVARYING { + { + p.SetState(13011) + p.Opt_varying() + } + + } + { + p.SetState(13014) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13015) + p.Expr_list() + } + { + p.SetState(13016) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBitwithoutlengthContext is an interface to support dynamic dispatch. +type IBitwithoutlengthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BIT() antlr.TerminalNode + Opt_varying() IOpt_varyingContext + + // IsBitwithoutlengthContext differentiates from other interfaces. + IsBitwithoutlengthContext() +} + +type BitwithoutlengthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBitwithoutlengthContext() *BitwithoutlengthContext { + var p = new(BitwithoutlengthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bitwithoutlength + return p +} + +func InitEmptyBitwithoutlengthContext(p *BitwithoutlengthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bitwithoutlength +} + +func (*BitwithoutlengthContext) IsBitwithoutlengthContext() {} + +func NewBitwithoutlengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BitwithoutlengthContext { + var p = new(BitwithoutlengthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_bitwithoutlength + + return p +} + +func (s *BitwithoutlengthContext) GetParser() antlr.Parser { return s.parser } + +func (s *BitwithoutlengthContext) BIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserBIT, 0) +} + +func (s *BitwithoutlengthContext) Opt_varying() IOpt_varyingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_varyingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_varyingContext) +} + +func (s *BitwithoutlengthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BitwithoutlengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BitwithoutlengthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterBitwithoutlength(s) + } +} + +func (s *BitwithoutlengthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitBitwithoutlength(s) + } +} + +func (s *BitwithoutlengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitBitwithoutlength(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Bitwithoutlength() (localctx IBitwithoutlengthContext) { + localctx = NewBitwithoutlengthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1688, RedshiftParserRULE_bitwithoutlength) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13018) + p.Match(RedshiftParserBIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13020) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1236, p.GetParserRuleContext()) == 1 { + { + p.SetState(13019) + p.Opt_varying() + } + + } 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 +} + +// ICharacterContext is an interface to support dynamic dispatch. +type ICharacterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Character_c() ICharacter_cContext + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Iconst() IIconstContext + Colid() IColidContext + + // IsCharacterContext differentiates from other interfaces. + IsCharacterContext() +} + +type CharacterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCharacterContext() *CharacterContext { + var p = new(CharacterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_character + return p +} + +func InitEmptyCharacterContext(p *CharacterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_character +} + +func (*CharacterContext) IsCharacterContext() {} + +func NewCharacterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CharacterContext { + var p = new(CharacterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_character + + return p +} + +func (s *CharacterContext) GetParser() antlr.Parser { return s.parser } + +func (s *CharacterContext) Character_c() ICharacter_cContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharacter_cContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharacter_cContext) +} + +func (s *CharacterContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *CharacterContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *CharacterContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *CharacterContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *CharacterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CharacterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CharacterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCharacter(s) + } +} + +func (s *CharacterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCharacter(s) + } +} + +func (s *CharacterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCharacter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Character() (localctx ICharacterContext) { + localctx = NewCharacterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1690, RedshiftParserRULE_character) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13022) + p.Character_c() + } + p.SetState(13030) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1238, p.GetParserRuleContext()) == 1 { + { + p.SetState(13023) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + { + p.SetState(13024) + p.Iconst() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(13025) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13028) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstcharacterContext is an interface to support dynamic dispatch. +type IConstcharacterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Character_c() ICharacter_cContext + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Iconst() IIconstContext + Colid() IColidContext + + // IsConstcharacterContext differentiates from other interfaces. + IsConstcharacterContext() +} + +type ConstcharacterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstcharacterContext() *ConstcharacterContext { + var p = new(ConstcharacterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constcharacter + return p +} + +func InitEmptyConstcharacterContext(p *ConstcharacterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constcharacter +} + +func (*ConstcharacterContext) IsConstcharacterContext() {} + +func NewConstcharacterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstcharacterContext { + var p = new(ConstcharacterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constcharacter + + return p +} + +func (s *ConstcharacterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstcharacterContext) Character_c() ICharacter_cContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharacter_cContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharacter_cContext) +} + +func (s *ConstcharacterContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ConstcharacterContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ConstcharacterContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *ConstcharacterContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ConstcharacterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstcharacterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstcharacterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstcharacter(s) + } +} + +func (s *ConstcharacterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstcharacter(s) + } +} + +func (s *ConstcharacterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstcharacter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constcharacter() (localctx IConstcharacterContext) { + localctx = NewConstcharacterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1692, RedshiftParserRULE_constcharacter) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13032) + p.Character_c() + } + p.SetState(13040) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(13033) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + { + p.SetState(13034) + p.Iconst() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(13035) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13038) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICharacter_cContext is an interface to support dynamic dispatch. +type ICharacter_cContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHARACTER() antlr.TerminalNode + CHAR_P() antlr.TerminalNode + NCHAR() antlr.TerminalNode + Opt_varying() IOpt_varyingContext + VARCHAR() antlr.TerminalNode + NATIONAL() antlr.TerminalNode + + // IsCharacter_cContext differentiates from other interfaces. + IsCharacter_cContext() +} + +type Character_cContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCharacter_cContext() *Character_cContext { + var p = new(Character_cContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_character_c + return p +} + +func InitEmptyCharacter_cContext(p *Character_cContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_character_c +} + +func (*Character_cContext) IsCharacter_cContext() {} + +func NewCharacter_cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Character_cContext { + var p = new(Character_cContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_character_c + + return p +} + +func (s *Character_cContext) GetParser() antlr.Parser { return s.parser } + +func (s *Character_cContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHARACTER, 0) +} + +func (s *Character_cContext) CHAR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHAR_P, 0) +} + +func (s *Character_cContext) NCHAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserNCHAR, 0) +} + +func (s *Character_cContext) Opt_varying() IOpt_varyingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_varyingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_varyingContext) +} + +func (s *Character_cContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARCHAR, 0) +} + +func (s *Character_cContext) NATIONAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserNATIONAL, 0) +} + +func (s *Character_cContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Character_cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Character_cContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCharacter_c(s) + } +} + +func (s *Character_cContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCharacter_c(s) + } +} + +func (s *Character_cContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCharacter_c(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Character_c() (localctx ICharacter_cContext) { + localctx = NewCharacter_cContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1694, RedshiftParserRULE_character_c) + var _la int + + p.SetState(13052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserNCHAR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13042) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-553)) & ^0x3f) == 0 && ((int64(1)<<(_la-553))&32771) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(13044) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1241, p.GetParserRuleContext()) == 1 { + { + p.SetState(13043) + p.Opt_varying() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserVARCHAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13046) + p.Match(RedshiftParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNATIONAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13047) + p.Match(RedshiftParserNATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13048) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCHAR_P || _la == RedshiftParserCHARACTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(13050) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1242, p.GetParserRuleContext()) == 1 { + { + p.SetState(13049) + p.Opt_varying() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_varyingContext is an interface to support dynamic dispatch. +type IOpt_varyingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VARYING() antlr.TerminalNode + + // IsOpt_varyingContext differentiates from other interfaces. + IsOpt_varyingContext() +} + +type Opt_varyingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_varyingContext() *Opt_varyingContext { + var p = new(Opt_varyingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_varying + return p +} + +func InitEmptyOpt_varyingContext(p *Opt_varyingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_varying +} + +func (*Opt_varyingContext) IsOpt_varyingContext() {} + +func NewOpt_varyingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_varyingContext { + var p = new(Opt_varyingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_varying + + return p +} + +func (s *Opt_varyingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_varyingContext) VARYING() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARYING, 0) +} + +func (s *Opt_varyingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_varyingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_varyingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_varying(s) + } +} + +func (s *Opt_varyingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_varying(s) + } +} + +func (s *Opt_varyingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_varying(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_varying() (localctx IOpt_varyingContext) { + localctx = NewOpt_varyingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1696, RedshiftParserRULE_opt_varying) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13054) + p.Match(RedshiftParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstdatetimeContext is an interface to support dynamic dispatch. +type IConstdatetimeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TIMESTAMP() antlr.TerminalNode + TIME() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Iconst() IIconstContext + CLOSE_PAREN() antlr.TerminalNode + Opt_timezone() IOpt_timezoneContext + + // IsConstdatetimeContext differentiates from other interfaces. + IsConstdatetimeContext() +} + +type ConstdatetimeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstdatetimeContext() *ConstdatetimeContext { + var p = new(ConstdatetimeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constdatetime + return p +} + +func InitEmptyConstdatetimeContext(p *ConstdatetimeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constdatetime +} + +func (*ConstdatetimeContext) IsConstdatetimeContext() {} + +func NewConstdatetimeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstdatetimeContext { + var p = new(ConstdatetimeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constdatetime + + return p +} + +func (s *ConstdatetimeContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstdatetimeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMESTAMP, 0) +} + +func (s *ConstdatetimeContext) TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIME, 0) +} + +func (s *ConstdatetimeContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *ConstdatetimeContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *ConstdatetimeContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *ConstdatetimeContext) Opt_timezone() IOpt_timezoneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_timezoneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_timezoneContext) +} + +func (s *ConstdatetimeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstdatetimeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstdatetimeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstdatetime(s) + } +} + +func (s *ConstdatetimeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstdatetime(s) + } +} + +func (s *ConstdatetimeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstdatetime(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constdatetime() (localctx IConstdatetimeContext) { + localctx = NewConstdatetimeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1698, RedshiftParserRULE_constdatetime) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13056) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserTIME || _la == RedshiftParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(13061) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1244, p.GetParserRuleContext()) == 1 { + { + p.SetState(13057) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13058) + p.Iconst() + } + { + p.SetState(13059) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13064) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1245, p.GetParserRuleContext()) == 1 { + { + p.SetState(13063) + p.Opt_timezone() + } + + } 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 +} + +// IConstintervalContext is an interface to support dynamic dispatch. +type IConstintervalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTERVAL() antlr.TerminalNode + + // IsConstintervalContext differentiates from other interfaces. + IsConstintervalContext() +} + +type ConstintervalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstintervalContext() *ConstintervalContext { + var p = new(ConstintervalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constinterval + return p +} + +func InitEmptyConstintervalContext(p *ConstintervalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_constinterval +} + +func (*ConstintervalContext) IsConstintervalContext() {} + +func NewConstintervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstintervalContext { + var p = new(ConstintervalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_constinterval + + return p +} + +func (s *ConstintervalContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstintervalContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTERVAL, 0) +} + +func (s *ConstintervalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstintervalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstintervalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterConstinterval(s) + } +} + +func (s *ConstintervalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitConstinterval(s) + } +} + +func (s *ConstintervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitConstinterval(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Constinterval() (localctx IConstintervalContext) { + localctx = NewConstintervalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1700, RedshiftParserRULE_constinterval) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13066) + p.Match(RedshiftParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_timezoneContext is an interface to support dynamic dispatch. +type IOpt_timezoneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsOpt_timezoneContext differentiates from other interfaces. + IsOpt_timezoneContext() +} + +type Opt_timezoneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_timezoneContext() *Opt_timezoneContext { + var p = new(Opt_timezoneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_timezone + return p +} + +func InitEmptyOpt_timezoneContext(p *Opt_timezoneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_timezone +} + +func (*Opt_timezoneContext) IsOpt_timezoneContext() {} + +func NewOpt_timezoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_timezoneContext { + var p = new(Opt_timezoneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_timezone + + return p +} + +func (s *Opt_timezoneContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_timezoneContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Opt_timezoneContext) TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIME, 0) +} + +func (s *Opt_timezoneContext) ZONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserZONE, 0) +} + +func (s *Opt_timezoneContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHOUT, 0) +} + +func (s *Opt_timezoneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_timezoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_timezoneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_timezone(s) + } +} + +func (s *Opt_timezoneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_timezone(s) + } +} + +func (s *Opt_timezoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_timezone(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_timezone() (localctx IOpt_timezoneContext) { + localctx = NewOpt_timezoneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1702, RedshiftParserRULE_opt_timezone) + p.SetState(13074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserWITH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13068) + p.Match(RedshiftParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13069) + p.Match(RedshiftParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13070) + p.Match(RedshiftParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserWITHOUT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13071) + p.Match(RedshiftParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13072) + p.Match(RedshiftParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13073) + p.Match(RedshiftParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_intervalContext is an interface to support dynamic dispatch. +type IOpt_intervalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + YEAR_P() antlr.TerminalNode + MONTH_P() antlr.TerminalNode + DAY_P() antlr.TerminalNode + HOUR_P() antlr.TerminalNode + MINUTE_P() antlr.TerminalNode + Interval_second() IInterval_secondContext + TO() antlr.TerminalNode + + // IsOpt_intervalContext differentiates from other interfaces. + IsOpt_intervalContext() +} + +type Opt_intervalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_intervalContext() *Opt_intervalContext { + var p = new(Opt_intervalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_interval + return p +} + +func InitEmptyOpt_intervalContext(p *Opt_intervalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_interval +} + +func (*Opt_intervalContext) IsOpt_intervalContext() {} + +func NewOpt_intervalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_intervalContext { + var p = new(Opt_intervalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_interval + + return p +} + +func (s *Opt_intervalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_intervalContext) YEAR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYEAR_P, 0) +} + +func (s *Opt_intervalContext) MONTH_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserMONTH_P, 0) +} + +func (s *Opt_intervalContext) DAY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDAY_P, 0) +} + +func (s *Opt_intervalContext) HOUR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserHOUR_P, 0) +} + +func (s *Opt_intervalContext) MINUTE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUTE_P, 0) +} + +func (s *Opt_intervalContext) Interval_second() IInterval_secondContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInterval_secondContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInterval_secondContext) +} + +func (s *Opt_intervalContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Opt_intervalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_intervalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_intervalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_interval(s) + } +} + +func (s *Opt_intervalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_interval(s) + } +} + +func (s *Opt_intervalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_interval(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_interval() (localctx IOpt_intervalContext) { + localctx = NewOpt_intervalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1704, RedshiftParserRULE_opt_interval) + p.SetState(13101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1249, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13076) + p.Match(RedshiftParserYEAR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13077) + p.Match(RedshiftParserMONTH_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13078) + p.Match(RedshiftParserDAY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13079) + p.Match(RedshiftParserHOUR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13080) + p.Match(RedshiftParserMINUTE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13081) + p.Interval_second() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13082) + p.Match(RedshiftParserYEAR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13083) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13084) + p.Match(RedshiftParserMONTH_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13085) + p.Match(RedshiftParserDAY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13086) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserHOUR_P: + { + p.SetState(13087) + p.Match(RedshiftParserHOUR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserMINUTE_P: + { + p.SetState(13088) + p.Match(RedshiftParserMINUTE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSECOND_P: + { + p.SetState(13089) + p.Interval_second() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(13092) + p.Match(RedshiftParserHOUR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13093) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserMINUTE_P: + { + p.SetState(13094) + p.Match(RedshiftParserMINUTE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSECOND_P: + { + p.SetState(13095) + p.Interval_second() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(13098) + p.Match(RedshiftParserMINUTE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13099) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13100) + p.Interval_second() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInterval_secondContext is an interface to support dynamic dispatch. +type IInterval_secondContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SECOND_P() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Iconst() IIconstContext + CLOSE_PAREN() antlr.TerminalNode + + // IsInterval_secondContext differentiates from other interfaces. + IsInterval_secondContext() +} + +type Interval_secondContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInterval_secondContext() *Interval_secondContext { + var p = new(Interval_secondContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_interval_second + return p +} + +func InitEmptyInterval_secondContext(p *Interval_secondContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_interval_second +} + +func (*Interval_secondContext) IsInterval_secondContext() {} + +func NewInterval_secondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Interval_secondContext { + var p = new(Interval_secondContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_interval_second + + return p +} + +func (s *Interval_secondContext) GetParser() antlr.Parser { return s.parser } + +func (s *Interval_secondContext) SECOND_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECOND_P, 0) +} + +func (s *Interval_secondContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Interval_secondContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Interval_secondContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Interval_secondContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Interval_secondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Interval_secondContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInterval_second(s) + } +} + +func (s *Interval_secondContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInterval_second(s) + } +} + +func (s *Interval_secondContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInterval_second(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Interval_second() (localctx IInterval_secondContext) { + localctx = NewInterval_secondContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1706, RedshiftParserRULE_interval_second) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13103) + p.Match(RedshiftParserSECOND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13108) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1250, p.GetParserRuleContext()) == 1 { + { + p.SetState(13104) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13105) + p.Iconst() + } + { + p.SetState(13106) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_escapeContext is an interface to support dynamic dispatch. +type IOpt_escapeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ESCAPE() antlr.TerminalNode + A_expr() IA_exprContext + + // IsOpt_escapeContext differentiates from other interfaces. + IsOpt_escapeContext() +} + +type Opt_escapeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_escapeContext() *Opt_escapeContext { + var p = new(Opt_escapeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_escape + return p +} + +func InitEmptyOpt_escapeContext(p *Opt_escapeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_escape +} + +func (*Opt_escapeContext) IsOpt_escapeContext() {} + +func NewOpt_escapeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_escapeContext { + var p = new(Opt_escapeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_escape + + return p +} + +func (s *Opt_escapeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_escapeContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserESCAPE, 0) +} + +func (s *Opt_escapeContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_escapeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_escapeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_escapeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_escape(s) + } +} + +func (s *Opt_escapeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_escape(s) + } +} + +func (s *Opt_escapeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_escape(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_escape() (localctx IOpt_escapeContext) { + localctx = NewOpt_escapeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1708, RedshiftParserRULE_opt_escape) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13110) + p.Match(RedshiftParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13111) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_exprContext is an interface to support dynamic dispatch. +type IA_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_qual() IA_expr_qualContext + + // IsA_exprContext differentiates from other interfaces. + IsA_exprContext() +} + +type A_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_exprContext() *A_exprContext { + var p = new(A_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr + return p +} + +func InitEmptyA_exprContext(p *A_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr +} + +func (*A_exprContext) IsA_exprContext() {} + +func NewA_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_exprContext { + var p = new(A_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr + + return p +} + +func (s *A_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_exprContext) A_expr_qual() IA_expr_qualContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_qualContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_qualContext) +} + +func (s *A_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr(s) + } +} + +func (s *A_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr(s) + } +} + +func (s *A_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr() (localctx IA_exprContext) { + localctx = NewA_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1710, RedshiftParserRULE_a_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13113) + p.A_expr_qual() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_qualContext is an interface to support dynamic dispatch. +type IA_expr_qualContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_lessless() IA_expr_lesslessContext + Qual_op() IQual_opContext + + // IsA_expr_qualContext differentiates from other interfaces. + IsA_expr_qualContext() +} + +type A_expr_qualContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_qualContext() *A_expr_qualContext { + var p = new(A_expr_qualContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_qual + return p +} + +func InitEmptyA_expr_qualContext(p *A_expr_qualContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_qual +} + +func (*A_expr_qualContext) IsA_expr_qualContext() {} + +func NewA_expr_qualContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_qualContext { + var p = new(A_expr_qualContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_qual + + return p +} + +func (s *A_expr_qualContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_qualContext) A_expr_lessless() IA_expr_lesslessContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_lesslessContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_lesslessContext) +} + +func (s *A_expr_qualContext) Qual_op() IQual_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQual_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQual_opContext) +} + +func (s *A_expr_qualContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_qualContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_qualContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_qual(s) + } +} + +func (s *A_expr_qualContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_qual(s) + } +} + +func (s *A_expr_qualContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_qual(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_qual() (localctx IA_expr_qualContext) { + localctx = NewA_expr_qualContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1712, RedshiftParserRULE_a_expr_qual) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13115) + p.A_expr_lessless() + } + p.SetState(13117) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1251, p.GetParserRuleContext()) == 1 { + { + p.SetState(13116) + p.Qual_op() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_lesslessContext is an interface to support dynamic dispatch. +type IA_expr_lesslessContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_or() []IA_expr_orContext + A_expr_or(i int) IA_expr_orContext + AllLESS_LESS() []antlr.TerminalNode + LESS_LESS(i int) antlr.TerminalNode + AllGREATER_GREATER() []antlr.TerminalNode + GREATER_GREATER(i int) antlr.TerminalNode + + // IsA_expr_lesslessContext differentiates from other interfaces. + IsA_expr_lesslessContext() +} + +type A_expr_lesslessContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_lesslessContext() *A_expr_lesslessContext { + var p = new(A_expr_lesslessContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_lessless + return p +} + +func InitEmptyA_expr_lesslessContext(p *A_expr_lesslessContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_lessless +} + +func (*A_expr_lesslessContext) IsA_expr_lesslessContext() {} + +func NewA_expr_lesslessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_lesslessContext { + var p = new(A_expr_lesslessContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_lessless + + return p +} + +func (s *A_expr_lesslessContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_lesslessContext) AllA_expr_or() []IA_expr_orContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_orContext); ok { + len++ + } + } + + tst := make([]IA_expr_orContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_orContext); ok { + tst[i] = t.(IA_expr_orContext) + i++ + } + } + + return tst +} + +func (s *A_expr_lesslessContext) A_expr_or(i int) IA_expr_orContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_orContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_orContext) +} + +func (s *A_expr_lesslessContext) AllLESS_LESS() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserLESS_LESS) +} + +func (s *A_expr_lesslessContext) LESS_LESS(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserLESS_LESS, i) +} + +func (s *A_expr_lesslessContext) AllGREATER_GREATER() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserGREATER_GREATER) +} + +func (s *A_expr_lesslessContext) GREATER_GREATER(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserGREATER_GREATER, i) +} + +func (s *A_expr_lesslessContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_lesslessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_lesslessContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_lessless(s) + } +} + +func (s *A_expr_lesslessContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_lessless(s) + } +} + +func (s *A_expr_lesslessContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_lessless(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_lessless() (localctx IA_expr_lesslessContext) { + localctx = NewA_expr_lesslessContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1714, RedshiftParserRULE_a_expr_lessless) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13119) + p.A_expr_or() + } + p.SetState(13124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1252, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13120) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserLESS_LESS || _la == RedshiftParserGREATER_GREATER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13121) + p.A_expr_or() + } + + } + p.SetState(13126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1252, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_orContext is an interface to support dynamic dispatch. +type IA_expr_orContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_and() []IA_expr_andContext + A_expr_and(i int) IA_expr_andContext + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + + // IsA_expr_orContext differentiates from other interfaces. + IsA_expr_orContext() +} + +type A_expr_orContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_orContext() *A_expr_orContext { + var p = new(A_expr_orContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_or + return p +} + +func InitEmptyA_expr_orContext(p *A_expr_orContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_or +} + +func (*A_expr_orContext) IsA_expr_orContext() {} + +func NewA_expr_orContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_orContext { + var p = new(A_expr_orContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_or + + return p +} + +func (s *A_expr_orContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_orContext) AllA_expr_and() []IA_expr_andContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_andContext); ok { + len++ + } + } + + tst := make([]IA_expr_andContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_andContext); ok { + tst[i] = t.(IA_expr_andContext) + i++ + } + } + + return tst +} + +func (s *A_expr_orContext) A_expr_and(i int) IA_expr_andContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_andContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_andContext) +} + +func (s *A_expr_orContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOR) +} + +func (s *A_expr_orContext) OR(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, i) +} + +func (s *A_expr_orContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_orContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_orContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_or(s) + } +} + +func (s *A_expr_orContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_or(s) + } +} + +func (s *A_expr_orContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_or(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_or() (localctx IA_expr_orContext) { + localctx = NewA_expr_orContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1716, RedshiftParserRULE_a_expr_or) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13127) + p.A_expr_and() + } + p.SetState(13132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1253, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13128) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13129) + p.A_expr_and() + } + + } + p.SetState(13134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1253, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_andContext is an interface to support dynamic dispatch. +type IA_expr_andContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_between() []IA_expr_betweenContext + A_expr_between(i int) IA_expr_betweenContext + AllAND() []antlr.TerminalNode + AND(i int) antlr.TerminalNode + + // IsA_expr_andContext differentiates from other interfaces. + IsA_expr_andContext() +} + +type A_expr_andContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_andContext() *A_expr_andContext { + var p = new(A_expr_andContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_and + return p +} + +func InitEmptyA_expr_andContext(p *A_expr_andContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_and +} + +func (*A_expr_andContext) IsA_expr_andContext() {} + +func NewA_expr_andContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_andContext { + var p = new(A_expr_andContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_and + + return p +} + +func (s *A_expr_andContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_andContext) AllA_expr_between() []IA_expr_betweenContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_betweenContext); ok { + len++ + } + } + + tst := make([]IA_expr_betweenContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_betweenContext); ok { + tst[i] = t.(IA_expr_betweenContext) + i++ + } + } + + return tst +} + +func (s *A_expr_andContext) A_expr_between(i int) IA_expr_betweenContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_betweenContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_betweenContext) +} + +func (s *A_expr_andContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserAND) +} + +func (s *A_expr_andContext) AND(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, i) +} + +func (s *A_expr_andContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_andContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_andContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_and(s) + } +} + +func (s *A_expr_andContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_and(s) + } +} + +func (s *A_expr_andContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_and(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_and() (localctx IA_expr_andContext) { + localctx = NewA_expr_andContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1718, RedshiftParserRULE_a_expr_and) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13135) + p.A_expr_between() + } + p.SetState(13140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1254, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13136) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13137) + p.A_expr_between() + } + + } + p.SetState(13142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1254, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_betweenContext is an interface to support dynamic dispatch. +type IA_expr_betweenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_in() []IA_expr_inContext + A_expr_in(i int) IA_expr_inContext + BETWEEN() antlr.TerminalNode + AND() antlr.TerminalNode + NOT() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + + // IsA_expr_betweenContext differentiates from other interfaces. + IsA_expr_betweenContext() +} + +type A_expr_betweenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_betweenContext() *A_expr_betweenContext { + var p = new(A_expr_betweenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_between + return p +} + +func InitEmptyA_expr_betweenContext(p *A_expr_betweenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_between +} + +func (*A_expr_betweenContext) IsA_expr_betweenContext() {} + +func NewA_expr_betweenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_betweenContext { + var p = new(A_expr_betweenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_between + + return p +} + +func (s *A_expr_betweenContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_betweenContext) AllA_expr_in() []IA_expr_inContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_inContext); ok { + len++ + } + } + + tst := make([]IA_expr_inContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_inContext); ok { + tst[i] = t.(IA_expr_inContext) + i++ + } + } + + return tst +} + +func (s *A_expr_betweenContext) A_expr_in(i int) IA_expr_inContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_inContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_inContext) +} + +func (s *A_expr_betweenContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserBETWEEN, 0) +} + +func (s *A_expr_betweenContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *A_expr_betweenContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *A_expr_betweenContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYMMETRIC, 0) +} + +func (s *A_expr_betweenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_betweenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_betweenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_between(s) + } +} + +func (s *A_expr_betweenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_between(s) + } +} + +func (s *A_expr_betweenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_between(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_between() (localctx IA_expr_betweenContext) { + localctx = NewA_expr_betweenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1720, RedshiftParserRULE_a_expr_between) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13143) + p.A_expr_in() + } + p.SetState(13155) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1257, p.GetParserRuleContext()) == 1 { + p.SetState(13145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(13144) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13147) + p.Match(RedshiftParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSYMMETRIC { + { + p.SetState(13148) + p.Match(RedshiftParserSYMMETRIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13151) + p.A_expr_in() + } + { + p.SetState(13152) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13153) + p.A_expr_in() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_inContext is an interface to support dynamic dispatch. +type IA_expr_inContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_unary_not() IA_expr_unary_notContext + IN_P() antlr.TerminalNode + In_expr() IIn_exprContext + NOT() antlr.TerminalNode + + // IsA_expr_inContext differentiates from other interfaces. + IsA_expr_inContext() +} + +type A_expr_inContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_inContext() *A_expr_inContext { + var p = new(A_expr_inContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_in + return p +} + +func InitEmptyA_expr_inContext(p *A_expr_inContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_in +} + +func (*A_expr_inContext) IsA_expr_inContext() {} + +func NewA_expr_inContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_inContext { + var p = new(A_expr_inContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_in + + return p +} + +func (s *A_expr_inContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_inContext) A_expr_unary_not() IA_expr_unary_notContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_unary_notContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_unary_notContext) +} + +func (s *A_expr_inContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *A_expr_inContext) In_expr() IIn_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_exprContext) +} + +func (s *A_expr_inContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *A_expr_inContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_inContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_inContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_in(s) + } +} + +func (s *A_expr_inContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_in(s) + } +} + +func (s *A_expr_inContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_in(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_in() (localctx IA_expr_inContext) { + localctx = NewA_expr_inContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1722, RedshiftParserRULE_a_expr_in) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13157) + p.A_expr_unary_not() + } + p.SetState(13163) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1259, p.GetParserRuleContext()) == 1 { + p.SetState(13159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(13158) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13161) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13162) + p.In_expr() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_unary_notContext is an interface to support dynamic dispatch. +type IA_expr_unary_notContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_isnull() IA_expr_isnullContext + NOT() antlr.TerminalNode + + // IsA_expr_unary_notContext differentiates from other interfaces. + IsA_expr_unary_notContext() +} + +type A_expr_unary_notContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_unary_notContext() *A_expr_unary_notContext { + var p = new(A_expr_unary_notContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_unary_not + return p +} + +func InitEmptyA_expr_unary_notContext(p *A_expr_unary_notContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_unary_not +} + +func (*A_expr_unary_notContext) IsA_expr_unary_notContext() {} + +func NewA_expr_unary_notContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_notContext { + var p = new(A_expr_unary_notContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_unary_not + + return p +} + +func (s *A_expr_unary_notContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_unary_notContext) A_expr_isnull() IA_expr_isnullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_isnullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_isnullContext) +} + +func (s *A_expr_unary_notContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *A_expr_unary_notContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_unary_notContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_unary_notContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_unary_not(s) + } +} + +func (s *A_expr_unary_notContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_unary_not(s) + } +} + +func (s *A_expr_unary_notContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_unary_not(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_unary_not() (localctx IA_expr_unary_notContext) { + localctx = NewA_expr_unary_notContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1724, RedshiftParserRULE_a_expr_unary_not) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(13165) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13168) + p.A_expr_isnull() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_isnullContext is an interface to support dynamic dispatch. +type IA_expr_isnullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_is_not() IA_expr_is_notContext + ISNULL() antlr.TerminalNode + NOTNULL() antlr.TerminalNode + + // IsA_expr_isnullContext differentiates from other interfaces. + IsA_expr_isnullContext() +} + +type A_expr_isnullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_isnullContext() *A_expr_isnullContext { + var p = new(A_expr_isnullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_isnull + return p +} + +func InitEmptyA_expr_isnullContext(p *A_expr_isnullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_isnull +} + +func (*A_expr_isnullContext) IsA_expr_isnullContext() {} + +func NewA_expr_isnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_isnullContext { + var p = new(A_expr_isnullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_isnull + + return p +} + +func (s *A_expr_isnullContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_isnullContext) A_expr_is_not() IA_expr_is_notContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_is_notContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_is_notContext) +} + +func (s *A_expr_isnullContext) ISNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserISNULL, 0) +} + +func (s *A_expr_isnullContext) NOTNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTNULL, 0) +} + +func (s *A_expr_isnullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_isnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_isnullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_isnull(s) + } +} + +func (s *A_expr_isnullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_isnull(s) + } +} + +func (s *A_expr_isnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_isnull(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_isnull() (localctx IA_expr_isnullContext) { + localctx = NewA_expr_isnullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1726, RedshiftParserRULE_a_expr_isnull) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13170) + p.A_expr_is_not() + } + p.SetState(13172) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1261, p.GetParserRuleContext()) == 1 { + { + p.SetState(13171) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserISNULL || _la == RedshiftParserNOTNULL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_is_notContext is an interface to support dynamic dispatch. +type IA_expr_is_notContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_compare() IA_expr_compareContext + IS() antlr.TerminalNode + NULL_P() antlr.TerminalNode + TRUE_P() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + UNKNOWN() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + FROM() antlr.TerminalNode + A_expr() IA_exprContext + OF() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Type_list() IType_listContext + CLOSE_PAREN() antlr.TerminalNode + DOCUMENT_P() antlr.TerminalNode + NORMALIZED() antlr.TerminalNode + NOT() antlr.TerminalNode + Unicode_normal_form() IUnicode_normal_formContext + + // IsA_expr_is_notContext differentiates from other interfaces. + IsA_expr_is_notContext() +} + +type A_expr_is_notContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_is_notContext() *A_expr_is_notContext { + var p = new(A_expr_is_notContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_is_not + return p +} + +func InitEmptyA_expr_is_notContext(p *A_expr_is_notContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_is_not +} + +func (*A_expr_is_notContext) IsA_expr_is_notContext() {} + +func NewA_expr_is_notContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_is_notContext { + var p = new(A_expr_is_notContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_is_not + + return p +} + +func (s *A_expr_is_notContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_is_notContext) A_expr_compare() IA_expr_compareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_compareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_compareContext) +} + +func (s *A_expr_is_notContext) IS() antlr.TerminalNode { + return s.GetToken(RedshiftParserIS, 0) +} + +func (s *A_expr_is_notContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *A_expr_is_notContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *A_expr_is_notContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *A_expr_is_notContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNKNOWN, 0) +} + +func (s *A_expr_is_notContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTINCT, 0) +} + +func (s *A_expr_is_notContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *A_expr_is_notContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *A_expr_is_notContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *A_expr_is_notContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *A_expr_is_notContext) Type_list() IType_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_listContext) +} + +func (s *A_expr_is_notContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *A_expr_is_notContext) DOCUMENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOCUMENT_P, 0) +} + +func (s *A_expr_is_notContext) NORMALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserNORMALIZED, 0) +} + +func (s *A_expr_is_notContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *A_expr_is_notContext) Unicode_normal_form() IUnicode_normal_formContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnicode_normal_formContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnicode_normal_formContext) +} + +func (s *A_expr_is_notContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_is_notContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_is_notContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_is_not(s) + } +} + +func (s *A_expr_is_notContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_is_not(s) + } +} + +func (s *A_expr_is_notContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_is_not(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_is_not() (localctx IA_expr_is_notContext) { + localctx = NewA_expr_is_notContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1728, RedshiftParserRULE_a_expr_is_not) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13174) + p.A_expr_compare() + } + p.SetState(13198) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1265, p.GetParserRuleContext()) == 1 { + { + p.SetState(13175) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(13176) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNULL_P: + { + p.SetState(13179) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserTRUE_P: + { + p.SetState(13180) + p.Match(RedshiftParserTRUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserFALSE_P: + { + p.SetState(13181) + p.Match(RedshiftParserFALSE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUNKNOWN: + { + p.SetState(13182) + p.Match(RedshiftParserUNKNOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDISTINCT: + { + p.SetState(13183) + p.Match(RedshiftParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13184) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13185) + p.A_expr() + } + + case RedshiftParserOF: + { + p.SetState(13186) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13187) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13188) + p.Type_list() + } + { + p.SetState(13189) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDOCUMENT_P: + { + p.SetState(13191) + p.Match(RedshiftParserDOCUMENT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNORMALIZED, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD: + p.SetState(13193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-682)) & ^0x3f) == 0 && ((int64(1)<<(_la-682))&15) != 0 { + { + p.SetState(13192) + p.Unicode_normal_form() + } + + } + { + p.SetState(13195) + p.Match(RedshiftParserNORMALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_compareContext is an interface to support dynamic dispatch. +type IA_expr_compareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_prior_or_level() []IA_expr_prior_or_levelContext + A_expr_prior_or_level(i int) IA_expr_prior_or_levelContext + Subquery_Op() ISubquery_OpContext + Sub_type() ISub_typeContext + LT() antlr.TerminalNode + GT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + LESS_EQUALS() antlr.TerminalNode + GREATER_EQUALS() antlr.TerminalNode + NOT_EQUALS() antlr.TerminalNode + Select_with_parens() ISelect_with_parensContext + OPEN_PAREN() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsA_expr_compareContext differentiates from other interfaces. + IsA_expr_compareContext() +} + +type A_expr_compareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_compareContext() *A_expr_compareContext { + var p = new(A_expr_compareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_compare + return p +} + +func InitEmptyA_expr_compareContext(p *A_expr_compareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_compare +} + +func (*A_expr_compareContext) IsA_expr_compareContext() {} + +func NewA_expr_compareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_compareContext { + var p = new(A_expr_compareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_compare + + return p +} + +func (s *A_expr_compareContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_compareContext) AllA_expr_prior_or_level() []IA_expr_prior_or_levelContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_prior_or_levelContext); ok { + len++ + } + } + + tst := make([]IA_expr_prior_or_levelContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_prior_or_levelContext); ok { + tst[i] = t.(IA_expr_prior_or_levelContext) + i++ + } + } + + return tst +} + +func (s *A_expr_compareContext) A_expr_prior_or_level(i int) IA_expr_prior_or_levelContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_prior_or_levelContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_prior_or_levelContext) +} + +func (s *A_expr_compareContext) Subquery_Op() ISubquery_OpContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_OpContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_OpContext) +} + +func (s *A_expr_compareContext) Sub_type() ISub_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISub_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISub_typeContext) +} + +func (s *A_expr_compareContext) LT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLT, 0) +} + +func (s *A_expr_compareContext) GT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGT, 0) +} + +func (s *A_expr_compareContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *A_expr_compareContext) LESS_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserLESS_EQUALS, 0) +} + +func (s *A_expr_compareContext) GREATER_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGREATER_EQUALS, 0) +} + +func (s *A_expr_compareContext) NOT_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT_EQUALS, 0) +} + +func (s *A_expr_compareContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *A_expr_compareContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *A_expr_compareContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *A_expr_compareContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *A_expr_compareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_compareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_compareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_compare(s) + } +} + +func (s *A_expr_compareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_compare(s) + } +} + +func (s *A_expr_compareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_compare(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_compare() (localctx IA_expr_compareContext) { + localctx = NewA_expr_compareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1730, RedshiftParserRULE_a_expr_compare) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13200) + p.A_expr_prior_or_level() + } + p.SetState(13212) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1267, p.GetParserRuleContext()) == 1 { + { + p.SetState(13201) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&44237824) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13202) + p.A_expr_prior_or_level() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1267, p.GetParserRuleContext()) == 2 { + { + p.SetState(13203) + p.Subquery_Op() + } + { + p.SetState(13204) + p.Sub_type() + } + p.SetState(13210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1266, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13205) + p.Select_with_parens() + } + + case 2: + { + p.SetState(13206) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13207) + p.A_expr() + } + { + p.SetState(13208) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_prior_or_levelContext is an interface to support dynamic dispatch. +type IA_expr_prior_or_levelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_like() IA_expr_likeContext + PRIOR() antlr.TerminalNode + LEVEL() antlr.TerminalNode + + // IsA_expr_prior_or_levelContext differentiates from other interfaces. + IsA_expr_prior_or_levelContext() +} + +type A_expr_prior_or_levelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_prior_or_levelContext() *A_expr_prior_or_levelContext { + var p = new(A_expr_prior_or_levelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_prior_or_level + return p +} + +func InitEmptyA_expr_prior_or_levelContext(p *A_expr_prior_or_levelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_prior_or_level +} + +func (*A_expr_prior_or_levelContext) IsA_expr_prior_or_levelContext() {} + +func NewA_expr_prior_or_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_prior_or_levelContext { + var p = new(A_expr_prior_or_levelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_prior_or_level + + return p +} + +func (s *A_expr_prior_or_levelContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_prior_or_levelContext) A_expr_like() IA_expr_likeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_likeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_likeContext) +} + +func (s *A_expr_prior_or_levelContext) PRIOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIOR, 0) +} + +func (s *A_expr_prior_or_levelContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *A_expr_prior_or_levelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_prior_or_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_prior_or_levelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_prior_or_level(s) + } +} + +func (s *A_expr_prior_or_levelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_prior_or_level(s) + } +} + +func (s *A_expr_prior_or_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_prior_or_level(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_prior_or_level() (localctx IA_expr_prior_or_levelContext) { + localctx = NewA_expr_prior_or_levelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1732, RedshiftParserRULE_a_expr_prior_or_level) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13215) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1268, p.GetParserRuleContext()) == 1 { + { + p.SetState(13214) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserLEVEL || _la == RedshiftParserPRIOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13217) + p.A_expr_like() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_likeContext is an interface to support dynamic dispatch. +type IA_expr_likeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_qual_op() []IA_expr_qual_opContext + A_expr_qual_op(i int) IA_expr_qual_opContext + LIKE() antlr.TerminalNode + ILIKE() antlr.TerminalNode + SIMILAR() antlr.TerminalNode + TO() antlr.TerminalNode + NOT() antlr.TerminalNode + Opt_escape() IOpt_escapeContext + + // IsA_expr_likeContext differentiates from other interfaces. + IsA_expr_likeContext() +} + +type A_expr_likeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_likeContext() *A_expr_likeContext { + var p = new(A_expr_likeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_like + return p +} + +func InitEmptyA_expr_likeContext(p *A_expr_likeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_like +} + +func (*A_expr_likeContext) IsA_expr_likeContext() {} + +func NewA_expr_likeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_likeContext { + var p = new(A_expr_likeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_like + + return p +} + +func (s *A_expr_likeContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_likeContext) AllA_expr_qual_op() []IA_expr_qual_opContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_qual_opContext); ok { + len++ + } + } + + tst := make([]IA_expr_qual_opContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_qual_opContext); ok { + tst[i] = t.(IA_expr_qual_opContext) + i++ + } + } + + return tst +} + +func (s *A_expr_likeContext) A_expr_qual_op(i int) IA_expr_qual_opContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_qual_opContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_qual_opContext) +} + +func (s *A_expr_likeContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *A_expr_likeContext) ILIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserILIKE, 0) +} + +func (s *A_expr_likeContext) SIMILAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIMILAR, 0) +} + +func (s *A_expr_likeContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *A_expr_likeContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *A_expr_likeContext) Opt_escape() IOpt_escapeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_escapeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_escapeContext) +} + +func (s *A_expr_likeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_likeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_likeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_like(s) + } +} + +func (s *A_expr_likeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_like(s) + } +} + +func (s *A_expr_likeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_like(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_like() (localctx IA_expr_likeContext) { + localctx = NewA_expr_likeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1734, RedshiftParserRULE_a_expr_like) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13219) + p.A_expr_qual_op() + } + p.SetState(13233) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1272, p.GetParserRuleContext()) == 1 { + p.SetState(13221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(13220) + p.Match(RedshiftParserNOT) + 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 RedshiftParserLIKE: + { + p.SetState(13223) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserILIKE: + { + p.SetState(13224) + p.Match(RedshiftParserILIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSIMILAR: + { + p.SetState(13225) + p.Match(RedshiftParserSIMILAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13226) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13229) + p.A_expr_qual_op() + } + p.SetState(13231) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1271, p.GetParserRuleContext()) == 1 { + { + p.SetState(13230) + p.Opt_escape() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_qual_opContext is an interface to support dynamic dispatch. +type IA_expr_qual_opContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_unary_qualop() []IA_expr_unary_qualopContext + A_expr_unary_qualop(i int) IA_expr_unary_qualopContext + AllQual_op() []IQual_opContext + Qual_op(i int) IQual_opContext + + // IsA_expr_qual_opContext differentiates from other interfaces. + IsA_expr_qual_opContext() +} + +type A_expr_qual_opContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_qual_opContext() *A_expr_qual_opContext { + var p = new(A_expr_qual_opContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_qual_op + return p +} + +func InitEmptyA_expr_qual_opContext(p *A_expr_qual_opContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_qual_op +} + +func (*A_expr_qual_opContext) IsA_expr_qual_opContext() {} + +func NewA_expr_qual_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_qual_opContext { + var p = new(A_expr_qual_opContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_qual_op + + return p +} + +func (s *A_expr_qual_opContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_qual_opContext) AllA_expr_unary_qualop() []IA_expr_unary_qualopContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_unary_qualopContext); ok { + len++ + } + } + + tst := make([]IA_expr_unary_qualopContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_unary_qualopContext); ok { + tst[i] = t.(IA_expr_unary_qualopContext) + i++ + } + } + + return tst +} + +func (s *A_expr_qual_opContext) A_expr_unary_qualop(i int) IA_expr_unary_qualopContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_unary_qualopContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_unary_qualopContext) +} + +func (s *A_expr_qual_opContext) AllQual_op() []IQual_opContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQual_opContext); ok { + len++ + } + } + + tst := make([]IQual_opContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQual_opContext); ok { + tst[i] = t.(IQual_opContext) + i++ + } + } + + return tst +} + +func (s *A_expr_qual_opContext) Qual_op(i int) IQual_opContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQual_opContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQual_opContext) +} + +func (s *A_expr_qual_opContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_qual_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_qual_opContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_qual_op(s) + } +} + +func (s *A_expr_qual_opContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_qual_op(s) + } +} + +func (s *A_expr_qual_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_qual_op(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_qual_op() (localctx IA_expr_qual_opContext) { + localctx = NewA_expr_qual_opContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1736, RedshiftParserRULE_a_expr_qual_op) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13235) + p.A_expr_unary_qualop() + } + p.SetState(13241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1273, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13236) + p.Qual_op() + } + { + p.SetState(13237) + p.A_expr_unary_qualop() + } + + } + p.SetState(13243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1273, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_unary_qualopContext is an interface to support dynamic dispatch. +type IA_expr_unary_qualopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_add() IA_expr_addContext + Qual_op() IQual_opContext + + // IsA_expr_unary_qualopContext differentiates from other interfaces. + IsA_expr_unary_qualopContext() +} + +type A_expr_unary_qualopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_unary_qualopContext() *A_expr_unary_qualopContext { + var p = new(A_expr_unary_qualopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_unary_qualop + return p +} + +func InitEmptyA_expr_unary_qualopContext(p *A_expr_unary_qualopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_unary_qualop +} + +func (*A_expr_unary_qualopContext) IsA_expr_unary_qualopContext() {} + +func NewA_expr_unary_qualopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_qualopContext { + var p = new(A_expr_unary_qualopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_unary_qualop + + return p +} + +func (s *A_expr_unary_qualopContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_unary_qualopContext) A_expr_add() IA_expr_addContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_addContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_addContext) +} + +func (s *A_expr_unary_qualopContext) Qual_op() IQual_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQual_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQual_opContext) +} + +func (s *A_expr_unary_qualopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_unary_qualopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_unary_qualopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_unary_qualop(s) + } +} + +func (s *A_expr_unary_qualopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_unary_qualop(s) + } +} + +func (s *A_expr_unary_qualopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_unary_qualop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_unary_qualop() (localctx IA_expr_unary_qualopContext) { + localctx = NewA_expr_unary_qualopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1738, RedshiftParserRULE_a_expr_unary_qualop) + p.EnterOuterAlt(localctx, 1) + p.SetState(13245) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1274, p.GetParserRuleContext()) == 1 { + { + p.SetState(13244) + p.Qual_op() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13247) + p.A_expr_add() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_addContext is an interface to support dynamic dispatch. +type IA_expr_addContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_mul() []IA_expr_mulContext + A_expr_mul(i int) IA_expr_mulContext + AllMINUS() []antlr.TerminalNode + MINUS(i int) antlr.TerminalNode + AllPLUS() []antlr.TerminalNode + PLUS(i int) antlr.TerminalNode + + // IsA_expr_addContext differentiates from other interfaces. + IsA_expr_addContext() +} + +type A_expr_addContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_addContext() *A_expr_addContext { + var p = new(A_expr_addContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_add + return p +} + +func InitEmptyA_expr_addContext(p *A_expr_addContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_add +} + +func (*A_expr_addContext) IsA_expr_addContext() {} + +func NewA_expr_addContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_addContext { + var p = new(A_expr_addContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_add + + return p +} + +func (s *A_expr_addContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_addContext) AllA_expr_mul() []IA_expr_mulContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_mulContext); ok { + len++ + } + } + + tst := make([]IA_expr_mulContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_mulContext); ok { + tst[i] = t.(IA_expr_mulContext) + i++ + } + } + + return tst +} + +func (s *A_expr_addContext) A_expr_mul(i int) IA_expr_mulContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_mulContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_mulContext) +} + +func (s *A_expr_addContext) AllMINUS() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserMINUS) +} + +func (s *A_expr_addContext) MINUS(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUS, i) +} + +func (s *A_expr_addContext) AllPLUS() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserPLUS) +} + +func (s *A_expr_addContext) PLUS(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserPLUS, i) +} + +func (s *A_expr_addContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_addContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_addContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_add(s) + } +} + +func (s *A_expr_addContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_add(s) + } +} + +func (s *A_expr_addContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_add(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_add() (localctx IA_expr_addContext) { + localctx = NewA_expr_addContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1740, RedshiftParserRULE_a_expr_add) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13249) + p.A_expr_mul() + } + p.SetState(13254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1275, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13250) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserPLUS || _la == RedshiftParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13251) + p.A_expr_mul() + } + + } + p.SetState(13256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1275, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_mulContext is an interface to support dynamic dispatch. +type IA_expr_mulContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr_caret() []IA_expr_caretContext + A_expr_caret(i int) IA_expr_caretContext + AllSTAR() []antlr.TerminalNode + STAR(i int) antlr.TerminalNode + AllSLASH() []antlr.TerminalNode + SLASH(i int) antlr.TerminalNode + AllPERCENT() []antlr.TerminalNode + PERCENT(i int) antlr.TerminalNode + + // IsA_expr_mulContext differentiates from other interfaces. + IsA_expr_mulContext() +} + +type A_expr_mulContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_mulContext() *A_expr_mulContext { + var p = new(A_expr_mulContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_mul + return p +} + +func InitEmptyA_expr_mulContext(p *A_expr_mulContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_mul +} + +func (*A_expr_mulContext) IsA_expr_mulContext() {} + +func NewA_expr_mulContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_mulContext { + var p = new(A_expr_mulContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_mul + + return p +} + +func (s *A_expr_mulContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_mulContext) AllA_expr_caret() []IA_expr_caretContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_expr_caretContext); ok { + len++ + } + } + + tst := make([]IA_expr_caretContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_expr_caretContext); ok { + tst[i] = t.(IA_expr_caretContext) + i++ + } + } + + return tst +} + +func (s *A_expr_mulContext) A_expr_caret(i int) IA_expr_caretContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_caretContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_caretContext) +} + +func (s *A_expr_mulContext) AllSTAR() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserSTAR) +} + +func (s *A_expr_mulContext) STAR(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, i) +} + +func (s *A_expr_mulContext) AllSLASH() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserSLASH) +} + +func (s *A_expr_mulContext) SLASH(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserSLASH, i) +} + +func (s *A_expr_mulContext) AllPERCENT() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserPERCENT) +} + +func (s *A_expr_mulContext) PERCENT(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENT, i) +} + +func (s *A_expr_mulContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_mulContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_mulContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_mul(s) + } +} + +func (s *A_expr_mulContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_mul(s) + } +} + +func (s *A_expr_mulContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_mul(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_mul() (localctx IA_expr_mulContext) { + localctx = NewA_expr_mulContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1742, RedshiftParserRULE_a_expr_mul) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13257) + p.A_expr_caret() + } + p.SetState(13262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1276, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13258) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&134234624) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13259) + p.A_expr_caret() + } + + } + p.SetState(13264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1276, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_caretContext is an interface to support dynamic dispatch. +type IA_expr_caretContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_unary_sign() IA_expr_unary_signContext + CARET() antlr.TerminalNode + A_expr() IA_exprContext + + // IsA_expr_caretContext differentiates from other interfaces. + IsA_expr_caretContext() +} + +type A_expr_caretContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_caretContext() *A_expr_caretContext { + var p = new(A_expr_caretContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_caret + return p +} + +func InitEmptyA_expr_caretContext(p *A_expr_caretContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_caret +} + +func (*A_expr_caretContext) IsA_expr_caretContext() {} + +func NewA_expr_caretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_caretContext { + var p = new(A_expr_caretContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_caret + + return p +} + +func (s *A_expr_caretContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_caretContext) A_expr_unary_sign() IA_expr_unary_signContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_unary_signContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_unary_signContext) +} + +func (s *A_expr_caretContext) CARET() antlr.TerminalNode { + return s.GetToken(RedshiftParserCARET, 0) +} + +func (s *A_expr_caretContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *A_expr_caretContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_caretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_caretContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_caret(s) + } +} + +func (s *A_expr_caretContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_caret(s) + } +} + +func (s *A_expr_caretContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_caret(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_caret() (localctx IA_expr_caretContext) { + localctx = NewA_expr_caretContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1744, RedshiftParserRULE_a_expr_caret) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13265) + p.A_expr_unary_sign() + } + p.SetState(13268) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1277, p.GetParserRuleContext()) == 1 { + { + p.SetState(13266) + p.Match(RedshiftParserCARET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13267) + p.A_expr() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_unary_signContext is an interface to support dynamic dispatch. +type IA_expr_unary_signContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_at_time_zone() IA_expr_at_time_zoneContext + MINUS() antlr.TerminalNode + PLUS() antlr.TerminalNode + + // IsA_expr_unary_signContext differentiates from other interfaces. + IsA_expr_unary_signContext() +} + +type A_expr_unary_signContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_unary_signContext() *A_expr_unary_signContext { + var p = new(A_expr_unary_signContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_unary_sign + return p +} + +func InitEmptyA_expr_unary_signContext(p *A_expr_unary_signContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_unary_sign +} + +func (*A_expr_unary_signContext) IsA_expr_unary_signContext() {} + +func NewA_expr_unary_signContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_unary_signContext { + var p = new(A_expr_unary_signContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_unary_sign + + return p +} + +func (s *A_expr_unary_signContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_unary_signContext) A_expr_at_time_zone() IA_expr_at_time_zoneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_at_time_zoneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_at_time_zoneContext) +} + +func (s *A_expr_unary_signContext) MINUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUS, 0) +} + +func (s *A_expr_unary_signContext) PLUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLUS, 0) +} + +func (s *A_expr_unary_signContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_unary_signContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_unary_signContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_unary_sign(s) + } +} + +func (s *A_expr_unary_signContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_unary_sign(s) + } +} + +func (s *A_expr_unary_signContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_unary_sign(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_unary_sign() (localctx IA_expr_unary_signContext) { + localctx = NewA_expr_unary_signContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1746, RedshiftParserRULE_a_expr_unary_sign) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPLUS || _la == RedshiftParserMINUS { + { + p.SetState(13270) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserPLUS || _la == RedshiftParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13273) + p.A_expr_at_time_zone() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_at_time_zoneContext is an interface to support dynamic dispatch. +type IA_expr_at_time_zoneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_collate() IA_expr_collateContext + AT() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + A_expr() IA_exprContext + + // IsA_expr_at_time_zoneContext differentiates from other interfaces. + IsA_expr_at_time_zoneContext() +} + +type A_expr_at_time_zoneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_at_time_zoneContext() *A_expr_at_time_zoneContext { + var p = new(A_expr_at_time_zoneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_at_time_zone + return p +} + +func InitEmptyA_expr_at_time_zoneContext(p *A_expr_at_time_zoneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_at_time_zone +} + +func (*A_expr_at_time_zoneContext) IsA_expr_at_time_zoneContext() {} + +func NewA_expr_at_time_zoneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_at_time_zoneContext { + var p = new(A_expr_at_time_zoneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_at_time_zone + + return p +} + +func (s *A_expr_at_time_zoneContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_at_time_zoneContext) A_expr_collate() IA_expr_collateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_collateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_collateContext) +} + +func (s *A_expr_at_time_zoneContext) AT() antlr.TerminalNode { + return s.GetToken(RedshiftParserAT, 0) +} + +func (s *A_expr_at_time_zoneContext) TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIME, 0) +} + +func (s *A_expr_at_time_zoneContext) ZONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserZONE, 0) +} + +func (s *A_expr_at_time_zoneContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *A_expr_at_time_zoneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_at_time_zoneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_at_time_zoneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_at_time_zone(s) + } +} + +func (s *A_expr_at_time_zoneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_at_time_zone(s) + } +} + +func (s *A_expr_at_time_zoneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_at_time_zone(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_at_time_zone() (localctx IA_expr_at_time_zoneContext) { + localctx = NewA_expr_at_time_zoneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1748, RedshiftParserRULE_a_expr_at_time_zone) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13275) + p.A_expr_collate() + } + p.SetState(13280) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1279, p.GetParserRuleContext()) == 1 { + { + p.SetState(13276) + p.Match(RedshiftParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13277) + p.Match(RedshiftParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13278) + p.Match(RedshiftParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13279) + p.A_expr() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_collateContext is an interface to support dynamic dispatch. +type IA_expr_collateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr_typecast() IA_expr_typecastContext + COLLATE() antlr.TerminalNode + Any_name() IAny_nameContext + + // IsA_expr_collateContext differentiates from other interfaces. + IsA_expr_collateContext() +} + +type A_expr_collateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_collateContext() *A_expr_collateContext { + var p = new(A_expr_collateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_collate + return p +} + +func InitEmptyA_expr_collateContext(p *A_expr_collateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_collate +} + +func (*A_expr_collateContext) IsA_expr_collateContext() {} + +func NewA_expr_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_collateContext { + var p = new(A_expr_collateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_collate + + return p +} + +func (s *A_expr_collateContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_collateContext) A_expr_typecast() IA_expr_typecastContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_expr_typecastContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_expr_typecastContext) +} + +func (s *A_expr_collateContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *A_expr_collateContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *A_expr_collateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_collateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_collate(s) + } +} + +func (s *A_expr_collateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_collate(s) + } +} + +func (s *A_expr_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_collate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_collate() (localctx IA_expr_collateContext) { + localctx = NewA_expr_collateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1750, RedshiftParserRULE_a_expr_collate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13282) + p.A_expr_typecast() + } + p.SetState(13285) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1280, p.GetParserRuleContext()) == 1 { + { + p.SetState(13283) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13284) + p.Any_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IA_expr_typecastContext is an interface to support dynamic dispatch. +type IA_expr_typecastContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + C_expr() IC_exprContext + AllTYPECAST() []antlr.TerminalNode + TYPECAST(i int) antlr.TerminalNode + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + + // IsA_expr_typecastContext differentiates from other interfaces. + IsA_expr_typecastContext() +} + +type A_expr_typecastContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyA_expr_typecastContext() *A_expr_typecastContext { + var p = new(A_expr_typecastContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_typecast + return p +} + +func InitEmptyA_expr_typecastContext(p *A_expr_typecastContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_a_expr_typecast +} + +func (*A_expr_typecastContext) IsA_expr_typecastContext() {} + +func NewA_expr_typecastContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *A_expr_typecastContext { + var p = new(A_expr_typecastContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_a_expr_typecast + + return p +} + +func (s *A_expr_typecastContext) GetParser() antlr.Parser { return s.parser } + +func (s *A_expr_typecastContext) C_expr() IC_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_exprContext) +} + +func (s *A_expr_typecastContext) AllTYPECAST() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserTYPECAST) +} + +func (s *A_expr_typecastContext) TYPECAST(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPECAST, i) +} + +func (s *A_expr_typecastContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *A_expr_typecastContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *A_expr_typecastContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *A_expr_typecastContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *A_expr_typecastContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterA_expr_typecast(s) + } +} + +func (s *A_expr_typecastContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitA_expr_typecast(s) + } +} + +func (s *A_expr_typecastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitA_expr_typecast(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) A_expr_typecast() (localctx IA_expr_typecastContext) { + localctx = NewA_expr_typecastContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1752, RedshiftParserRULE_a_expr_typecast) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13287) + p.C_expr() + } + p.SetState(13292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserTYPECAST { + { + p.SetState(13288) + p.Match(RedshiftParserTYPECAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13289) + p.Typename() + } + + p.SetState(13294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IB_exprContext is an interface to support dynamic dispatch. +type IB_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + C_expr() IC_exprContext + AllB_expr() []IB_exprContext + B_expr(i int) IB_exprContext + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + Qual_op() IQual_opContext + CARET() antlr.TerminalNode + STAR() antlr.TerminalNode + SLASH() antlr.TerminalNode + PERCENT() antlr.TerminalNode + LT() antlr.TerminalNode + GT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + LESS_EQUALS() antlr.TerminalNode + GREATER_EQUALS() antlr.TerminalNode + NOT_EQUALS() antlr.TerminalNode + TYPECAST() antlr.TerminalNode + Typename() ITypenameContext + IS() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + FROM() antlr.TerminalNode + OF() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Type_list() IType_listContext + CLOSE_PAREN() antlr.TerminalNode + DOCUMENT_P() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsB_exprContext differentiates from other interfaces. + IsB_exprContext() +} + +type B_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyB_exprContext() *B_exprContext { + var p = new(B_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_b_expr + return p +} + +func InitEmptyB_exprContext(p *B_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_b_expr +} + +func (*B_exprContext) IsB_exprContext() {} + +func NewB_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *B_exprContext { + var p = new(B_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_b_expr + + return p +} + +func (s *B_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *B_exprContext) C_expr() IC_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_exprContext) +} + +func (s *B_exprContext) AllB_expr() []IB_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IB_exprContext); ok { + len++ + } + } + + tst := make([]IB_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IB_exprContext); ok { + tst[i] = t.(IB_exprContext) + i++ + } + } + + return tst +} + +func (s *B_exprContext) B_expr(i int) IB_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IB_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IB_exprContext) +} + +func (s *B_exprContext) PLUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLUS, 0) +} + +func (s *B_exprContext) MINUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUS, 0) +} + +func (s *B_exprContext) Qual_op() IQual_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQual_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQual_opContext) +} + +func (s *B_exprContext) CARET() antlr.TerminalNode { + return s.GetToken(RedshiftParserCARET, 0) +} + +func (s *B_exprContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *B_exprContext) SLASH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSLASH, 0) +} + +func (s *B_exprContext) PERCENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENT, 0) +} + +func (s *B_exprContext) LT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLT, 0) +} + +func (s *B_exprContext) GT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGT, 0) +} + +func (s *B_exprContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *B_exprContext) LESS_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserLESS_EQUALS, 0) +} + +func (s *B_exprContext) GREATER_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGREATER_EQUALS, 0) +} + +func (s *B_exprContext) NOT_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT_EQUALS, 0) +} + +func (s *B_exprContext) TYPECAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPECAST, 0) +} + +func (s *B_exprContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *B_exprContext) IS() antlr.TerminalNode { + return s.GetToken(RedshiftParserIS, 0) +} + +func (s *B_exprContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTINCT, 0) +} + +func (s *B_exprContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *B_exprContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *B_exprContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *B_exprContext) Type_list() IType_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_listContext) +} + +func (s *B_exprContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *B_exprContext) DOCUMENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOCUMENT_P, 0) +} + +func (s *B_exprContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *B_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *B_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *B_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterB_expr(s) + } +} + +func (s *B_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitB_expr(s) + } +} + +func (s *B_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitB_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) B_expr() (localctx IB_exprContext) { + return p.b_expr(0) +} + +func (p *RedshiftParser) b_expr(_p int) (localctx IB_exprContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewB_exprContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IB_exprContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1754 + p.EnterRecursionRule(localctx, 1754, RedshiftParserRULE_b_expr, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1282, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13296) + p.C_expr() + } + + case 2: + { + p.SetState(13297) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserPLUS || _la == RedshiftParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13298) + p.b_expr(9) + } + + case 3: + { + p.SetState(13299) + p.Qual_op() + } + { + p.SetState(13300) + p.b_expr(3) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(13343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1286, 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(13341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1285, p.GetParserRuleContext()) { + case 1: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13304) + + if !(p.Precpred(p.GetParserRuleContext(), 8)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 8)", "")) + goto errorExit + } + { + p.SetState(13305) + p.Match(RedshiftParserCARET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13306) + p.b_expr(9) + } + + case 2: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13307) + + if !(p.Precpred(p.GetParserRuleContext(), 7)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 7)", "")) + goto errorExit + } + { + p.SetState(13308) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&134234624) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13309) + p.b_expr(8) + } + + case 3: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13310) + + if !(p.Precpred(p.GetParserRuleContext(), 6)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) + goto errorExit + } + { + p.SetState(13311) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserPLUS || _la == RedshiftParserMINUS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13312) + p.b_expr(7) + } + + case 4: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13313) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(13314) + p.Qual_op() + } + { + p.SetState(13315) + p.b_expr(6) + } + + case 5: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13317) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + { + p.SetState(13318) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&44237824) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13319) + p.b_expr(5) + } + + case 6: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13320) + + if !(p.Precpred(p.GetParserRuleContext(), 10)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 10)", "")) + goto errorExit + } + { + p.SetState(13321) + p.Match(RedshiftParserTYPECAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13322) + p.Typename() + } + + case 7: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13323) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(13324) + p.Qual_op() + } + + case 8: + localctx = NewB_exprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, RedshiftParserRULE_b_expr) + p.SetState(13325) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(13326) + p.Match(RedshiftParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(13327) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDISTINCT: + { + p.SetState(13330) + p.Match(RedshiftParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13331) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13332) + p.b_expr(0) + } + + case RedshiftParserOF: + { + p.SetState(13333) + p.Match(RedshiftParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13334) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13335) + p.Type_list() + } + { + p.SetState(13336) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDOCUMENT_P: + { + p.SetState(13338) + p.Match(RedshiftParserDOCUMENT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(13345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1286, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.UnrollRecursionContexts(_parentctx) + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IC_exprContext is an interface to support dynamic dispatch. +type IC_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsC_exprContext differentiates from other interfaces. + IsC_exprContext() +} + +type C_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_exprContext() *C_exprContext { + var p = new(C_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_c_expr + return p +} + +func InitEmptyC_exprContext(p *C_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_c_expr +} + +func (*C_exprContext) IsC_exprContext() {} + +func NewC_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_exprContext { + var p = new(C_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_c_expr + + return p +} + +func (s *C_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_exprContext) CopyAll(ctx *C_exprContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *C_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type C_expr_existsContext struct { + C_exprContext +} + +func NewC_expr_existsContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_existsContext { + var p = new(C_expr_existsContext) + + InitEmptyC_exprContext(&p.C_exprContext) + p.parser = parser + p.CopyAll(ctx.(*C_exprContext)) + + return p +} + +func (s *C_expr_existsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_expr_existsContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *C_expr_existsContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *C_expr_existsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterC_expr_exists(s) + } +} + +func (s *C_expr_existsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitC_expr_exists(s) + } +} + +func (s *C_expr_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitC_expr_exists(s) + + default: + return t.VisitChildren(s) + } +} + +type C_expr_caseContext struct { + C_exprContext +} + +func NewC_expr_caseContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_caseContext { + var p = new(C_expr_caseContext) + + InitEmptyC_exprContext(&p.C_exprContext) + p.parser = parser + p.CopyAll(ctx.(*C_exprContext)) + + return p +} + +func (s *C_expr_caseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_expr_caseContext) Case_expr() ICase_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_exprContext) +} + +func (s *C_expr_caseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterC_expr_case(s) + } +} + +func (s *C_expr_caseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitC_expr_case(s) + } +} + +func (s *C_expr_caseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitC_expr_case(s) + + default: + return t.VisitChildren(s) + } +} + +type C_expr_exprContext struct { + C_exprContext + a_expr_in_parens IA_exprContext +} + +func NewC_expr_exprContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *C_expr_exprContext { + var p = new(C_expr_exprContext) + + InitEmptyC_exprContext(&p.C_exprContext) + p.parser = parser + p.CopyAll(ctx.(*C_exprContext)) + + return p +} + +func (s *C_expr_exprContext) GetA_expr_in_parens() IA_exprContext { return s.a_expr_in_parens } + +func (s *C_expr_exprContext) SetA_expr_in_parens(v IA_exprContext) { s.a_expr_in_parens = v } + +func (s *C_expr_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_expr_exprContext) ARRAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserARRAY, 0) +} + +func (s *C_expr_exprContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *C_expr_exprContext) Array_expr() IArray_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_exprContext) +} + +func (s *C_expr_exprContext) PARAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAM, 0) +} + +func (s *C_expr_exprContext) Opt_indirection() IOpt_indirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_indirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_indirectionContext) +} + +func (s *C_expr_exprContext) GROUPING() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUPING, 0) +} + +func (s *C_expr_exprContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *C_expr_exprContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *C_expr_exprContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *C_expr_exprContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIQUE, 0) +} + +func (s *C_expr_exprContext) Columnref() IColumnrefContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumnrefContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumnrefContext) +} + +func (s *C_expr_exprContext) Aexprconst() IAexprconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAexprconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAexprconstContext) +} + +func (s *C_expr_exprContext) Plsqlvariablename() IPlsqlvariablenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsqlvariablenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsqlvariablenameContext) +} + +func (s *C_expr_exprContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *C_expr_exprContext) Func_expr() IFunc_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_exprContext) +} + +func (s *C_expr_exprContext) Indirection() IIndirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndirectionContext) +} + +func (s *C_expr_exprContext) Explicit_row() IExplicit_rowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplicit_rowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplicit_rowContext) +} + +func (s *C_expr_exprContext) Implicit_row() IImplicit_rowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplicit_rowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplicit_rowContext) +} + +func (s *C_expr_exprContext) AllRow() []IRowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRowContext); ok { + len++ + } + } + + tst := make([]IRowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRowContext); ok { + tst[i] = t.(IRowContext) + i++ + } + } + + return tst +} + +func (s *C_expr_exprContext) Row(i int) IRowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRowContext) +} + +func (s *C_expr_exprContext) OVERLAPS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVERLAPS, 0) +} + +func (s *C_expr_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterC_expr_expr(s) + } +} + +func (s *C_expr_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitC_expr_expr(s) + } +} + +func (s *C_expr_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitC_expr_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) C_expr() (localctx IC_exprContext) { + localctx = NewC_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1756, RedshiftParserRULE_c_expr) + p.SetState(13382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1289, p.GetParserRuleContext()) { + case 1: + localctx = NewC_expr_existsContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13346) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13347) + p.Select_with_parens() + } + + case 2: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13348) + p.Match(RedshiftParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN: + { + p.SetState(13349) + p.Select_with_parens() + } + + case RedshiftParserOPEN_BRACKET: + { + p.SetState(13350) + p.Array_expr() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13353) + p.Match(RedshiftParserPARAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13354) + p.Opt_indirection() + } + + case 4: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13355) + p.Match(RedshiftParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13356) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13357) + p.Expr_list() + } + { + p.SetState(13358) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13360) + p.Match(RedshiftParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13361) + p.Select_with_parens() + } + + case 6: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13362) + p.Columnref() + } + + case 7: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13363) + p.Aexprconst() + } + + case 8: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13364) + p.Plsqlvariablename() + } + + case 9: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 9) + { + p.SetState(13365) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13366) + + var _x = p.A_expr() + + localctx.(*C_expr_exprContext).a_expr_in_parens = _x + } + { + p.SetState(13367) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13368) + p.Opt_indirection() + } + + case 10: + localctx = NewC_expr_caseContext(p, localctx) + p.EnterOuterAlt(localctx, 10) + { + p.SetState(13370) + p.Case_expr() + } + + case 11: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 11) + { + p.SetState(13371) + p.Func_expr() + } + + case 12: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 12) + { + p.SetState(13372) + p.Select_with_parens() + } + p.SetState(13374) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1288, p.GetParserRuleContext()) == 1 { + { + p.SetState(13373) + p.Indirection() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 13: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 13) + { + p.SetState(13376) + p.Explicit_row() + } + + case 14: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 14) + { + p.SetState(13377) + p.Implicit_row() + } + + case 15: + localctx = NewC_expr_exprContext(p, localctx) + p.EnterOuterAlt(localctx, 15) + { + p.SetState(13378) + p.Row() + } + { + p.SetState(13379) + p.Match(RedshiftParserOVERLAPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13380) + p.Row() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsqlvariablenameContext is an interface to support dynamic dispatch. +type IPlsqlvariablenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLSQLVARIABLENAME() antlr.TerminalNode + + // IsPlsqlvariablenameContext differentiates from other interfaces. + IsPlsqlvariablenameContext() +} + +type PlsqlvariablenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsqlvariablenameContext() *PlsqlvariablenameContext { + var p = new(PlsqlvariablenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlvariablename + return p +} + +func InitEmptyPlsqlvariablenameContext(p *PlsqlvariablenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlvariablename +} + +func (*PlsqlvariablenameContext) IsPlsqlvariablenameContext() {} + +func NewPlsqlvariablenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlvariablenameContext { + var p = new(PlsqlvariablenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_plsqlvariablename + + return p +} + +func (s *PlsqlvariablenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *PlsqlvariablenameContext) PLSQLVARIABLENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLSQLVARIABLENAME, 0) +} + +func (s *PlsqlvariablenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PlsqlvariablenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PlsqlvariablenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPlsqlvariablename(s) + } +} + +func (s *PlsqlvariablenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPlsqlvariablename(s) + } +} + +func (s *PlsqlvariablenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPlsqlvariablename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Plsqlvariablename() (localctx IPlsqlvariablenameContext) { + localctx = NewPlsqlvariablenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1758, RedshiftParserRULE_plsqlvariablename) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13384) + p.Match(RedshiftParserPLSQLVARIABLENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_applicationContext is an interface to support dynamic dispatch. +type IFunc_applicationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_name() IFunc_nameContext + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Func_arg_list() IFunc_arg_listContext + VARIADIC() antlr.TerminalNode + Func_arg_expr() IFunc_arg_exprContext + STAR() antlr.TerminalNode + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + COMMA() antlr.TerminalNode + Opt_sort_clause() IOpt_sort_clauseContext + + // IsFunc_applicationContext differentiates from other interfaces. + IsFunc_applicationContext() +} + +type Func_applicationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_applicationContext() *Func_applicationContext { + var p = new(Func_applicationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_application + return p +} + +func InitEmptyFunc_applicationContext(p *Func_applicationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_application +} + +func (*Func_applicationContext) IsFunc_applicationContext() {} + +func NewFunc_applicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_applicationContext { + var p = new(Func_applicationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_application + + return p +} + +func (s *Func_applicationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_applicationContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *Func_applicationContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Func_applicationContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Func_applicationContext) Func_arg_list() IFunc_arg_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_arg_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_arg_listContext) +} + +func (s *Func_applicationContext) VARIADIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARIADIC, 0) +} + +func (s *Func_applicationContext) Func_arg_expr() IFunc_arg_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_arg_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_arg_exprContext) +} + +func (s *Func_applicationContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *Func_applicationContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Func_applicationContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTINCT, 0) +} + +func (s *Func_applicationContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Func_applicationContext) Opt_sort_clause() IOpt_sort_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sort_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sort_clauseContext) +} + +func (s *Func_applicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_applicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_applicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_application(s) + } +} + +func (s *Func_applicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_application(s) + } +} + +func (s *Func_applicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_application(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_application() (localctx IFunc_applicationContext) { + localctx = NewFunc_applicationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1760, RedshiftParserRULE_func_application) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13386) + p.Func_name() + } + { + p.SetState(13387) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserPARAM, RedshiftParserOperator, RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserSESSION_USER, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserBinaryStringConstant, RedshiftParserHexadecimalStringConstant, RedshiftParserIntegral, RedshiftParserNumeric, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + { + p.SetState(13388) + p.Func_arg_list() + } + p.SetState(13392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(13389) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13390) + p.Match(RedshiftParserVARIADIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13391) + p.Func_arg_expr() + } + + } + p.SetState(13395) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserORDER { + { + p.SetState(13394) + p.Opt_sort_clause() + } + + } + + case RedshiftParserVARIADIC: + { + p.SetState(13397) + p.Match(RedshiftParserVARIADIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13398) + p.Func_arg_expr() + } + p.SetState(13400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserORDER { + { + p.SetState(13399) + p.Opt_sort_clause() + } + + } + + case RedshiftParserALL, RedshiftParserDISTINCT: + { + p.SetState(13402) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserALL || _la == RedshiftParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13403) + p.Func_arg_list() + } + p.SetState(13405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserORDER { + { + p.SetState(13404) + p.Opt_sort_clause() + } + + } + + case RedshiftParserSTAR: + { + p.SetState(13407) + p.Match(RedshiftParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCLOSE_PAREN: + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13411) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_exprContext is an interface to support dynamic dispatch. +type IFunc_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_application() IFunc_applicationContext + Within_group_clause() IWithin_group_clauseContext + Filter_clause() IFilter_clauseContext + Over_clause() IOver_clauseContext + Func_expr_common_subexpr() IFunc_expr_common_subexprContext + + // IsFunc_exprContext differentiates from other interfaces. + IsFunc_exprContext() +} + +type Func_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_exprContext() *Func_exprContext { + var p = new(Func_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_expr + return p +} + +func InitEmptyFunc_exprContext(p *Func_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_expr +} + +func (*Func_exprContext) IsFunc_exprContext() {} + +func NewFunc_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_exprContext { + var p = new(Func_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_expr + + return p +} + +func (s *Func_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_exprContext) Func_application() IFunc_applicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_applicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_applicationContext) +} + +func (s *Func_exprContext) Within_group_clause() IWithin_group_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithin_group_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithin_group_clauseContext) +} + +func (s *Func_exprContext) Filter_clause() IFilter_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilter_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilter_clauseContext) +} + +func (s *Func_exprContext) Over_clause() IOver_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clauseContext) +} + +func (s *Func_exprContext) Func_expr_common_subexpr() IFunc_expr_common_subexprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_expr_common_subexprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_expr_common_subexprContext) +} + +func (s *Func_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_expr(s) + } +} + +func (s *Func_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_expr(s) + } +} + +func (s *Func_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_expr() (localctx IFunc_exprContext) { + localctx = NewFunc_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1762, RedshiftParserRULE_func_expr) + p.SetState(13424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1298, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13413) + p.Func_application() + } + p.SetState(13415) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1295, p.GetParserRuleContext()) == 1 { + { + p.SetState(13414) + p.Within_group_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13418) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1296, p.GetParserRuleContext()) == 1 { + { + p.SetState(13417) + p.Filter_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13421) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1297, p.GetParserRuleContext()) == 1 { + { + p.SetState(13420) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13423) + p.Func_expr_common_subexpr() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_expr_windowlessContext is an interface to support dynamic dispatch. +type IFunc_expr_windowlessContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Func_application() IFunc_applicationContext + Func_expr_common_subexpr() IFunc_expr_common_subexprContext + + // IsFunc_expr_windowlessContext differentiates from other interfaces. + IsFunc_expr_windowlessContext() +} + +type Func_expr_windowlessContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_expr_windowlessContext() *Func_expr_windowlessContext { + var p = new(Func_expr_windowlessContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_expr_windowless + return p +} + +func InitEmptyFunc_expr_windowlessContext(p *Func_expr_windowlessContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_expr_windowless +} + +func (*Func_expr_windowlessContext) IsFunc_expr_windowlessContext() {} + +func NewFunc_expr_windowlessContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_expr_windowlessContext { + var p = new(Func_expr_windowlessContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_expr_windowless + + return p +} + +func (s *Func_expr_windowlessContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_expr_windowlessContext) Func_application() IFunc_applicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_applicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_applicationContext) +} + +func (s *Func_expr_windowlessContext) Func_expr_common_subexpr() IFunc_expr_common_subexprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_expr_common_subexprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_expr_common_subexprContext) +} + +func (s *Func_expr_windowlessContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_expr_windowlessContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_expr_windowlessContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_expr_windowless(s) + } +} + +func (s *Func_expr_windowlessContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_expr_windowless(s) + } +} + +func (s *Func_expr_windowlessContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_expr_windowless(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_expr_windowless() (localctx IFunc_expr_windowlessContext) { + localctx = NewFunc_expr_windowlessContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1764, RedshiftParserRULE_func_expr_windowless) + p.SetState(13428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1299, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13426) + p.Func_application() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13427) + p.Func_expr_common_subexpr() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_expr_common_subexprContext is an interface to support dynamic dispatch. +type IFunc_expr_common_subexprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLLATION() antlr.TerminalNode + FOR() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + CURRENT_TIME() antlr.TerminalNode + Iconst() IIconstContext + CURRENT_TIMESTAMP() antlr.TerminalNode + LOCALTIME() antlr.TerminalNode + LOCALTIMESTAMP() antlr.TerminalNode + CURRENT_ROLE() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + SESSION_USER() antlr.TerminalNode + USER() antlr.TerminalNode + CURRENT_CATALOG() antlr.TerminalNode + CURRENT_SCHEMA() antlr.TerminalNode + CAST() antlr.TerminalNode + AS() antlr.TerminalNode + Typename() ITypenameContext + EXTRACT() antlr.TerminalNode + Extract_list() IExtract_listContext + NORMALIZE() antlr.TerminalNode + COMMA() antlr.TerminalNode + Unicode_normal_form() IUnicode_normal_formContext + OVERLAY() antlr.TerminalNode + Overlay_list() IOverlay_listContext + POSITION() antlr.TerminalNode + Position_list() IPosition_listContext + SUBSTRING() antlr.TerminalNode + Substr_list() ISubstr_listContext + TREAT() antlr.TerminalNode + TRIM() antlr.TerminalNode + Trim_list() ITrim_listContext + BOTH() antlr.TerminalNode + LEADING() antlr.TerminalNode + TRAILING() antlr.TerminalNode + NULLIF() antlr.TerminalNode + COALESCE() antlr.TerminalNode + Expr_list() IExpr_listContext + GREATEST() antlr.TerminalNode + LEAST() antlr.TerminalNode + XMLCONCAT() antlr.TerminalNode + XMLELEMENT() antlr.TerminalNode + NAME_P() antlr.TerminalNode + Collabel() ICollabelContext + Xml_attributes() IXml_attributesContext + XMLEXISTS() antlr.TerminalNode + C_expr() IC_exprContext + Xmlexists_argument() IXmlexists_argumentContext + XMLFOREST() antlr.TerminalNode + Xml_attribute_list() IXml_attribute_listContext + XMLPARSE() antlr.TerminalNode + Document_or_content() IDocument_or_contentContext + Xml_whitespace_option() IXml_whitespace_optionContext + XMLPI() antlr.TerminalNode + XMLROOT() antlr.TerminalNode + XML_P() antlr.TerminalNode + Xml_root_version() IXml_root_versionContext + Opt_xml_root_standalone() IOpt_xml_root_standaloneContext + XMLSERIALIZE() antlr.TerminalNode + Simpletypename() ISimpletypenameContext + + // IsFunc_expr_common_subexprContext differentiates from other interfaces. + IsFunc_expr_common_subexprContext() +} + +type Func_expr_common_subexprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_expr_common_subexprContext() *Func_expr_common_subexprContext { + var p = new(Func_expr_common_subexprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_expr_common_subexpr + return p +} + +func InitEmptyFunc_expr_common_subexprContext(p *Func_expr_common_subexprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_expr_common_subexpr +} + +func (*Func_expr_common_subexprContext) IsFunc_expr_common_subexprContext() {} + +func NewFunc_expr_common_subexprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_expr_common_subexprContext { + var p = new(Func_expr_common_subexprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_expr_common_subexpr + + return p +} + +func (s *Func_expr_common_subexprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_expr_common_subexprContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *Func_expr_common_subexprContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Func_expr_common_subexprContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Func_expr_common_subexprContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Func_expr_common_subexprContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Func_expr_common_subexprContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Func_expr_common_subexprContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_DATE, 0) +} + +func (s *Func_expr_common_subexprContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_TIME, 0) +} + +func (s *Func_expr_common_subexprContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Func_expr_common_subexprContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_TIMESTAMP, 0) +} + +func (s *Func_expr_common_subexprContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCALTIME, 0) +} + +func (s *Func_expr_common_subexprContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCALTIMESTAMP, 0) +} + +func (s *Func_expr_common_subexprContext) CURRENT_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_ROLE, 0) +} + +func (s *Func_expr_common_subexprContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_USER, 0) +} + +func (s *Func_expr_common_subexprContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_USER, 0) +} + +func (s *Func_expr_common_subexprContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *Func_expr_common_subexprContext) CURRENT_CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_CATALOG, 0) +} + +func (s *Func_expr_common_subexprContext) CURRENT_SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_SCHEMA, 0) +} + +func (s *Func_expr_common_subexprContext) CAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCAST, 0) +} + +func (s *Func_expr_common_subexprContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Func_expr_common_subexprContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Func_expr_common_subexprContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTRACT, 0) +} + +func (s *Func_expr_common_subexprContext) Extract_list() IExtract_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtract_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtract_listContext) +} + +func (s *Func_expr_common_subexprContext) NORMALIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNORMALIZE, 0) +} + +func (s *Func_expr_common_subexprContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Func_expr_common_subexprContext) Unicode_normal_form() IUnicode_normal_formContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnicode_normal_formContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnicode_normal_formContext) +} + +func (s *Func_expr_common_subexprContext) OVERLAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVERLAY, 0) +} + +func (s *Func_expr_common_subexprContext) Overlay_list() IOverlay_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverlay_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverlay_listContext) +} + +func (s *Func_expr_common_subexprContext) POSITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOSITION, 0) +} + +func (s *Func_expr_common_subexprContext) Position_list() IPosition_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPosition_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPosition_listContext) +} + +func (s *Func_expr_common_subexprContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSTRING, 0) +} + +func (s *Func_expr_common_subexprContext) Substr_list() ISubstr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubstr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubstr_listContext) +} + +func (s *Func_expr_common_subexprContext) TREAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserTREAT, 0) +} + +func (s *Func_expr_common_subexprContext) TRIM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIM, 0) +} + +func (s *Func_expr_common_subexprContext) Trim_list() ITrim_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrim_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrim_listContext) +} + +func (s *Func_expr_common_subexprContext) BOTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserBOTH, 0) +} + +func (s *Func_expr_common_subexprContext) LEADING() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEADING, 0) +} + +func (s *Func_expr_common_subexprContext) TRAILING() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRAILING, 0) +} + +func (s *Func_expr_common_subexprContext) NULLIF() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULLIF, 0) +} + +func (s *Func_expr_common_subexprContext) COALESCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOALESCE, 0) +} + +func (s *Func_expr_common_subexprContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Func_expr_common_subexprContext) GREATEST() antlr.TerminalNode { + return s.GetToken(RedshiftParserGREATEST, 0) +} + +func (s *Func_expr_common_subexprContext) LEAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEAST, 0) +} + +func (s *Func_expr_common_subexprContext) XMLCONCAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLCONCAT, 0) +} + +func (s *Func_expr_common_subexprContext) XMLELEMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLELEMENT, 0) +} + +func (s *Func_expr_common_subexprContext) NAME_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAME_P, 0) +} + +func (s *Func_expr_common_subexprContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Func_expr_common_subexprContext) Xml_attributes() IXml_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_attributesContext) +} + +func (s *Func_expr_common_subexprContext) XMLEXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLEXISTS, 0) +} + +func (s *Func_expr_common_subexprContext) C_expr() IC_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_exprContext) +} + +func (s *Func_expr_common_subexprContext) Xmlexists_argument() IXmlexists_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlexists_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlexists_argumentContext) +} + +func (s *Func_expr_common_subexprContext) XMLFOREST() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLFOREST, 0) +} + +func (s *Func_expr_common_subexprContext) Xml_attribute_list() IXml_attribute_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_attribute_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_attribute_listContext) +} + +func (s *Func_expr_common_subexprContext) XMLPARSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLPARSE, 0) +} + +func (s *Func_expr_common_subexprContext) Document_or_content() IDocument_or_contentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDocument_or_contentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDocument_or_contentContext) +} + +func (s *Func_expr_common_subexprContext) Xml_whitespace_option() IXml_whitespace_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_whitespace_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_whitespace_optionContext) +} + +func (s *Func_expr_common_subexprContext) XMLPI() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLPI, 0) +} + +func (s *Func_expr_common_subexprContext) XMLROOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLROOT, 0) +} + +func (s *Func_expr_common_subexprContext) XML_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserXML_P, 0) +} + +func (s *Func_expr_common_subexprContext) Xml_root_version() IXml_root_versionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_root_versionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_root_versionContext) +} + +func (s *Func_expr_common_subexprContext) Opt_xml_root_standalone() IOpt_xml_root_standaloneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_xml_root_standaloneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_xml_root_standaloneContext) +} + +func (s *Func_expr_common_subexprContext) XMLSERIALIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLSERIALIZE, 0) +} + +func (s *Func_expr_common_subexprContext) Simpletypename() ISimpletypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimpletypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimpletypenameContext) +} + +func (s *Func_expr_common_subexprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_expr_common_subexprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_expr_common_subexprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_expr_common_subexpr(s) + } +} + +func (s *Func_expr_common_subexprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_expr_common_subexpr(s) + } +} + +func (s *Func_expr_common_subexprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_expr_common_subexpr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_expr_common_subexpr() (localctx IFunc_expr_common_subexprContext) { + localctx = NewFunc_expr_common_subexprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1766, RedshiftParserRULE_func_expr_common_subexpr) + var _la int + + p.SetState(13613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCOLLATION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13430) + p.Match(RedshiftParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13431) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13432) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13433) + p.A_expr() + } + { + p.SetState(13434) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCURRENT_DATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13436) + p.Match(RedshiftParserCURRENT_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCURRENT_TIME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13437) + p.Match(RedshiftParserCURRENT_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13442) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1300, p.GetParserRuleContext()) == 1 { + { + p.SetState(13438) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13439) + p.Iconst() + } + { + p.SetState(13440) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserCURRENT_TIMESTAMP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13444) + p.Match(RedshiftParserCURRENT_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13449) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1301, p.GetParserRuleContext()) == 1 { + { + p.SetState(13445) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13446) + p.Iconst() + } + { + p.SetState(13447) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserLOCALTIME: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13451) + p.Match(RedshiftParserLOCALTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13456) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1302, p.GetParserRuleContext()) == 1 { + { + p.SetState(13452) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13453) + p.Iconst() + } + { + p.SetState(13454) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserLOCALTIMESTAMP: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13458) + p.Match(RedshiftParserLOCALTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13463) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1303, p.GetParserRuleContext()) == 1 { + { + p.SetState(13459) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13460) + p.Iconst() + } + { + p.SetState(13461) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserCURRENT_ROLE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13465) + p.Match(RedshiftParserCURRENT_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCURRENT_USER: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13466) + p.Match(RedshiftParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSESSION_USER: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(13467) + p.Match(RedshiftParserSESSION_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUSER: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(13468) + p.Match(RedshiftParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCURRENT_CATALOG: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(13469) + p.Match(RedshiftParserCURRENT_CATALOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCURRENT_SCHEMA: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(13470) + p.Match(RedshiftParserCURRENT_SCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCAST: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(13471) + p.Match(RedshiftParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13472) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13473) + p.A_expr() + } + { + p.SetState(13474) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13475) + p.Typename() + } + { + p.SetState(13476) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEXTRACT: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(13478) + p.Match(RedshiftParserEXTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13479) + p.Match(RedshiftParserOPEN_PAREN) + 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 ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1152921504893115397) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&4758090527419678849) != 0) || ((int64((_la-211)) & ^0x3f) == 0 && ((int64(1)<<(_la-211))&57561641360820233) != 0) || ((int64((_la-276)) & ^0x3f) == 0 && ((int64(1)<<(_la-276))&36418059031838721) != 0) || _la == RedshiftParserTYPE_P || _la == RedshiftParserYEAR_P || _la == RedshiftParserCALL || _la == RedshiftParserCURRENT_P || ((int64((_la-676)) & ^0x3f) == 0 && ((int64(1)<<(_la-676))&13124950286337) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137841649801) != 0) { + { + p.SetState(13480) + p.Extract_list() + } + + } + { + p.SetState(13483) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNORMALIZE: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(13484) + p.Match(RedshiftParserNORMALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13485) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13486) + p.A_expr() + } + p.SetState(13489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(13487) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13488) + p.Unicode_normal_form() + } + + } + { + p.SetState(13491) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserOVERLAY: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(13493) + p.Match(RedshiftParserOVERLAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13494) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13495) + p.Overlay_list() + } + { + p.SetState(13496) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserPOSITION: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(13498) + p.Match(RedshiftParserPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13499) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013541) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(13500) + p.Position_list() + } + + } + { + p.SetState(13503) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSUBSTRING: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(13504) + p.Match(RedshiftParserSUBSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13505) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13506) + p.Substr_list() + } + { + p.SetState(13507) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserTREAT: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(13509) + p.Match(RedshiftParserTREAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13510) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13511) + p.A_expr() + } + { + p.SetState(13512) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13513) + p.Typename() + } + { + p.SetState(13514) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserTRIM: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(13516) + p.Match(RedshiftParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13517) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-39)) & ^0x3f) == 0 && ((int64(1)<<(_la-39))&144115205255725057) != 0 { + { + p.SetState(13518) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-39)) & ^0x3f) == 0 && ((int64(1)<<(_la-39))&144115205255725057) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13521) + p.Trim_list() + } + { + p.SetState(13522) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNULLIF: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(13524) + p.Match(RedshiftParserNULLIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13525) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13526) + p.A_expr() + } + { + p.SetState(13527) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13528) + p.A_expr() + } + { + p.SetState(13529) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserCOALESCE: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(13531) + p.Match(RedshiftParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13532) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13533) + p.Expr_list() + } + { + p.SetState(13534) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserGREATEST: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(13536) + p.Match(RedshiftParserGREATEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13537) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13538) + p.Expr_list() + } + { + p.SetState(13539) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserLEAST: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(13541) + p.Match(RedshiftParserLEAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13542) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13543) + p.Expr_list() + } + { + p.SetState(13544) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLCONCAT: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(13546) + p.Match(RedshiftParserXMLCONCAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13547) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13548) + p.Expr_list() + } + { + p.SetState(13549) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLELEMENT: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(13551) + p.Match(RedshiftParserXMLELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13552) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13553) + p.Match(RedshiftParserNAME_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13554) + p.Collabel() + } + p.SetState(13560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(13555) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1308, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13556) + p.Xml_attributes() + } + + case 2: + { + p.SetState(13557) + p.Expr_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + { + p.SetState(13562) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLEXISTS: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(13564) + p.Match(RedshiftParserXMLEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13565) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13566) + p.C_expr() + } + { + p.SetState(13567) + p.Xmlexists_argument() + } + { + p.SetState(13568) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLFOREST: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(13570) + p.Match(RedshiftParserXMLFOREST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13571) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13572) + p.Xml_attribute_list() + } + { + p.SetState(13573) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLPARSE: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(13575) + p.Match(RedshiftParserXMLPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13576) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13577) + p.Document_or_content() + } + { + p.SetState(13578) + p.A_expr() + } + p.SetState(13580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPRESERVE || _la == RedshiftParserSTRIP_P { + { + p.SetState(13579) + p.Xml_whitespace_option() + } + + } + { + p.SetState(13582) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLPI: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(13584) + p.Match(RedshiftParserXMLPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13585) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13586) + p.Match(RedshiftParserNAME_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13587) + p.Collabel() + } + p.SetState(13590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(13588) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13589) + p.A_expr() + } + + } + { + p.SetState(13592) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLROOT: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(13594) + p.Match(RedshiftParserXMLROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13595) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13596) + p.Match(RedshiftParserXML_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13597) + p.A_expr() + } + { + p.SetState(13598) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13599) + p.Xml_root_version() + } + p.SetState(13601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(13600) + p.Opt_xml_root_standalone() + } + + } + { + p.SetState(13603) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserXMLSERIALIZE: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(13605) + p.Match(RedshiftParserXMLSERIALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13606) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13607) + p.Document_or_content() + } + { + p.SetState(13608) + p.A_expr() + } + { + p.SetState(13609) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13610) + p.Simpletypename() + } + { + p.SetState(13611) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_root_versionContext is an interface to support dynamic dispatch. +type IXml_root_versionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSION_P() antlr.TerminalNode + A_expr() IA_exprContext + NO() antlr.TerminalNode + VALUE_P() antlr.TerminalNode + + // IsXml_root_versionContext differentiates from other interfaces. + IsXml_root_versionContext() +} + +type Xml_root_versionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_root_versionContext() *Xml_root_versionContext { + var p = new(Xml_root_versionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_root_version + return p +} + +func InitEmptyXml_root_versionContext(p *Xml_root_versionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_root_version +} + +func (*Xml_root_versionContext) IsXml_root_versionContext() {} + +func NewXml_root_versionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_root_versionContext { + var p = new(Xml_root_versionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_root_version + + return p +} + +func (s *Xml_root_versionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_root_versionContext) VERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERSION_P, 0) +} + +func (s *Xml_root_versionContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Xml_root_versionContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Xml_root_versionContext) VALUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUE_P, 0) +} + +func (s *Xml_root_versionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_root_versionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_root_versionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_root_version(s) + } +} + +func (s *Xml_root_versionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_root_version(s) + } +} + +func (s *Xml_root_versionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_root_version(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_root_version() (localctx IXml_root_versionContext) { + localctx = NewXml_root_versionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1768, RedshiftParserRULE_xml_root_version) + p.SetState(13620) + 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(13615) + p.Match(RedshiftParserVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13616) + p.A_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13617) + p.Match(RedshiftParserVERSION_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13618) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13619) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_xml_root_standaloneContext is an interface to support dynamic dispatch. +type IOpt_xml_root_standaloneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA() antlr.TerminalNode + STANDALONE_P() antlr.TerminalNode + YES_P() antlr.TerminalNode + NO() antlr.TerminalNode + VALUE_P() antlr.TerminalNode + + // IsOpt_xml_root_standaloneContext differentiates from other interfaces. + IsOpt_xml_root_standaloneContext() +} + +type Opt_xml_root_standaloneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_xml_root_standaloneContext() *Opt_xml_root_standaloneContext { + var p = new(Opt_xml_root_standaloneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_xml_root_standalone + return p +} + +func InitEmptyOpt_xml_root_standaloneContext(p *Opt_xml_root_standaloneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_xml_root_standalone +} + +func (*Opt_xml_root_standaloneContext) IsOpt_xml_root_standaloneContext() {} + +func NewOpt_xml_root_standaloneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_xml_root_standaloneContext { + var p = new(Opt_xml_root_standaloneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_xml_root_standalone + + return p +} + +func (s *Opt_xml_root_standaloneContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_xml_root_standaloneContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Opt_xml_root_standaloneContext) STANDALONE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTANDALONE_P, 0) +} + +func (s *Opt_xml_root_standaloneContext) YES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYES_P, 0) +} + +func (s *Opt_xml_root_standaloneContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_xml_root_standaloneContext) VALUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUE_P, 0) +} + +func (s *Opt_xml_root_standaloneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_xml_root_standaloneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_xml_root_standaloneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_xml_root_standalone(s) + } +} + +func (s *Opt_xml_root_standaloneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_xml_root_standalone(s) + } +} + +func (s *Opt_xml_root_standaloneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_xml_root_standalone(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_xml_root_standalone() (localctx IOpt_xml_root_standaloneContext) { + localctx = NewOpt_xml_root_standaloneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1770, RedshiftParserRULE_opt_xml_root_standalone) + p.SetState(13632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1315, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13622) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13623) + p.Match(RedshiftParserSTANDALONE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13624) + p.Match(RedshiftParserYES_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13625) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13626) + p.Match(RedshiftParserSTANDALONE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13627) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13628) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13629) + p.Match(RedshiftParserSTANDALONE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13630) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13631) + p.Match(RedshiftParserVALUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_attributesContext is an interface to support dynamic dispatch. +type IXml_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLATTRIBUTES() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Xml_attribute_list() IXml_attribute_listContext + CLOSE_PAREN() antlr.TerminalNode + + // IsXml_attributesContext differentiates from other interfaces. + IsXml_attributesContext() +} + +type Xml_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_attributesContext() *Xml_attributesContext { + var p = new(Xml_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_attributes + return p +} + +func InitEmptyXml_attributesContext(p *Xml_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_attributes +} + +func (*Xml_attributesContext) IsXml_attributesContext() {} + +func NewXml_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attributesContext { + var p = new(Xml_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_attributes + + return p +} + +func (s *Xml_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_attributesContext) XMLATTRIBUTES() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLATTRIBUTES, 0) +} + +func (s *Xml_attributesContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Xml_attributesContext) Xml_attribute_list() IXml_attribute_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_attribute_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_attribute_listContext) +} + +func (s *Xml_attributesContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Xml_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_attributes(s) + } +} + +func (s *Xml_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_attributes(s) + } +} + +func (s *Xml_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_attributes() (localctx IXml_attributesContext) { + localctx = NewXml_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1772, RedshiftParserRULE_xml_attributes) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13634) + p.Match(RedshiftParserXMLATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13635) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13636) + p.Xml_attribute_list() + } + { + p.SetState(13637) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_attribute_listContext is an interface to support dynamic dispatch. +type IXml_attribute_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllXml_attribute_el() []IXml_attribute_elContext + Xml_attribute_el(i int) IXml_attribute_elContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXml_attribute_listContext differentiates from other interfaces. + IsXml_attribute_listContext() +} + +type Xml_attribute_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_attribute_listContext() *Xml_attribute_listContext { + var p = new(Xml_attribute_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_attribute_list + return p +} + +func InitEmptyXml_attribute_listContext(p *Xml_attribute_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_attribute_list +} + +func (*Xml_attribute_listContext) IsXml_attribute_listContext() {} + +func NewXml_attribute_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attribute_listContext { + var p = new(Xml_attribute_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_attribute_list + + return p +} + +func (s *Xml_attribute_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_attribute_listContext) AllXml_attribute_el() []IXml_attribute_elContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_attribute_elContext); ok { + len++ + } + } + + tst := make([]IXml_attribute_elContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_attribute_elContext); ok { + tst[i] = t.(IXml_attribute_elContext) + i++ + } + } + + return tst +} + +func (s *Xml_attribute_listContext) Xml_attribute_el(i int) IXml_attribute_elContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_attribute_elContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_attribute_elContext) +} + +func (s *Xml_attribute_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Xml_attribute_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Xml_attribute_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_attribute_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_attribute_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_attribute_list(s) + } +} + +func (s *Xml_attribute_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_attribute_list(s) + } +} + +func (s *Xml_attribute_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_attribute_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_attribute_list() (localctx IXml_attribute_listContext) { + localctx = NewXml_attribute_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1774, RedshiftParserRULE_xml_attribute_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13639) + p.Xml_attribute_el() + } + p.SetState(13644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(13640) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13641) + p.Xml_attribute_el() + } + + p.SetState(13646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_attribute_elContext is an interface to support dynamic dispatch. +type IXml_attribute_elContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + AS() antlr.TerminalNode + Collabel() ICollabelContext + + // IsXml_attribute_elContext differentiates from other interfaces. + IsXml_attribute_elContext() +} + +type Xml_attribute_elContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_attribute_elContext() *Xml_attribute_elContext { + var p = new(Xml_attribute_elContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_attribute_el + return p +} + +func InitEmptyXml_attribute_elContext(p *Xml_attribute_elContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_attribute_el +} + +func (*Xml_attribute_elContext) IsXml_attribute_elContext() {} + +func NewXml_attribute_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attribute_elContext { + var p = new(Xml_attribute_elContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_attribute_el + + return p +} + +func (s *Xml_attribute_elContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_attribute_elContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Xml_attribute_elContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Xml_attribute_elContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Xml_attribute_elContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_attribute_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_attribute_elContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_attribute_el(s) + } +} + +func (s *Xml_attribute_elContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_attribute_el(s) + } +} + +func (s *Xml_attribute_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_attribute_el(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_attribute_el() (localctx IXml_attribute_elContext) { + localctx = NewXml_attribute_elContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1776, RedshiftParserRULE_xml_attribute_el) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13647) + p.A_expr() + } + p.SetState(13650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAS { + { + p.SetState(13648) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13649) + p.Collabel() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDocument_or_contentContext is an interface to support dynamic dispatch. +type IDocument_or_contentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOCUMENT_P() antlr.TerminalNode + CONTENT_P() antlr.TerminalNode + + // IsDocument_or_contentContext differentiates from other interfaces. + IsDocument_or_contentContext() +} + +type Document_or_contentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDocument_or_contentContext() *Document_or_contentContext { + var p = new(Document_or_contentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_document_or_content + return p +} + +func InitEmptyDocument_or_contentContext(p *Document_or_contentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_document_or_content +} + +func (*Document_or_contentContext) IsDocument_or_contentContext() {} + +func NewDocument_or_contentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Document_or_contentContext { + var p = new(Document_or_contentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_document_or_content + + return p +} + +func (s *Document_or_contentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Document_or_contentContext) DOCUMENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOCUMENT_P, 0) +} + +func (s *Document_or_contentContext) CONTENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONTENT_P, 0) +} + +func (s *Document_or_contentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Document_or_contentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Document_or_contentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDocument_or_content(s) + } +} + +func (s *Document_or_contentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDocument_or_content(s) + } +} + +func (s *Document_or_contentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDocument_or_content(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Document_or_content() (localctx IDocument_or_contentContext) { + localctx = NewDocument_or_contentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1778, RedshiftParserRULE_document_or_content) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13652) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCONTENT_P || _la == RedshiftParserDOCUMENT_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_whitespace_optionContext is an interface to support dynamic dispatch. +type IXml_whitespace_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRESERVE() antlr.TerminalNode + WHITESPACE_P() antlr.TerminalNode + STRIP_P() antlr.TerminalNode + + // IsXml_whitespace_optionContext differentiates from other interfaces. + IsXml_whitespace_optionContext() +} + +type Xml_whitespace_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_whitespace_optionContext() *Xml_whitespace_optionContext { + var p = new(Xml_whitespace_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_whitespace_option + return p +} + +func InitEmptyXml_whitespace_optionContext(p *Xml_whitespace_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_whitespace_option +} + +func (*Xml_whitespace_optionContext) IsXml_whitespace_optionContext() {} + +func NewXml_whitespace_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_whitespace_optionContext { + var p = new(Xml_whitespace_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_whitespace_option + + return p +} + +func (s *Xml_whitespace_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_whitespace_optionContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRESERVE, 0) +} + +func (s *Xml_whitespace_optionContext) WHITESPACE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHITESPACE_P, 0) +} + +func (s *Xml_whitespace_optionContext) STRIP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRIP_P, 0) +} + +func (s *Xml_whitespace_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_whitespace_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_whitespace_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_whitespace_option(s) + } +} + +func (s *Xml_whitespace_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_whitespace_option(s) + } +} + +func (s *Xml_whitespace_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_whitespace_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_whitespace_option() (localctx IXml_whitespace_optionContext) { + localctx = NewXml_whitespace_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1780, RedshiftParserRULE_xml_whitespace_option) + p.SetState(13658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserPRESERVE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13654) + p.Match(RedshiftParserPRESERVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13655) + p.Match(RedshiftParserWHITESPACE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSTRIP_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13656) + p.Match(RedshiftParserSTRIP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13657) + p.Match(RedshiftParserWHITESPACE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlexists_argumentContext is an interface to support dynamic dispatch. +type IXmlexists_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PASSING() antlr.TerminalNode + C_expr() IC_exprContext + AllXml_passing_mech() []IXml_passing_mechContext + Xml_passing_mech(i int) IXml_passing_mechContext + + // IsXmlexists_argumentContext differentiates from other interfaces. + IsXmlexists_argumentContext() +} + +type Xmlexists_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlexists_argumentContext() *Xmlexists_argumentContext { + var p = new(Xmlexists_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmlexists_argument + return p +} + +func InitEmptyXmlexists_argumentContext(p *Xmlexists_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xmlexists_argument +} + +func (*Xmlexists_argumentContext) IsXmlexists_argumentContext() {} + +func NewXmlexists_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlexists_argumentContext { + var p = new(Xmlexists_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xmlexists_argument + + return p +} + +func (s *Xmlexists_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlexists_argumentContext) PASSING() antlr.TerminalNode { + return s.GetToken(RedshiftParserPASSING, 0) +} + +func (s *Xmlexists_argumentContext) C_expr() IC_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_exprContext) +} + +func (s *Xmlexists_argumentContext) AllXml_passing_mech() []IXml_passing_mechContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_passing_mechContext); ok { + len++ + } + } + + tst := make([]IXml_passing_mechContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_passing_mechContext); ok { + tst[i] = t.(IXml_passing_mechContext) + i++ + } + } + + return tst +} + +func (s *Xmlexists_argumentContext) Xml_passing_mech(i int) IXml_passing_mechContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_passing_mechContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_passing_mechContext) +} + +func (s *Xmlexists_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlexists_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlexists_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXmlexists_argument(s) + } +} + +func (s *Xmlexists_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXmlexists_argument(s) + } +} + +func (s *Xmlexists_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXmlexists_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xmlexists_argument() (localctx IXmlexists_argumentContext) { + localctx = NewXmlexists_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1782, RedshiftParserRULE_xmlexists_argument) + p.SetState(13675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1319, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13660) + p.Match(RedshiftParserPASSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13661) + p.C_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13662) + p.Match(RedshiftParserPASSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13663) + p.C_expr() + } + { + p.SetState(13664) + p.Xml_passing_mech() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13666) + p.Match(RedshiftParserPASSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13667) + p.Xml_passing_mech() + } + { + p.SetState(13668) + p.C_expr() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13670) + p.Match(RedshiftParserPASSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13671) + p.Xml_passing_mech() + } + { + p.SetState(13672) + p.C_expr() + } + { + p.SetState(13673) + p.Xml_passing_mech() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_passing_mechContext is an interface to support dynamic dispatch. +type IXml_passing_mechContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + REF() antlr.TerminalNode + VALUE_P() antlr.TerminalNode + + // IsXml_passing_mechContext differentiates from other interfaces. + IsXml_passing_mechContext() +} + +type Xml_passing_mechContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_passing_mechContext() *Xml_passing_mechContext { + var p = new(Xml_passing_mechContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_passing_mech + return p +} + +func InitEmptyXml_passing_mechContext(p *Xml_passing_mechContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xml_passing_mech +} + +func (*Xml_passing_mechContext) IsXml_passing_mechContext() {} + +func NewXml_passing_mechContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_passing_mechContext { + var p = new(Xml_passing_mechContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xml_passing_mech + + return p +} + +func (s *Xml_passing_mechContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_passing_mechContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Xml_passing_mechContext) REF() antlr.TerminalNode { + return s.GetToken(RedshiftParserREF, 0) +} + +func (s *Xml_passing_mechContext) VALUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUE_P, 0) +} + +func (s *Xml_passing_mechContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_passing_mechContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_passing_mechContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXml_passing_mech(s) + } +} + +func (s *Xml_passing_mechContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXml_passing_mech(s) + } +} + +func (s *Xml_passing_mechContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXml_passing_mech(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xml_passing_mech() (localctx IXml_passing_mechContext) { + localctx = NewXml_passing_mechContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1784, RedshiftParserRULE_xml_passing_mech) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13677) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13678) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserREF || _la == RedshiftParserVALUE_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWithin_group_clauseContext is an interface to support dynamic dispatch. +type IWithin_group_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITHIN() antlr.TerminalNode + GROUP_P() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Sort_clause() ISort_clauseContext + CLOSE_PAREN() antlr.TerminalNode + + // IsWithin_group_clauseContext differentiates from other interfaces. + IsWithin_group_clauseContext() +} + +type Within_group_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithin_group_clauseContext() *Within_group_clauseContext { + var p = new(Within_group_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_within_group_clause + return p +} + +func InitEmptyWithin_group_clauseContext(p *Within_group_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_within_group_clause +} + +func (*Within_group_clauseContext) IsWithin_group_clauseContext() {} + +func NewWithin_group_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Within_group_clauseContext { + var p = new(Within_group_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_within_group_clause + + return p +} + +func (s *Within_group_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Within_group_clauseContext) WITHIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHIN, 0) +} + +func (s *Within_group_clauseContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *Within_group_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Within_group_clauseContext) Sort_clause() ISort_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISort_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISort_clauseContext) +} + +func (s *Within_group_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Within_group_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Within_group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Within_group_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWithin_group_clause(s) + } +} + +func (s *Within_group_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWithin_group_clause(s) + } +} + +func (s *Within_group_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWithin_group_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Within_group_clause() (localctx IWithin_group_clauseContext) { + localctx = NewWithin_group_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1786, RedshiftParserRULE_within_group_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13680) + p.Match(RedshiftParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13681) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13682) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13683) + p.Sort_clause() + } + { + p.SetState(13684) + p.Match(RedshiftParserCLOSE_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 + + // Getter signatures + FILTER() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + WHERE() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsFilter_clauseContext differentiates from other interfaces. + IsFilter_clauseContext() +} + +type Filter_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilter_clauseContext() *Filter_clauseContext { + var p = new(Filter_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_filter_clause + return p +} + +func InitEmptyFilter_clauseContext(p *Filter_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_filter_clause + + return p +} + +func (s *Filter_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filter_clauseContext) FILTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILTER, 0) +} + +func (s *Filter_clauseContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Filter_clauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHERE, 0) +} + +func (s *Filter_clauseContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Filter_clauseContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Filter_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filter_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filter_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFilter_clause(s) + } +} + +func (s *Filter_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFilter_clause(s) + } +} + +func (s *Filter_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFilter_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Filter_clause() (localctx IFilter_clauseContext) { + localctx = NewFilter_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1788, RedshiftParserRULE_filter_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13686) + p.Match(RedshiftParserFILTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13687) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13688) + p.Match(RedshiftParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13689) + p.A_expr() + } + { + p.SetState(13690) + p.Match(RedshiftParserCLOSE_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 +} + +// IWindow_clauseContext is an interface to support dynamic dispatch. +type IWindow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WINDOW() antlr.TerminalNode + Window_definition_list() IWindow_definition_listContext + + // IsWindow_clauseContext differentiates from other interfaces. + IsWindow_clauseContext() +} + +type Window_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_clauseContext() *Window_clauseContext { + var p = new(Window_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_clause + return p +} + +func InitEmptyWindow_clauseContext(p *Window_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_clause +} + +func (*Window_clauseContext) IsWindow_clauseContext() {} + +func NewWindow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_clauseContext { + var p = new(Window_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_window_clause + + return p +} + +func (s *Window_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_clauseContext) WINDOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserWINDOW, 0) +} + +func (s *Window_clauseContext) Window_definition_list() IWindow_definition_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_definition_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_definition_listContext) +} + +func (s *Window_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWindow_clause(s) + } +} + +func (s *Window_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWindow_clause(s) + } +} + +func (s *Window_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWindow_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Window_clause() (localctx IWindow_clauseContext) { + localctx = NewWindow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1790, RedshiftParserRULE_window_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13692) + p.Match(RedshiftParserWINDOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13693) + p.Window_definition_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 +} + +// IWindow_definition_listContext is an interface to support dynamic dispatch. +type IWindow_definition_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWindow_definition() []IWindow_definitionContext + Window_definition(i int) IWindow_definitionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWindow_definition_listContext differentiates from other interfaces. + IsWindow_definition_listContext() +} + +type Window_definition_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_definition_listContext() *Window_definition_listContext { + var p = new(Window_definition_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_definition_list + return p +} + +func InitEmptyWindow_definition_listContext(p *Window_definition_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_definition_list +} + +func (*Window_definition_listContext) IsWindow_definition_listContext() {} + +func NewWindow_definition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definition_listContext { + var p = new(Window_definition_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_window_definition_list + + return p +} + +func (s *Window_definition_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_definition_listContext) AllWindow_definition() []IWindow_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindow_definitionContext); ok { + len++ + } + } + + tst := make([]IWindow_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindow_definitionContext); ok { + tst[i] = t.(IWindow_definitionContext) + i++ + } + } + + return tst +} + +func (s *Window_definition_listContext) Window_definition(i int) IWindow_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindow_definitionContext) +} + +func (s *Window_definition_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Window_definition_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Window_definition_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_definition_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_definition_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWindow_definition_list(s) + } +} + +func (s *Window_definition_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWindow_definition_list(s) + } +} + +func (s *Window_definition_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWindow_definition_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Window_definition_list() (localctx IWindow_definition_listContext) { + localctx = NewWindow_definition_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1792, RedshiftParserRULE_window_definition_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13695) + p.Window_definition() + } + p.SetState(13700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1320, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13696) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13697) + p.Window_definition() + } + + } + p.SetState(13702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1320, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_definitionContext is an interface to support dynamic dispatch. +type IWindow_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + AS() antlr.TerminalNode + Window_specification() IWindow_specificationContext + + // IsWindow_definitionContext differentiates from other interfaces. + IsWindow_definitionContext() +} + +type Window_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_definitionContext() *Window_definitionContext { + var p = new(Window_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_definition + return p +} + +func InitEmptyWindow_definitionContext(p *Window_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_definition +} + +func (*Window_definitionContext) IsWindow_definitionContext() {} + +func NewWindow_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_definitionContext { + var p = new(Window_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_window_definition + + return p +} + +func (s *Window_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_definitionContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Window_definitionContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Window_definitionContext) Window_specification() IWindow_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_specificationContext) +} + +func (s *Window_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWindow_definition(s) + } +} + +func (s *Window_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWindow_definition(s) + } +} + +func (s *Window_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWindow_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Window_definition() (localctx IWindow_definitionContext) { + localctx = NewWindow_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1794, RedshiftParserRULE_window_definition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13703) + p.Colid() + } + { + p.SetState(13704) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13705) + p.Window_specification() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOver_clauseContext is an interface to support dynamic dispatch. +type IOver_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVER() antlr.TerminalNode + Window_specification() IWindow_specificationContext + Colid() IColidContext + + // IsOver_clauseContext differentiates from other interfaces. + IsOver_clauseContext() +} + +type Over_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOver_clauseContext() *Over_clauseContext { + var p = new(Over_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_over_clause + return p +} + +func InitEmptyOver_clauseContext(p *Over_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_over_clause + + return p +} + +func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clauseContext) OVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVER, 0) +} + +func (s *Over_clauseContext) Window_specification() IWindow_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_specificationContext) +} + +func (s *Over_clauseContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Over_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Over_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Over_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOver_clause(s) + } +} + +func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOver_clause(s) + } +} + +func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOver_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Over_clause() (localctx IOver_clauseContext) { + localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1796, RedshiftParserRULE_over_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13707) + p.Match(RedshiftParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN: + { + p.SetState(13708) + p.Window_specification() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(13709) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindow_specificationContext is an interface to support dynamic dispatch. +type IWindow_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Opt_existing_window_name() IOpt_existing_window_nameContext + Opt_partition_clause() IOpt_partition_clauseContext + Opt_sort_clause() IOpt_sort_clauseContext + Opt_frame_clause() IOpt_frame_clauseContext + + // IsWindow_specificationContext differentiates from other interfaces. + IsWindow_specificationContext() +} + +type Window_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindow_specificationContext() *Window_specificationContext { + var p = new(Window_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_specification + return p +} + +func InitEmptyWindow_specificationContext(p *Window_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_window_specification +} + +func (*Window_specificationContext) IsWindow_specificationContext() {} + +func NewWindow_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Window_specificationContext { + var p = new(Window_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_window_specification + + return p +} + +func (s *Window_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Window_specificationContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Window_specificationContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Window_specificationContext) Opt_existing_window_name() IOpt_existing_window_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_existing_window_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_existing_window_nameContext) +} + +func (s *Window_specificationContext) Opt_partition_clause() IOpt_partition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_partition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_partition_clauseContext) +} + +func (s *Window_specificationContext) Opt_sort_clause() IOpt_sort_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sort_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sort_clauseContext) +} + +func (s *Window_specificationContext) Opt_frame_clause() IOpt_frame_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_frame_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_frame_clauseContext) +} + +func (s *Window_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Window_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Window_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWindow_specification(s) + } +} + +func (s *Window_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWindow_specification(s) + } +} + +func (s *Window_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWindow_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Window_specification() (localctx IWindow_specificationContext) { + localctx = NewWindow_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1798, RedshiftParserRULE_window_specification) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13712) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13714) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1322, p.GetParserRuleContext()) == 1 { + { + p.SetState(13713) + p.Opt_existing_window_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserPARTITION { + { + p.SetState(13716) + p.Opt_partition_clause() + } + + } + p.SetState(13720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserORDER { + { + p.SetState(13719) + p.Opt_sort_clause() + } + + } + p.SetState(13723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserRANGE || _la == RedshiftParserROWS || _la == RedshiftParserGROUPS { + { + p.SetState(13722) + p.Opt_frame_clause() + } + + } + { + p.SetState(13725) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_existing_window_nameContext is an interface to support dynamic dispatch. +type IOpt_existing_window_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + + // IsOpt_existing_window_nameContext differentiates from other interfaces. + IsOpt_existing_window_nameContext() +} + +type Opt_existing_window_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_existing_window_nameContext() *Opt_existing_window_nameContext { + var p = new(Opt_existing_window_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_existing_window_name + return p +} + +func InitEmptyOpt_existing_window_nameContext(p *Opt_existing_window_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_existing_window_name +} + +func (*Opt_existing_window_nameContext) IsOpt_existing_window_nameContext() {} + +func NewOpt_existing_window_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_existing_window_nameContext { + var p = new(Opt_existing_window_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_existing_window_name + + return p +} + +func (s *Opt_existing_window_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_existing_window_nameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Opt_existing_window_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_existing_window_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_existing_window_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_existing_window_name(s) + } +} + +func (s *Opt_existing_window_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_existing_window_name(s) + } +} + +func (s *Opt_existing_window_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_existing_window_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_existing_window_name() (localctx IOpt_existing_window_nameContext) { + localctx = NewOpt_existing_window_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1800, RedshiftParserRULE_opt_existing_window_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13727) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_partition_clauseContext is an interface to support dynamic dispatch. +type IOpt_partition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsOpt_partition_clauseContext differentiates from other interfaces. + IsOpt_partition_clauseContext() +} + +type Opt_partition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_partition_clauseContext() *Opt_partition_clauseContext { + var p = new(Opt_partition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_partition_clause + return p +} + +func InitEmptyOpt_partition_clauseContext(p *Opt_partition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_partition_clause +} + +func (*Opt_partition_clauseContext) IsOpt_partition_clauseContext() {} + +func NewOpt_partition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_partition_clauseContext { + var p = new(Opt_partition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_partition_clause + + return p +} + +func (s *Opt_partition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_partition_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *Opt_partition_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Opt_partition_clauseContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Opt_partition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_partition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_partition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_partition_clause(s) + } +} + +func (s *Opt_partition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_partition_clause(s) + } +} + +func (s *Opt_partition_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_partition_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_partition_clause() (localctx IOpt_partition_clauseContext) { + localctx = NewOpt_partition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1802, RedshiftParserRULE_opt_partition_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13729) + p.Match(RedshiftParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13730) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13731) + p.Expr_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_frame_clauseContext is an interface to support dynamic dispatch. +type IOpt_frame_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RANGE() antlr.TerminalNode + Frame_extent() IFrame_extentContext + Opt_window_exclusion_clause() IOpt_window_exclusion_clauseContext + ROWS() antlr.TerminalNode + GROUPS() antlr.TerminalNode + + // IsOpt_frame_clauseContext differentiates from other interfaces. + IsOpt_frame_clauseContext() +} + +type Opt_frame_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_frame_clauseContext() *Opt_frame_clauseContext { + var p = new(Opt_frame_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_frame_clause + return p +} + +func InitEmptyOpt_frame_clauseContext(p *Opt_frame_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_frame_clause +} + +func (*Opt_frame_clauseContext) IsOpt_frame_clauseContext() {} + +func NewOpt_frame_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_frame_clauseContext { + var p = new(Opt_frame_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_frame_clause + + return p +} + +func (s *Opt_frame_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_frame_clauseContext) RANGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRANGE, 0) +} + +func (s *Opt_frame_clauseContext) Frame_extent() IFrame_extentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrame_extentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrame_extentContext) +} + +func (s *Opt_frame_clauseContext) Opt_window_exclusion_clause() IOpt_window_exclusion_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_window_exclusion_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_window_exclusion_clauseContext) +} + +func (s *Opt_frame_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWS, 0) +} + +func (s *Opt_frame_clauseContext) GROUPS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUPS, 0) +} + +func (s *Opt_frame_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_frame_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_frame_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_frame_clause(s) + } +} + +func (s *Opt_frame_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_frame_clause(s) + } +} + +func (s *Opt_frame_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_frame_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_frame_clause() (localctx IOpt_frame_clauseContext) { + localctx = NewOpt_frame_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1804, RedshiftParserRULE_opt_frame_clause) + var _la int + + p.SetState(13748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserRANGE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13733) + p.Match(RedshiftParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13734) + p.Frame_extent() + } + p.SetState(13736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCLUDE { + { + p.SetState(13735) + p.Opt_window_exclusion_clause() + } + + } + + case RedshiftParserROWS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13738) + p.Match(RedshiftParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13739) + p.Frame_extent() + } + p.SetState(13741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCLUDE { + { + p.SetState(13740) + p.Opt_window_exclusion_clause() + } + + } + + case RedshiftParserGROUPS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13743) + p.Match(RedshiftParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13744) + p.Frame_extent() + } + p.SetState(13746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCLUDE { + { + p.SetState(13745) + p.Opt_window_exclusion_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 +} + +// IFrame_extentContext is an interface to support dynamic dispatch. +type IFrame_extentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFrame_bound() []IFrame_boundContext + Frame_bound(i int) IFrame_boundContext + BETWEEN() antlr.TerminalNode + AND() antlr.TerminalNode + + // IsFrame_extentContext differentiates from other interfaces. + IsFrame_extentContext() +} + +type Frame_extentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrame_extentContext() *Frame_extentContext { + var p = new(Frame_extentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frame_extent + return p +} + +func InitEmptyFrame_extentContext(p *Frame_extentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frame_extent +} + +func (*Frame_extentContext) IsFrame_extentContext() {} + +func NewFrame_extentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_extentContext { + var p = new(Frame_extentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_frame_extent + + return p +} + +func (s *Frame_extentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Frame_extentContext) AllFrame_bound() []IFrame_boundContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFrame_boundContext); ok { + len++ + } + } + + tst := make([]IFrame_boundContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFrame_boundContext); ok { + tst[i] = t.(IFrame_boundContext) + i++ + } + } + + return tst +} + +func (s *Frame_extentContext) Frame_bound(i int) IFrame_boundContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrame_boundContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFrame_boundContext) +} + +func (s *Frame_extentContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserBETWEEN, 0) +} + +func (s *Frame_extentContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Frame_extentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Frame_extentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Frame_extentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFrame_extent(s) + } +} + +func (s *Frame_extentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFrame_extent(s) + } +} + +func (s *Frame_extentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFrame_extent(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Frame_extent() (localctx IFrame_extentContext) { + localctx = NewFrame_extentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1806, RedshiftParserRULE_frame_extent) + p.SetState(13756) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1330, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13750) + p.Frame_bound() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13751) + p.Match(RedshiftParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13752) + p.Frame_bound() + } + { + p.SetState(13753) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13754) + p.Frame_bound() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrame_boundContext is an interface to support dynamic dispatch. +type IFrame_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNBOUNDED() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + CURRENT_P() antlr.TerminalNode + ROW() antlr.TerminalNode + A_expr() IA_exprContext + + // IsFrame_boundContext differentiates from other interfaces. + IsFrame_boundContext() +} + +type Frame_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrame_boundContext() *Frame_boundContext { + var p = new(Frame_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frame_bound + return p +} + +func InitEmptyFrame_boundContext(p *Frame_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_frame_bound +} + +func (*Frame_boundContext) IsFrame_boundContext() {} + +func NewFrame_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Frame_boundContext { + var p = new(Frame_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_frame_bound + + return p +} + +func (s *Frame_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Frame_boundContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNBOUNDED, 0) +} + +func (s *Frame_boundContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRECEDING, 0) +} + +func (s *Frame_boundContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOLLOWING, 0) +} + +func (s *Frame_boundContext) CURRENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_P, 0) +} + +func (s *Frame_boundContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Frame_boundContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Frame_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Frame_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Frame_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFrame_bound(s) + } +} + +func (s *Frame_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFrame_bound(s) + } +} + +func (s *Frame_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFrame_bound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Frame_bound() (localctx IFrame_boundContext) { + localctx = NewFrame_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1808, RedshiftParserRULE_frame_bound) + var _la int + + p.SetState(13765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1331, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13758) + p.Match(RedshiftParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13759) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFOLLOWING || _la == RedshiftParserPRECEDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13760) + p.Match(RedshiftParserCURRENT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13761) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13762) + p.A_expr() + } + { + p.SetState(13763) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFOLLOWING || _la == RedshiftParserPRECEDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_window_exclusion_clauseContext is an interface to support dynamic dispatch. +type IOpt_window_exclusion_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCLUDE() antlr.TerminalNode + CURRENT_P() antlr.TerminalNode + ROW() antlr.TerminalNode + GROUP_P() antlr.TerminalNode + TIES() antlr.TerminalNode + NO() antlr.TerminalNode + OTHERS() antlr.TerminalNode + + // IsOpt_window_exclusion_clauseContext differentiates from other interfaces. + IsOpt_window_exclusion_clauseContext() +} + +type Opt_window_exclusion_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_window_exclusion_clauseContext() *Opt_window_exclusion_clauseContext { + var p = new(Opt_window_exclusion_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_window_exclusion_clause + return p +} + +func InitEmptyOpt_window_exclusion_clauseContext(p *Opt_window_exclusion_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_window_exclusion_clause +} + +func (*Opt_window_exclusion_clauseContext) IsOpt_window_exclusion_clauseContext() {} + +func NewOpt_window_exclusion_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_window_exclusion_clauseContext { + var p = new(Opt_window_exclusion_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_window_exclusion_clause + + return p +} + +func (s *Opt_window_exclusion_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_window_exclusion_clauseContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDE, 0) +} + +func (s *Opt_window_exclusion_clauseContext) CURRENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_P, 0) +} + +func (s *Opt_window_exclusion_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Opt_window_exclusion_clauseContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *Opt_window_exclusion_clauseContext) TIES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIES, 0) +} + +func (s *Opt_window_exclusion_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_window_exclusion_clauseContext) OTHERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOTHERS, 0) +} + +func (s *Opt_window_exclusion_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_window_exclusion_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_window_exclusion_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_window_exclusion_clause(s) + } +} + +func (s *Opt_window_exclusion_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_window_exclusion_clause(s) + } +} + +func (s *Opt_window_exclusion_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_window_exclusion_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_window_exclusion_clause() (localctx IOpt_window_exclusion_clauseContext) { + localctx = NewOpt_window_exclusion_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1810, RedshiftParserRULE_opt_window_exclusion_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13767) + p.Match(RedshiftParserEXCLUDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCURRENT_P: + { + p.SetState(13768) + p.Match(RedshiftParserCURRENT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13769) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserGROUP_P: + { + p.SetState(13770) + p.Match(RedshiftParserGROUP_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserTIES: + { + p.SetState(13771) + p.Match(RedshiftParserTIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserNO: + { + p.SetState(13772) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13773) + p.Match(RedshiftParserOTHERS) + 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 +} + +// IRowContext is an interface to support dynamic dispatch. +type IRowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + COMMA() antlr.TerminalNode + A_expr() IA_exprContext + + // IsRowContext differentiates from other interfaces. + IsRowContext() +} + +type RowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRowContext() *RowContext { + var p = new(RowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row + return p +} + +func InitEmptyRowContext(p *RowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_row +} + +func (*RowContext) IsRowContext() {} + +func NewRowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RowContext { + var p = new(RowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_row + + return p +} + +func (s *RowContext) GetParser() antlr.Parser { return s.parser } + +func (s *RowContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *RowContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *RowContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *RowContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *RowContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *RowContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *RowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRow(s) + } +} + +func (s *RowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRow(s) + } +} + +func (s *RowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRow(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Row() (localctx IRowContext) { + localctx = NewRowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1812, RedshiftParserRULE_row) + var _la int + + p.SetState(13788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserROW: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13776) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13777) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(13778) + p.Expr_list() + } + + } + { + p.SetState(13781) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserOPEN_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13782) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13783) + p.Expr_list() + } + { + p.SetState(13784) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13785) + p.A_expr() + } + { + p.SetState(13786) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExplicit_rowContext is an interface to support dynamic dispatch. +type IExplicit_rowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsExplicit_rowContext differentiates from other interfaces. + IsExplicit_rowContext() +} + +type Explicit_rowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplicit_rowContext() *Explicit_rowContext { + var p = new(Explicit_rowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explicit_row + return p +} + +func InitEmptyExplicit_rowContext(p *Explicit_rowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_explicit_row +} + +func (*Explicit_rowContext) IsExplicit_rowContext() {} + +func NewExplicit_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explicit_rowContext { + var p = new(Explicit_rowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_explicit_row + + return p +} + +func (s *Explicit_rowContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explicit_rowContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Explicit_rowContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Explicit_rowContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Explicit_rowContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Explicit_rowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explicit_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explicit_rowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExplicit_row(s) + } +} + +func (s *Explicit_rowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExplicit_row(s) + } +} + +func (s *Explicit_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExplicit_row(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Explicit_row() (localctx IExplicit_rowContext) { + localctx = NewExplicit_rowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1814, RedshiftParserRULE_explicit_row) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13790) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13791) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(13792) + p.Expr_list() + } + + } + { + p.SetState(13795) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImplicit_rowContext is an interface to support dynamic dispatch. +type IImplicit_rowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Expr_list() IExpr_listContext + COMMA() antlr.TerminalNode + A_expr() IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + + // IsImplicit_rowContext differentiates from other interfaces. + IsImplicit_rowContext() +} + +type Implicit_rowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImplicit_rowContext() *Implicit_rowContext { + var p = new(Implicit_rowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_implicit_row + return p +} + +func InitEmptyImplicit_rowContext(p *Implicit_rowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_implicit_row +} + +func (*Implicit_rowContext) IsImplicit_rowContext() {} + +func NewImplicit_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implicit_rowContext { + var p = new(Implicit_rowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_implicit_row + + return p +} + +func (s *Implicit_rowContext) GetParser() antlr.Parser { return s.parser } + +func (s *Implicit_rowContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Implicit_rowContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Implicit_rowContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Implicit_rowContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Implicit_rowContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Implicit_rowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Implicit_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Implicit_rowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterImplicit_row(s) + } +} + +func (s *Implicit_rowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitImplicit_row(s) + } +} + +func (s *Implicit_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitImplicit_row(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Implicit_row() (localctx IImplicit_rowContext) { + localctx = NewImplicit_rowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1816, RedshiftParserRULE_implicit_row) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13797) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13798) + p.Expr_list() + } + { + p.SetState(13799) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13800) + p.A_expr() + } + { + p.SetState(13801) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISub_typeContext is an interface to support dynamic dispatch. +type ISub_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANY() antlr.TerminalNode + SOME() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsSub_typeContext differentiates from other interfaces. + IsSub_typeContext() +} + +type Sub_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySub_typeContext() *Sub_typeContext { + var p = new(Sub_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sub_type + return p +} + +func InitEmptySub_typeContext(p *Sub_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sub_type +} + +func (*Sub_typeContext) IsSub_typeContext() {} + +func NewSub_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sub_typeContext { + var p = new(Sub_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sub_type + + return p +} + +func (s *Sub_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sub_typeContext) ANY() antlr.TerminalNode { + return s.GetToken(RedshiftParserANY, 0) +} + +func (s *Sub_typeContext) SOME() antlr.TerminalNode { + return s.GetToken(RedshiftParserSOME, 0) +} + +func (s *Sub_typeContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Sub_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sub_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sub_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSub_type(s) + } +} + +func (s *Sub_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSub_type(s) + } +} + +func (s *Sub_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSub_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sub_type() (localctx ISub_typeContext) { + localctx = NewSub_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1818, RedshiftParserRULE_sub_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13803) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-30)) & ^0x3f) == 0 && ((int64(1)<<(_la-30))&2305843009213693969) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAll_opContext is an interface to support dynamic dispatch. +type IAll_opContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Operator() antlr.TerminalNode + Mathop() IMathopContext + + // IsAll_opContext differentiates from other interfaces. + IsAll_opContext() +} + +type All_opContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_opContext() *All_opContext { + var p = new(All_opContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_op + return p +} + +func InitEmptyAll_opContext(p *All_opContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_all_op +} + +func (*All_opContext) IsAll_opContext() {} + +func NewAll_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_opContext { + var p = new(All_opContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_all_op + + return p +} + +func (s *All_opContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_opContext) Operator() antlr.TerminalNode { + return s.GetToken(RedshiftParserOperator, 0) +} + +func (s *All_opContext) Mathop() IMathopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMathopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMathopContext) +} + +func (s *All_opContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_opContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAll_op(s) + } +} + +func (s *All_opContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAll_op(s) + } +} + +func (s *All_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAll_op(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) All_op() (localctx IAll_opContext) { + localctx = NewAll_opContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1820, RedshiftParserRULE_all_op) + p.SetState(13807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOperator: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13805) + p.Match(RedshiftParserOperator) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSTAR, RedshiftParserEQUAL, RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserSLASH, RedshiftParserCARET, RedshiftParserLT, RedshiftParserGT, RedshiftParserLESS_EQUALS, RedshiftParserGREATER_EQUALS, RedshiftParserNOT_EQUALS, RedshiftParserPERCENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13806) + p.Mathop() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMathopContext is an interface to support dynamic dispatch. +type IMathopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + STAR() antlr.TerminalNode + SLASH() antlr.TerminalNode + PERCENT() antlr.TerminalNode + CARET() antlr.TerminalNode + LT() antlr.TerminalNode + GT() antlr.TerminalNode + EQUAL() antlr.TerminalNode + LESS_EQUALS() antlr.TerminalNode + GREATER_EQUALS() antlr.TerminalNode + NOT_EQUALS() antlr.TerminalNode + + // IsMathopContext differentiates from other interfaces. + IsMathopContext() +} + +type MathopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMathopContext() *MathopContext { + var p = new(MathopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_mathop + return p +} + +func InitEmptyMathopContext(p *MathopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_mathop +} + +func (*MathopContext) IsMathopContext() {} + +func NewMathopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MathopContext { + var p = new(MathopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_mathop + + return p +} + +func (s *MathopContext) GetParser() antlr.Parser { return s.parser } + +func (s *MathopContext) PLUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLUS, 0) +} + +func (s *MathopContext) MINUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUS, 0) +} + +func (s *MathopContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *MathopContext) SLASH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSLASH, 0) +} + +func (s *MathopContext) PERCENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENT, 0) +} + +func (s *MathopContext) CARET() antlr.TerminalNode { + return s.GetToken(RedshiftParserCARET, 0) +} + +func (s *MathopContext) LT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLT, 0) +} + +func (s *MathopContext) GT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGT, 0) +} + +func (s *MathopContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *MathopContext) LESS_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserLESS_EQUALS, 0) +} + +func (s *MathopContext) GREATER_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGREATER_EQUALS, 0) +} + +func (s *MathopContext) NOT_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT_EQUALS, 0) +} + +func (s *MathopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MathopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MathopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMathop(s) + } +} + +func (s *MathopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMathop(s) + } +} + +func (s *MathopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMathop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Mathop() (localctx IMathopContext) { + localctx = NewMathopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1822, RedshiftParserRULE_mathop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13809) + _la = p.GetTokenStream().LA(1) + + if !((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&178517504) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQual_opContext is an interface to support dynamic dispatch. +type IQual_opContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Operator() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Any_operator() IAny_operatorContext + CLOSE_PAREN() antlr.TerminalNode + + // IsQual_opContext differentiates from other interfaces. + IsQual_opContext() +} + +type Qual_opContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQual_opContext() *Qual_opContext { + var p = new(Qual_opContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qual_op + return p +} + +func InitEmptyQual_opContext(p *Qual_opContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qual_op +} + +func (*Qual_opContext) IsQual_opContext() {} + +func NewQual_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qual_opContext { + var p = new(Qual_opContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_qual_op + + return p +} + +func (s *Qual_opContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qual_opContext) Operator() antlr.TerminalNode { + return s.GetToken(RedshiftParserOperator, 0) +} + +func (s *Qual_opContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *Qual_opContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Qual_opContext) Any_operator() IAny_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_operatorContext) +} + +func (s *Qual_opContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Qual_opContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qual_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qual_opContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterQual_op(s) + } +} + +func (s *Qual_opContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitQual_op(s) + } +} + +func (s *Qual_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitQual_op(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Qual_op() (localctx IQual_opContext) { + localctx = NewQual_opContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1824, RedshiftParserRULE_qual_op) + p.SetState(13817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOperator: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13811) + p.Match(RedshiftParserOperator) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserOPERATOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13812) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13813) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13814) + p.Any_operator() + } + { + p.SetState(13815) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQual_all_opContext is an interface to support dynamic dispatch. +type IQual_all_opContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + All_op() IAll_opContext + OPERATOR() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Any_operator() IAny_operatorContext + CLOSE_PAREN() antlr.TerminalNode + + // IsQual_all_opContext differentiates from other interfaces. + IsQual_all_opContext() +} + +type Qual_all_opContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQual_all_opContext() *Qual_all_opContext { + var p = new(Qual_all_opContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qual_all_op + return p +} + +func InitEmptyQual_all_opContext(p *Qual_all_opContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qual_all_op +} + +func (*Qual_all_opContext) IsQual_all_opContext() {} + +func NewQual_all_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qual_all_opContext { + var p = new(Qual_all_opContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_qual_all_op + + return p +} + +func (s *Qual_all_opContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qual_all_opContext) All_op() IAll_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_opContext) +} + +func (s *Qual_all_opContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *Qual_all_opContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Qual_all_opContext) Any_operator() IAny_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_operatorContext) +} + +func (s *Qual_all_opContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Qual_all_opContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qual_all_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qual_all_opContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterQual_all_op(s) + } +} + +func (s *Qual_all_opContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitQual_all_op(s) + } +} + +func (s *Qual_all_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitQual_all_op(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Qual_all_op() (localctx IQual_all_opContext) { + localctx = NewQual_all_opContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1826, RedshiftParserRULE_qual_all_op) + p.SetState(13825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSTAR, RedshiftParserEQUAL, RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserSLASH, RedshiftParserCARET, RedshiftParserLT, RedshiftParserGT, RedshiftParserLESS_EQUALS, RedshiftParserGREATER_EQUALS, RedshiftParserNOT_EQUALS, RedshiftParserPERCENT, RedshiftParserOperator: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13819) + p.All_op() + } + + case RedshiftParserOPERATOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13820) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13821) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13822) + p.Any_operator() + } + { + p.SetState(13823) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubquery_OpContext is an interface to support dynamic dispatch. +type ISubquery_OpContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + All_op() IAll_opContext + OPERATOR() antlr.TerminalNode + OPEN_PAREN() antlr.TerminalNode + Any_operator() IAny_operatorContext + CLOSE_PAREN() antlr.TerminalNode + LIKE() antlr.TerminalNode + NOT() antlr.TerminalNode + ILIKE() antlr.TerminalNode + + // IsSubquery_OpContext differentiates from other interfaces. + IsSubquery_OpContext() +} + +type Subquery_OpContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_OpContext() *Subquery_OpContext { + var p = new(Subquery_OpContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_subquery_Op + return p +} + +func InitEmptySubquery_OpContext(p *Subquery_OpContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_subquery_Op +} + +func (*Subquery_OpContext) IsSubquery_OpContext() {} + +func NewSubquery_OpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_OpContext { + var p = new(Subquery_OpContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_subquery_Op + + return p +} + +func (s *Subquery_OpContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_OpContext) All_op() IAll_opContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_opContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_opContext) +} + +func (s *Subquery_OpContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *Subquery_OpContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Subquery_OpContext) Any_operator() IAny_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_operatorContext) +} + +func (s *Subquery_OpContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Subquery_OpContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *Subquery_OpContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Subquery_OpContext) ILIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserILIKE, 0) +} + +func (s *Subquery_OpContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_OpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_OpContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSubquery_Op(s) + } +} + +func (s *Subquery_OpContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSubquery_Op(s) + } +} + +func (s *Subquery_OpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSubquery_Op(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Subquery_Op() (localctx ISubquery_OpContext) { + localctx = NewSubquery_OpContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1828, RedshiftParserRULE_subquery_Op) + p.SetState(13839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1339, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13827) + p.All_op() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13828) + p.Match(RedshiftParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13829) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13830) + p.Any_operator() + } + { + p.SetState(13831) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13833) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13834) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13835) + p.Match(RedshiftParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13836) + p.Match(RedshiftParserILIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13837) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13838) + p.Match(RedshiftParserILIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpr_listContext is an interface to support dynamic dispatch. +type IExpr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpr_listContext differentiates from other interfaces. + IsExpr_listContext() +} + +type Expr_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_listContext() *Expr_listContext { + var p = new(Expr_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_list + return p +} + +func InitEmptyExpr_listContext(p *Expr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_list +} + +func (*Expr_listContext) IsExpr_listContext() {} + +func NewExpr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_listContext { + var p = new(Expr_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_expr_list + + return p +} + +func (s *Expr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_listContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Expr_listContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Expr_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Expr_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Expr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExpr_list(s) + } +} + +func (s *Expr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExpr_list(s) + } +} + +func (s *Expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExpr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Expr_list() (localctx IExpr_listContext) { + localctx = NewExpr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1830, RedshiftParserRULE_expr_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13841) + p.A_expr() + } + p.SetState(13846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1340, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13842) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13843) + p.A_expr() + } + + } + p.SetState(13848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1340, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_arg_listContext is an interface to support dynamic dispatch. +type IFunc_arg_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFunc_arg_expr() []IFunc_arg_exprContext + Func_arg_expr(i int) IFunc_arg_exprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_arg_listContext differentiates from other interfaces. + IsFunc_arg_listContext() +} + +type Func_arg_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_arg_listContext() *Func_arg_listContext { + var p = new(Func_arg_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg_list + return p +} + +func InitEmptyFunc_arg_listContext(p *Func_arg_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg_list +} + +func (*Func_arg_listContext) IsFunc_arg_listContext() {} + +func NewFunc_arg_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_listContext { + var p = new(Func_arg_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_arg_list + + return p +} + +func (s *Func_arg_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_arg_listContext) AllFunc_arg_expr() []IFunc_arg_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunc_arg_exprContext); ok { + len++ + } + } + + tst := make([]IFunc_arg_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunc_arg_exprContext); ok { + tst[i] = t.(IFunc_arg_exprContext) + i++ + } + } + + return tst +} + +func (s *Func_arg_listContext) Func_arg_expr(i int) IFunc_arg_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_arg_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunc_arg_exprContext) +} + +func (s *Func_arg_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Func_arg_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Func_arg_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_arg_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_arg_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_arg_list(s) + } +} + +func (s *Func_arg_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_arg_list(s) + } +} + +func (s *Func_arg_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_arg_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_arg_list() (localctx IFunc_arg_listContext) { + localctx = NewFunc_arg_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1832, RedshiftParserRULE_func_arg_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13849) + p.Func_arg_expr() + } + p.SetState(13854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1341, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13850) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13851) + p.Func_arg_expr() + } + + } + p.SetState(13856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1341, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_arg_exprContext is an interface to support dynamic dispatch. +type IFunc_arg_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + Param_name() IParam_nameContext + COLON_EQUALS() antlr.TerminalNode + EQUALS_GREATER() antlr.TerminalNode + + // IsFunc_arg_exprContext differentiates from other interfaces. + IsFunc_arg_exprContext() +} + +type Func_arg_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_arg_exprContext() *Func_arg_exprContext { + var p = new(Func_arg_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg_expr + return p +} + +func InitEmptyFunc_arg_exprContext(p *Func_arg_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_arg_expr +} + +func (*Func_arg_exprContext) IsFunc_arg_exprContext() {} + +func NewFunc_arg_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_arg_exprContext { + var p = new(Func_arg_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_arg_expr + + return p +} + +func (s *Func_arg_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_arg_exprContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Func_arg_exprContext) Param_name() IParam_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParam_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParam_nameContext) +} + +func (s *Func_arg_exprContext) COLON_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLON_EQUALS, 0) +} + +func (s *Func_arg_exprContext) EQUALS_GREATER() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUALS_GREATER, 0) +} + +func (s *Func_arg_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_arg_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_arg_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_arg_expr(s) + } +} + +func (s *Func_arg_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_arg_expr(s) + } +} + +func (s *Func_arg_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_arg_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_arg_expr() (localctx IFunc_arg_exprContext) { + localctx = NewFunc_arg_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1834, RedshiftParserRULE_func_arg_expr) + var _la int + + p.SetState(13862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1342, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13857) + p.A_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13858) + p.Param_name() + } + { + p.SetState(13859) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCOLON_EQUALS || _la == RedshiftParserEQUALS_GREATER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13860) + p.A_expr() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_listContext is an interface to support dynamic dispatch. +type IType_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTypename() []ITypenameContext + Typename(i int) ITypenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsType_listContext differentiates from other interfaces. + IsType_listContext() +} + +type Type_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_listContext() *Type_listContext { + var p = new(Type_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_list + return p +} + +func InitEmptyType_listContext(p *Type_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_list +} + +func (*Type_listContext) IsType_listContext() {} + +func NewType_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_listContext { + var p = new(Type_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_type_list + + return p +} + +func (s *Type_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_listContext) AllTypename() []ITypenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITypenameContext); ok { + len++ + } + } + + tst := make([]ITypenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITypenameContext); ok { + tst[i] = t.(ITypenameContext) + i++ + } + } + + return tst +} + +func (s *Type_listContext) Typename(i int) ITypenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Type_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Type_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Type_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterType_list(s) + } +} + +func (s *Type_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitType_list(s) + } +} + +func (s *Type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitType_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Type_list() (localctx IType_listContext) { + localctx = NewType_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1836, RedshiftParserRULE_type_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13864) + p.Typename() + } + p.SetState(13869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(13865) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13866) + p.Typename() + } + + p.SetState(13871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_exprContext is an interface to support dynamic dispatch. +type IArray_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_BRACKET() antlr.TerminalNode + CLOSE_BRACKET() antlr.TerminalNode + Expr_list() IExpr_listContext + Array_expr_list() IArray_expr_listContext + + // IsArray_exprContext differentiates from other interfaces. + IsArray_exprContext() +} + +type Array_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_exprContext() *Array_exprContext { + var p = new(Array_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_array_expr + return p +} + +func InitEmptyArray_exprContext(p *Array_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_array_expr +} + +func (*Array_exprContext) IsArray_exprContext() {} + +func NewArray_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_exprContext { + var p = new(Array_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_array_expr + + return p +} + +func (s *Array_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_exprContext) OPEN_BRACKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_BRACKET, 0) +} + +func (s *Array_exprContext) CLOSE_BRACKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_BRACKET, 0) +} + +func (s *Array_exprContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Array_exprContext) Array_expr_list() IArray_expr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_expr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArray_expr_listContext) +} + +func (s *Array_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterArray_expr(s) + } +} + +func (s *Array_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitArray_expr(s) + } +} + +func (s *Array_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitArray_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Array_expr() (localctx IArray_exprContext) { + localctx = NewArray_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1838, RedshiftParserRULE_array_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13872) + p.Match(RedshiftParserOPEN_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserPARAM, RedshiftParserOperator, RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserSESSION_USER, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserBinaryStringConstant, RedshiftParserHexadecimalStringConstant, RedshiftParserIntegral, RedshiftParserNumeric, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + { + p.SetState(13873) + p.Expr_list() + } + + case RedshiftParserOPEN_BRACKET: + { + p.SetState(13874) + p.Array_expr_list() + } + + case RedshiftParserCLOSE_BRACKET: + + default: + } + { + p.SetState(13877) + p.Match(RedshiftParserCLOSE_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArray_expr_listContext is an interface to support dynamic dispatch. +type IArray_expr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllArray_expr() []IArray_exprContext + Array_expr(i int) IArray_exprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsArray_expr_listContext differentiates from other interfaces. + IsArray_expr_listContext() +} + +type Array_expr_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArray_expr_listContext() *Array_expr_listContext { + var p = new(Array_expr_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_array_expr_list + return p +} + +func InitEmptyArray_expr_listContext(p *Array_expr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_array_expr_list +} + +func (*Array_expr_listContext) IsArray_expr_listContext() {} + +func NewArray_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Array_expr_listContext { + var p = new(Array_expr_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_array_expr_list + + return p +} + +func (s *Array_expr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Array_expr_listContext) AllArray_expr() []IArray_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArray_exprContext); ok { + len++ + } + } + + tst := make([]IArray_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArray_exprContext); ok { + tst[i] = t.(IArray_exprContext) + i++ + } + } + + return tst +} + +func (s *Array_expr_listContext) Array_expr(i int) IArray_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArray_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArray_exprContext) +} + +func (s *Array_expr_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Array_expr_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Array_expr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Array_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Array_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterArray_expr_list(s) + } +} + +func (s *Array_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitArray_expr_list(s) + } +} + +func (s *Array_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitArray_expr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Array_expr_list() (localctx IArray_expr_listContext) { + localctx = NewArray_expr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1840, RedshiftParserRULE_array_expr_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13879) + p.Array_expr() + } + p.SetState(13884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(13880) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13881) + p.Array_expr() + } + + p.SetState(13886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtract_listContext is an interface to support dynamic dispatch. +type IExtract_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Extract_arg() IExtract_argContext + FROM() antlr.TerminalNode + A_expr() IA_exprContext + + // IsExtract_listContext differentiates from other interfaces. + IsExtract_listContext() +} + +type Extract_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtract_listContext() *Extract_listContext { + var p = new(Extract_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extract_list + return p +} + +func InitEmptyExtract_listContext(p *Extract_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extract_list +} + +func (*Extract_listContext) IsExtract_listContext() {} + +func NewExtract_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_listContext { + var p = new(Extract_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_extract_list + + return p +} + +func (s *Extract_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extract_listContext) Extract_arg() IExtract_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtract_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtract_argContext) +} + +func (s *Extract_listContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Extract_listContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Extract_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extract_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extract_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExtract_list(s) + } +} + +func (s *Extract_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExtract_list(s) + } +} + +func (s *Extract_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExtract_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Extract_list() (localctx IExtract_listContext) { + localctx = NewExtract_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1842, RedshiftParserRULE_extract_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13887) + p.Extract_arg() + } + { + p.SetState(13888) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13889) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExtract_argContext is an interface to support dynamic dispatch. +type IExtract_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + YEAR_P() antlr.TerminalNode + MONTH_P() antlr.TerminalNode + DAY_P() antlr.TerminalNode + HOUR_P() antlr.TerminalNode + MINUTE_P() antlr.TerminalNode + SECOND_P() antlr.TerminalNode + Sconst() ISconstContext + + // IsExtract_argContext differentiates from other interfaces. + IsExtract_argContext() +} + +type Extract_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtract_argContext() *Extract_argContext { + var p = new(Extract_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extract_arg + return p +} + +func InitEmptyExtract_argContext(p *Extract_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_extract_arg +} + +func (*Extract_argContext) IsExtract_argContext() {} + +func NewExtract_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extract_argContext { + var p = new(Extract_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_extract_arg + + return p +} + +func (s *Extract_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extract_argContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Extract_argContext) YEAR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYEAR_P, 0) +} + +func (s *Extract_argContext) MONTH_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserMONTH_P, 0) +} + +func (s *Extract_argContext) DAY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDAY_P, 0) +} + +func (s *Extract_argContext) HOUR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserHOUR_P, 0) +} + +func (s *Extract_argContext) MINUTE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUTE_P, 0) +} + +func (s *Extract_argContext) SECOND_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECOND_P, 0) +} + +func (s *Extract_argContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Extract_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extract_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extract_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExtract_arg(s) + } +} + +func (s *Extract_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExtract_arg(s) + } +} + +func (s *Extract_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExtract_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Extract_arg() (localctx IExtract_argContext) { + localctx = NewExtract_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1844, RedshiftParserRULE_extract_arg) + p.SetState(13899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserOUTER_P, RedshiftParserABSOLUTE_P, RedshiftParserBACKWARD, RedshiftParserCHAIN, RedshiftParserCLOSE, RedshiftParserCOMMIT, RedshiftParserCONTINUE_P, RedshiftParserCURSOR, RedshiftParserFIRST_P, RedshiftParserFORWARD, RedshiftParserINSERT, RedshiftParserLAST_P, RedshiftParserMOVE, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserOPTION, RedshiftParserPRIOR, RedshiftParserRELATIVE_P, RedshiftParserRESET, RedshiftParserROLLBACK, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSET, RedshiftParserTYPE_P, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserROWTYPE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13891) + p.Identifier() + } + + case RedshiftParserYEAR_P: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13892) + p.Match(RedshiftParserYEAR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserMONTH_P: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13893) + p.Match(RedshiftParserMONTH_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDAY_P: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13894) + p.Match(RedshiftParserDAY_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserHOUR_P: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13895) + p.Match(RedshiftParserHOUR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserMINUTE_P: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13896) + p.Match(RedshiftParserMINUTE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSECOND_P: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13897) + p.Match(RedshiftParserSECOND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13898) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnicode_normal_formContext is an interface to support dynamic dispatch. +type IUnicode_normal_formContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NFC() antlr.TerminalNode + NFD() antlr.TerminalNode + NFKC() antlr.TerminalNode + NFKD() antlr.TerminalNode + + // IsUnicode_normal_formContext differentiates from other interfaces. + IsUnicode_normal_formContext() +} + +type Unicode_normal_formContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnicode_normal_formContext() *Unicode_normal_formContext { + var p = new(Unicode_normal_formContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unicode_normal_form + return p +} + +func InitEmptyUnicode_normal_formContext(p *Unicode_normal_formContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unicode_normal_form +} + +func (*Unicode_normal_formContext) IsUnicode_normal_formContext() {} + +func NewUnicode_normal_formContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unicode_normal_formContext { + var p = new(Unicode_normal_formContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_unicode_normal_form + + return p +} + +func (s *Unicode_normal_formContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unicode_normal_formContext) NFC() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFC, 0) +} + +func (s *Unicode_normal_formContext) NFD() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFD, 0) +} + +func (s *Unicode_normal_formContext) NFKC() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFKC, 0) +} + +func (s *Unicode_normal_formContext) NFKD() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFKD, 0) +} + +func (s *Unicode_normal_formContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unicode_normal_formContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unicode_normal_formContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUnicode_normal_form(s) + } +} + +func (s *Unicode_normal_formContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUnicode_normal_form(s) + } +} + +func (s *Unicode_normal_formContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUnicode_normal_form(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Unicode_normal_form() (localctx IUnicode_normal_formContext) { + localctx = NewUnicode_normal_formContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1846, RedshiftParserRULE_unicode_normal_form) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13901) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-682)) & ^0x3f) == 0 && ((int64(1)<<(_la-682))&15) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverlay_listContext is an interface to support dynamic dispatch. +type IOverlay_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + PLACING() antlr.TerminalNode + FROM() antlr.TerminalNode + FOR() antlr.TerminalNode + + // IsOverlay_listContext differentiates from other interfaces. + IsOverlay_listContext() +} + +type Overlay_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverlay_listContext() *Overlay_listContext { + var p = new(Overlay_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_overlay_list + return p +} + +func InitEmptyOverlay_listContext(p *Overlay_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_overlay_list +} + +func (*Overlay_listContext) IsOverlay_listContext() {} + +func NewOverlay_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overlay_listContext { + var p = new(Overlay_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_overlay_list + + return p +} + +func (s *Overlay_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Overlay_listContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Overlay_listContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Overlay_listContext) PLACING() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLACING, 0) +} + +func (s *Overlay_listContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Overlay_listContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Overlay_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Overlay_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Overlay_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOverlay_list(s) + } +} + +func (s *Overlay_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOverlay_list(s) + } +} + +func (s *Overlay_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOverlay_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Overlay_list() (localctx IOverlay_listContext) { + localctx = NewOverlay_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1848, RedshiftParserRULE_overlay_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13903) + p.A_expr() + } + { + p.SetState(13904) + p.Match(RedshiftParserPLACING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13905) + p.A_expr() + } + { + p.SetState(13906) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13907) + p.A_expr() + } + p.SetState(13910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFOR { + { + p.SetState(13908) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13909) + p.A_expr() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPosition_listContext is an interface to support dynamic dispatch. +type IPosition_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllB_expr() []IB_exprContext + B_expr(i int) IB_exprContext + IN_P() antlr.TerminalNode + + // IsPosition_listContext differentiates from other interfaces. + IsPosition_listContext() +} + +type Position_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPosition_listContext() *Position_listContext { + var p = new(Position_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_position_list + return p +} + +func InitEmptyPosition_listContext(p *Position_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_position_list +} + +func (*Position_listContext) IsPosition_listContext() {} + +func NewPosition_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Position_listContext { + var p = new(Position_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_position_list + + return p +} + +func (s *Position_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Position_listContext) AllB_expr() []IB_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IB_exprContext); ok { + len++ + } + } + + tst := make([]IB_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IB_exprContext); ok { + tst[i] = t.(IB_exprContext) + i++ + } + } + + return tst +} + +func (s *Position_listContext) B_expr(i int) IB_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IB_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IB_exprContext) +} + +func (s *Position_listContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Position_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Position_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Position_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPosition_list(s) + } +} + +func (s *Position_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPosition_list(s) + } +} + +func (s *Position_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPosition_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Position_list() (localctx IPosition_listContext) { + localctx = NewPosition_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1850, RedshiftParserRULE_position_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13912) + p.b_expr(0) + } + { + p.SetState(13913) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13914) + p.b_expr(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubstr_listContext is an interface to support dynamic dispatch. +type ISubstr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + FROM() antlr.TerminalNode + FOR() antlr.TerminalNode + SIMILAR() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsSubstr_listContext differentiates from other interfaces. + IsSubstr_listContext() +} + +type Substr_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubstr_listContext() *Substr_listContext { + var p = new(Substr_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_substr_list + return p +} + +func InitEmptySubstr_listContext(p *Substr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_substr_list +} + +func (*Substr_listContext) IsSubstr_listContext() {} + +func NewSubstr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Substr_listContext { + var p = new(Substr_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_substr_list + + return p +} + +func (s *Substr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Substr_listContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Substr_listContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Substr_listContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Substr_listContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Substr_listContext) SIMILAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIMILAR, 0) +} + +func (s *Substr_listContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserESCAPE, 0) +} + +func (s *Substr_listContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Substr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Substr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Substr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSubstr_list(s) + } +} + +func (s *Substr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSubstr_list(s) + } +} + +func (s *Substr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSubstr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Substr_list() (localctx ISubstr_listContext) { + localctx = NewSubstr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1852, RedshiftParserRULE_substr_list) + p.SetState(13943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1348, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13916) + p.A_expr() + } + { + p.SetState(13917) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13918) + p.A_expr() + } + { + p.SetState(13919) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13920) + p.A_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13922) + p.A_expr() + } + { + p.SetState(13923) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13924) + p.A_expr() + } + { + p.SetState(13925) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13926) + p.A_expr() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13928) + p.A_expr() + } + { + p.SetState(13929) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13930) + p.A_expr() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13932) + p.A_expr() + } + { + p.SetState(13933) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13934) + p.A_expr() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13936) + p.A_expr() + } + { + p.SetState(13937) + p.Match(RedshiftParserSIMILAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13938) + p.A_expr() + } + { + p.SetState(13939) + p.Match(RedshiftParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13940) + p.A_expr() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13942) + p.Expr_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrim_listContext is an interface to support dynamic dispatch. +type ITrim_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + FROM() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsTrim_listContext differentiates from other interfaces. + IsTrim_listContext() +} + +type Trim_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrim_listContext() *Trim_listContext { + var p = new(Trim_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_trim_list + return p +} + +func InitEmptyTrim_listContext(p *Trim_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_trim_list +} + +func (*Trim_listContext) IsTrim_listContext() {} + +func NewTrim_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trim_listContext { + var p = new(Trim_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_trim_list + + return p +} + +func (s *Trim_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trim_listContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Trim_listContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Trim_listContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Trim_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trim_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trim_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTrim_list(s) + } +} + +func (s *Trim_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTrim_list(s) + } +} + +func (s *Trim_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTrim_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Trim_list() (localctx ITrim_listContext) { + localctx = NewTrim_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1854, RedshiftParserRULE_trim_list) + p.SetState(13952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1349, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13945) + p.A_expr() + } + { + p.SetState(13946) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13947) + p.Expr_list() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13949) + p.Match(RedshiftParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13950) + p.Expr_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13951) + p.Expr_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIn_exprContext is an interface to support dynamic dispatch. +type IIn_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsIn_exprContext differentiates from other interfaces. + IsIn_exprContext() +} + +type In_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_exprContext() *In_exprContext { + var p = new(In_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_in_expr + return p +} + +func InitEmptyIn_exprContext(p *In_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_in_expr +} + +func (*In_exprContext) IsIn_exprContext() {} + +func NewIn_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_exprContext { + var p = new(In_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_in_expr + + return p +} + +func (s *In_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *In_exprContext) CopyAll(ctx *In_exprContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *In_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type In_expr_listContext struct { + In_exprContext +} + +func NewIn_expr_listContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *In_expr_listContext { + var p = new(In_expr_listContext) + + InitEmptyIn_exprContext(&p.In_exprContext) + p.parser = parser + p.CopyAll(ctx.(*In_exprContext)) + + return p +} + +func (s *In_expr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_expr_listContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *In_expr_listContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *In_expr_listContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *In_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIn_expr_list(s) + } +} + +func (s *In_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIn_expr_list(s) + } +} + +func (s *In_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIn_expr_list(s) + + default: + return t.VisitChildren(s) + } +} + +type In_expr_selectContext struct { + In_exprContext +} + +func NewIn_expr_selectContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *In_expr_selectContext { + var p = new(In_expr_selectContext) + + InitEmptyIn_exprContext(&p.In_exprContext) + p.parser = parser + p.CopyAll(ctx.(*In_exprContext)) + + return p +} + +func (s *In_expr_selectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_expr_selectContext) Select_with_parens() ISelect_with_parensContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_with_parensContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_with_parensContext) +} + +func (s *In_expr_selectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIn_expr_select(s) + } +} + +func (s *In_expr_selectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIn_expr_select(s) + } +} + +func (s *In_expr_selectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIn_expr_select(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) In_expr() (localctx IIn_exprContext) { + localctx = NewIn_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1856, RedshiftParserRULE_in_expr) + p.SetState(13959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1350, p.GetParserRuleContext()) { + case 1: + localctx = NewIn_expr_selectContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13954) + p.Select_with_parens() + } + + case 2: + localctx = NewIn_expr_listContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13955) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13956) + p.Expr_list() + } + { + p.SetState(13957) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_exprContext is an interface to support dynamic dispatch. +type ICase_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CASE() antlr.TerminalNode + When_clause_list() IWhen_clause_listContext + END_P() antlr.TerminalNode + Case_arg() ICase_argContext + Case_default() ICase_defaultContext + + // IsCase_exprContext differentiates from other interfaces. + IsCase_exprContext() +} + +type Case_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_exprContext() *Case_exprContext { + var p = new(Case_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_expr + return p +} + +func InitEmptyCase_exprContext(p *Case_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_expr +} + +func (*Case_exprContext) IsCase_exprContext() {} + +func NewCase_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_exprContext { + var p = new(Case_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_case_expr + + return p +} + +func (s *Case_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_exprContext) CASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE, 0) +} + +func (s *Case_exprContext) When_clause_list() IWhen_clause_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhen_clause_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhen_clause_listContext) +} + +func (s *Case_exprContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *Case_exprContext) Case_arg() ICase_argContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_argContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_argContext) +} + +func (s *Case_exprContext) Case_default() ICase_defaultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_defaultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_defaultContext) +} + +func (s *Case_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCase_expr(s) + } +} + +func (s *Case_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCase_expr(s) + } +} + +func (s *Case_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCase_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Case_expr() (localctx ICase_exprContext) { + localctx = NewCase_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1858, RedshiftParserRULE_case_expr) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13961) + p.Match(RedshiftParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(13962) + p.Case_arg() + } + + } + { + p.SetState(13965) + p.When_clause_list() + } + p.SetState(13967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserELSE { + { + p.SetState(13966) + p.Case_default() + } + + } + { + p.SetState(13969) + p.Match(RedshiftParserEND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhen_clause_listContext is an interface to support dynamic dispatch. +type IWhen_clause_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWhen_clause() []IWhen_clauseContext + When_clause(i int) IWhen_clauseContext + + // IsWhen_clause_listContext differentiates from other interfaces. + IsWhen_clause_listContext() +} + +type When_clause_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhen_clause_listContext() *When_clause_listContext { + var p = new(When_clause_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_when_clause_list + return p +} + +func InitEmptyWhen_clause_listContext(p *When_clause_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_when_clause_list +} + +func (*When_clause_listContext) IsWhen_clause_listContext() {} + +func NewWhen_clause_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_clause_listContext { + var p = new(When_clause_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_when_clause_list + + return p +} + +func (s *When_clause_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *When_clause_listContext) AllWhen_clause() []IWhen_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWhen_clauseContext); ok { + len++ + } + } + + tst := make([]IWhen_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWhen_clauseContext); ok { + tst[i] = t.(IWhen_clauseContext) + i++ + } + } + + return tst +} + +func (s *When_clause_listContext) When_clause(i int) IWhen_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhen_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWhen_clauseContext) +} + +func (s *When_clause_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *When_clause_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *When_clause_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWhen_clause_list(s) + } +} + +func (s *When_clause_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWhen_clause_list(s) + } +} + +func (s *When_clause_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWhen_clause_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) When_clause_list() (localctx IWhen_clause_listContext) { + localctx = NewWhen_clause_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1860, RedshiftParserRULE_when_clause_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserWHEN { + { + p.SetState(13971) + p.When_clause() + } + + p.SetState(13974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWhen_clauseContext is an interface to support dynamic dispatch. +type IWhen_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + THEN() antlr.TerminalNode + + // IsWhen_clauseContext differentiates from other interfaces. + IsWhen_clauseContext() +} + +type When_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhen_clauseContext() *When_clauseContext { + var p = new(When_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_when_clause + return p +} + +func InitEmptyWhen_clauseContext(p *When_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_when_clause +} + +func (*When_clauseContext) IsWhen_clauseContext() {} + +func NewWhen_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *When_clauseContext { + var p = new(When_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_when_clause + + return p +} + +func (s *When_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *When_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *When_clauseContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *When_clauseContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *When_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *When_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *When_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *When_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterWhen_clause(s) + } +} + +func (s *When_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitWhen_clause(s) + } +} + +func (s *When_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitWhen_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) When_clause() (localctx IWhen_clauseContext) { + localctx = NewWhen_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1862, RedshiftParserRULE_when_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13976) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13977) + p.A_expr() + } + { + p.SetState(13978) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13979) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_defaultContext is an interface to support dynamic dispatch. +type ICase_defaultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + A_expr() IA_exprContext + + // IsCase_defaultContext differentiates from other interfaces. + IsCase_defaultContext() +} + +type Case_defaultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_defaultContext() *Case_defaultContext { + var p = new(Case_defaultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_default + return p +} + +func InitEmptyCase_defaultContext(p *Case_defaultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_default +} + +func (*Case_defaultContext) IsCase_defaultContext() {} + +func NewCase_defaultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_defaultContext { + var p = new(Case_defaultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_case_default + + return p +} + +func (s *Case_defaultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_defaultContext) ELSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserELSE, 0) +} + +func (s *Case_defaultContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Case_defaultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_defaultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_defaultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCase_default(s) + } +} + +func (s *Case_defaultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCase_default(s) + } +} + +func (s *Case_defaultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCase_default(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Case_default() (localctx ICase_defaultContext) { + localctx = NewCase_defaultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1864, RedshiftParserRULE_case_default) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13981) + p.Match(RedshiftParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13982) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_argContext is an interface to support dynamic dispatch. +type ICase_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + + // IsCase_argContext differentiates from other interfaces. + IsCase_argContext() +} + +type Case_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_argContext() *Case_argContext { + var p = new(Case_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_arg + return p +} + +func InitEmptyCase_argContext(p *Case_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_arg +} + +func (*Case_argContext) IsCase_argContext() {} + +func NewCase_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_argContext { + var p = new(Case_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_case_arg + + return p +} + +func (s *Case_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_argContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Case_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCase_arg(s) + } +} + +func (s *Case_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCase_arg(s) + } +} + +func (s *Case_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCase_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Case_arg() (localctx ICase_argContext) { + localctx = NewCase_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1866, RedshiftParserRULE_case_arg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13984) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumnrefContext is an interface to support dynamic dispatch. +type IColumnrefContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Indirection() IIndirectionContext + + // IsColumnrefContext differentiates from other interfaces. + IsColumnrefContext() +} + +type ColumnrefContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumnrefContext() *ColumnrefContext { + var p = new(ColumnrefContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnref + return p +} + +func InitEmptyColumnrefContext(p *ColumnrefContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_columnref +} + +func (*ColumnrefContext) IsColumnrefContext() {} + +func NewColumnrefContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColumnrefContext { + var p = new(ColumnrefContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_columnref + + return p +} + +func (s *ColumnrefContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColumnrefContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *ColumnrefContext) Indirection() IIndirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndirectionContext) +} + +func (s *ColumnrefContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColumnrefContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColumnrefContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColumnref(s) + } +} + +func (s *ColumnrefContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColumnref(s) + } +} + +func (s *ColumnrefContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColumnref(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Columnref() (localctx IColumnrefContext) { + localctx = NewColumnrefContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1868, RedshiftParserRULE_columnref) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13986) + p.Colid() + } + p.SetState(13988) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1354, p.GetParserRuleContext()) == 1 { + { + p.SetState(13987) + p.Indirection() + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndirection_elContext is an interface to support dynamic dispatch. +type IIndirection_elContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DOT() antlr.TerminalNode + Attr_name() IAttr_nameContext + STAR() antlr.TerminalNode + OPEN_BRACKET() antlr.TerminalNode + CLOSE_BRACKET() antlr.TerminalNode + A_expr() IA_exprContext + COLON() antlr.TerminalNode + AllOpt_slice_bound() []IOpt_slice_boundContext + Opt_slice_bound(i int) IOpt_slice_boundContext + + // IsIndirection_elContext differentiates from other interfaces. + IsIndirection_elContext() +} + +type Indirection_elContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndirection_elContext() *Indirection_elContext { + var p = new(Indirection_elContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_indirection_el + return p +} + +func InitEmptyIndirection_elContext(p *Indirection_elContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_indirection_el +} + +func (*Indirection_elContext) IsIndirection_elContext() {} + +func NewIndirection_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indirection_elContext { + var p = new(Indirection_elContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_indirection_el + + return p +} + +func (s *Indirection_elContext) GetParser() antlr.Parser { return s.parser } + +func (s *Indirection_elContext) DOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT, 0) +} + +func (s *Indirection_elContext) Attr_name() IAttr_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttr_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttr_nameContext) +} + +func (s *Indirection_elContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *Indirection_elContext) OPEN_BRACKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_BRACKET, 0) +} + +func (s *Indirection_elContext) CLOSE_BRACKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_BRACKET, 0) +} + +func (s *Indirection_elContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Indirection_elContext) COLON() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLON, 0) +} + +func (s *Indirection_elContext) AllOpt_slice_bound() []IOpt_slice_boundContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpt_slice_boundContext); ok { + len++ + } + } + + tst := make([]IOpt_slice_boundContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpt_slice_boundContext); ok { + tst[i] = t.(IOpt_slice_boundContext) + i++ + } + } + + return tst +} + +func (s *Indirection_elContext) Opt_slice_bound(i int) IOpt_slice_boundContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_slice_boundContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpt_slice_boundContext) +} + +func (s *Indirection_elContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Indirection_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Indirection_elContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndirection_el(s) + } +} + +func (s *Indirection_elContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndirection_el(s) + } +} + +func (s *Indirection_elContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndirection_el(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Indirection_el() (localctx IIndirection_elContext) { + localctx = NewIndirection_elContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1870, RedshiftParserRULE_indirection_el) + var _la int + + p.SetState(14007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserDOT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13990) + p.Match(RedshiftParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserALL, RedshiftParserANALYSE, RedshiftParserANALYZE, RedshiftParserAND, RedshiftParserANY, RedshiftParserARRAY, RedshiftParserAS, RedshiftParserASC, RedshiftParserASYMMETRIC, RedshiftParserBOTH, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCHECK, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCREATE, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDEFERRABLE, RedshiftParserDESC, RedshiftParserDISTINCT, RedshiftParserDO, RedshiftParserELSE, RedshiftParserEXCEPT, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserFOR, RedshiftParserFOREIGN, RedshiftParserFROM, RedshiftParserGRANT, RedshiftParserGROUP_P, RedshiftParserHAVING, RedshiftParserIN_P, RedshiftParserINITIALLY, RedshiftParserINTERSECT, RedshiftParserLATERAL_P, RedshiftParserLEADING, RedshiftParserLIMIT, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserON, RedshiftParserONLY, RedshiftParserOR, RedshiftParserORDER, RedshiftParserPLACING, RedshiftParserPRIMARY, RedshiftParserPUBLIC, RedshiftParserREFERENCES, RedshiftParserRETURNING, RedshiftParserSELECT, RedshiftParserSESSION_USER, RedshiftParserSOME, RedshiftParserSYMMETRIC, RedshiftParserTABLE, RedshiftParserTHEN, RedshiftParserTO, RedshiftParserTRAILING, RedshiftParserTRUE_P, RedshiftParserUNION, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserUSING, RedshiftParserVARIADIC, RedshiftParserWHEN, RedshiftParserWHERE, RedshiftParserWINDOW, RedshiftParserWITH, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserEND_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(13991) + p.Attr_name() + } + + case RedshiftParserSTAR: + { + p.SetState(13992) + p.Match(RedshiftParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case RedshiftParserOPEN_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13995) + p.Match(RedshiftParserOPEN_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1358, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13996) + p.A_expr() + } + + case 2: + p.SetState(13998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(13997) + p.Opt_slice_bound() + } + + } + { + p.SetState(14000) + p.Match(RedshiftParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(14001) + p.Opt_slice_bound() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(14006) + p.Match(RedshiftParserCLOSE_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_slice_boundContext is an interface to support dynamic dispatch. +type IOpt_slice_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + + // IsOpt_slice_boundContext differentiates from other interfaces. + IsOpt_slice_boundContext() +} + +type Opt_slice_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_slice_boundContext() *Opt_slice_boundContext { + var p = new(Opt_slice_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_slice_bound + return p +} + +func InitEmptyOpt_slice_boundContext(p *Opt_slice_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_slice_bound +} + +func (*Opt_slice_boundContext) IsOpt_slice_boundContext() {} + +func NewOpt_slice_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_slice_boundContext { + var p = new(Opt_slice_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_slice_bound + + return p +} + +func (s *Opt_slice_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_slice_boundContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_slice_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_slice_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_slice_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_slice_bound(s) + } +} + +func (s *Opt_slice_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_slice_bound(s) + } +} + +func (s *Opt_slice_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_slice_bound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_slice_bound() (localctx IOpt_slice_boundContext) { + localctx = NewOpt_slice_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1872, RedshiftParserRULE_opt_slice_bound) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14009) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndirectionContext is an interface to support dynamic dispatch. +type IIndirectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIndirection_el() []IIndirection_elContext + Indirection_el(i int) IIndirection_elContext + + // IsIndirectionContext differentiates from other interfaces. + IsIndirectionContext() +} + +type IndirectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndirectionContext() *IndirectionContext { + var p = new(IndirectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_indirection + return p +} + +func InitEmptyIndirectionContext(p *IndirectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_indirection +} + +func (*IndirectionContext) IsIndirectionContext() {} + +func NewIndirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndirectionContext { + var p = new(IndirectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_indirection + + return p +} + +func (s *IndirectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndirectionContext) AllIndirection_el() []IIndirection_elContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndirection_elContext); ok { + len++ + } + } + + tst := make([]IIndirection_elContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndirection_elContext); ok { + tst[i] = t.(IIndirection_elContext) + i++ + } + } + + return tst +} + +func (s *IndirectionContext) Indirection_el(i int) IIndirection_elContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirection_elContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndirection_elContext) +} + +func (s *IndirectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndirectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIndirection(s) + } +} + +func (s *IndirectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIndirection(s) + } +} + +func (s *IndirectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIndirection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Indirection() (localctx IIndirectionContext) { + localctx = NewIndirectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1874, RedshiftParserRULE_indirection) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14012) + 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(14011) + p.Indirection_el() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14014) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1360, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_indirectionContext is an interface to support dynamic dispatch. +type IOpt_indirectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIndirection_el() []IIndirection_elContext + Indirection_el(i int) IIndirection_elContext + + // IsOpt_indirectionContext differentiates from other interfaces. + IsOpt_indirectionContext() +} + +type Opt_indirectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_indirectionContext() *Opt_indirectionContext { + var p = new(Opt_indirectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_indirection + return p +} + +func InitEmptyOpt_indirectionContext(p *Opt_indirectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_indirection +} + +func (*Opt_indirectionContext) IsOpt_indirectionContext() {} + +func NewOpt_indirectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_indirectionContext { + var p = new(Opt_indirectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_indirection + + return p +} + +func (s *Opt_indirectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_indirectionContext) AllIndirection_el() []IIndirection_elContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndirection_elContext); ok { + len++ + } + } + + tst := make([]IIndirection_elContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndirection_elContext); ok { + tst[i] = t.(IIndirection_elContext) + i++ + } + } + + return tst +} + +func (s *Opt_indirectionContext) Indirection_el(i int) IIndirection_elContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirection_elContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndirection_elContext) +} + +func (s *Opt_indirectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_indirectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_indirectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_indirection(s) + } +} + +func (s *Opt_indirectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_indirection(s) + } +} + +func (s *Opt_indirectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_indirection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_indirection() (localctx IOpt_indirectionContext) { + localctx = NewOpt_indirectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1876, RedshiftParserRULE_opt_indirection) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1361, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14016) + p.Indirection_el() + } + + } + p.SetState(14021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1361, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_target_listContext is an interface to support dynamic dispatch. +type IOpt_target_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Target_list() ITarget_listContext + + // IsOpt_target_listContext differentiates from other interfaces. + IsOpt_target_listContext() +} + +type Opt_target_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_target_listContext() *Opt_target_listContext { + var p = new(Opt_target_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_target_list + return p +} + +func InitEmptyOpt_target_listContext(p *Opt_target_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_target_list +} + +func (*Opt_target_listContext) IsOpt_target_listContext() {} + +func NewOpt_target_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_target_listContext { + var p = new(Opt_target_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_target_list + + return p +} + +func (s *Opt_target_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_target_listContext) Target_list() ITarget_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITarget_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITarget_listContext) +} + +func (s *Opt_target_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_target_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_target_list(s) + } +} + +func (s *Opt_target_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_target_list(s) + } +} + +func (s *Opt_target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_target_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_target_list() (localctx IOpt_target_listContext) { + localctx = NewOpt_target_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1878, RedshiftParserRULE_opt_target_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14022) + p.Target_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 +} + +// ITarget_listContext is an interface to support dynamic dispatch. +type ITarget_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTarget_el() []ITarget_elContext + Target_el(i int) ITarget_elContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTarget_listContext differentiates from other interfaces. + IsTarget_listContext() +} + +type Target_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTarget_listContext() *Target_listContext { + var p = new(Target_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_target_list + return p +} + +func InitEmptyTarget_listContext(p *Target_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_target_list +} + +func (*Target_listContext) IsTarget_listContext() {} + +func NewTarget_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_listContext { + var p = new(Target_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_target_list + + return p +} + +func (s *Target_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Target_listContext) AllTarget_el() []ITarget_elContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITarget_elContext); ok { + len++ + } + } + + tst := make([]ITarget_elContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITarget_elContext); ok { + tst[i] = t.(ITarget_elContext) + i++ + } + } + + return tst +} + +func (s *Target_listContext) Target_el(i int) ITarget_elContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITarget_elContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITarget_elContext) +} + +func (s *Target_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Target_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Target_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Target_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Target_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTarget_list(s) + } +} + +func (s *Target_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTarget_list(s) + } +} + +func (s *Target_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTarget_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Target_list() (localctx ITarget_listContext) { + localctx = NewTarget_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1880, RedshiftParserRULE_target_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14024) + p.Target_el() + } + p.SetState(14029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1362, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14025) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14026) + p.Target_el() + } + + } + p.SetState(14031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1362, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITarget_elContext is an interface to support dynamic dispatch. +type ITarget_elContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsTarget_elContext differentiates from other interfaces. + IsTarget_elContext() +} + +type Target_elContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTarget_elContext() *Target_elContext { + var p = new(Target_elContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_target_el + return p +} + +func InitEmptyTarget_elContext(p *Target_elContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_target_el +} + +func (*Target_elContext) IsTarget_elContext() {} + +func NewTarget_elContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_elContext { + var p = new(Target_elContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_target_el + + return p +} + +func (s *Target_elContext) GetParser() antlr.Parser { return s.parser } + +func (s *Target_elContext) CopyAll(ctx *Target_elContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *Target_elContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Target_elContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type Target_labelContext struct { + Target_elContext +} + +func NewTarget_labelContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Target_labelContext { + var p = new(Target_labelContext) + + InitEmptyTarget_elContext(&p.Target_elContext) + p.parser = parser + p.CopyAll(ctx.(*Target_elContext)) + + return p +} + +func (s *Target_labelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Target_labelContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Target_labelContext) Target_alias() ITarget_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITarget_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITarget_aliasContext) +} + +func (s *Target_labelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTarget_label(s) + } +} + +func (s *Target_labelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTarget_label(s) + } +} + +func (s *Target_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTarget_label(s) + + default: + return t.VisitChildren(s) + } +} + +type Target_starContext struct { + Target_elContext +} + +func NewTarget_starContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Target_starContext { + var p = new(Target_starContext) + + InitEmptyTarget_elContext(&p.Target_elContext) + p.parser = parser + p.CopyAll(ctx.(*Target_elContext)) + + return p +} + +func (s *Target_starContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Target_starContext) STAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTAR, 0) +} + +func (s *Target_starContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTarget_star(s) + } +} + +func (s *Target_starContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTarget_star(s) + } +} + +func (s *Target_starContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTarget_star(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Target_el() (localctx ITarget_elContext) { + localctx = NewTarget_elContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1882, RedshiftParserRULE_target_el) + p.SetState(14037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserPLUS, RedshiftParserMINUS, RedshiftParserPARAM, RedshiftParserOperator, RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCASE, RedshiftParserCAST, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_CATALOG, RedshiftParserCURRENT_DATE, RedshiftParserCURRENT_ROLE, RedshiftParserCURRENT_TIME, RedshiftParserCURRENT_TIMESTAMP, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFALSE_P, RedshiftParserFETCH, RedshiftParserLOCALTIME, RedshiftParserLOCALTIMESTAMP, RedshiftParserNOT, RedshiftParserNULL_P, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserSESSION_USER, RedshiftParserTABLE, RedshiftParserTRUE_P, RedshiftParserUNIQUE, RedshiftParserUSER, RedshiftParserAUTHORIZATION, RedshiftParserBINARY, RedshiftParserCOLLATION, RedshiftParserCONCURRENTLY, RedshiftParserCROSS, RedshiftParserCURRENT_SCHEMA, RedshiftParserFREEZE, RedshiftParserFULL, RedshiftParserILIKE, RedshiftParserINNER_P, RedshiftParserIS, RedshiftParserISNULL, RedshiftParserJOIN, RedshiftParserLEFT, RedshiftParserLIKE, RedshiftParserNATURAL, RedshiftParserNOTNULL, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserOVERLAPS, RedshiftParserRIGHT, RedshiftParserSIMILAR, RedshiftParserVERBOSE, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserTABLESAMPLE, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserBinaryStringConstant, RedshiftParserHexadecimalStringConstant, RedshiftParserIntegral, RedshiftParserNumeric, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER, RedshiftParserEscapeStringConstant: + localctx = NewTarget_labelContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14032) + p.A_expr() + } + p.SetState(14034) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1363, p.GetParserRuleContext()) == 1 { + { + p.SetState(14033) + p.Target_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserSTAR: + localctx = NewTarget_starContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14036) + p.Match(RedshiftParserSTAR) + 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 +} + +// ITarget_aliasContext is an interface to support dynamic dispatch. +type ITarget_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + Collabel() ICollabelContext + Identifier() IIdentifierContext + + // IsTarget_aliasContext differentiates from other interfaces. + IsTarget_aliasContext() +} + +type Target_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTarget_aliasContext() *Target_aliasContext { + var p = new(Target_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_target_alias + return p +} + +func InitEmptyTarget_aliasContext(p *Target_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_target_alias +} + +func (*Target_aliasContext) IsTarget_aliasContext() {} + +func NewTarget_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Target_aliasContext { + var p = new(Target_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_target_alias + + return p +} + +func (s *Target_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Target_aliasContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Target_aliasContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Target_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 *Target_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Target_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Target_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTarget_alias(s) + } +} + +func (s *Target_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTarget_alias(s) + } +} + +func (s *Target_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTarget_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Target_alias() (localctx ITarget_aliasContext) { + localctx = NewTarget_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1884, RedshiftParserRULE_target_alias) + p.SetState(14042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14039) + p.Match(RedshiftParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14040) + p.Collabel() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserOUTER_P, RedshiftParserABSOLUTE_P, RedshiftParserBACKWARD, RedshiftParserCHAIN, RedshiftParserCLOSE, RedshiftParserCOMMIT, RedshiftParserCONTINUE_P, RedshiftParserCURSOR, RedshiftParserFIRST_P, RedshiftParserFORWARD, RedshiftParserINSERT, RedshiftParserLAST_P, RedshiftParserMOVE, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserOPTION, RedshiftParserPRIOR, RedshiftParserRELATIVE_P, RedshiftParserRESET, RedshiftParserROLLBACK, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSET, RedshiftParserTYPE_P, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserROWTYPE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14041) + 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 +} + +// IQualified_name_listContext is an interface to support dynamic dispatch. +type IQualified_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllQualified_name() []IQualified_nameContext + Qualified_name(i int) IQualified_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsQualified_name_listContext differentiates from other interfaces. + IsQualified_name_listContext() +} + +type Qualified_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualified_name_listContext() *Qualified_name_listContext { + var p = new(Qualified_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qualified_name_list + return p +} + +func InitEmptyQualified_name_listContext(p *Qualified_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qualified_name_list +} + +func (*Qualified_name_listContext) IsQualified_name_listContext() {} + +func NewQualified_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_name_listContext { + var p = new(Qualified_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_qualified_name_list + + return p +} + +func (s *Qualified_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualified_name_listContext) AllQualified_name() []IQualified_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_nameContext); ok { + len++ + } + } + + tst := make([]IQualified_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_nameContext); ok { + tst[i] = t.(IQualified_nameContext) + i++ + } + } + + return tst +} + +func (s *Qualified_name_listContext) Qualified_name(i int) IQualified_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_nameContext) +} + +func (s *Qualified_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Qualified_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Qualified_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualified_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualified_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterQualified_name_list(s) + } +} + +func (s *Qualified_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitQualified_name_list(s) + } +} + +func (s *Qualified_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitQualified_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Qualified_name_list() (localctx IQualified_name_listContext) { + localctx = NewQualified_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1886, RedshiftParserRULE_qualified_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14044) + p.Qualified_name() + } + p.SetState(14049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14045) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14046) + p.Qualified_name() + } + + p.SetState(14051) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualified_nameContext is an interface to support dynamic dispatch. +type IQualified_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Indirection() IIndirectionContext + + // IsQualified_nameContext differentiates from other interfaces. + IsQualified_nameContext() +} + +type Qualified_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualified_nameContext() *Qualified_nameContext { + var p = new(Qualified_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qualified_name + return p +} + +func InitEmptyQualified_nameContext(p *Qualified_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_qualified_name +} + +func (*Qualified_nameContext) IsQualified_nameContext() {} + +func NewQualified_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_nameContext { + var p = new(Qualified_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_qualified_name + + return p +} + +func (s *Qualified_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualified_nameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Qualified_nameContext) Indirection() IIndirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndirectionContext) +} + +func (s *Qualified_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualified_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualified_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterQualified_name(s) + } +} + +func (s *Qualified_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitQualified_name(s) + } +} + +func (s *Qualified_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitQualified_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Qualified_name() (localctx IQualified_nameContext) { + localctx = NewQualified_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1888, RedshiftParserRULE_qualified_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14052) + p.Colid() + } + p.SetState(14054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_BRACKET || _la == RedshiftParserDOT { + { + p.SetState(14053) + p.Indirection() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IName_listContext is an interface to support dynamic dispatch. +type IName_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllName() []INameContext + Name(i int) INameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsName_listContext differentiates from other interfaces. + IsName_listContext() +} + +type Name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyName_listContext() *Name_listContext { + var p = new(Name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_name_list + return p +} + +func InitEmptyName_listContext(p *Name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_name_list +} + +func (*Name_listContext) IsName_listContext() {} + +func NewName_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Name_listContext { + var p = new(Name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_name_list + + return p +} + +func (s *Name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Name_listContext) AllName() []INameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INameContext); ok { + len++ + } + } + + tst := make([]INameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INameContext); ok { + tst[i] = t.(INameContext) + i++ + } + } + + return tst +} + +func (s *Name_listContext) Name(i int) INameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INameContext) +} + +func (s *Name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterName_list(s) + } +} + +func (s *Name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitName_list(s) + } +} + +func (s *Name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitName_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Name_list() (localctx IName_listContext) { + localctx = NewName_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1890, RedshiftParserRULE_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14056) + p.Name() + } + p.SetState(14061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14057) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14058) + p.Name() + } + + p.SetState(14063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INameContext is an interface to support dynamic dispatch. +type INameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + + // IsNameContext differentiates from other interfaces. + IsNameContext() +} + +type NameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNameContext() *NameContext { + var p = new(NameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_name + return p +} + +func InitEmptyNameContext(p *NameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_name +} + +func (*NameContext) IsNameContext() {} + +func NewNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NameContext { + var p = new(NameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_name + + return p +} + +func (s *NameContext) GetParser() antlr.Parser { return s.parser } + +func (s *NameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *NameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterName(s) + } +} + +func (s *NameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitName(s) + } +} + +func (s *NameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitName(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Name() (localctx INameContext) { + localctx = NewNameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1892, RedshiftParserRULE_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14064) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttr_nameContext is an interface to support dynamic dispatch. +type IAttr_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Collabel() ICollabelContext + + // IsAttr_nameContext differentiates from other interfaces. + IsAttr_nameContext() +} + +type Attr_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttr_nameContext() *Attr_nameContext { + var p = new(Attr_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attr_name + return p +} + +func InitEmptyAttr_nameContext(p *Attr_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_attr_name +} + +func (*Attr_nameContext) IsAttr_nameContext() {} + +func NewAttr_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attr_nameContext { + var p = new(Attr_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_attr_name + + return p +} + +func (s *Attr_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attr_nameContext) Collabel() ICollabelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollabelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollabelContext) +} + +func (s *Attr_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attr_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attr_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAttr_name(s) + } +} + +func (s *Attr_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAttr_name(s) + } +} + +func (s *Attr_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAttr_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Attr_name() (localctx IAttr_nameContext) { + localctx = NewAttr_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1894, RedshiftParserRULE_attr_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14066) + p.Collabel() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFile_nameContext is an interface to support dynamic dispatch. +type IFile_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + + // IsFile_nameContext differentiates from other interfaces. + IsFile_nameContext() +} + +type File_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_nameContext() *File_nameContext { + var p = new(File_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_file_name + return p +} + +func InitEmptyFile_nameContext(p *File_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_file_name +} + +func (*File_nameContext) IsFile_nameContext() {} + +func NewFile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_nameContext { + var p = new(File_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_file_name + + return p +} + +func (s *File_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_nameContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *File_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFile_name(s) + } +} + +func (s *File_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFile_name(s) + } +} + +func (s *File_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFile_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) File_name() (localctx IFile_nameContext) { + localctx = NewFile_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1896, RedshiftParserRULE_file_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14068) + p.Sconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_nameContext is an interface to support dynamic dispatch. +type IFunc_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Builtin_function_name() IBuiltin_function_nameContext + Type_function_name() IType_function_nameContext + Colid() IColidContext + Indirection() IIndirectionContext + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + + // IsFunc_nameContext differentiates from other interfaces. + IsFunc_nameContext() +} + +type Func_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_nameContext() *Func_nameContext { + var p = new(Func_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_name + return p +} + +func InitEmptyFunc_nameContext(p *Func_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_func_name +} + +func (*Func_nameContext) IsFunc_nameContext() {} + +func NewFunc_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_nameContext { + var p = new(Func_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_func_name + + return p +} + +func (s *Func_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_nameContext) Builtin_function_name() IBuiltin_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuiltin_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuiltin_function_nameContext) +} + +func (s *Func_nameContext) Type_function_name() IType_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_nameContext) +} + +func (s *Func_nameContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Func_nameContext) Indirection() IIndirectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndirectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndirectionContext) +} + +func (s *Func_nameContext) LEFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEFT, 0) +} + +func (s *Func_nameContext) RIGHT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRIGHT, 0) +} + +func (s *Func_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFunc_name(s) + } +} + +func (s *Func_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFunc_name(s) + } +} + +func (s *Func_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFunc_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Func_name() (localctx IFunc_nameContext) { + localctx = NewFunc_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1898, RedshiftParserRULE_func_name) + p.SetState(14077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1369, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14070) + p.Builtin_function_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14071) + p.Type_function_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14072) + p.Colid() + } + { + p.SetState(14073) + p.Indirection() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14075) + p.Match(RedshiftParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14076) + p.Match(RedshiftParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAexprconstContext is an interface to support dynamic dispatch. +type IAexprconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Iconst() IIconstContext + Fconst() IFconstContext + Sconst() ISconstContext + Bconst() IBconstContext + Xconst() IXconstContext + Func_name() IFunc_nameContext + OPEN_PAREN() antlr.TerminalNode + Func_arg_list() IFunc_arg_listContext + CLOSE_PAREN() antlr.TerminalNode + Opt_sort_clause() IOpt_sort_clauseContext + Consttypename() IConsttypenameContext + Constinterval() IConstintervalContext + Opt_interval() IOpt_intervalContext + TRUE_P() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + NULL_P() antlr.TerminalNode + + // IsAexprconstContext differentiates from other interfaces. + IsAexprconstContext() +} + +type AexprconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAexprconstContext() *AexprconstContext { + var p = new(AexprconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aexprconst + return p +} + +func InitEmptyAexprconstContext(p *AexprconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_aexprconst +} + +func (*AexprconstContext) IsAexprconstContext() {} + +func NewAexprconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AexprconstContext { + var p = new(AexprconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_aexprconst + + return p +} + +func (s *AexprconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *AexprconstContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *AexprconstContext) Fconst() IFconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFconstContext) +} + +func (s *AexprconstContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *AexprconstContext) Bconst() IBconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBconstContext) +} + +func (s *AexprconstContext) Xconst() IXconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXconstContext) +} + +func (s *AexprconstContext) Func_name() IFunc_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_nameContext) +} + +func (s *AexprconstContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *AexprconstContext) Func_arg_list() IFunc_arg_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_arg_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_arg_listContext) +} + +func (s *AexprconstContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *AexprconstContext) Opt_sort_clause() IOpt_sort_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_sort_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_sort_clauseContext) +} + +func (s *AexprconstContext) Consttypename() IConsttypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConsttypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConsttypenameContext) +} + +func (s *AexprconstContext) Constinterval() IConstintervalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstintervalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstintervalContext) +} + +func (s *AexprconstContext) Opt_interval() IOpt_intervalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_intervalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_intervalContext) +} + +func (s *AexprconstContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *AexprconstContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *AexprconstContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *AexprconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AexprconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AexprconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAexprconst(s) + } +} + +func (s *AexprconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAexprconst(s) + } +} + +func (s *AexprconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAexprconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Aexprconst() (localctx IAexprconstContext) { + localctx = NewAexprconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1900, RedshiftParserRULE_aexprconst) + var _la int + + p.SetState(14114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1374, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14079) + p.Iconst() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14080) + p.Fconst() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14081) + p.Sconst() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14082) + p.Bconst() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14083) + p.Xconst() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14084) + p.Func_name() + } + p.SetState(14094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(14085) + p.Sconst() + } + + case RedshiftParserOPEN_PAREN: + { + p.SetState(14086) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14087) + p.Func_arg_list() + } + p.SetState(14089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserORDER { + { + p.SetState(14088) + p.Opt_sort_clause() + } + + } + { + p.SetState(14091) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14092) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14096) + p.Consttypename() + } + { + p.SetState(14097) + p.Sconst() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14099) + p.Constinterval() + } + p.SetState(14109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant, RedshiftParserUnicodeEscapeStringConstant, RedshiftParserBeginDollarStringConstant, RedshiftParserEscapeStringConstant: + { + p.SetState(14100) + p.Sconst() + } + p.SetState(14102) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1372, p.GetParserRuleContext()) == 1 { + { + p.SetState(14101) + p.Opt_interval() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserOPEN_PAREN: + { + p.SetState(14104) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14105) + p.Iconst() + } + { + p.SetState(14106) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14107) + p.Sconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14111) + p.Match(RedshiftParserTRUE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(14112) + p.Match(RedshiftParserFALSE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(14113) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXconstContext is an interface to support dynamic dispatch. +type IXconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HexadecimalStringConstant() antlr.TerminalNode + + // IsXconstContext differentiates from other interfaces. + IsXconstContext() +} + +type XconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXconstContext() *XconstContext { + var p = new(XconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xconst + return p +} + +func InitEmptyXconstContext(p *XconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_xconst +} + +func (*XconstContext) IsXconstContext() {} + +func NewXconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XconstContext { + var p = new(XconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_xconst + + return p +} + +func (s *XconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *XconstContext) HexadecimalStringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserHexadecimalStringConstant, 0) +} + +func (s *XconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterXconst(s) + } +} + +func (s *XconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitXconst(s) + } +} + +func (s *XconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitXconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Xconst() (localctx IXconstContext) { + localctx = NewXconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1902, RedshiftParserRULE_xconst) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14116) + p.Match(RedshiftParserHexadecimalStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBconstContext is an interface to support dynamic dispatch. +type IBconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BinaryStringConstant() antlr.TerminalNode + + // IsBconstContext differentiates from other interfaces. + IsBconstContext() +} + +type BconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBconstContext() *BconstContext { + var p = new(BconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bconst + return p +} + +func InitEmptyBconstContext(p *BconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_bconst +} + +func (*BconstContext) IsBconstContext() {} + +func NewBconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BconstContext { + var p = new(BconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_bconst + + return p +} + +func (s *BconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *BconstContext) BinaryStringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserBinaryStringConstant, 0) +} + +func (s *BconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterBconst(s) + } +} + +func (s *BconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitBconst(s) + } +} + +func (s *BconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitBconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Bconst() (localctx IBconstContext) { + localctx = NewBconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1904, RedshiftParserRULE_bconst) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14118) + p.Match(RedshiftParserBinaryStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFconstContext is an interface to support dynamic dispatch. +type IFconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric() antlr.TerminalNode + + // IsFconstContext differentiates from other interfaces. + IsFconstContext() +} + +type FconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFconstContext() *FconstContext { + var p = new(FconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fconst + return p +} + +func InitEmptyFconstContext(p *FconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_fconst +} + +func (*FconstContext) IsFconstContext() {} + +func NewFconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FconstContext { + var p = new(FconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_fconst + + return p +} + +func (s *FconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *FconstContext) Numeric() antlr.TerminalNode { + return s.GetToken(RedshiftParserNumeric, 0) +} + +func (s *FconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFconst(s) + } +} + +func (s *FconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFconst(s) + } +} + +func (s *FconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Fconst() (localctx IFconstContext) { + localctx = NewFconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1906, RedshiftParserRULE_fconst) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14120) + p.Match(RedshiftParserNumeric) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIconstContext is an interface to support dynamic dispatch. +type IIconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Integral() antlr.TerminalNode + + // IsIconstContext differentiates from other interfaces. + IsIconstContext() +} + +type IconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIconstContext() *IconstContext { + var p = new(IconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iconst + return p +} + +func InitEmptyIconstContext(p *IconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_iconst +} + +func (*IconstContext) IsIconstContext() {} + +func NewIconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IconstContext { + var p = new(IconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_iconst + + return p +} + +func (s *IconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *IconstContext) Integral() antlr.TerminalNode { + return s.GetToken(RedshiftParserIntegral, 0) +} + +func (s *IconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIconst(s) + } +} + +func (s *IconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIconst(s) + } +} + +func (s *IconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Iconst() (localctx IIconstContext) { + localctx = NewIconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1908, RedshiftParserRULE_iconst) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14122) + p.Match(RedshiftParserIntegral) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISconstContext is an interface to support dynamic dispatch. +type ISconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Anysconst() IAnysconstContext + Opt_uescape() IOpt_uescapeContext + + // IsSconstContext differentiates from other interfaces. + IsSconstContext() +} + +type SconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySconstContext() *SconstContext { + var p = new(SconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sconst + return p +} + +func InitEmptySconstContext(p *SconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sconst +} + +func (*SconstContext) IsSconstContext() {} + +func NewSconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SconstContext { + var p = new(SconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sconst + + return p +} + +func (s *SconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *SconstContext) Anysconst() IAnysconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnysconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnysconstContext) +} + +func (s *SconstContext) Opt_uescape() IOpt_uescapeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_uescapeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_uescapeContext) +} + +func (s *SconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSconst(s) + } +} + +func (s *SconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSconst(s) + } +} + +func (s *SconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sconst() (localctx ISconstContext) { + localctx = NewSconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1910, RedshiftParserRULE_sconst) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14124) + p.Anysconst() + } + p.SetState(14126) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1375, p.GetParserRuleContext()) == 1 { + { + p.SetState(14125) + p.Opt_uescape() + } + + } 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 +} + +// IAnysconstContext is an interface to support dynamic dispatch. +type IAnysconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + StringConstant() antlr.TerminalNode + UnicodeEscapeStringConstant() antlr.TerminalNode + BeginDollarStringConstant() antlr.TerminalNode + EndDollarStringConstant() antlr.TerminalNode + AllDollarText() []antlr.TerminalNode + DollarText(i int) antlr.TerminalNode + EscapeStringConstant() antlr.TerminalNode + + // IsAnysconstContext differentiates from other interfaces. + IsAnysconstContext() +} + +type AnysconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnysconstContext() *AnysconstContext { + var p = new(AnysconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_anysconst + return p +} + +func InitEmptyAnysconstContext(p *AnysconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_anysconst +} + +func (*AnysconstContext) IsAnysconstContext() {} + +func NewAnysconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnysconstContext { + var p = new(AnysconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_anysconst + + return p +} + +func (s *AnysconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnysconstContext) StringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserStringConstant, 0) +} + +func (s *AnysconstContext) UnicodeEscapeStringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserUnicodeEscapeStringConstant, 0) +} + +func (s *AnysconstContext) BeginDollarStringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserBeginDollarStringConstant, 0) +} + +func (s *AnysconstContext) EndDollarStringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserEndDollarStringConstant, 0) +} + +func (s *AnysconstContext) AllDollarText() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserDollarText) +} + +func (s *AnysconstContext) DollarText(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserDollarText, i) +} + +func (s *AnysconstContext) EscapeStringConstant() antlr.TerminalNode { + return s.GetToken(RedshiftParserEscapeStringConstant, 0) +} + +func (s *AnysconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnysconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnysconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAnysconst(s) + } +} + +func (s *AnysconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAnysconst(s) + } +} + +func (s *AnysconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAnysconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Anysconst() (localctx IAnysconstContext) { + localctx = NewAnysconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1912, RedshiftParserRULE_anysconst) + var _la int + + p.SetState(14139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserStringConstant: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14128) + p.Match(RedshiftParserStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUnicodeEscapeStringConstant: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14129) + p.Match(RedshiftParserUnicodeEscapeStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserBeginDollarStringConstant: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14130) + p.Match(RedshiftParserBeginDollarStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserDollarText { + { + p.SetState(14131) + p.Match(RedshiftParserDollarText) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(14136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14137) + p.Match(RedshiftParserEndDollarStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserEscapeStringConstant: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14138) + p.Match(RedshiftParserEscapeStringConstant) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_uescapeContext is an interface to support dynamic dispatch. +type IOpt_uescapeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UESCAPE() antlr.TerminalNode + Anysconst() IAnysconstContext + + // IsOpt_uescapeContext differentiates from other interfaces. + IsOpt_uescapeContext() +} + +type Opt_uescapeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_uescapeContext() *Opt_uescapeContext { + var p = new(Opt_uescapeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_uescape + return p +} + +func InitEmptyOpt_uescapeContext(p *Opt_uescapeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_uescape +} + +func (*Opt_uescapeContext) IsOpt_uescapeContext() {} + +func NewOpt_uescapeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_uescapeContext { + var p = new(Opt_uescapeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_uescape + + return p +} + +func (s *Opt_uescapeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_uescapeContext) UESCAPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUESCAPE, 0) +} + +func (s *Opt_uescapeContext) Anysconst() IAnysconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnysconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnysconstContext) +} + +func (s *Opt_uescapeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_uescapeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_uescapeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_uescape(s) + } +} + +func (s *Opt_uescapeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_uescape(s) + } +} + +func (s *Opt_uescapeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_uescape(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_uescape() (localctx IOpt_uescapeContext) { + localctx = NewOpt_uescapeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1914, RedshiftParserRULE_opt_uescape) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14141) + p.Match(RedshiftParserUESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14142) + p.Anysconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISignediconstContext is an interface to support dynamic dispatch. +type ISignediconstContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Iconst() IIconstContext + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + + // IsSignediconstContext differentiates from other interfaces. + IsSignediconstContext() +} + +type SignediconstContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySignediconstContext() *SignediconstContext { + var p = new(SignediconstContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_signediconst + return p +} + +func InitEmptySignediconstContext(p *SignediconstContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_signediconst +} + +func (*SignediconstContext) IsSignediconstContext() {} + +func NewSignediconstContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignediconstContext { + var p = new(SignediconstContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_signediconst + + return p +} + +func (s *SignediconstContext) GetParser() antlr.Parser { return s.parser } + +func (s *SignediconstContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *SignediconstContext) PLUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLUS, 0) +} + +func (s *SignediconstContext) MINUS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUS, 0) +} + +func (s *SignediconstContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SignediconstContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SignediconstContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSignediconst(s) + } +} + +func (s *SignediconstContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSignediconst(s) + } +} + +func (s *SignediconstContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSignediconst(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Signediconst() (localctx ISignediconstContext) { + localctx = NewSignediconstContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1916, RedshiftParserRULE_signediconst) + p.SetState(14149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIntegral: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14144) + p.Iconst() + } + + case RedshiftParserPLUS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14145) + p.Match(RedshiftParserPLUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14146) + p.Iconst() + } + + case RedshiftParserMINUS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14147) + p.Match(RedshiftParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14148) + p.Iconst() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoleidContext is an interface to support dynamic dispatch. +type IRoleidContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rolespec() IRolespecContext + + // IsRoleidContext differentiates from other interfaces. + IsRoleidContext() +} + +type RoleidContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoleidContext() *RoleidContext { + var p = new(RoleidContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_roleid + return p +} + +func InitEmptyRoleidContext(p *RoleidContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_roleid +} + +func (*RoleidContext) IsRoleidContext() {} + +func NewRoleidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RoleidContext { + var p = new(RoleidContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_roleid + + return p +} + +func (s *RoleidContext) GetParser() antlr.Parser { return s.parser } + +func (s *RoleidContext) Rolespec() IRolespecContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *RoleidContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RoleidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RoleidContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRoleid(s) + } +} + +func (s *RoleidContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRoleid(s) + } +} + +func (s *RoleidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRoleid(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Roleid() (localctx IRoleidContext) { + localctx = NewRoleidContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1918, RedshiftParserRULE_roleid) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14151) + p.Rolespec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRolespecContext is an interface to support dynamic dispatch. +type IRolespecContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Nonreservedword() INonreservedwordContext + NamespaceUser() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + SESSION_USER() antlr.TerminalNode + + // IsRolespecContext differentiates from other interfaces. + IsRolespecContext() +} + +type RolespecContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRolespecContext() *RolespecContext { + var p = new(RolespecContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rolespec + return p +} + +func InitEmptyRolespecContext(p *RolespecContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_rolespec +} + +func (*RolespecContext) IsRolespecContext() {} + +func NewRolespecContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RolespecContext { + var p = new(RolespecContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_rolespec + + return p +} + +func (s *RolespecContext) GetParser() antlr.Parser { return s.parser } + +func (s *RolespecContext) Nonreservedword() INonreservedwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INonreservedwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INonreservedwordContext) +} + +func (s *RolespecContext) NamespaceUser() antlr.TerminalNode { + return s.GetToken(RedshiftParserNamespaceUser, 0) +} + +func (s *RolespecContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_USER, 0) +} + +func (s *RolespecContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_USER, 0) +} + +func (s *RolespecContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RolespecContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RolespecContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRolespec(s) + } +} + +func (s *RolespecContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRolespec(s) + } +} + +func (s *RolespecContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRolespec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Rolespec() (localctx IRolespecContext) { + localctx = NewRolespecContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1920, RedshiftParserRULE_rolespec) + p.SetState(14157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1379, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14153) + p.Nonreservedword() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14154) + p.Match(RedshiftParserNamespaceUser) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14155) + p.Match(RedshiftParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14156) + p.Match(RedshiftParserSESSION_USER) + 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 +} + +// IRole_listContext is an interface to support dynamic dispatch. +type IRole_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRolespec() []IRolespecContext + Rolespec(i int) IRolespecContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRole_listContext differentiates from other interfaces. + IsRole_listContext() +} + +type Role_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_listContext() *Role_listContext { + var p = new(Role_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_role_list + return p +} + +func InitEmptyRole_listContext(p *Role_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_role_list +} + +func (*Role_listContext) IsRole_listContext() {} + +func NewRole_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_listContext { + var p = new(Role_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_role_list + + return p +} + +func (s *Role_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_listContext) AllRolespec() []IRolespecContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRolespecContext); ok { + len++ + } + } + + tst := make([]IRolespecContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRolespecContext); ok { + tst[i] = t.(IRolespecContext) + i++ + } + } + + return tst +} + +func (s *Role_listContext) Rolespec(i int) IRolespecContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRolespecContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRolespecContext) +} + +func (s *Role_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Role_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Role_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterRole_list(s) + } +} + +func (s *Role_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitRole_list(s) + } +} + +func (s *Role_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitRole_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Role_list() (localctx IRole_listContext) { + localctx = NewRole_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1922, RedshiftParserRULE_role_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14159) + p.Rolespec() + } + p.SetState(14164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1380, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14160) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14161) + p.Rolespec() + } + + } + p.SetState(14166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1380, 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 +} + +// IColidContext is an interface to support dynamic dispatch. +type IColidContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Unreserved_keyword() IUnreserved_keywordContext + Col_name_keyword() ICol_name_keywordContext + Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + + // IsColidContext differentiates from other interfaces. + IsColidContext() +} + +type ColidContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColidContext() *ColidContext { + var p = new(ColidContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colid + return p +} + +func InitEmptyColidContext(p *ColidContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_colid +} + +func (*ColidContext) IsColidContext() {} + +func NewColidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ColidContext { + var p = new(ColidContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_colid + + return p +} + +func (s *ColidContext) GetParser() antlr.Parser { return s.parser } + +func (s *ColidContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ColidContext) Unreserved_keyword() IUnreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnreserved_keywordContext) +} + +func (s *ColidContext) Col_name_keyword() ICol_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICol_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICol_name_keywordContext) +} + +func (s *ColidContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_unreserved_keywordContext) +} + +func (s *ColidContext) LEFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEFT, 0) +} + +func (s *ColidContext) RIGHT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRIGHT, 0) +} + +func (s *ColidContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ColidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ColidContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterColid(s) + } +} + +func (s *ColidContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitColid(s) + } +} + +func (s *ColidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitColid(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Colid() (localctx IColidContext) { + localctx = NewColidContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1924, RedshiftParserRULE_colid) + p.SetState(14173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1381, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14167) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14168) + p.Unreserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14169) + p.Col_name_keyword() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14170) + p.Plsql_unreserved_keyword() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14171) + p.Match(RedshiftParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14172) + p.Match(RedshiftParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_aliasContext is an interface to support dynamic dispatch. +type ITable_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Unreserved_keyword() IUnreserved_keywordContext + Col_name_keyword() ICol_name_keywordContext + Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext + + // IsTable_aliasContext differentiates from other interfaces. + IsTable_aliasContext() +} + +type Table_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_aliasContext() *Table_aliasContext { + var p = new(Table_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_table_alias + return p +} + +func InitEmptyTable_aliasContext(p *Table_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_table_alias + + return p +} + +func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_aliasContext) Unreserved_keyword() IUnreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnreserved_keywordContext) +} + +func (s *Table_aliasContext) Col_name_keyword() ICol_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICol_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICol_name_keywordContext) +} + +func (s *Table_aliasContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_unreserved_keywordContext) +} + +func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterTable_alias(s) + } +} + +func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitTable_alias(s) + } +} + +func (s *Table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitTable_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Table_alias() (localctx ITable_aliasContext) { + localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1926, RedshiftParserRULE_table_alias) + p.SetState(14179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1382, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14175) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14176) + p.Unreserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14177) + p.Col_name_keyword() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14178) + p.Plsql_unreserved_keyword() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_function_nameContext is an interface to support dynamic dispatch. +type IType_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Unreserved_keyword() IUnreserved_keywordContext + Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext + Type_func_name_keyword() IType_func_name_keywordContext + + // IsType_function_nameContext differentiates from other interfaces. + IsType_function_nameContext() +} + +type Type_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_function_nameContext() *Type_function_nameContext { + var p = new(Type_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_function_name + return p +} + +func InitEmptyType_function_nameContext(p *Type_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_function_name +} + +func (*Type_function_nameContext) IsType_function_nameContext() {} + +func NewType_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_function_nameContext { + var p = new(Type_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_type_function_name + + return p +} + +func (s *Type_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_function_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Type_function_nameContext) Unreserved_keyword() IUnreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnreserved_keywordContext) +} + +func (s *Type_function_nameContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_unreserved_keywordContext) +} + +func (s *Type_function_nameContext) Type_func_name_keyword() IType_func_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_func_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_func_name_keywordContext) +} + +func (s *Type_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterType_function_name(s) + } +} + +func (s *Type_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitType_function_name(s) + } +} + +func (s *Type_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitType_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Type_function_name() (localctx IType_function_nameContext) { + localctx = NewType_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1928, RedshiftParserRULE_type_function_name) + p.SetState(14185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1383, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14181) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14182) + p.Unreserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14183) + p.Plsql_unreserved_keyword() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14184) + p.Type_func_name_keyword() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INonreservedwordContext is an interface to support dynamic dispatch. +type INonreservedwordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Unreserved_keyword() IUnreserved_keywordContext + Col_name_keyword() ICol_name_keywordContext + Type_func_name_keyword() IType_func_name_keywordContext + + // IsNonreservedwordContext differentiates from other interfaces. + IsNonreservedwordContext() +} + +type NonreservedwordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNonreservedwordContext() *NonreservedwordContext { + var p = new(NonreservedwordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_nonreservedword + return p +} + +func InitEmptyNonreservedwordContext(p *NonreservedwordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_nonreservedword +} + +func (*NonreservedwordContext) IsNonreservedwordContext() {} + +func NewNonreservedwordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NonreservedwordContext { + var p = new(NonreservedwordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_nonreservedword + + return p +} + +func (s *NonreservedwordContext) GetParser() antlr.Parser { return s.parser } + +func (s *NonreservedwordContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *NonreservedwordContext) Unreserved_keyword() IUnreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnreserved_keywordContext) +} + +func (s *NonreservedwordContext) Col_name_keyword() ICol_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICol_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICol_name_keywordContext) +} + +func (s *NonreservedwordContext) Type_func_name_keyword() IType_func_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_func_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_func_name_keywordContext) +} + +func (s *NonreservedwordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NonreservedwordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NonreservedwordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterNonreservedword(s) + } +} + +func (s *NonreservedwordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitNonreservedword(s) + } +} + +func (s *NonreservedwordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitNonreservedword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Nonreservedword() (localctx INonreservedwordContext) { + localctx = NewNonreservedwordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1930, RedshiftParserRULE_nonreservedword) + p.SetState(14191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1384, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14187) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14188) + p.Unreserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14189) + p.Col_name_keyword() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14190) + p.Type_func_name_keyword() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollabelContext is an interface to support dynamic dispatch. +type ICollabelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext + Unreserved_keyword() IUnreserved_keywordContext + Col_name_keyword() ICol_name_keywordContext + Type_func_name_keyword() IType_func_name_keywordContext + Reserved_keyword() IReserved_keywordContext + + // IsCollabelContext differentiates from other interfaces. + IsCollabelContext() +} + +type CollabelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollabelContext() *CollabelContext { + var p = new(CollabelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_collabel + return p +} + +func InitEmptyCollabelContext(p *CollabelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_collabel +} + +func (*CollabelContext) IsCollabelContext() {} + +func NewCollabelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollabelContext { + var p = new(CollabelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_collabel + + return p +} + +func (s *CollabelContext) GetParser() antlr.Parser { return s.parser } + +func (s *CollabelContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *CollabelContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_unreserved_keywordContext) +} + +func (s *CollabelContext) Unreserved_keyword() IUnreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnreserved_keywordContext) +} + +func (s *CollabelContext) Col_name_keyword() ICol_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICol_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICol_name_keywordContext) +} + +func (s *CollabelContext) Type_func_name_keyword() IType_func_name_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_func_name_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_func_name_keywordContext) +} + +func (s *CollabelContext) Reserved_keyword() IReserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReserved_keywordContext) +} + +func (s *CollabelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollabelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CollabelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCollabel(s) + } +} + +func (s *CollabelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCollabel(s) + } +} + +func (s *CollabelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCollabel(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Collabel() (localctx ICollabelContext) { + localctx = NewCollabelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1932, RedshiftParserRULE_collabel) + p.SetState(14199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1385, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14193) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14194) + p.Plsql_unreserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14195) + p.Unreserved_keyword() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14196) + p.Col_name_keyword() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14197) + p.Type_func_name_keyword() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14198) + p.Reserved_keyword() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentifierContext is an interface to support dynamic dispatch. +type IIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() antlr.TerminalNode + Opt_uescape() IOpt_uescapeContext + QuotedIdentifier() antlr.TerminalNode + UnicodeQuotedIdentifier() antlr.TerminalNode + Plsqlvariablename() IPlsqlvariablenameContext + Plsqlidentifier() IPlsqlidentifierContext + Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext + + // IsIdentifierContext differentiates from other interfaces. + IsIdentifierContext() +} + +type IdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierContext() *IdentifierContext { + var p = new(IdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_identifier + return p +} + +func InitEmptyIdentifierContext(p *IdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_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 = RedshiftParserRULE_identifier + + return p +} + +func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierContext) Identifier() antlr.TerminalNode { + return s.GetToken(RedshiftParserIdentifier, 0) +} + +func (s *IdentifierContext) Opt_uescape() IOpt_uescapeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_uescapeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_uescapeContext) +} + +func (s *IdentifierContext) QuotedIdentifier() antlr.TerminalNode { + return s.GetToken(RedshiftParserQuotedIdentifier, 0) +} + +func (s *IdentifierContext) UnicodeQuotedIdentifier() antlr.TerminalNode { + return s.GetToken(RedshiftParserUnicodeQuotedIdentifier, 0) +} + +func (s *IdentifierContext) Plsqlvariablename() IPlsqlvariablenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsqlvariablenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsqlvariablenameContext) +} + +func (s *IdentifierContext) Plsqlidentifier() IPlsqlidentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsqlidentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsqlidentifierContext) +} + +func (s *IdentifierContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_unreserved_keywordContext) +} + +func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterIdentifier(s) + } +} + +func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitIdentifier(s) + } +} + +func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Identifier() (localctx IIdentifierContext) { + localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1934, RedshiftParserRULE_identifier) + p.SetState(14210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserIdentifier: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14201) + p.Match(RedshiftParserIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14203) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1386, p.GetParserRuleContext()) == 1 { + { + p.SetState(14202) + p.Opt_uescape() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case RedshiftParserQuotedIdentifier: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14205) + p.Match(RedshiftParserQuotedIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserUnicodeQuotedIdentifier: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14206) + p.Match(RedshiftParserUnicodeQuotedIdentifier) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserPLSQLVARIABLENAME: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14207) + p.Plsqlvariablename() + } + + case RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14208) + p.Plsqlidentifier() + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserOUTER_P, RedshiftParserABSOLUTE_P, RedshiftParserBACKWARD, RedshiftParserCHAIN, RedshiftParserCLOSE, RedshiftParserCOMMIT, RedshiftParserCONTINUE_P, RedshiftParserCURSOR, RedshiftParserFIRST_P, RedshiftParserFORWARD, RedshiftParserINSERT, RedshiftParserLAST_P, RedshiftParserMOVE, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserOPTION, RedshiftParserPRIOR, RedshiftParserRELATIVE_P, RedshiftParserRESET, RedshiftParserROLLBACK, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSET, RedshiftParserTYPE_P, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserROWTYPE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14209) + p.Plsql_unreserved_keyword() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsqlidentifierContext is an interface to support dynamic dispatch. +type IPlsqlidentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLSQLIDENTIFIER() antlr.TerminalNode + + // IsPlsqlidentifierContext differentiates from other interfaces. + IsPlsqlidentifierContext() +} + +type PlsqlidentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsqlidentifierContext() *PlsqlidentifierContext { + var p = new(PlsqlidentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlidentifier + return p +} + +func InitEmptyPlsqlidentifierContext(p *PlsqlidentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsqlidentifier +} + +func (*PlsqlidentifierContext) IsPlsqlidentifierContext() {} + +func NewPlsqlidentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PlsqlidentifierContext { + var p = new(PlsqlidentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_plsqlidentifier + + return p +} + +func (s *PlsqlidentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *PlsqlidentifierContext) PLSQLIDENTIFIER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLSQLIDENTIFIER, 0) +} + +func (s *PlsqlidentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PlsqlidentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PlsqlidentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPlsqlidentifier(s) + } +} + +func (s *PlsqlidentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPlsqlidentifier(s) + } +} + +func (s *PlsqlidentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPlsqlidentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Plsqlidentifier() (localctx IPlsqlidentifierContext) { + localctx = NewPlsqlidentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1936, RedshiftParserRULE_plsqlidentifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14212) + p.Match(RedshiftParserPLSQLIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnreserved_keywordContext is an interface to support dynamic dispatch. +type IUnreserved_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT_P() antlr.TerminalNode + ABSOLUTE_P() antlr.TerminalNode + ACCESS() antlr.TerminalNode + ACTION() antlr.TerminalNode + ADD_P() antlr.TerminalNode + ADMIN() antlr.TerminalNode + AFTER() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + ALSO() antlr.TerminalNode + ALTER() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + ASSERTION() antlr.TerminalNode + ASSIGNMENT() antlr.TerminalNode + AT() antlr.TerminalNode + ATOMIC_P() antlr.TerminalNode + ATTACH() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + BACKWARD() antlr.TerminalNode + BEFORE() antlr.TerminalNode + BEGIN_P() antlr.TerminalNode + BY() antlr.TerminalNode + CACHE() antlr.TerminalNode + CALL() antlr.TerminalNode + CALLED() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CASCADED() antlr.TerminalNode + CATALOG() antlr.TerminalNode + CHAIN() antlr.TerminalNode + CHARACTERISTICS() antlr.TerminalNode + CHECKPOINT() antlr.TerminalNode + CLASS() antlr.TerminalNode + CLOSE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + COMMENT() antlr.TerminalNode + COMMENTS() antlr.TerminalNode + COMMIT() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + CONFLICT() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + CONTENT_P() antlr.TerminalNode + CONTINUE_P() antlr.TerminalNode + CONVERSION_P() antlr.TerminalNode + COPY() antlr.TerminalNode + COST() antlr.TerminalNode + CSV() antlr.TerminalNode + CUBE() antlr.TerminalNode + CURRENT_P() antlr.TerminalNode + CURSOR() antlr.TerminalNode + CYCLE() antlr.TerminalNode + DATA_P() antlr.TerminalNode + DATABASE() antlr.TerminalNode + DAY_P() antlr.TerminalNode + DEALLOCATE() antlr.TerminalNode + DECLARE() antlr.TerminalNode + DEFAULTS() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + DEFINER() antlr.TerminalNode + DELETE_P() antlr.TerminalNode + DELIMITER() antlr.TerminalNode + DELIMITERS() antlr.TerminalNode + DEPENDS() antlr.TerminalNode + DETACH() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + DISABLE_P() antlr.TerminalNode + DISCARD() antlr.TerminalNode + DOCUMENT_P() antlr.TerminalNode + DOMAIN_P() antlr.TerminalNode + DOUBLE_P() antlr.TerminalNode + DROP() antlr.TerminalNode + EACH() antlr.TerminalNode + ENABLE_P() antlr.TerminalNode + ENCODING() antlr.TerminalNode + ENCRYPTED() antlr.TerminalNode + ENUM_P() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + EVENT() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + EXCLUSIVE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + EXPLAIN() antlr.TerminalNode + EXPRESSION() antlr.TerminalNode + EXTENSION() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FAMILY() antlr.TerminalNode + FILTER() antlr.TerminalNode + FIRST_P() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + FORCE() antlr.TerminalNode + FORWARD() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + GENERATED() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + GRANTED() antlr.TerminalNode + GROUPS() antlr.TerminalNode + HANDLER() antlr.TerminalNode + HEADER_P() antlr.TerminalNode + HOLD() antlr.TerminalNode + HOUR_P() antlr.TerminalNode + IDENTITY_P() antlr.TerminalNode + IF_P() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + IMPLICIT_P() antlr.TerminalNode + IMPORT_P() antlr.TerminalNode + INCLUDE() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + INDEX() antlr.TerminalNode + INDEXES() antlr.TerminalNode + INHERIT() antlr.TerminalNode + INHERITS() antlr.TerminalNode + INLINE_P() antlr.TerminalNode + INPUT_P() antlr.TerminalNode + INSENSITIVE() antlr.TerminalNode + INSERT() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + INVOKER() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + KEY() antlr.TerminalNode + LABEL() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + LARGE_P() antlr.TerminalNode + LAST_P() antlr.TerminalNode + LEAKPROOF() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LISTEN() antlr.TerminalNode + LOAD() antlr.TerminalNode + LOCAL() antlr.TerminalNode + LOCATION() antlr.TerminalNode + LOCK_P() antlr.TerminalNode + LOCKED() antlr.TerminalNode + LOGGED() antlr.TerminalNode + MAPPING() antlr.TerminalNode + MATCH() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + METHOD() antlr.TerminalNode + MINUTE_P() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MODE() antlr.TerminalNode + MONTH_P() antlr.TerminalNode + MOVE() antlr.TerminalNode + NAME_P() antlr.TerminalNode + NAMES() antlr.TerminalNode + NEW() antlr.TerminalNode + NEXT() antlr.TerminalNode + NFC() antlr.TerminalNode + NFD() antlr.TerminalNode + NFKC() antlr.TerminalNode + NFKD() antlr.TerminalNode + NO() antlr.TerminalNode + NORMALIZED() antlr.TerminalNode + NOTHING() antlr.TerminalNode + NOTIFY() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + NULLS_P() antlr.TerminalNode + OBJECT_P() antlr.TerminalNode + OF() antlr.TerminalNode + OFF() antlr.TerminalNode + OIDS() antlr.TerminalNode + OLD() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + OPTION() antlr.TerminalNode + OPTIONS() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + OTHERS() antlr.TerminalNode + OVER() antlr.TerminalNode + OVERRIDING() antlr.TerminalNode + OWNED() antlr.TerminalNode + OWNER() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + PARAMETER() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + PARSER() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + PARTITION() antlr.TerminalNode + PASSING() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + PLANS() antlr.TerminalNode + POLICY() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + PREPARE() antlr.TerminalNode + PREPARED() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + PRIOR() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + PROCEDURAL() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + PROGRAM() antlr.TerminalNode + PUBLICATION() antlr.TerminalNode + QUOTE() antlr.TerminalNode + RANGE() antlr.TerminalNode + READ() antlr.TerminalNode + REASSIGN() antlr.TerminalNode + RECHECK() antlr.TerminalNode + RECURSIVE() antlr.TerminalNode + REF() antlr.TerminalNode + REFERENCING() antlr.TerminalNode + REFRESH() antlr.TerminalNode + REINDEX() antlr.TerminalNode + RELATIVE_P() antlr.TerminalNode + RELEASE() antlr.TerminalNode + RENAME() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + REPLICA() antlr.TerminalNode + RESET() antlr.TerminalNode + RESTART() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + RETURNS() antlr.TerminalNode + REVOKE() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + ROUTINE() antlr.TerminalNode + ROUTINES() antlr.TerminalNode + ROWS() antlr.TerminalNode + RULE() antlr.TerminalNode + SAVEPOINT() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + SCROLL() antlr.TerminalNode + SEARCH() antlr.TerminalNode + SECOND_P() antlr.TerminalNode + SECURITY() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SEQUENCES() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + SERVER() antlr.TerminalNode + SESSION() antlr.TerminalNode + SET() antlr.TerminalNode + SETS() antlr.TerminalNode + SHARE() antlr.TerminalNode + SHOW() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + SKIP_P() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SQL_P() antlr.TerminalNode + STABLE() antlr.TerminalNode + STANDALONE_P() antlr.TerminalNode + START() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + STDIN() antlr.TerminalNode + STDOUT() antlr.TerminalNode + STORAGE() antlr.TerminalNode + STORED() antlr.TerminalNode + STRICT_P() antlr.TerminalNode + STRIP_P() antlr.TerminalNode + SUBSCRIPTION() antlr.TerminalNode + SUPPORT() antlr.TerminalNode + SYSID() antlr.TerminalNode + SYSTEM_P() antlr.TerminalNode + TABLES() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TEMP() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TEXT_P() antlr.TerminalNode + TIES() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + TRUSTED() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + TYPES_P() antlr.TerminalNode + UESCAPE() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + UNENCRYPTED() antlr.TerminalNode + UNKNOWN() antlr.TerminalNode + UNLISTEN() antlr.TerminalNode + UNLOGGED() antlr.TerminalNode + UNTIL() antlr.TerminalNode + UPDATE() antlr.TerminalNode + VACUUM() antlr.TerminalNode + VALID() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + VALIDATOR() antlr.TerminalNode + VALUE_P() antlr.TerminalNode + VARYING() antlr.TerminalNode + VERSION_P() antlr.TerminalNode + VIEW() antlr.TerminalNode + VIEWS() antlr.TerminalNode + VOLATILE() antlr.TerminalNode + WHITESPACE_P() antlr.TerminalNode + WITHIN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WORK() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + WRITE() antlr.TerminalNode + XML_P() antlr.TerminalNode + YEAR_P() antlr.TerminalNode + YES_P() antlr.TerminalNode + ZONE() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + DATASHARE() antlr.TerminalNode + PUBLICACCESSIBLE() antlr.TerminalNode + INCLUDENEW() antlr.TerminalNode + IAM_ROLE() antlr.TerminalNode + CATALOG_ROLE() antlr.TerminalNode + CATALOG_ID() antlr.TerminalNode + HIVE() antlr.TerminalNode + METASTORE() antlr.TerminalNode + URI() antlr.TerminalNode + POSTGRES() antlr.TerminalNode + MYSQL() antlr.TerminalNode + SECRET_ARN() antlr.TerminalNode + KINESIS() antlr.TerminalNode + KAFKA() antlr.TerminalNode + MSK() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + AUTHENTICATION_ARN() antlr.TerminalNode + SESSION_TOKEN() antlr.TerminalNode + MTLS() antlr.TerminalNode + MASKING() antlr.TerminalNode + RLS() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + PROTECTED() antlr.TerminalNode + MODEL() antlr.TerminalNode + TARGET() antlr.TerminalNode + SAGEMAKER() antlr.TerminalNode + AUTO() antlr.TerminalNode + MODEL_TYPE() antlr.TerminalNode + PROBLEM_TYPE() antlr.TerminalNode + OBJECTIVE() antlr.TerminalNode + PREPROCESSORS() antlr.TerminalNode + HYPERPARAMETERS() antlr.TerminalNode + XGBOOST() antlr.TerminalNode + MLP() antlr.TerminalNode + LINEAR_LEARNER() antlr.TerminalNode + KMEANS() antlr.TerminalNode + FORECAST() antlr.TerminalNode + REGRESSION() antlr.TerminalNode + BINARY_CLASSIFICATION() antlr.TerminalNode + MULTICLASS_CLASSIFICATION() antlr.TerminalNode + S3_BUCKET() antlr.TerminalNode + TAGS() antlr.TerminalNode + KMS_KEY_ID() antlr.TerminalNode + S3_GARBAGE_COLLECT() antlr.TerminalNode + MAX_CELLS() antlr.TerminalNode + MAX_RUNTIME() antlr.TerminalNode + HORIZON() antlr.TerminalNode + FREQUENCY() antlr.TerminalNode + PERCENTILES() antlr.TerminalNode + MAX_BATCH_ROWS() antlr.TerminalNode + UNLOAD() antlr.TerminalNode + MANIFEST() antlr.TerminalNode + ADDQUOTES() antlr.TerminalNode + ALLOWOVERWRITE() antlr.TerminalNode + CLEANPATH() antlr.TerminalNode + MAXFILESIZE() antlr.TerminalNode + ROWGROUPSIZE() antlr.TerminalNode + BZIP2() antlr.TerminalNode + GZIP() antlr.TerminalNode + ZSTD() antlr.TerminalNode + DATABASES() antlr.TerminalNode + DATASHARES() antlr.TerminalNode + GRANTS() antlr.TerminalNode + USE() antlr.TerminalNode + CANCEL() antlr.TerminalNode + SESSION_AUTHORIZATION() antlr.TerminalNode + SESSION_CHARACTERISTICS() antlr.TerminalNode + COMPRESSION() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + APPEND() antlr.TerminalNode + MB() antlr.TerminalNode + GB() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + NONATOMIC() antlr.TerminalNode + MANAGEDBY() antlr.TerminalNode + ADX() antlr.TerminalNode + REMOVE() antlr.TerminalNode + DUPLICATES() antlr.TerminalNode + BEDROCK() antlr.TerminalNode + MODEL_ID() antlr.TerminalNode + PROMPT() antlr.TerminalNode + SUFFIX() antlr.TerminalNode + REQUEST_TYPE() antlr.TerminalNode + RESPONSE_TYPE() antlr.TerminalNode + RAW() antlr.TerminalNode + UNIFIED() antlr.TerminalNode + SUPER() antlr.TerminalNode + CI() antlr.TerminalNode + CS() antlr.TerminalNode + PLPYTHONU() antlr.TerminalNode + FILLTARGET() antlr.TerminalNode + IGNOREEXTRA() antlr.TerminalNode + CREATEUSER() antlr.TerminalNode + NOCREATEUSER() antlr.TerminalNode + REGION() antlr.TerminalNode + PORT() antlr.TerminalNode + REDSHIFT() antlr.TerminalNode + IAM() antlr.TerminalNode + CREATEDB() antlr.TerminalNode + NOCREATEDB() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + EXTERNALID() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + SYSLOG() antlr.TerminalNode + CREDENTIALS() antlr.TerminalNode + UNRESTRICTED() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + APPLICATION_ARN() antlr.TerminalNode + AUTO_CREATE_ROLES() antlr.TerminalNode + COMPROWS() antlr.TerminalNode + PROVIDER_URL() antlr.TerminalNode + PROVIDER_URL_PORT() antlr.TerminalNode + ATTRIBUTE_MAP() antlr.TerminalNode + PROVIDER_ARN() antlr.TerminalNode + ASSUME_ROLE_ARN() antlr.TerminalNode + PROPERTIES() antlr.TerminalNode + AVRO() antlr.TerminalNode + RCFILE() antlr.TerminalNode + SEQUENCEFILE() antlr.TerminalNode + TEXTFILE() antlr.TerminalNode + ORC() antlr.TerminalNode + ION() antlr.TerminalNode + LAMBDA() antlr.TerminalNode + FIXEDWIDTH() antlr.TerminalNode + PARQUET() antlr.TerminalNode + LZOP() antlr.TerminalNode + REMOVEQUOTES() antlr.TerminalNode + TRUNCATECOLUMNS() antlr.TerminalNode + FILLRECORD() antlr.TerminalNode + BLANKSASNULL() antlr.TerminalNode + EMPTYASNULL() antlr.TerminalNode + MAXERROR() antlr.TerminalNode + DATEFORMAT() antlr.TerminalNode + TIMEFORMAT() antlr.TerminalNode + ACCEPTINVCHARS() antlr.TerminalNode + ACCEPTANYDATE() antlr.TerminalNode + IGNOREHEADER() antlr.TerminalNode + IGNOREBLANKLINES() antlr.TerminalNode + COMPUPDATE() antlr.TerminalNode + STATUPDATE() antlr.TerminalNode + EXPLICIT_IDS() antlr.TerminalNode + READRATIO() antlr.TerminalNode + ROUNDEC() antlr.TerminalNode + TRIMBLANKS() antlr.TerminalNode + PRESET() antlr.TerminalNode + ACCESS_KEY_ID() antlr.TerminalNode + SECRET_ACCESS_KEY() antlr.TerminalNode + SESSION_TOKEN_KW() antlr.TerminalNode + HEADER() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + FUNCTION_NAME() antlr.TerminalNode + + // IsUnreserved_keywordContext differentiates from other interfaces. + IsUnreserved_keywordContext() +} + +type Unreserved_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnreserved_keywordContext() *Unreserved_keywordContext { + var p = new(Unreserved_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unreserved_keyword + return p +} + +func InitEmptyUnreserved_keywordContext(p *Unreserved_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_unreserved_keyword +} + +func (*Unreserved_keywordContext) IsUnreserved_keywordContext() {} + +func NewUnreserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unreserved_keywordContext { + var p = new(Unreserved_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_unreserved_keyword + + return p +} + +func (s *Unreserved_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unreserved_keywordContext) ABORT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserABORT_P, 0) +} + +func (s *Unreserved_keywordContext) ABSOLUTE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserABSOLUTE_P, 0) +} + +func (s *Unreserved_keywordContext) ACCESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS, 0) +} + +func (s *Unreserved_keywordContext) ACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserACTION, 0) +} + +func (s *Unreserved_keywordContext) ADD_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserADD_P, 0) +} + +func (s *Unreserved_keywordContext) ADMIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserADMIN, 0) +} + +func (s *Unreserved_keywordContext) AFTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserAFTER, 0) +} + +func (s *Unreserved_keywordContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGGREGATE, 0) +} + +func (s *Unreserved_keywordContext) ALSO() antlr.TerminalNode { + return s.GetToken(RedshiftParserALSO, 0) +} + +func (s *Unreserved_keywordContext) ALTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserALTER, 0) +} + +func (s *Unreserved_keywordContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(RedshiftParserALWAYS, 0) +} + +func (s *Unreserved_keywordContext) ASSERTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSERTION, 0) +} + +func (s *Unreserved_keywordContext) ASSIGNMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSIGNMENT, 0) +} + +func (s *Unreserved_keywordContext) AT() antlr.TerminalNode { + return s.GetToken(RedshiftParserAT, 0) +} + +func (s *Unreserved_keywordContext) ATOMIC_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserATOMIC_P, 0) +} + +func (s *Unreserved_keywordContext) ATTACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTACH, 0) +} + +func (s *Unreserved_keywordContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTRIBUTE, 0) +} + +func (s *Unreserved_keywordContext) BACKWARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserBACKWARD, 0) +} + +func (s *Unreserved_keywordContext) BEFORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEFORE, 0) +} + +func (s *Unreserved_keywordContext) BEGIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEGIN_P, 0) +} + +func (s *Unreserved_keywordContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Unreserved_keywordContext) CACHE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCACHE, 0) +} + +func (s *Unreserved_keywordContext) CALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCALL, 0) +} + +func (s *Unreserved_keywordContext) CALLED() antlr.TerminalNode { + return s.GetToken(RedshiftParserCALLED, 0) +} + +func (s *Unreserved_keywordContext) CASCADE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADE, 0) +} + +func (s *Unreserved_keywordContext) CASCADED() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASCADED, 0) +} + +func (s *Unreserved_keywordContext) CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG, 0) +} + +func (s *Unreserved_keywordContext) CHAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHAIN, 0) +} + +func (s *Unreserved_keywordContext) CHARACTERISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHARACTERISTICS, 0) +} + +func (s *Unreserved_keywordContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECKPOINT, 0) +} + +func (s *Unreserved_keywordContext) CLASS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLASS, 0) +} + +func (s *Unreserved_keywordContext) CLOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE, 0) +} + +func (s *Unreserved_keywordContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLUSTER, 0) +} + +func (s *Unreserved_keywordContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMNS, 0) +} + +func (s *Unreserved_keywordContext) COMMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMENT, 0) +} + +func (s *Unreserved_keywordContext) COMMENTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMENTS, 0) +} + +func (s *Unreserved_keywordContext) COMMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMIT, 0) +} + +func (s *Unreserved_keywordContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMITTED, 0) +} + +func (s *Unreserved_keywordContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFIGURATION, 0) +} + +func (s *Unreserved_keywordContext) CONFLICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONFLICT, 0) +} + +func (s *Unreserved_keywordContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONNECTION, 0) +} + +func (s *Unreserved_keywordContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINTS, 0) +} + +func (s *Unreserved_keywordContext) CONTENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONTENT_P, 0) +} + +func (s *Unreserved_keywordContext) CONTINUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONTINUE_P, 0) +} + +func (s *Unreserved_keywordContext) CONVERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONVERSION_P, 0) +} + +func (s *Unreserved_keywordContext) COPY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOPY, 0) +} + +func (s *Unreserved_keywordContext) COST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOST, 0) +} + +func (s *Unreserved_keywordContext) CSV() antlr.TerminalNode { + return s.GetToken(RedshiftParserCSV, 0) +} + +func (s *Unreserved_keywordContext) CUBE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCUBE, 0) +} + +func (s *Unreserved_keywordContext) CURRENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_P, 0) +} + +func (s *Unreserved_keywordContext) CURSOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURSOR, 0) +} + +func (s *Unreserved_keywordContext) CYCLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCYCLE, 0) +} + +func (s *Unreserved_keywordContext) DATA_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATA_P, 0) +} + +func (s *Unreserved_keywordContext) DATABASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASE, 0) +} + +func (s *Unreserved_keywordContext) DAY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDAY_P, 0) +} + +func (s *Unreserved_keywordContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEALLOCATE, 0) +} + +func (s *Unreserved_keywordContext) DECLARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDECLARE, 0) +} + +func (s *Unreserved_keywordContext) DEFAULTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULTS, 0) +} + +func (s *Unreserved_keywordContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRED, 0) +} + +func (s *Unreserved_keywordContext) DEFINER() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFINER, 0) +} + +func (s *Unreserved_keywordContext) DELETE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELETE_P, 0) +} + +func (s *Unreserved_keywordContext) DELIMITER() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELIMITER, 0) +} + +func (s *Unreserved_keywordContext) DELIMITERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELIMITERS, 0) +} + +func (s *Unreserved_keywordContext) DEPENDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEPENDS, 0) +} + +func (s *Unreserved_keywordContext) DETACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserDETACH, 0) +} + +func (s *Unreserved_keywordContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserDICTIONARY, 0) +} + +func (s *Unreserved_keywordContext) DISABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISABLE_P, 0) +} + +func (s *Unreserved_keywordContext) DISCARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISCARD, 0) +} + +func (s *Unreserved_keywordContext) DOCUMENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOCUMENT_P, 0) +} + +func (s *Unreserved_keywordContext) DOMAIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOMAIN_P, 0) +} + +func (s *Unreserved_keywordContext) DOUBLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOUBLE_P, 0) +} + +func (s *Unreserved_keywordContext) DROP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDROP, 0) +} + +func (s *Unreserved_keywordContext) EACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserEACH, 0) +} + +func (s *Unreserved_keywordContext) ENABLE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserENABLE_P, 0) +} + +func (s *Unreserved_keywordContext) ENCODING() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODING, 0) +} + +func (s *Unreserved_keywordContext) ENCRYPTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCRYPTED, 0) +} + +func (s *Unreserved_keywordContext) ENUM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserENUM_P, 0) +} + +func (s *Unreserved_keywordContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserESCAPE, 0) +} + +func (s *Unreserved_keywordContext) EVENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEVENT, 0) +} + +func (s *Unreserved_keywordContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDE, 0) +} + +func (s *Unreserved_keywordContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUDING, 0) +} + +func (s *Unreserved_keywordContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCLUSIVE, 0) +} + +func (s *Unreserved_keywordContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *Unreserved_keywordContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPLAIN, 0) +} + +func (s *Unreserved_keywordContext) EXPRESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPRESSION, 0) +} + +func (s *Unreserved_keywordContext) EXTENSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTENSION, 0) +} + +func (s *Unreserved_keywordContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNAL, 0) +} + +func (s *Unreserved_keywordContext) FAMILY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFAMILY, 0) +} + +func (s *Unreserved_keywordContext) FILTER() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILTER, 0) +} + +func (s *Unreserved_keywordContext) FIRST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIRST_P, 0) +} + +func (s *Unreserved_keywordContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOLLOWING, 0) +} + +func (s *Unreserved_keywordContext) FORCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORCE, 0) +} + +func (s *Unreserved_keywordContext) FORWARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORWARD, 0) +} + +func (s *Unreserved_keywordContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION, 0) +} + +func (s *Unreserved_keywordContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTIONS, 0) +} + +func (s *Unreserved_keywordContext) GENERATED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGENERATED, 0) +} + +func (s *Unreserved_keywordContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserGLOBAL, 0) +} + +func (s *Unreserved_keywordContext) GRANTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANTED, 0) +} + +func (s *Unreserved_keywordContext) GROUPS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUPS, 0) +} + +func (s *Unreserved_keywordContext) HANDLER() antlr.TerminalNode { + return s.GetToken(RedshiftParserHANDLER, 0) +} + +func (s *Unreserved_keywordContext) HEADER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserHEADER_P, 0) +} + +func (s *Unreserved_keywordContext) HOLD() antlr.TerminalNode { + return s.GetToken(RedshiftParserHOLD, 0) +} + +func (s *Unreserved_keywordContext) HOUR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserHOUR_P, 0) +} + +func (s *Unreserved_keywordContext) IDENTITY_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY_P, 0) +} + +func (s *Unreserved_keywordContext) IF_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, 0) +} + +func (s *Unreserved_keywordContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMEDIATE, 0) +} + +func (s *Unreserved_keywordContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMMUTABLE, 0) +} + +func (s *Unreserved_keywordContext) IMPLICIT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMPLICIT_P, 0) +} + +func (s *Unreserved_keywordContext) IMPORT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIMPORT_P, 0) +} + +func (s *Unreserved_keywordContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDE, 0) +} + +func (s *Unreserved_keywordContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDING, 0) +} + +func (s *Unreserved_keywordContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCREMENT, 0) +} + +func (s *Unreserved_keywordContext) INDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEX, 0) +} + +func (s *Unreserved_keywordContext) INDEXES() antlr.TerminalNode { + return s.GetToken(RedshiftParserINDEXES, 0) +} + +func (s *Unreserved_keywordContext) INHERIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINHERIT, 0) +} + +func (s *Unreserved_keywordContext) INHERITS() antlr.TerminalNode { + return s.GetToken(RedshiftParserINHERITS, 0) +} + +func (s *Unreserved_keywordContext) INLINE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINLINE_P, 0) +} + +func (s *Unreserved_keywordContext) INPUT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINPUT_P, 0) +} + +func (s *Unreserved_keywordContext) INSENSITIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSENSITIVE, 0) +} + +func (s *Unreserved_keywordContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *Unreserved_keywordContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSTEAD, 0) +} + +func (s *Unreserved_keywordContext) INVOKER() antlr.TerminalNode { + return s.GetToken(RedshiftParserINVOKER, 0) +} + +func (s *Unreserved_keywordContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserISOLATION, 0) +} + +func (s *Unreserved_keywordContext) KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserKEY, 0) +} + +func (s *Unreserved_keywordContext) LABEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLABEL, 0) +} + +func (s *Unreserved_keywordContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLANGUAGE, 0) +} + +func (s *Unreserved_keywordContext) LARGE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLARGE_P, 0) +} + +func (s *Unreserved_keywordContext) LAST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLAST_P, 0) +} + +func (s *Unreserved_keywordContext) LEAKPROOF() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEAKPROOF, 0) +} + +func (s *Unreserved_keywordContext) LEVEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEVEL, 0) +} + +func (s *Unreserved_keywordContext) LISTEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserLISTEN, 0) +} + +func (s *Unreserved_keywordContext) LOAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOAD, 0) +} + +func (s *Unreserved_keywordContext) LOCAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCAL, 0) +} + +func (s *Unreserved_keywordContext) LOCATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCATION, 0) +} + +func (s *Unreserved_keywordContext) LOCK_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCK_P, 0) +} + +func (s *Unreserved_keywordContext) LOCKED() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCKED, 0) +} + +func (s *Unreserved_keywordContext) LOGGED() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOGGED, 0) +} + +func (s *Unreserved_keywordContext) MAPPING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAPPING, 0) +} + +func (s *Unreserved_keywordContext) MATCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATCH, 0) +} + +func (s *Unreserved_keywordContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserMATERIALIZED, 0) +} + +func (s *Unreserved_keywordContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAXVALUE, 0) +} + +func (s *Unreserved_keywordContext) METHOD() antlr.TerminalNode { + return s.GetToken(RedshiftParserMETHOD, 0) +} + +func (s *Unreserved_keywordContext) MINUTE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINUTE_P, 0) +} + +func (s *Unreserved_keywordContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMINVALUE, 0) +} + +func (s *Unreserved_keywordContext) MODE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODE, 0) +} + +func (s *Unreserved_keywordContext) MONTH_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserMONTH_P, 0) +} + +func (s *Unreserved_keywordContext) MOVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMOVE, 0) +} + +func (s *Unreserved_keywordContext) NAME_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAME_P, 0) +} + +func (s *Unreserved_keywordContext) NAMES() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMES, 0) +} + +func (s *Unreserved_keywordContext) NEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEW, 0) +} + +func (s *Unreserved_keywordContext) NEXT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEXT, 0) +} + +func (s *Unreserved_keywordContext) NFC() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFC, 0) +} + +func (s *Unreserved_keywordContext) NFD() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFD, 0) +} + +func (s *Unreserved_keywordContext) NFKC() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFKC, 0) +} + +func (s *Unreserved_keywordContext) NFKD() antlr.TerminalNode { + return s.GetToken(RedshiftParserNFKD, 0) +} + +func (s *Unreserved_keywordContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Unreserved_keywordContext) NORMALIZED() antlr.TerminalNode { + return s.GetToken(RedshiftParserNORMALIZED, 0) +} + +func (s *Unreserved_keywordContext) NOTHING() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTHING, 0) +} + +func (s *Unreserved_keywordContext) NOTIFY() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTIFY, 0) +} + +func (s *Unreserved_keywordContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOWAIT, 0) +} + +func (s *Unreserved_keywordContext) NULLS_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULLS_P, 0) +} + +func (s *Unreserved_keywordContext) OBJECT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOBJECT_P, 0) +} + +func (s *Unreserved_keywordContext) OF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOF, 0) +} + +func (s *Unreserved_keywordContext) OFF() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFF, 0) +} + +func (s *Unreserved_keywordContext) OIDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOIDS, 0) +} + +func (s *Unreserved_keywordContext) OLD() antlr.TerminalNode { + return s.GetToken(RedshiftParserOLD, 0) +} + +func (s *Unreserved_keywordContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPERATOR, 0) +} + +func (s *Unreserved_keywordContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Unreserved_keywordContext) OPTIONS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTIONS, 0) +} + +func (s *Unreserved_keywordContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserORDINALITY, 0) +} + +func (s *Unreserved_keywordContext) OTHERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOTHERS, 0) +} + +func (s *Unreserved_keywordContext) OVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVER, 0) +} + +func (s *Unreserved_keywordContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVERRIDING, 0) +} + +func (s *Unreserved_keywordContext) OWNED() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNED, 0) +} + +func (s *Unreserved_keywordContext) OWNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserOWNER, 0) +} + +func (s *Unreserved_keywordContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARALLEL, 0) +} + +func (s *Unreserved_keywordContext) PARAMETER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAMETER, 0) +} + +func (s *Unreserved_keywordContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLIC, 0) +} + +func (s *Unreserved_keywordContext) PARSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARSER, 0) +} + +func (s *Unreserved_keywordContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTIAL, 0) +} + +func (s *Unreserved_keywordContext) PARTITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARTITION, 0) +} + +func (s *Unreserved_keywordContext) PASSING() antlr.TerminalNode { + return s.GetToken(RedshiftParserPASSING, 0) +} + +func (s *Unreserved_keywordContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(RedshiftParserPASSWORD, 0) +} + +func (s *Unreserved_keywordContext) PLANS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLANS, 0) +} + +func (s *Unreserved_keywordContext) POLICY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOLICY, 0) +} + +func (s *Unreserved_keywordContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRECEDING, 0) +} + +func (s *Unreserved_keywordContext) PREPARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPARE, 0) +} + +func (s *Unreserved_keywordContext) PREPARED() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPARED, 0) +} + +func (s *Unreserved_keywordContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRESERVE, 0) +} + +func (s *Unreserved_keywordContext) PRIOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIOR, 0) +} + +func (s *Unreserved_keywordContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIORITY, 0) +} + +func (s *Unreserved_keywordContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIVILEGES, 0) +} + +func (s *Unreserved_keywordContext) PROCEDURAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURAL, 0) +} + +func (s *Unreserved_keywordContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURE, 0) +} + +func (s *Unreserved_keywordContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROCEDURES, 0) +} + +func (s *Unreserved_keywordContext) PROGRAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROGRAM, 0) +} + +func (s *Unreserved_keywordContext) PUBLICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICATION, 0) +} + +func (s *Unreserved_keywordContext) QUOTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTE, 0) +} + +func (s *Unreserved_keywordContext) RANGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRANGE, 0) +} + +func (s *Unreserved_keywordContext) READ() antlr.TerminalNode { + return s.GetToken(RedshiftParserREAD, 0) +} + +func (s *Unreserved_keywordContext) REASSIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserREASSIGN, 0) +} + +func (s *Unreserved_keywordContext) RECHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserRECHECK, 0) +} + +func (s *Unreserved_keywordContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRECURSIVE, 0) +} + +func (s *Unreserved_keywordContext) REF() antlr.TerminalNode { + return s.GetToken(RedshiftParserREF, 0) +} + +func (s *Unreserved_keywordContext) REFERENCING() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCING, 0) +} + +func (s *Unreserved_keywordContext) REFRESH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFRESH, 0) +} + +func (s *Unreserved_keywordContext) REINDEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserREINDEX, 0) +} + +func (s *Unreserved_keywordContext) RELATIVE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserRELATIVE_P, 0) +} + +func (s *Unreserved_keywordContext) RELEASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRELEASE, 0) +} + +func (s *Unreserved_keywordContext) RENAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserRENAME, 0) +} + +func (s *Unreserved_keywordContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPEATABLE, 0) +} + +func (s *Unreserved_keywordContext) REPLICA() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLICA, 0) +} + +func (s *Unreserved_keywordContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *Unreserved_keywordContext) RESTART() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTART, 0) +} + +func (s *Unreserved_keywordContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICT, 0) +} + +func (s *Unreserved_keywordContext) RETURNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNS, 0) +} + +func (s *Unreserved_keywordContext) REVOKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVOKE, 0) +} + +func (s *Unreserved_keywordContext) ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLE, 0) +} + +func (s *Unreserved_keywordContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLLBACK, 0) +} + +func (s *Unreserved_keywordContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLLUP, 0) +} + +func (s *Unreserved_keywordContext) ROUTINE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINE, 0) +} + +func (s *Unreserved_keywordContext) ROUTINES() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUTINES, 0) +} + +func (s *Unreserved_keywordContext) ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWS, 0) +} + +func (s *Unreserved_keywordContext) RULE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRULE, 0) +} + +func (s *Unreserved_keywordContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSAVEPOINT, 0) +} + +func (s *Unreserved_keywordContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Unreserved_keywordContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMAS, 0) +} + +func (s *Unreserved_keywordContext) SCROLL() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCROLL, 0) +} + +func (s *Unreserved_keywordContext) SEARCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEARCH, 0) +} + +func (s *Unreserved_keywordContext) SECOND_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECOND_P, 0) +} + +func (s *Unreserved_keywordContext) SECURITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECURITY, 0) +} + +func (s *Unreserved_keywordContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCE, 0) +} + +func (s *Unreserved_keywordContext) SEQUENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCES, 0) +} + +func (s *Unreserved_keywordContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERIALIZABLE, 0) +} + +func (s *Unreserved_keywordContext) SERVER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSERVER, 0) +} + +func (s *Unreserved_keywordContext) SESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION, 0) +} + +func (s *Unreserved_keywordContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Unreserved_keywordContext) SETS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETS, 0) +} + +func (s *Unreserved_keywordContext) SHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHARE, 0) +} + +func (s *Unreserved_keywordContext) SHOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSHOW, 0) +} + +func (s *Unreserved_keywordContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIMPLE, 0) +} + +func (s *Unreserved_keywordContext) SKIP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSKIP_P, 0) +} + +func (s *Unreserved_keywordContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSNAPSHOT, 0) +} + +func (s *Unreserved_keywordContext) SQL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSQL_P, 0) +} + +func (s *Unreserved_keywordContext) STABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTABLE, 0) +} + +func (s *Unreserved_keywordContext) STANDALONE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTANDALONE_P, 0) +} + +func (s *Unreserved_keywordContext) START() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTART, 0) +} + +func (s *Unreserved_keywordContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATEMENT, 0) +} + +func (s *Unreserved_keywordContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATISTICS, 0) +} + +func (s *Unreserved_keywordContext) STDIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTDIN, 0) +} + +func (s *Unreserved_keywordContext) STDOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTDOUT, 0) +} + +func (s *Unreserved_keywordContext) STORAGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTORAGE, 0) +} + +func (s *Unreserved_keywordContext) STORED() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTORED, 0) +} + +func (s *Unreserved_keywordContext) STRICT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRICT_P, 0) +} + +func (s *Unreserved_keywordContext) STRIP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRIP_P, 0) +} + +func (s *Unreserved_keywordContext) SUBSCRIPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSCRIPTION, 0) +} + +func (s *Unreserved_keywordContext) SUPPORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUPPORT, 0) +} + +func (s *Unreserved_keywordContext) SYSID() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSID, 0) +} + +func (s *Unreserved_keywordContext) SYSTEM_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSTEM_P, 0) +} + +func (s *Unreserved_keywordContext) TABLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLES, 0) +} + +func (s *Unreserved_keywordContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESPACE, 0) +} + +func (s *Unreserved_keywordContext) TEMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMP, 0) +} + +func (s *Unreserved_keywordContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPLATE, 0) +} + +func (s *Unreserved_keywordContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEMPORARY, 0) +} + +func (s *Unreserved_keywordContext) TEXT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXT_P, 0) +} + +func (s *Unreserved_keywordContext) TIES() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIES, 0) +} + +func (s *Unreserved_keywordContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION, 0) +} + +func (s *Unreserved_keywordContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSFORM, 0) +} + +func (s *Unreserved_keywordContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIGGER, 0) +} + +func (s *Unreserved_keywordContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNCATE, 0) +} + +func (s *Unreserved_keywordContext) TRUSTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUSTED, 0) +} + +func (s *Unreserved_keywordContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Unreserved_keywordContext) TYPES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPES_P, 0) +} + +func (s *Unreserved_keywordContext) UESCAPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUESCAPE, 0) +} + +func (s *Unreserved_keywordContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNBOUNDED, 0) +} + +func (s *Unreserved_keywordContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNCOMMITTED, 0) +} + +func (s *Unreserved_keywordContext) UNENCRYPTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNENCRYPTED, 0) +} + +func (s *Unreserved_keywordContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNKNOWN, 0) +} + +func (s *Unreserved_keywordContext) UNLISTEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLISTEN, 0) +} + +func (s *Unreserved_keywordContext) UNLOGGED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLOGGED, 0) +} + +func (s *Unreserved_keywordContext) UNTIL() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNTIL, 0) +} + +func (s *Unreserved_keywordContext) UPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPDATE, 0) +} + +func (s *Unreserved_keywordContext) VACUUM() antlr.TerminalNode { + return s.GetToken(RedshiftParserVACUUM, 0) +} + +func (s *Unreserved_keywordContext) VALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALID, 0) +} + +func (s *Unreserved_keywordContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALIDATE, 0) +} + +func (s *Unreserved_keywordContext) VALIDATOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALIDATOR, 0) +} + +func (s *Unreserved_keywordContext) VALUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUE_P, 0) +} + +func (s *Unreserved_keywordContext) VARYING() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARYING, 0) +} + +func (s *Unreserved_keywordContext) VERSION_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERSION_P, 0) +} + +func (s *Unreserved_keywordContext) VIEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEW, 0) +} + +func (s *Unreserved_keywordContext) VIEWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserVIEWS, 0) +} + +func (s *Unreserved_keywordContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVOLATILE, 0) +} + +func (s *Unreserved_keywordContext) WHITESPACE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHITESPACE_P, 0) +} + +func (s *Unreserved_keywordContext) WITHIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHIN, 0) +} + +func (s *Unreserved_keywordContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITHOUT, 0) +} + +func (s *Unreserved_keywordContext) WORK() antlr.TerminalNode { + return s.GetToken(RedshiftParserWORK, 0) +} + +func (s *Unreserved_keywordContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRAPPER, 0) +} + +func (s *Unreserved_keywordContext) WRITE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWRITE, 0) +} + +func (s *Unreserved_keywordContext) XML_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserXML_P, 0) +} + +func (s *Unreserved_keywordContext) YEAR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYEAR_P, 0) +} + +func (s *Unreserved_keywordContext) YES_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserYES_P, 0) +} + +func (s *Unreserved_keywordContext) ZONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserZONE, 0) +} + +func (s *Unreserved_keywordContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFINITION, 0) +} + +func (s *Unreserved_keywordContext) DATASHARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARE, 0) +} + +func (s *Unreserved_keywordContext) PUBLICACCESSIBLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPUBLICACCESSIBLE, 0) +} + +func (s *Unreserved_keywordContext) INCLUDENEW() antlr.TerminalNode { + return s.GetToken(RedshiftParserINCLUDENEW, 0) +} + +func (s *Unreserved_keywordContext) IAM_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM_ROLE, 0) +} + +func (s *Unreserved_keywordContext) CATALOG_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG_ROLE, 0) +} + +func (s *Unreserved_keywordContext) CATALOG_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserCATALOG_ID, 0) +} + +func (s *Unreserved_keywordContext) HIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserHIVE, 0) +} + +func (s *Unreserved_keywordContext) METASTORE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMETASTORE, 0) +} + +func (s *Unreserved_keywordContext) URI() antlr.TerminalNode { + return s.GetToken(RedshiftParserURI, 0) +} + +func (s *Unreserved_keywordContext) POSTGRES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOSTGRES, 0) +} + +func (s *Unreserved_keywordContext) MYSQL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMYSQL, 0) +} + +func (s *Unreserved_keywordContext) SECRET_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECRET_ARN, 0) +} + +func (s *Unreserved_keywordContext) KINESIS() antlr.TerminalNode { + return s.GetToken(RedshiftParserKINESIS, 0) +} + +func (s *Unreserved_keywordContext) KAFKA() antlr.TerminalNode { + return s.GetToken(RedshiftParserKAFKA, 0) +} + +func (s *Unreserved_keywordContext) MSK() antlr.TerminalNode { + return s.GetToken(RedshiftParserMSK, 0) +} + +func (s *Unreserved_keywordContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION, 0) +} + +func (s *Unreserved_keywordContext) AUTHENTICATION_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHENTICATION_ARN, 0) +} + +func (s *Unreserved_keywordContext) SESSION_TOKEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_TOKEN, 0) +} + +func (s *Unreserved_keywordContext) MTLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMTLS, 0) +} + +func (s *Unreserved_keywordContext) MASKING() antlr.TerminalNode { + return s.GetToken(RedshiftParserMASKING, 0) +} + +func (s *Unreserved_keywordContext) RLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRLS, 0) +} + +func (s *Unreserved_keywordContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(RedshiftParserIDENTITY, 0) +} + +func (s *Unreserved_keywordContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER, 0) +} + +func (s *Unreserved_keywordContext) PROTECTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROTECTED, 0) +} + +func (s *Unreserved_keywordContext) MODEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL, 0) +} + +func (s *Unreserved_keywordContext) TARGET() antlr.TerminalNode { + return s.GetToken(RedshiftParserTARGET, 0) +} + +func (s *Unreserved_keywordContext) SAGEMAKER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSAGEMAKER, 0) +} + +func (s *Unreserved_keywordContext) AUTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO, 0) +} + +func (s *Unreserved_keywordContext) MODEL_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL_TYPE, 0) +} + +func (s *Unreserved_keywordContext) PROBLEM_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROBLEM_TYPE, 0) +} + +func (s *Unreserved_keywordContext) OBJECTIVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserOBJECTIVE, 0) +} + +func (s *Unreserved_keywordContext) PREPROCESSORS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPREPROCESSORS, 0) +} + +func (s *Unreserved_keywordContext) HYPERPARAMETERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserHYPERPARAMETERS, 0) +} + +func (s *Unreserved_keywordContext) XGBOOST() antlr.TerminalNode { + return s.GetToken(RedshiftParserXGBOOST, 0) +} + +func (s *Unreserved_keywordContext) MLP() antlr.TerminalNode { + return s.GetToken(RedshiftParserMLP, 0) +} + +func (s *Unreserved_keywordContext) LINEAR_LEARNER() antlr.TerminalNode { + return s.GetToken(RedshiftParserLINEAR_LEARNER, 0) +} + +func (s *Unreserved_keywordContext) KMEANS() antlr.TerminalNode { + return s.GetToken(RedshiftParserKMEANS, 0) +} + +func (s *Unreserved_keywordContext) FORECAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORECAST, 0) +} + +func (s *Unreserved_keywordContext) REGRESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGRESSION, 0) +} + +func (s *Unreserved_keywordContext) BINARY_CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserBINARY_CLASSIFICATION, 0) +} + +func (s *Unreserved_keywordContext) MULTICLASS_CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserMULTICLASS_CLASSIFICATION, 0) +} + +func (s *Unreserved_keywordContext) S3_BUCKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserS3_BUCKET, 0) +} + +func (s *Unreserved_keywordContext) TAGS() antlr.TerminalNode { + return s.GetToken(RedshiftParserTAGS, 0) +} + +func (s *Unreserved_keywordContext) KMS_KEY_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserKMS_KEY_ID, 0) +} + +func (s *Unreserved_keywordContext) S3_GARBAGE_COLLECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserS3_GARBAGE_COLLECT, 0) +} + +func (s *Unreserved_keywordContext) MAX_CELLS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_CELLS, 0) +} + +func (s *Unreserved_keywordContext) MAX_RUNTIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_RUNTIME, 0) +} + +func (s *Unreserved_keywordContext) HORIZON() antlr.TerminalNode { + return s.GetToken(RedshiftParserHORIZON, 0) +} + +func (s *Unreserved_keywordContext) FREQUENCY() antlr.TerminalNode { + return s.GetToken(RedshiftParserFREQUENCY, 0) +} + +func (s *Unreserved_keywordContext) PERCENTILES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERCENTILES, 0) +} + +func (s *Unreserved_keywordContext) MAX_BATCH_ROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAX_BATCH_ROWS, 0) +} + +func (s *Unreserved_keywordContext) UNLOAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLOAD, 0) +} + +func (s *Unreserved_keywordContext) MANIFEST() antlr.TerminalNode { + return s.GetToken(RedshiftParserMANIFEST, 0) +} + +func (s *Unreserved_keywordContext) ADDQUOTES() antlr.TerminalNode { + return s.GetToken(RedshiftParserADDQUOTES, 0) +} + +func (s *Unreserved_keywordContext) ALLOWOVERWRITE() antlr.TerminalNode { + return s.GetToken(RedshiftParserALLOWOVERWRITE, 0) +} + +func (s *Unreserved_keywordContext) CLEANPATH() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLEANPATH, 0) +} + +func (s *Unreserved_keywordContext) MAXFILESIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAXFILESIZE, 0) +} + +func (s *Unreserved_keywordContext) ROWGROUPSIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWGROUPSIZE, 0) +} + +func (s *Unreserved_keywordContext) BZIP2() antlr.TerminalNode { + return s.GetToken(RedshiftParserBZIP2, 0) +} + +func (s *Unreserved_keywordContext) GZIP() antlr.TerminalNode { + return s.GetToken(RedshiftParserGZIP, 0) +} + +func (s *Unreserved_keywordContext) ZSTD() antlr.TerminalNode { + return s.GetToken(RedshiftParserZSTD, 0) +} + +func (s *Unreserved_keywordContext) DATABASES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATABASES, 0) +} + +func (s *Unreserved_keywordContext) DATASHARES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATASHARES, 0) +} + +func (s *Unreserved_keywordContext) GRANTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANTS, 0) +} + +func (s *Unreserved_keywordContext) USE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSE, 0) +} + +func (s *Unreserved_keywordContext) CANCEL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCANCEL, 0) +} + +func (s *Unreserved_keywordContext) SESSION_AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_AUTHORIZATION, 0) +} + +func (s *Unreserved_keywordContext) SESSION_CHARACTERISTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_CHARACTERISTICS, 0) +} + +func (s *Unreserved_keywordContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPRESSION, 0) +} + +func (s *Unreserved_keywordContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIBRARY, 0) +} + +func (s *Unreserved_keywordContext) APPEND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAPPEND, 0) +} + +func (s *Unreserved_keywordContext) MB() antlr.TerminalNode { + return s.GetToken(RedshiftParserMB, 0) +} + +func (s *Unreserved_keywordContext) GB() antlr.TerminalNode { + return s.GetToken(RedshiftParserGB, 0) +} + +func (s *Unreserved_keywordContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCOUNT, 0) +} + +func (s *Unreserved_keywordContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNAMESPACE, 0) +} + +func (s *Unreserved_keywordContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDESCRIBE, 0) +} + +func (s *Unreserved_keywordContext) NONATOMIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONATOMIC, 0) +} + +func (s *Unreserved_keywordContext) MANAGEDBY() antlr.TerminalNode { + return s.GetToken(RedshiftParserMANAGEDBY, 0) +} + +func (s *Unreserved_keywordContext) ADX() antlr.TerminalNode { + return s.GetToken(RedshiftParserADX, 0) +} + +func (s *Unreserved_keywordContext) REMOVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREMOVE, 0) +} + +func (s *Unreserved_keywordContext) DUPLICATES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDUPLICATES, 0) +} + +func (s *Unreserved_keywordContext) BEDROCK() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEDROCK, 0) +} + +func (s *Unreserved_keywordContext) MODEL_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserMODEL_ID, 0) +} + +func (s *Unreserved_keywordContext) PROMPT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROMPT, 0) +} + +func (s *Unreserved_keywordContext) SUFFIX() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUFFIX, 0) +} + +func (s *Unreserved_keywordContext) REQUEST_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREQUEST_TYPE, 0) +} + +func (s *Unreserved_keywordContext) RESPONSE_TYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESPONSE_TYPE, 0) +} + +func (s *Unreserved_keywordContext) RAW() antlr.TerminalNode { + return s.GetToken(RedshiftParserRAW, 0) +} + +func (s *Unreserved_keywordContext) UNIFIED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIFIED, 0) +} + +func (s *Unreserved_keywordContext) SUPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUPER, 0) +} + +func (s *Unreserved_keywordContext) CI() antlr.TerminalNode { + return s.GetToken(RedshiftParserCI, 0) +} + +func (s *Unreserved_keywordContext) CS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCS, 0) +} + +func (s *Unreserved_keywordContext) PLPYTHONU() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLPYTHONU, 0) +} + +func (s *Unreserved_keywordContext) FILLTARGET() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILLTARGET, 0) +} + +func (s *Unreserved_keywordContext) IGNOREEXTRA() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNOREEXTRA, 0) +} + +func (s *Unreserved_keywordContext) CREATEUSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATEUSER, 0) +} + +func (s *Unreserved_keywordContext) NOCREATEUSER() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOCREATEUSER, 0) +} + +func (s *Unreserved_keywordContext) REGION() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGION, 0) +} + +func (s *Unreserved_keywordContext) PORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPORT, 0) +} + +func (s *Unreserved_keywordContext) REDSHIFT() antlr.TerminalNode { + return s.GetToken(RedshiftParserREDSHIFT, 0) +} + +func (s *Unreserved_keywordContext) IAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserIAM, 0) +} + +func (s *Unreserved_keywordContext) CREATEDB() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATEDB, 0) +} + +func (s *Unreserved_keywordContext) NOCREATEDB() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOCREATEDB, 0) +} + +func (s *Unreserved_keywordContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESTRICTED, 0) +} + +func (s *Unreserved_keywordContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNLIMITED, 0) +} + +func (s *Unreserved_keywordContext) EXTERNALID() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTERNALID, 0) +} + +func (s *Unreserved_keywordContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMEOUT, 0) +} + +func (s *Unreserved_keywordContext) SYSLOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYSLOG, 0) +} + +func (s *Unreserved_keywordContext) CREDENTIALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREDENTIALS, 0) +} + +func (s *Unreserved_keywordContext) UNRESTRICTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNRESTRICTED, 0) +} + +func (s *Unreserved_keywordContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAMETERS, 0) +} + +func (s *Unreserved_keywordContext) APPLICATION_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserAPPLICATION_ARN, 0) +} + +func (s *Unreserved_keywordContext) AUTO_CREATE_ROLES() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTO_CREATE_ROLES, 0) +} + +func (s *Unreserved_keywordContext) COMPROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPROWS, 0) +} + +func (s *Unreserved_keywordContext) PROVIDER_URL() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER_URL, 0) +} + +func (s *Unreserved_keywordContext) PROVIDER_URL_PORT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER_URL_PORT, 0) +} + +func (s *Unreserved_keywordContext) ATTRIBUTE_MAP() antlr.TerminalNode { + return s.GetToken(RedshiftParserATTRIBUTE_MAP, 0) +} + +func (s *Unreserved_keywordContext) PROVIDER_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROVIDER_ARN, 0) +} + +func (s *Unreserved_keywordContext) ASSUME_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSUME_ROLE_ARN, 0) +} + +func (s *Unreserved_keywordContext) PROPERTIES() antlr.TerminalNode { + return s.GetToken(RedshiftParserPROPERTIES, 0) +} + +func (s *Unreserved_keywordContext) AVRO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAVRO, 0) +} + +func (s *Unreserved_keywordContext) RCFILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRCFILE, 0) +} + +func (s *Unreserved_keywordContext) SEQUENCEFILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEQUENCEFILE, 0) +} + +func (s *Unreserved_keywordContext) TEXTFILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTEXTFILE, 0) +} + +func (s *Unreserved_keywordContext) ORC() antlr.TerminalNode { + return s.GetToken(RedshiftParserORC, 0) +} + +func (s *Unreserved_keywordContext) ION() antlr.TerminalNode { + return s.GetToken(RedshiftParserION, 0) +} + +func (s *Unreserved_keywordContext) LAMBDA() antlr.TerminalNode { + return s.GetToken(RedshiftParserLAMBDA, 0) +} + +func (s *Unreserved_keywordContext) FIXEDWIDTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIXEDWIDTH, 0) +} + +func (s *Unreserved_keywordContext) PARQUET() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARQUET, 0) +} + +func (s *Unreserved_keywordContext) LZOP() antlr.TerminalNode { + return s.GetToken(RedshiftParserLZOP, 0) +} + +func (s *Unreserved_keywordContext) REMOVEQUOTES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREMOVEQUOTES, 0) +} + +func (s *Unreserved_keywordContext) TRUNCATECOLUMNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNCATECOLUMNS, 0) +} + +func (s *Unreserved_keywordContext) FILLRECORD() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILLRECORD, 0) +} + +func (s *Unreserved_keywordContext) BLANKSASNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserBLANKSASNULL, 0) +} + +func (s *Unreserved_keywordContext) EMPTYASNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEMPTYASNULL, 0) +} + +func (s *Unreserved_keywordContext) MAXERROR() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAXERROR, 0) +} + +func (s *Unreserved_keywordContext) DATEFORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATEFORMAT, 0) +} + +func (s *Unreserved_keywordContext) TIMEFORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMEFORMAT, 0) +} + +func (s *Unreserved_keywordContext) ACCEPTINVCHARS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCEPTINVCHARS, 0) +} + +func (s *Unreserved_keywordContext) ACCEPTANYDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCEPTANYDATE, 0) +} + +func (s *Unreserved_keywordContext) IGNOREHEADER() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNOREHEADER, 0) +} + +func (s *Unreserved_keywordContext) IGNOREBLANKLINES() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNOREBLANKLINES, 0) +} + +func (s *Unreserved_keywordContext) COMPUPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPUPDATE, 0) +} + +func (s *Unreserved_keywordContext) STATUPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATUPDATE, 0) +} + +func (s *Unreserved_keywordContext) EXPLICIT_IDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPLICIT_IDS, 0) +} + +func (s *Unreserved_keywordContext) READRATIO() antlr.TerminalNode { + return s.GetToken(RedshiftParserREADRATIO, 0) +} + +func (s *Unreserved_keywordContext) ROUNDEC() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUNDEC, 0) +} + +func (s *Unreserved_keywordContext) TRIMBLANKS() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIMBLANKS, 0) +} + +func (s *Unreserved_keywordContext) PRESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRESET, 0) +} + +func (s *Unreserved_keywordContext) ACCESS_KEY_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS_KEY_ID, 0) +} + +func (s *Unreserved_keywordContext) SECRET_ACCESS_KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECRET_ACCESS_KEY, 0) +} + +func (s *Unreserved_keywordContext) SESSION_TOKEN_KW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_TOKEN_KW, 0) +} + +func (s *Unreserved_keywordContext) HEADER() antlr.TerminalNode { + return s.GetToken(RedshiftParserHEADER, 0) +} + +func (s *Unreserved_keywordContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETTINGS, 0) +} + +func (s *Unreserved_keywordContext) FUNCTION_NAME() antlr.TerminalNode { + return s.GetToken(RedshiftParserFUNCTION_NAME, 0) +} + +func (s *Unreserved_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unreserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unreserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterUnreserved_keyword(s) + } +} + +func (s *Unreserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitUnreserved_keyword(s) + } +} + +func (s *Unreserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitUnreserved_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Unreserved_keyword() (localctx IUnreserved_keywordContext) { + localctx = NewUnreserved_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1938, RedshiftParserRULE_unreserved_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14214) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-86)) & ^0x3f) == 0 && ((int64(1)<<(_la-86))&-34084860461055) != 0) || ((int64((_la-150)) & ^0x3f) == 0 && ((int64(1)<<(_la-150))&-285212673) != 0) || ((int64((_la-214)) & ^0x3f) == 0 && ((int64(1)<<(_la-214))&-9895604649985) != 0) || ((int64((_la-278)) & ^0x3f) == 0 && ((int64(1)<<(_la-278))&-2147484161) != 0) || ((int64((_la-342)) & ^0x3f) == 0 && ((int64(1)<<(_la-342))&-2805953674084353) != 0) || ((int64((_la-406)) & ^0x3f) == 0 && ((int64(1)<<(_la-406))&-1) != 0) || ((int64((_la-470)) & ^0x3f) == 0 && ((int64(1)<<(_la-470))&-1) != 0) || ((int64((_la-534)) & ^0x3f) == 0 && ((int64(1)<<(_la-534))&549755846655) != 0) || ((int64((_la-603)) & ^0x3f) == 0 && ((int64(1)<<(_la-603))&-1688918579740417) != 0) || ((int64((_la-667)) & ^0x3f) == 0 && ((int64(1)<<(_la-667))&2096299) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICol_name_keywordContext is an interface to support dynamic dispatch. +type ICol_name_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BETWEEN() antlr.TerminalNode + BIGINT() antlr.TerminalNode + Bit() IBitContext + BOOLEAN_P() antlr.TerminalNode + CHAR_P() antlr.TerminalNode + Character() ICharacterContext + COALESCE() antlr.TerminalNode + DEC() antlr.TerminalNode + DECIMAL_P() antlr.TerminalNode + EXISTS() antlr.TerminalNode + EXTRACT() antlr.TerminalNode + FLOAT_P() antlr.TerminalNode + GREATEST() antlr.TerminalNode + GROUPING() antlr.TerminalNode + INOUT() antlr.TerminalNode + INT_P() antlr.TerminalNode + INTEGER() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + JSON() antlr.TerminalNode + IGNOREHEADER() antlr.TerminalNode + IGNOREBLANKLINES() antlr.TerminalNode + TRUNCATECOLUMNS() antlr.TerminalNode + FILLRECORD() antlr.TerminalNode + BLANKSASNULL() antlr.TerminalNode + EMPTYASNULL() antlr.TerminalNode + ACCEPTINVCHARS() antlr.TerminalNode + ACCEPTANYDATE() antlr.TerminalNode + DATEFORMAT() antlr.TerminalNode + TIMEFORMAT() antlr.TerminalNode + COMPUPDATE() antlr.TerminalNode + STATUPDATE() antlr.TerminalNode + MAXERROR() antlr.TerminalNode + READRATIO() antlr.TerminalNode + MANIFEST() antlr.TerminalNode + ENCRYPTED() antlr.TerminalNode + REMOVEQUOTES() antlr.TerminalNode + EXPLICIT_IDS() antlr.TerminalNode + ROUNDEC() antlr.TerminalNode + TRIMBLANKS() antlr.TerminalNode + FIXEDWIDTH() antlr.TerminalNode + ACCESS_KEY_ID() antlr.TerminalNode + SECRET_ACCESS_KEY() antlr.TerminalNode + SESSION_TOKEN_KW() antlr.TerminalNode + GZIP() antlr.TerminalNode + BZIP2() antlr.TerminalNode + LZOP() antlr.TerminalNode + ZSTD() antlr.TerminalNode + AVRO() antlr.TerminalNode + PARQUET() antlr.TerminalNode + ORC() antlr.TerminalNode + REGION() antlr.TerminalNode + DELIMITER() antlr.TerminalNode + ENCODING() antlr.TerminalNode + COMPRESSION() antlr.TerminalNode + QUOTE() antlr.TerminalNode + COMPROWS() antlr.TerminalNode + LEAST() antlr.TerminalNode + NATIONAL() antlr.TerminalNode + NCHAR() antlr.TerminalNode + NONE() antlr.TerminalNode + NORMALIZE() antlr.TerminalNode + NULLIF() antlr.TerminalNode + Numeric() INumericContext + OFFSET() antlr.TerminalNode + OUT_P() antlr.TerminalNode + OVERLAY() antlr.TerminalNode + POSITION() antlr.TerminalNode + PRECISION() antlr.TerminalNode + REAL() antlr.TerminalNode + ROW() antlr.TerminalNode + SETOF() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + SUBSTRING() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TREAT() antlr.TerminalNode + TRIM() antlr.TerminalNode + VALUES() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + XMLATTRIBUTES() antlr.TerminalNode + XMLCONCAT() antlr.TerminalNode + XMLELEMENT() antlr.TerminalNode + XMLEXISTS() antlr.TerminalNode + XMLFOREST() antlr.TerminalNode + XMLNAMESPACES() antlr.TerminalNode + XMLPARSE() antlr.TerminalNode + XMLPI() antlr.TerminalNode + XMLROOT() antlr.TerminalNode + XMLSERIALIZE() antlr.TerminalNode + XMLTABLE() antlr.TerminalNode + Builtin_function_name() IBuiltin_function_nameContext + + // IsCol_name_keywordContext differentiates from other interfaces. + IsCol_name_keywordContext() +} + +type Col_name_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCol_name_keywordContext() *Col_name_keywordContext { + var p = new(Col_name_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_col_name_keyword + return p +} + +func InitEmptyCol_name_keywordContext(p *Col_name_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_col_name_keyword +} + +func (*Col_name_keywordContext) IsCol_name_keywordContext() {} + +func NewCol_name_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Col_name_keywordContext { + var p = new(Col_name_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_col_name_keyword + + return p +} + +func (s *Col_name_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Col_name_keywordContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserBETWEEN, 0) +} + +func (s *Col_name_keywordContext) BIGINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserBIGINT, 0) +} + +func (s *Col_name_keywordContext) Bit() IBitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitContext) +} + +func (s *Col_name_keywordContext) BOOLEAN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserBOOLEAN_P, 0) +} + +func (s *Col_name_keywordContext) CHAR_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHAR_P, 0) +} + +func (s *Col_name_keywordContext) Character() ICharacterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharacterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharacterContext) +} + +func (s *Col_name_keywordContext) COALESCE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOALESCE, 0) +} + +func (s *Col_name_keywordContext) DEC() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEC, 0) +} + +func (s *Col_name_keywordContext) DECIMAL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserDECIMAL_P, 0) +} + +func (s *Col_name_keywordContext) EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXISTS, 0) +} + +func (s *Col_name_keywordContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXTRACT, 0) +} + +func (s *Col_name_keywordContext) FLOAT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFLOAT_P, 0) +} + +func (s *Col_name_keywordContext) GREATEST() antlr.TerminalNode { + return s.GetToken(RedshiftParserGREATEST, 0) +} + +func (s *Col_name_keywordContext) GROUPING() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUPING, 0) +} + +func (s *Col_name_keywordContext) INOUT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINOUT, 0) +} + +func (s *Col_name_keywordContext) INT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINT_P, 0) +} + +func (s *Col_name_keywordContext) INTEGER() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTEGER, 0) +} + +func (s *Col_name_keywordContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTERVAL, 0) +} + +func (s *Col_name_keywordContext) JSON() antlr.TerminalNode { + return s.GetToken(RedshiftParserJSON, 0) +} + +func (s *Col_name_keywordContext) IGNOREHEADER() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNOREHEADER, 0) +} + +func (s *Col_name_keywordContext) IGNOREBLANKLINES() antlr.TerminalNode { + return s.GetToken(RedshiftParserIGNOREBLANKLINES, 0) +} + +func (s *Col_name_keywordContext) TRUNCATECOLUMNS() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNCATECOLUMNS, 0) +} + +func (s *Col_name_keywordContext) FILLRECORD() antlr.TerminalNode { + return s.GetToken(RedshiftParserFILLRECORD, 0) +} + +func (s *Col_name_keywordContext) BLANKSASNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserBLANKSASNULL, 0) +} + +func (s *Col_name_keywordContext) EMPTYASNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEMPTYASNULL, 0) +} + +func (s *Col_name_keywordContext) ACCEPTINVCHARS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCEPTINVCHARS, 0) +} + +func (s *Col_name_keywordContext) ACCEPTANYDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCEPTANYDATE, 0) +} + +func (s *Col_name_keywordContext) DATEFORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATEFORMAT, 0) +} + +func (s *Col_name_keywordContext) TIMEFORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMEFORMAT, 0) +} + +func (s *Col_name_keywordContext) COMPUPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPUPDATE, 0) +} + +func (s *Col_name_keywordContext) STATUPDATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATUPDATE, 0) +} + +func (s *Col_name_keywordContext) MAXERROR() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAXERROR, 0) +} + +func (s *Col_name_keywordContext) READRATIO() antlr.TerminalNode { + return s.GetToken(RedshiftParserREADRATIO, 0) +} + +func (s *Col_name_keywordContext) MANIFEST() antlr.TerminalNode { + return s.GetToken(RedshiftParserMANIFEST, 0) +} + +func (s *Col_name_keywordContext) ENCRYPTED() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCRYPTED, 0) +} + +func (s *Col_name_keywordContext) REMOVEQUOTES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREMOVEQUOTES, 0) +} + +func (s *Col_name_keywordContext) EXPLICIT_IDS() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXPLICIT_IDS, 0) +} + +func (s *Col_name_keywordContext) ROUNDEC() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUNDEC, 0) +} + +func (s *Col_name_keywordContext) TRIMBLANKS() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIMBLANKS, 0) +} + +func (s *Col_name_keywordContext) FIXEDWIDTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIXEDWIDTH, 0) +} + +func (s *Col_name_keywordContext) ACCESS_KEY_ID() antlr.TerminalNode { + return s.GetToken(RedshiftParserACCESS_KEY_ID, 0) +} + +func (s *Col_name_keywordContext) SECRET_ACCESS_KEY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSECRET_ACCESS_KEY, 0) +} + +func (s *Col_name_keywordContext) SESSION_TOKEN_KW() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_TOKEN_KW, 0) +} + +func (s *Col_name_keywordContext) GZIP() antlr.TerminalNode { + return s.GetToken(RedshiftParserGZIP, 0) +} + +func (s *Col_name_keywordContext) BZIP2() antlr.TerminalNode { + return s.GetToken(RedshiftParserBZIP2, 0) +} + +func (s *Col_name_keywordContext) LZOP() antlr.TerminalNode { + return s.GetToken(RedshiftParserLZOP, 0) +} + +func (s *Col_name_keywordContext) ZSTD() antlr.TerminalNode { + return s.GetToken(RedshiftParserZSTD, 0) +} + +func (s *Col_name_keywordContext) AVRO() antlr.TerminalNode { + return s.GetToken(RedshiftParserAVRO, 0) +} + +func (s *Col_name_keywordContext) PARQUET() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARQUET, 0) +} + +func (s *Col_name_keywordContext) ORC() antlr.TerminalNode { + return s.GetToken(RedshiftParserORC, 0) +} + +func (s *Col_name_keywordContext) REGION() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGION, 0) +} + +func (s *Col_name_keywordContext) DELIMITER() antlr.TerminalNode { + return s.GetToken(RedshiftParserDELIMITER, 0) +} + +func (s *Col_name_keywordContext) ENCODING() antlr.TerminalNode { + return s.GetToken(RedshiftParserENCODING, 0) +} + +func (s *Col_name_keywordContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPRESSION, 0) +} + +func (s *Col_name_keywordContext) QUOTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTE, 0) +} + +func (s *Col_name_keywordContext) COMPROWS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMPROWS, 0) +} + +func (s *Col_name_keywordContext) LEAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEAST, 0) +} + +func (s *Col_name_keywordContext) NATIONAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserNATIONAL, 0) +} + +func (s *Col_name_keywordContext) NCHAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserNCHAR, 0) +} + +func (s *Col_name_keywordContext) NONE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNONE, 0) +} + +func (s *Col_name_keywordContext) NORMALIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNORMALIZE, 0) +} + +func (s *Col_name_keywordContext) NULLIF() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULLIF, 0) +} + +func (s *Col_name_keywordContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Col_name_keywordContext) OFFSET() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFFSET, 0) +} + +func (s *Col_name_keywordContext) OUT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOUT_P, 0) +} + +func (s *Col_name_keywordContext) OVERLAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVERLAY, 0) +} + +func (s *Col_name_keywordContext) POSITION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOSITION, 0) +} + +func (s *Col_name_keywordContext) PRECISION() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRECISION, 0) +} + +func (s *Col_name_keywordContext) REAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserREAL, 0) +} + +func (s *Col_name_keywordContext) ROW() antlr.TerminalNode { + return s.GetToken(RedshiftParserROW, 0) +} + +func (s *Col_name_keywordContext) SETOF() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETOF, 0) +} + +func (s *Col_name_keywordContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSMALLINT, 0) +} + +func (s *Col_name_keywordContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSTRING, 0) +} + +func (s *Col_name_keywordContext) TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIME, 0) +} + +func (s *Col_name_keywordContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMESTAMP, 0) +} + +func (s *Col_name_keywordContext) TREAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserTREAT, 0) +} + +func (s *Col_name_keywordContext) TRIM() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIM, 0) +} + +func (s *Col_name_keywordContext) VALUES() antlr.TerminalNode { + return s.GetToken(RedshiftParserVALUES, 0) +} + +func (s *Col_name_keywordContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARCHAR, 0) +} + +func (s *Col_name_keywordContext) XMLATTRIBUTES() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLATTRIBUTES, 0) +} + +func (s *Col_name_keywordContext) XMLCONCAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLCONCAT, 0) +} + +func (s *Col_name_keywordContext) XMLELEMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLELEMENT, 0) +} + +func (s *Col_name_keywordContext) XMLEXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLEXISTS, 0) +} + +func (s *Col_name_keywordContext) XMLFOREST() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLFOREST, 0) +} + +func (s *Col_name_keywordContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLNAMESPACES, 0) +} + +func (s *Col_name_keywordContext) XMLPARSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLPARSE, 0) +} + +func (s *Col_name_keywordContext) XMLPI() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLPI, 0) +} + +func (s *Col_name_keywordContext) XMLROOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLROOT, 0) +} + +func (s *Col_name_keywordContext) XMLSERIALIZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLSERIALIZE, 0) +} + +func (s *Col_name_keywordContext) XMLTABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLTABLE, 0) +} + +func (s *Col_name_keywordContext) Builtin_function_name() IBuiltin_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuiltin_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuiltin_function_nameContext) +} + +func (s *Col_name_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Col_name_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Col_name_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCol_name_keyword(s) + } +} + +func (s *Col_name_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCol_name_keyword(s) + } +} + +func (s *Col_name_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCol_name_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Col_name_keyword() (localctx ICol_name_keywordContext) { + localctx = NewCol_name_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1940, RedshiftParserRULE_col_name_keyword) + p.SetState(14307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1388, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14216) + p.Match(RedshiftParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14217) + p.Match(RedshiftParserBIGINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14218) + p.Bit() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14219) + p.Match(RedshiftParserBOOLEAN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14220) + p.Match(RedshiftParserCHAR_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14221) + p.Character() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14222) + p.Match(RedshiftParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14223) + p.Match(RedshiftParserDEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14224) + p.Match(RedshiftParserDECIMAL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(14225) + p.Match(RedshiftParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(14226) + p.Match(RedshiftParserEXTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(14227) + p.Match(RedshiftParserFLOAT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(14228) + p.Match(RedshiftParserGREATEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(14229) + p.Match(RedshiftParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(14230) + p.Match(RedshiftParserINOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(14231) + p.Match(RedshiftParserINT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(14232) + p.Match(RedshiftParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(14233) + p.Match(RedshiftParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(14234) + p.Match(RedshiftParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(14235) + p.Match(RedshiftParserIGNOREHEADER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(14236) + p.Match(RedshiftParserIGNOREBLANKLINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(14237) + p.Match(RedshiftParserTRUNCATECOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(14238) + p.Match(RedshiftParserFILLRECORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(14239) + p.Match(RedshiftParserBLANKSASNULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(14240) + p.Match(RedshiftParserEMPTYASNULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(14241) + p.Match(RedshiftParserACCEPTINVCHARS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(14242) + p.Match(RedshiftParserACCEPTANYDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(14243) + p.Match(RedshiftParserDATEFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(14244) + p.Match(RedshiftParserTIMEFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(14245) + p.Match(RedshiftParserCOMPUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(14246) + p.Match(RedshiftParserSTATUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(14247) + p.Match(RedshiftParserMAXERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(14248) + p.Match(RedshiftParserREADRATIO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(14249) + p.Match(RedshiftParserMANIFEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(14250) + p.Match(RedshiftParserENCRYPTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(14251) + p.Match(RedshiftParserREMOVEQUOTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(14252) + p.Match(RedshiftParserEXPLICIT_IDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(14253) + p.Match(RedshiftParserROUNDEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(14254) + p.Match(RedshiftParserTRIMBLANKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(14255) + p.Match(RedshiftParserFIXEDWIDTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(14256) + p.Match(RedshiftParserACCESS_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(14257) + p.Match(RedshiftParserSECRET_ACCESS_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(14258) + p.Match(RedshiftParserSESSION_TOKEN_KW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(14259) + p.Match(RedshiftParserGZIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(14260) + p.Match(RedshiftParserBZIP2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(14261) + p.Match(RedshiftParserLZOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(14262) + p.Match(RedshiftParserZSTD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(14263) + p.Match(RedshiftParserAVRO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(14264) + p.Match(RedshiftParserPARQUET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(14265) + p.Match(RedshiftParserORC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(14266) + p.Match(RedshiftParserREGION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(14267) + p.Match(RedshiftParserDELIMITER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(14268) + p.Match(RedshiftParserENCODING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(14269) + p.Match(RedshiftParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(14270) + p.Match(RedshiftParserQUOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(14271) + p.Match(RedshiftParserCOMPROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(14272) + p.Match(RedshiftParserLEAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(14273) + p.Match(RedshiftParserNATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(14274) + p.Match(RedshiftParserNCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(14275) + p.Match(RedshiftParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(14276) + p.Match(RedshiftParserNORMALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(14277) + p.Match(RedshiftParserNULLIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(14278) + p.Numeric() + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(14279) + p.Match(RedshiftParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(14280) + p.Match(RedshiftParserOUT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(14281) + p.Match(RedshiftParserOVERLAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(14282) + p.Match(RedshiftParserPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(14283) + p.Match(RedshiftParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(14284) + p.Match(RedshiftParserREAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(14285) + p.Match(RedshiftParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(14286) + p.Match(RedshiftParserSETOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(14287) + p.Match(RedshiftParserSMALLINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(14288) + p.Match(RedshiftParserSUBSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(14289) + p.Match(RedshiftParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(14290) + p.Match(RedshiftParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(14291) + p.Match(RedshiftParserTREAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(14292) + p.Match(RedshiftParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(14293) + p.Match(RedshiftParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(14294) + p.Match(RedshiftParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(14295) + p.Match(RedshiftParserXMLATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(14296) + p.Match(RedshiftParserXMLCONCAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(14297) + p.Match(RedshiftParserXMLELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(14298) + p.Match(RedshiftParserXMLEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(14299) + p.Match(RedshiftParserXMLFOREST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(14300) + p.Match(RedshiftParserXMLNAMESPACES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(14301) + p.Match(RedshiftParserXMLPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(14302) + p.Match(RedshiftParserXMLPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(14303) + p.Match(RedshiftParserXMLROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(14304) + p.Match(RedshiftParserXMLSERIALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(14305) + p.Match(RedshiftParserXMLTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(14306) + p.Builtin_function_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_func_name_keywordContext is an interface to support dynamic dispatch. +type IType_func_name_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTHORIZATION() antlr.TerminalNode + BINARY() antlr.TerminalNode + COLLATION() antlr.TerminalNode + CONCURRENTLY() antlr.TerminalNode + CROSS() antlr.TerminalNode + CURRENT_SCHEMA() antlr.TerminalNode + FREEZE() antlr.TerminalNode + FULL() antlr.TerminalNode + ILIKE() antlr.TerminalNode + INNER_P() antlr.TerminalNode + IS() antlr.TerminalNode + ISNULL() antlr.TerminalNode + JOIN() antlr.TerminalNode + LIKE() antlr.TerminalNode + NATURAL() antlr.TerminalNode + NOTNULL() antlr.TerminalNode + OUTER_P() antlr.TerminalNode + OVERLAPS() antlr.TerminalNode + SIMILAR() antlr.TerminalNode + TABLESAMPLE() antlr.TerminalNode + VERBOSE() antlr.TerminalNode + + // IsType_func_name_keywordContext differentiates from other interfaces. + IsType_func_name_keywordContext() +} + +type Type_func_name_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_func_name_keywordContext() *Type_func_name_keywordContext { + var p = new(Type_func_name_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_func_name_keyword + return p +} + +func InitEmptyType_func_name_keywordContext(p *Type_func_name_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_type_func_name_keyword +} + +func (*Type_func_name_keywordContext) IsType_func_name_keywordContext() {} + +func NewType_func_name_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_func_name_keywordContext { + var p = new(Type_func_name_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_type_func_name_keyword + + return p +} + +func (s *Type_func_name_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_func_name_keywordContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserAUTHORIZATION, 0) +} + +func (s *Type_func_name_keywordContext) BINARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBINARY, 0) +} + +func (s *Type_func_name_keywordContext) COLLATION() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATION, 0) +} + +func (s *Type_func_name_keywordContext) CONCURRENTLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONCURRENTLY, 0) +} + +func (s *Type_func_name_keywordContext) CROSS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCROSS, 0) +} + +func (s *Type_func_name_keywordContext) CURRENT_SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_SCHEMA, 0) +} + +func (s *Type_func_name_keywordContext) FREEZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserFREEZE, 0) +} + +func (s *Type_func_name_keywordContext) FULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserFULL, 0) +} + +func (s *Type_func_name_keywordContext) ILIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserILIKE, 0) +} + +func (s *Type_func_name_keywordContext) INNER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserINNER_P, 0) +} + +func (s *Type_func_name_keywordContext) IS() antlr.TerminalNode { + return s.GetToken(RedshiftParserIS, 0) +} + +func (s *Type_func_name_keywordContext) ISNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserISNULL, 0) +} + +func (s *Type_func_name_keywordContext) JOIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserJOIN, 0) +} + +func (s *Type_func_name_keywordContext) LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIKE, 0) +} + +func (s *Type_func_name_keywordContext) NATURAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserNATURAL, 0) +} + +func (s *Type_func_name_keywordContext) NOTNULL() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTNULL, 0) +} + +func (s *Type_func_name_keywordContext) OUTER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOUTER_P, 0) +} + +func (s *Type_func_name_keywordContext) OVERLAPS() antlr.TerminalNode { + return s.GetToken(RedshiftParserOVERLAPS, 0) +} + +func (s *Type_func_name_keywordContext) SIMILAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIMILAR, 0) +} + +func (s *Type_func_name_keywordContext) TABLESAMPLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLESAMPLE, 0) +} + +func (s *Type_func_name_keywordContext) VERBOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserVERBOSE, 0) +} + +func (s *Type_func_name_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_func_name_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_func_name_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterType_func_name_keyword(s) + } +} + +func (s *Type_func_name_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitType_func_name_keyword(s) + } +} + +func (s *Type_func_name_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitType_func_name_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Type_func_name_keyword() (localctx IType_func_name_keywordContext) { + localctx = NewType_func_name_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1942, RedshiftParserRULE_type_func_name_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14309) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-107)) & ^0x3f) == 0 && ((int64(1)<<(_la-107))&14139387) != 0) || _la == RedshiftParserTABLESAMPLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReserved_keywordContext is an interface to support dynamic dispatch. +type IReserved_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + ANALYSE() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + AND() antlr.TerminalNode + ANY() antlr.TerminalNode + ARRAY() antlr.TerminalNode + AS() antlr.TerminalNode + ASC() antlr.TerminalNode + ASYMMETRIC() antlr.TerminalNode + BOTH() antlr.TerminalNode + CASE() antlr.TerminalNode + CAST() antlr.TerminalNode + CHECK() antlr.TerminalNode + COLLATE() antlr.TerminalNode + COLUMN() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + CREATE() antlr.TerminalNode + CURRENT_CATALOG() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + CURRENT_ROLE() antlr.TerminalNode + CURRENT_TIME() antlr.TerminalNode + CURRENT_TIMESTAMP() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + DEFERRABLE() antlr.TerminalNode + DESC() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + DO() antlr.TerminalNode + ELSE() antlr.TerminalNode + END_P() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + FALSE_P() antlr.TerminalNode + FETCH() antlr.TerminalNode + FOR() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + FROM() antlr.TerminalNode + GRANT() antlr.TerminalNode + GROUP_P() antlr.TerminalNode + HAVING() antlr.TerminalNode + IN_P() antlr.TerminalNode + INITIALLY() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + LATERAL_P() antlr.TerminalNode + LEADING() antlr.TerminalNode + LIMIT() antlr.TerminalNode + LOCALTIME() antlr.TerminalNode + LOCALTIMESTAMP() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_P() antlr.TerminalNode + OFFSET() antlr.TerminalNode + ON() antlr.TerminalNode + ONLY() antlr.TerminalNode + OR() antlr.TerminalNode + ORDER() antlr.TerminalNode + PLACING() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + RETURNING() antlr.TerminalNode + SELECT() antlr.TerminalNode + SESSION_USER() antlr.TerminalNode + SOME() antlr.TerminalNode + SYMMETRIC() antlr.TerminalNode + TABLE() antlr.TerminalNode + THEN() antlr.TerminalNode + TO() antlr.TerminalNode + TRAILING() antlr.TerminalNode + TRUE_P() antlr.TerminalNode + UNION() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + USER() antlr.TerminalNode + USING() antlr.TerminalNode + VARIADIC() antlr.TerminalNode + WHEN() antlr.TerminalNode + WHERE() antlr.TerminalNode + WINDOW() antlr.TerminalNode + WITH() antlr.TerminalNode + + // IsReserved_keywordContext differentiates from other interfaces. + IsReserved_keywordContext() +} + +type Reserved_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReserved_keywordContext() *Reserved_keywordContext { + var p = new(Reserved_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reserved_keyword + return p +} + +func InitEmptyReserved_keywordContext(p *Reserved_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_reserved_keyword +} + +func (*Reserved_keywordContext) IsReserved_keywordContext() {} + +func NewReserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reserved_keywordContext { + var p = new(Reserved_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_reserved_keyword + + return p +} + +func (s *Reserved_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reserved_keywordContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Reserved_keywordContext) ANALYSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserANALYSE, 0) +} + +func (s *Reserved_keywordContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(RedshiftParserANALYZE, 0) +} + +func (s *Reserved_keywordContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Reserved_keywordContext) ANY() antlr.TerminalNode { + return s.GetToken(RedshiftParserANY, 0) +} + +func (s *Reserved_keywordContext) ARRAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserARRAY, 0) +} + +func (s *Reserved_keywordContext) AS() antlr.TerminalNode { + return s.GetToken(RedshiftParserAS, 0) +} + +func (s *Reserved_keywordContext) ASC() antlr.TerminalNode { + return s.GetToken(RedshiftParserASC, 0) +} + +func (s *Reserved_keywordContext) ASYMMETRIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserASYMMETRIC, 0) +} + +func (s *Reserved_keywordContext) BOTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserBOTH, 0) +} + +func (s *Reserved_keywordContext) CASE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE, 0) +} + +func (s *Reserved_keywordContext) CAST() antlr.TerminalNode { + return s.GetToken(RedshiftParserCAST, 0) +} + +func (s *Reserved_keywordContext) CHECK() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHECK, 0) +} + +func (s *Reserved_keywordContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Reserved_keywordContext) COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMN, 0) +} + +func (s *Reserved_keywordContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *Reserved_keywordContext) CREATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCREATE, 0) +} + +func (s *Reserved_keywordContext) CURRENT_CATALOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_CATALOG, 0) +} + +func (s *Reserved_keywordContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_DATE, 0) +} + +func (s *Reserved_keywordContext) CURRENT_ROLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_ROLE, 0) +} + +func (s *Reserved_keywordContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_TIME, 0) +} + +func (s *Reserved_keywordContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_TIMESTAMP, 0) +} + +func (s *Reserved_keywordContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_USER, 0) +} + +func (s *Reserved_keywordContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFERRABLE, 0) +} + +func (s *Reserved_keywordContext) DESC() antlr.TerminalNode { + return s.GetToken(RedshiftParserDESC, 0) +} + +func (s *Reserved_keywordContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDISTINCT, 0) +} + +func (s *Reserved_keywordContext) DO() antlr.TerminalNode { + return s.GetToken(RedshiftParserDO, 0) +} + +func (s *Reserved_keywordContext) ELSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserELSE, 0) +} + +func (s *Reserved_keywordContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *Reserved_keywordContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCEPT, 0) +} + +func (s *Reserved_keywordContext) FALSE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFALSE_P, 0) +} + +func (s *Reserved_keywordContext) FETCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFETCH, 0) +} + +func (s *Reserved_keywordContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Reserved_keywordContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREIGN, 0) +} + +func (s *Reserved_keywordContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Reserved_keywordContext) GRANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserGRANT, 0) +} + +func (s *Reserved_keywordContext) GROUP_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserGROUP_P, 0) +} + +func (s *Reserved_keywordContext) HAVING() antlr.TerminalNode { + return s.GetToken(RedshiftParserHAVING, 0) +} + +func (s *Reserved_keywordContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Reserved_keywordContext) INITIALLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserINITIALLY, 0) +} + +func (s *Reserved_keywordContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTERSECT, 0) +} + +func (s *Reserved_keywordContext) LATERAL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLATERAL_P, 0) +} + +func (s *Reserved_keywordContext) LEADING() antlr.TerminalNode { + return s.GetToken(RedshiftParserLEADING, 0) +} + +func (s *Reserved_keywordContext) LIMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserLIMIT, 0) +} + +func (s *Reserved_keywordContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCALTIME, 0) +} + +func (s *Reserved_keywordContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOCALTIMESTAMP, 0) +} + +func (s *Reserved_keywordContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Reserved_keywordContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Reserved_keywordContext) OFFSET() antlr.TerminalNode { + return s.GetToken(RedshiftParserOFFSET, 0) +} + +func (s *Reserved_keywordContext) ON() antlr.TerminalNode { + return s.GetToken(RedshiftParserON, 0) +} + +func (s *Reserved_keywordContext) ONLY() antlr.TerminalNode { + return s.GetToken(RedshiftParserONLY, 0) +} + +func (s *Reserved_keywordContext) OR() antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, 0) +} + +func (s *Reserved_keywordContext) ORDER() antlr.TerminalNode { + return s.GetToken(RedshiftParserORDER, 0) +} + +func (s *Reserved_keywordContext) PLACING() antlr.TerminalNode { + return s.GetToken(RedshiftParserPLACING, 0) +} + +func (s *Reserved_keywordContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIMARY, 0) +} + +func (s *Reserved_keywordContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREFERENCES, 0) +} + +func (s *Reserved_keywordContext) RETURNING() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURNING, 0) +} + +func (s *Reserved_keywordContext) SELECT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSELECT, 0) +} + +func (s *Reserved_keywordContext) SESSION_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserSESSION_USER, 0) +} + +func (s *Reserved_keywordContext) SOME() antlr.TerminalNode { + return s.GetToken(RedshiftParserSOME, 0) +} + +func (s *Reserved_keywordContext) SYMMETRIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserSYMMETRIC, 0) +} + +func (s *Reserved_keywordContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Reserved_keywordContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *Reserved_keywordContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Reserved_keywordContext) TRAILING() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRAILING, 0) +} + +func (s *Reserved_keywordContext) TRUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUE_P, 0) +} + +func (s *Reserved_keywordContext) UNION() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNION, 0) +} + +func (s *Reserved_keywordContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNIQUE, 0) +} + +func (s *Reserved_keywordContext) USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSER, 0) +} + +func (s *Reserved_keywordContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Reserved_keywordContext) VARIADIC() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARIADIC, 0) +} + +func (s *Reserved_keywordContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *Reserved_keywordContext) WHERE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHERE, 0) +} + +func (s *Reserved_keywordContext) WINDOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserWINDOW, 0) +} + +func (s *Reserved_keywordContext) WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserWITH, 0) +} + +func (s *Reserved_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterReserved_keyword(s) + } +} + +func (s *Reserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitReserved_keyword(s) + } +} + +func (s *Reserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitReserved_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Reserved_keyword() (localctx IReserved_keywordContext) { + localctx = NewReserved_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1944, RedshiftParserRULE_reserved_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14311) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9007200328482816) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&8796088827775) != 0) || _la == RedshiftParserEND_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBuiltin_function_nameContext is an interface to support dynamic dispatch. +type IBuiltin_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLCOMMENT() antlr.TerminalNode + XML_IS_WELL_FORMED() antlr.TerminalNode + XML_IS_WELL_FORMED_DOCUMENT() antlr.TerminalNode + XML_IS_WELL_FORMED_CONTENT() antlr.TerminalNode + XMLAGG() antlr.TerminalNode + XPATH() antlr.TerminalNode + XPATH_EXISTS() antlr.TerminalNode + ABS() antlr.TerminalNode + CBRT() antlr.TerminalNode + CEIL() antlr.TerminalNode + CEILING() antlr.TerminalNode + DEGREES() antlr.TerminalNode + DIV() antlr.TerminalNode + EXP() antlr.TerminalNode + FACTORIAL() antlr.TerminalNode + FLOOR() antlr.TerminalNode + GCD() antlr.TerminalNode + LCM() antlr.TerminalNode + LN() antlr.TerminalNode + LOG() antlr.TerminalNode + LOG10() antlr.TerminalNode + MIN_SCALE() antlr.TerminalNode + MOD() antlr.TerminalNode + PI() antlr.TerminalNode + POWER() antlr.TerminalNode + RADIANS() antlr.TerminalNode + ROUND() antlr.TerminalNode + SCALE() antlr.TerminalNode + SIGN() antlr.TerminalNode + SQRT() antlr.TerminalNode + TRIM_SCALE() antlr.TerminalNode + TRUNC() antlr.TerminalNode + WIDTH_BUCKET() antlr.TerminalNode + RANDOM() antlr.TerminalNode + SETSEED() antlr.TerminalNode + ACOS() antlr.TerminalNode + ACOSD() antlr.TerminalNode + ACOSH() antlr.TerminalNode + ASIN() antlr.TerminalNode + ASIND() antlr.TerminalNode + ASINH() antlr.TerminalNode + ATAN() antlr.TerminalNode + ATAND() antlr.TerminalNode + ATANH() antlr.TerminalNode + ATAN2() antlr.TerminalNode + ATAN2D() antlr.TerminalNode + COS() antlr.TerminalNode + COSD() antlr.TerminalNode + COSH() antlr.TerminalNode + COT() antlr.TerminalNode + COTD() antlr.TerminalNode + SIN() antlr.TerminalNode + SIND() antlr.TerminalNode + SINH() antlr.TerminalNode + TAN() antlr.TerminalNode + TAND() antlr.TerminalNode + TANH() antlr.TerminalNode + BIT_LENGTH() antlr.TerminalNode + CHAR_LENGTH() antlr.TerminalNode + CHARACTER_LENGTH() antlr.TerminalNode + LOWER() antlr.TerminalNode + OCTET_LENGTH() antlr.TerminalNode + UPPER() antlr.TerminalNode + ASCII() antlr.TerminalNode + BTRIM() antlr.TerminalNode + CHR() antlr.TerminalNode + CONCAT() antlr.TerminalNode + CONCAT_WS() antlr.TerminalNode + FORMAT() antlr.TerminalNode + INITCAP() antlr.TerminalNode + LENGTH() antlr.TerminalNode + LPAD() antlr.TerminalNode + LTRIM() antlr.TerminalNode + MD5() antlr.TerminalNode + PARSE_IDENT() antlr.TerminalNode + PG_CLIENT_ENCODING() antlr.TerminalNode + QUOTE_IDENT() antlr.TerminalNode + QUOTE_LITERAL() antlr.TerminalNode + QUOTE_NULLABLE() antlr.TerminalNode + REGEXP_COUNT() antlr.TerminalNode + REGEXP_INSTR() antlr.TerminalNode + REGEXP_LIKE() antlr.TerminalNode + REGEXP_MATCH() antlr.TerminalNode + REGEXP_MATCHES() antlr.TerminalNode + REGEXP_REPLACE() antlr.TerminalNode + REGEXP_SPLIT_TO_ARRAY() antlr.TerminalNode + REGEXP_SPLIT_TO_TABLE() antlr.TerminalNode + REGEXP_SUBSTR() antlr.TerminalNode + REPEAT() antlr.TerminalNode + REPLACE() antlr.TerminalNode + REVERSE() antlr.TerminalNode + RPAD() antlr.TerminalNode + RTRIM() antlr.TerminalNode + SPLIT_PART() antlr.TerminalNode + STARTS_WITH() antlr.TerminalNode + STRING_TO_ARRAY() antlr.TerminalNode + STRING_TO_TABLE() antlr.TerminalNode + STRPOS() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + TO_ASCII() antlr.TerminalNode + TO_HEX() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + UNISTR() antlr.TerminalNode + AGE() antlr.TerminalNode + DATE_BIN() antlr.TerminalNode + DATE_PART() antlr.TerminalNode + DATE_TRUNC() antlr.TerminalNode + ISFINITE() antlr.TerminalNode + JUSTIFY_DAYS() antlr.TerminalNode + JUSTIFY_HOURS() antlr.TerminalNode + JUSTIFY_INTERVAL() antlr.TerminalNode + MAKE_DATE() antlr.TerminalNode + MAKE_INTERVAL() antlr.TerminalNode + MAKE_TIME() antlr.TerminalNode + MAKE_TIMESTAMP() antlr.TerminalNode + MAKE_TIMESTAMPTZ() antlr.TerminalNode + CLOCK_TIMESTAMP() antlr.TerminalNode + NOW() antlr.TerminalNode + STATEMENT_TIMESTAMP() antlr.TerminalNode + TIMEOFDAY() antlr.TerminalNode + TRANSACTION_TIMESTAMP() antlr.TerminalNode + TO_TIMESTAMP() antlr.TerminalNode + TO_CHAR() antlr.TerminalNode + TO_DATE() antlr.TerminalNode + TO_NUMBER() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + + // IsBuiltin_function_nameContext differentiates from other interfaces. + IsBuiltin_function_nameContext() +} + +type Builtin_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBuiltin_function_nameContext() *Builtin_function_nameContext { + var p = new(Builtin_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_builtin_function_name + return p +} + +func InitEmptyBuiltin_function_nameContext(p *Builtin_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_builtin_function_name +} + +func (*Builtin_function_nameContext) IsBuiltin_function_nameContext() {} + +func NewBuiltin_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Builtin_function_nameContext { + var p = new(Builtin_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_builtin_function_name + + return p +} + +func (s *Builtin_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Builtin_function_nameContext) XMLCOMMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLCOMMENT, 0) +} + +func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED() antlr.TerminalNode { + return s.GetToken(RedshiftParserXML_IS_WELL_FORMED, 0) +} + +func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED_DOCUMENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, 0) +} + +func (s *Builtin_function_nameContext) XML_IS_WELL_FORMED_CONTENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserXML_IS_WELL_FORMED_CONTENT, 0) +} + +func (s *Builtin_function_nameContext) XMLAGG() antlr.TerminalNode { + return s.GetToken(RedshiftParserXMLAGG, 0) +} + +func (s *Builtin_function_nameContext) XPATH() antlr.TerminalNode { + return s.GetToken(RedshiftParserXPATH, 0) +} + +func (s *Builtin_function_nameContext) XPATH_EXISTS() antlr.TerminalNode { + return s.GetToken(RedshiftParserXPATH_EXISTS, 0) +} + +func (s *Builtin_function_nameContext) ABS() antlr.TerminalNode { + return s.GetToken(RedshiftParserABS, 0) +} + +func (s *Builtin_function_nameContext) CBRT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCBRT, 0) +} + +func (s *Builtin_function_nameContext) CEIL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCEIL, 0) +} + +func (s *Builtin_function_nameContext) CEILING() antlr.TerminalNode { + return s.GetToken(RedshiftParserCEILING, 0) +} + +func (s *Builtin_function_nameContext) DEGREES() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEGREES, 0) +} + +func (s *Builtin_function_nameContext) DIV() antlr.TerminalNode { + return s.GetToken(RedshiftParserDIV, 0) +} + +func (s *Builtin_function_nameContext) EXP() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXP, 0) +} + +func (s *Builtin_function_nameContext) FACTORIAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserFACTORIAL, 0) +} + +func (s *Builtin_function_nameContext) FLOOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFLOOR, 0) +} + +func (s *Builtin_function_nameContext) GCD() antlr.TerminalNode { + return s.GetToken(RedshiftParserGCD, 0) +} + +func (s *Builtin_function_nameContext) LCM() antlr.TerminalNode { + return s.GetToken(RedshiftParserLCM, 0) +} + +func (s *Builtin_function_nameContext) LN() antlr.TerminalNode { + return s.GetToken(RedshiftParserLN, 0) +} + +func (s *Builtin_function_nameContext) LOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOG, 0) +} + +func (s *Builtin_function_nameContext) LOG10() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOG10, 0) +} + +func (s *Builtin_function_nameContext) MIN_SCALE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMIN_SCALE, 0) +} + +func (s *Builtin_function_nameContext) MOD() antlr.TerminalNode { + return s.GetToken(RedshiftParserMOD, 0) +} + +func (s *Builtin_function_nameContext) PI() antlr.TerminalNode { + return s.GetToken(RedshiftParserPI, 0) +} + +func (s *Builtin_function_nameContext) POWER() antlr.TerminalNode { + return s.GetToken(RedshiftParserPOWER, 0) +} + +func (s *Builtin_function_nameContext) RADIANS() antlr.TerminalNode { + return s.GetToken(RedshiftParserRADIANS, 0) +} + +func (s *Builtin_function_nameContext) ROUND() antlr.TerminalNode { + return s.GetToken(RedshiftParserROUND, 0) +} + +func (s *Builtin_function_nameContext) SCALE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCALE, 0) +} + +func (s *Builtin_function_nameContext) SIGN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIGN, 0) +} + +func (s *Builtin_function_nameContext) SQRT() antlr.TerminalNode { + return s.GetToken(RedshiftParserSQRT, 0) +} + +func (s *Builtin_function_nameContext) TRIM_SCALE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRIM_SCALE, 0) +} + +func (s *Builtin_function_nameContext) TRUNC() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRUNC, 0) +} + +func (s *Builtin_function_nameContext) WIDTH_BUCKET() antlr.TerminalNode { + return s.GetToken(RedshiftParserWIDTH_BUCKET, 0) +} + +func (s *Builtin_function_nameContext) RANDOM() antlr.TerminalNode { + return s.GetToken(RedshiftParserRANDOM, 0) +} + +func (s *Builtin_function_nameContext) SETSEED() antlr.TerminalNode { + return s.GetToken(RedshiftParserSETSEED, 0) +} + +func (s *Builtin_function_nameContext) ACOS() antlr.TerminalNode { + return s.GetToken(RedshiftParserACOS, 0) +} + +func (s *Builtin_function_nameContext) ACOSD() antlr.TerminalNode { + return s.GetToken(RedshiftParserACOSD, 0) +} + +func (s *Builtin_function_nameContext) ACOSH() antlr.TerminalNode { + return s.GetToken(RedshiftParserACOSH, 0) +} + +func (s *Builtin_function_nameContext) ASIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserASIN, 0) +} + +func (s *Builtin_function_nameContext) ASIND() antlr.TerminalNode { + return s.GetToken(RedshiftParserASIND, 0) +} + +func (s *Builtin_function_nameContext) ASINH() antlr.TerminalNode { + return s.GetToken(RedshiftParserASINH, 0) +} + +func (s *Builtin_function_nameContext) ATAN() antlr.TerminalNode { + return s.GetToken(RedshiftParserATAN, 0) +} + +func (s *Builtin_function_nameContext) ATAND() antlr.TerminalNode { + return s.GetToken(RedshiftParserATAND, 0) +} + +func (s *Builtin_function_nameContext) ATANH() antlr.TerminalNode { + return s.GetToken(RedshiftParserATANH, 0) +} + +func (s *Builtin_function_nameContext) ATAN2() antlr.TerminalNode { + return s.GetToken(RedshiftParserATAN2, 0) +} + +func (s *Builtin_function_nameContext) ATAN2D() antlr.TerminalNode { + return s.GetToken(RedshiftParserATAN2D, 0) +} + +func (s *Builtin_function_nameContext) COS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOS, 0) +} + +func (s *Builtin_function_nameContext) COSD() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOSD, 0) +} + +func (s *Builtin_function_nameContext) COSH() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOSH, 0) +} + +func (s *Builtin_function_nameContext) COT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOT, 0) +} + +func (s *Builtin_function_nameContext) COTD() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOTD, 0) +} + +func (s *Builtin_function_nameContext) SIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIN, 0) +} + +func (s *Builtin_function_nameContext) SIND() antlr.TerminalNode { + return s.GetToken(RedshiftParserSIND, 0) +} + +func (s *Builtin_function_nameContext) SINH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSINH, 0) +} + +func (s *Builtin_function_nameContext) TAN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTAN, 0) +} + +func (s *Builtin_function_nameContext) TAND() antlr.TerminalNode { + return s.GetToken(RedshiftParserTAND, 0) +} + +func (s *Builtin_function_nameContext) TANH() antlr.TerminalNode { + return s.GetToken(RedshiftParserTANH, 0) +} + +func (s *Builtin_function_nameContext) BIT_LENGTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserBIT_LENGTH, 0) +} + +func (s *Builtin_function_nameContext) CHAR_LENGTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHAR_LENGTH, 0) +} + +func (s *Builtin_function_nameContext) CHARACTER_LENGTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHARACTER_LENGTH, 0) +} + +func (s *Builtin_function_nameContext) LOWER() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOWER, 0) +} + +func (s *Builtin_function_nameContext) OCTET_LENGTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserOCTET_LENGTH, 0) +} + +func (s *Builtin_function_nameContext) UPPER() antlr.TerminalNode { + return s.GetToken(RedshiftParserUPPER, 0) +} + +func (s *Builtin_function_nameContext) ASCII() antlr.TerminalNode { + return s.GetToken(RedshiftParserASCII, 0) +} + +func (s *Builtin_function_nameContext) BTRIM() antlr.TerminalNode { + return s.GetToken(RedshiftParserBTRIM, 0) +} + +func (s *Builtin_function_nameContext) CHR() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHR, 0) +} + +func (s *Builtin_function_nameContext) CONCAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONCAT, 0) +} + +func (s *Builtin_function_nameContext) CONCAT_WS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONCAT_WS, 0) +} + +func (s *Builtin_function_nameContext) FORMAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORMAT, 0) +} + +func (s *Builtin_function_nameContext) INITCAP() antlr.TerminalNode { + return s.GetToken(RedshiftParserINITCAP, 0) +} + +func (s *Builtin_function_nameContext) LENGTH() antlr.TerminalNode { + return s.GetToken(RedshiftParserLENGTH, 0) +} + +func (s *Builtin_function_nameContext) LPAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserLPAD, 0) +} + +func (s *Builtin_function_nameContext) LTRIM() antlr.TerminalNode { + return s.GetToken(RedshiftParserLTRIM, 0) +} + +func (s *Builtin_function_nameContext) MD5() antlr.TerminalNode { + return s.GetToken(RedshiftParserMD5, 0) +} + +func (s *Builtin_function_nameContext) PARSE_IDENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARSE_IDENT, 0) +} + +func (s *Builtin_function_nameContext) PG_CLIENT_ENCODING() antlr.TerminalNode { + return s.GetToken(RedshiftParserPG_CLIENT_ENCODING, 0) +} + +func (s *Builtin_function_nameContext) QUOTE_IDENT() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTE_IDENT, 0) +} + +func (s *Builtin_function_nameContext) QUOTE_LITERAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTE_LITERAL, 0) +} + +func (s *Builtin_function_nameContext) QUOTE_NULLABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUOTE_NULLABLE, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_COUNT() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_COUNT, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_INSTR() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_INSTR, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_LIKE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_LIKE, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_MATCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_MATCH, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_MATCHES() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_MATCHES, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_REPLACE, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_SPLIT_TO_ARRAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_SPLIT_TO_ARRAY, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_SPLIT_TO_TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_SPLIT_TO_TABLE, 0) +} + +func (s *Builtin_function_nameContext) REGEXP_SUBSTR() antlr.TerminalNode { + return s.GetToken(RedshiftParserREGEXP_SUBSTR, 0) +} + +func (s *Builtin_function_nameContext) REPEAT() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPEAT, 0) +} + +func (s *Builtin_function_nameContext) REPLACE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREPLACE, 0) +} + +func (s *Builtin_function_nameContext) REVERSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVERSE, 0) +} + +func (s *Builtin_function_nameContext) RPAD() antlr.TerminalNode { + return s.GetToken(RedshiftParserRPAD, 0) +} + +func (s *Builtin_function_nameContext) RTRIM() antlr.TerminalNode { + return s.GetToken(RedshiftParserRTRIM, 0) +} + +func (s *Builtin_function_nameContext) SPLIT_PART() antlr.TerminalNode { + return s.GetToken(RedshiftParserSPLIT_PART, 0) +} + +func (s *Builtin_function_nameContext) STARTS_WITH() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTARTS_WITH, 0) +} + +func (s *Builtin_function_nameContext) STRING_TO_ARRAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRING_TO_ARRAY, 0) +} + +func (s *Builtin_function_nameContext) STRING_TO_TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRING_TO_TABLE, 0) +} + +func (s *Builtin_function_nameContext) STRPOS() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRPOS, 0) +} + +func (s *Builtin_function_nameContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(RedshiftParserSUBSTR, 0) +} + +func (s *Builtin_function_nameContext) TO_ASCII() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO_ASCII, 0) +} + +func (s *Builtin_function_nameContext) TO_HEX() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO_HEX, 0) +} + +func (s *Builtin_function_nameContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSLATE, 0) +} + +func (s *Builtin_function_nameContext) UNISTR() antlr.TerminalNode { + return s.GetToken(RedshiftParserUNISTR, 0) +} + +func (s *Builtin_function_nameContext) AGE() antlr.TerminalNode { + return s.GetToken(RedshiftParserAGE, 0) +} + +func (s *Builtin_function_nameContext) DATE_BIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATE_BIN, 0) +} + +func (s *Builtin_function_nameContext) DATE_PART() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATE_PART, 0) +} + +func (s *Builtin_function_nameContext) DATE_TRUNC() antlr.TerminalNode { + return s.GetToken(RedshiftParserDATE_TRUNC, 0) +} + +func (s *Builtin_function_nameContext) ISFINITE() antlr.TerminalNode { + return s.GetToken(RedshiftParserISFINITE, 0) +} + +func (s *Builtin_function_nameContext) JUSTIFY_DAYS() antlr.TerminalNode { + return s.GetToken(RedshiftParserJUSTIFY_DAYS, 0) +} + +func (s *Builtin_function_nameContext) JUSTIFY_HOURS() antlr.TerminalNode { + return s.GetToken(RedshiftParserJUSTIFY_HOURS, 0) +} + +func (s *Builtin_function_nameContext) JUSTIFY_INTERVAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserJUSTIFY_INTERVAL, 0) +} + +func (s *Builtin_function_nameContext) MAKE_DATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAKE_DATE, 0) +} + +func (s *Builtin_function_nameContext) MAKE_INTERVAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAKE_INTERVAL, 0) +} + +func (s *Builtin_function_nameContext) MAKE_TIME() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAKE_TIME, 0) +} + +func (s *Builtin_function_nameContext) MAKE_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAKE_TIMESTAMP, 0) +} + +func (s *Builtin_function_nameContext) MAKE_TIMESTAMPTZ() antlr.TerminalNode { + return s.GetToken(RedshiftParserMAKE_TIMESTAMPTZ, 0) +} + +func (s *Builtin_function_nameContext) CLOCK_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOCK_TIMESTAMP, 0) +} + +func (s *Builtin_function_nameContext) NOW() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOW, 0) +} + +func (s *Builtin_function_nameContext) STATEMENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTATEMENT_TIMESTAMP, 0) +} + +func (s *Builtin_function_nameContext) TIMEOFDAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserTIMEOFDAY, 0) +} + +func (s *Builtin_function_nameContext) TRANSACTION_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTRANSACTION_TIMESTAMP, 0) +} + +func (s *Builtin_function_nameContext) TO_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO_TIMESTAMP, 0) +} + +func (s *Builtin_function_nameContext) TO_CHAR() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO_CHAR, 0) +} + +func (s *Builtin_function_nameContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO_DATE, 0) +} + +func (s *Builtin_function_nameContext) TO_NUMBER() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO_NUMBER, 0) +} + +func (s *Builtin_function_nameContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_USER, 0) +} + +func (s *Builtin_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Builtin_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Builtin_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterBuiltin_function_name(s) + } +} + +func (s *Builtin_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitBuiltin_function_name(s) + } +} + +func (s *Builtin_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitBuiltin_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Builtin_function_name() (localctx IBuiltin_function_nameContext) { + localctx = NewBuiltin_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1946, RedshiftParserRULE_builtin_function_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14313) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCURRENT_USER || _la == RedshiftParserREPLACE || ((int64((_la-588)) & ^0x3f) == 0 && ((int64(1)<<(_la-588))&127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-130559) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&15) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPl_functionContext is an interface to support dynamic dispatch. +type IPl_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Comp_options() IComp_optionsContext + Pl_block() IPl_blockContext + Opt_semi() IOpt_semiContext + + // IsPl_functionContext differentiates from other interfaces. + IsPl_functionContext() +} + +type Pl_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPl_functionContext() *Pl_functionContext { + var p = new(Pl_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_pl_function + return p +} + +func InitEmptyPl_functionContext(p *Pl_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_pl_function +} + +func (*Pl_functionContext) IsPl_functionContext() {} + +func NewPl_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pl_functionContext { + var p = new(Pl_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_pl_function + + return p +} + +func (s *Pl_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pl_functionContext) Comp_options() IComp_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComp_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComp_optionsContext) +} + +func (s *Pl_functionContext) Pl_block() IPl_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPl_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPl_blockContext) +} + +func (s *Pl_functionContext) Opt_semi() IOpt_semiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_semiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_semiContext) +} + +func (s *Pl_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pl_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pl_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPl_function(s) + } +} + +func (s *Pl_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPl_function(s) + } +} + +func (s *Pl_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPl_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Pl_function() (localctx IPl_functionContext) { + localctx = NewPl_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1948, RedshiftParserRULE_pl_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14315) + p.Comp_options() + } + { + p.SetState(14316) + p.Pl_block() + } + p.SetState(14318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSEMI { + { + p.SetState(14317) + p.Opt_semi() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComp_optionsContext is an interface to support dynamic dispatch. +type IComp_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllComp_option() []IComp_optionContext + Comp_option(i int) IComp_optionContext + + // IsComp_optionsContext differentiates from other interfaces. + IsComp_optionsContext() +} + +type Comp_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComp_optionsContext() *Comp_optionsContext { + var p = new(Comp_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_comp_options + return p +} + +func InitEmptyComp_optionsContext(p *Comp_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_comp_options +} + +func (*Comp_optionsContext) IsComp_optionsContext() {} + +func NewComp_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comp_optionsContext { + var p = new(Comp_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_comp_options + + return p +} + +func (s *Comp_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comp_optionsContext) AllComp_option() []IComp_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComp_optionContext); ok { + len++ + } + } + + tst := make([]IComp_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComp_optionContext); ok { + tst[i] = t.(IComp_optionContext) + i++ + } + } + + return tst +} + +func (s *Comp_optionsContext) Comp_option(i int) IComp_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComp_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComp_optionContext) +} + +func (s *Comp_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comp_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comp_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterComp_options(s) + } +} + +func (s *Comp_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitComp_options(s) + } +} + +func (s *Comp_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitComp_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Comp_options() (localctx IComp_optionsContext) { + localctx = NewComp_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1950, RedshiftParserRULE_comp_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserOperator { + { + p.SetState(14320) + p.Comp_option() + } + + p.SetState(14325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComp_optionContext is an interface to support dynamic dispatch. +type IComp_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sharp() ISharpContext + OPTION() antlr.TerminalNode + DUMP() antlr.TerminalNode + PRINT_STRICT_PARAMS() antlr.TerminalNode + Option_value() IOption_valueContext + VARIABLE_CONFLICT() antlr.TerminalNode + ERROR() antlr.TerminalNode + USE_VARIABLE() antlr.TerminalNode + USE_COLUMN() antlr.TerminalNode + + // IsComp_optionContext differentiates from other interfaces. + IsComp_optionContext() +} + +type Comp_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComp_optionContext() *Comp_optionContext { + var p = new(Comp_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_comp_option + return p +} + +func InitEmptyComp_optionContext(p *Comp_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_comp_option +} + +func (*Comp_optionContext) IsComp_optionContext() {} + +func NewComp_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comp_optionContext { + var p = new(Comp_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_comp_option + + return p +} + +func (s *Comp_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comp_optionContext) Sharp() ISharpContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISharpContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISharpContext) +} + +func (s *Comp_optionContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Comp_optionContext) DUMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDUMP, 0) +} + +func (s *Comp_optionContext) PRINT_STRICT_PARAMS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRINT_STRICT_PARAMS, 0) +} + +func (s *Comp_optionContext) Option_value() IOption_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOption_valueContext) +} + +func (s *Comp_optionContext) VARIABLE_CONFLICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARIABLE_CONFLICT, 0) +} + +func (s *Comp_optionContext) ERROR() antlr.TerminalNode { + return s.GetToken(RedshiftParserERROR, 0) +} + +func (s *Comp_optionContext) USE_VARIABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSE_VARIABLE, 0) +} + +func (s *Comp_optionContext) USE_COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSE_COLUMN, 0) +} + +func (s *Comp_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comp_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comp_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterComp_option(s) + } +} + +func (s *Comp_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitComp_option(s) + } +} + +func (s *Comp_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitComp_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Comp_option() (localctx IComp_optionContext) { + localctx = NewComp_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1952, RedshiftParserRULE_comp_option) + p.SetState(14346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1391, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14326) + p.Sharp() + } + { + p.SetState(14327) + p.Match(RedshiftParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14328) + p.Match(RedshiftParserDUMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14330) + p.Sharp() + } + { + p.SetState(14331) + p.Match(RedshiftParserPRINT_STRICT_PARAMS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14332) + p.Option_value() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14334) + p.Sharp() + } + { + p.SetState(14335) + p.Match(RedshiftParserVARIABLE_CONFLICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14336) + p.Match(RedshiftParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14338) + p.Sharp() + } + { + p.SetState(14339) + p.Match(RedshiftParserVARIABLE_CONFLICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14340) + p.Match(RedshiftParserUSE_VARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14342) + p.Sharp() + } + { + p.SetState(14343) + p.Match(RedshiftParserVARIABLE_CONFLICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14344) + p.Match(RedshiftParserUSE_COLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISharpContext is an interface to support dynamic dispatch. +type ISharpContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Operator() antlr.TerminalNode + + // IsSharpContext differentiates from other interfaces. + IsSharpContext() +} + +type SharpContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySharpContext() *SharpContext { + var p = new(SharpContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sharp + return p +} + +func InitEmptySharpContext(p *SharpContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sharp +} + +func (*SharpContext) IsSharpContext() {} + +func NewSharpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SharpContext { + var p = new(SharpContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sharp + + return p +} + +func (s *SharpContext) GetParser() antlr.Parser { return s.parser } + +func (s *SharpContext) Operator() antlr.TerminalNode { + return s.GetToken(RedshiftParserOperator, 0) +} + +func (s *SharpContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SharpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SharpContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSharp(s) + } +} + +func (s *SharpContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSharp(s) + } +} + +func (s *SharpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSharp(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sharp() (localctx ISharpContext) { + localctx = NewSharpContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1954, RedshiftParserRULE_sharp) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14348) + p.Match(RedshiftParserOperator) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOption_valueContext is an interface to support dynamic dispatch. +type IOption_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sconst() ISconstContext + Reserved_keyword() IReserved_keywordContext + Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext + Unreserved_keyword() IUnreserved_keywordContext + + // IsOption_valueContext differentiates from other interfaces. + IsOption_valueContext() +} + +type Option_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOption_valueContext() *Option_valueContext { + var p = new(Option_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_option_value + return p +} + +func InitEmptyOption_valueContext(p *Option_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_option_value +} + +func (*Option_valueContext) IsOption_valueContext() {} + +func NewOption_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Option_valueContext { + var p = new(Option_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_option_value + + return p +} + +func (s *Option_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Option_valueContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Option_valueContext) Reserved_keyword() IReserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReserved_keywordContext) +} + +func (s *Option_valueContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_unreserved_keywordContext) +} + +func (s *Option_valueContext) Unreserved_keyword() IUnreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnreserved_keywordContext) +} + +func (s *Option_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Option_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Option_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOption_value(s) + } +} + +func (s *Option_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOption_value(s) + } +} + +func (s *Option_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOption_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Option_value() (localctx IOption_valueContext) { + localctx = NewOption_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1956, RedshiftParserRULE_option_value) + p.SetState(14354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1392, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14350) + p.Sconst() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14351) + p.Reserved_keyword() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14352) + p.Plsql_unreserved_keyword() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14353) + p.Unreserved_keyword() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_semiContext is an interface to support dynamic dispatch. +type IOpt_semiContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEMI() antlr.TerminalNode + + // IsOpt_semiContext differentiates from other interfaces. + IsOpt_semiContext() +} + +type Opt_semiContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_semiContext() *Opt_semiContext { + var p = new(Opt_semiContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_semi + return p +} + +func InitEmptyOpt_semiContext(p *Opt_semiContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_semi +} + +func (*Opt_semiContext) IsOpt_semiContext() {} + +func NewOpt_semiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_semiContext { + var p = new(Opt_semiContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_semi + + return p +} + +func (s *Opt_semiContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_semiContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Opt_semiContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_semiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_semiContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_semi(s) + } +} + +func (s *Opt_semiContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_semi(s) + } +} + +func (s *Opt_semiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_semi(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_semi() (localctx IOpt_semiContext) { + localctx = NewOpt_semiContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1958, RedshiftParserRULE_opt_semi) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14356) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPl_blockContext is an interface to support dynamic dispatch. +type IPl_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Decl_sect() IDecl_sectContext + BEGIN_P() antlr.TerminalNode + Proc_sect() IProc_sectContext + END_P() antlr.TerminalNode + Exception_sect() IException_sectContext + Opt_label() IOpt_labelContext + + // IsPl_blockContext differentiates from other interfaces. + IsPl_blockContext() +} + +type Pl_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPl_blockContext() *Pl_blockContext { + var p = new(Pl_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_pl_block + return p +} + +func InitEmptyPl_blockContext(p *Pl_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_pl_block +} + +func (*Pl_blockContext) IsPl_blockContext() {} + +func NewPl_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pl_blockContext { + var p = new(Pl_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_pl_block + + return p +} + +func (s *Pl_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pl_blockContext) Decl_sect() IDecl_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_sectContext) +} + +func (s *Pl_blockContext) BEGIN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserBEGIN_P, 0) +} + +func (s *Pl_blockContext) Proc_sect() IProc_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Pl_blockContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *Pl_blockContext) Exception_sect() IException_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_sectContext) +} + +func (s *Pl_blockContext) Opt_label() IOpt_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_labelContext) +} + +func (s *Pl_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pl_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pl_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPl_block(s) + } +} + +func (s *Pl_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPl_block(s) + } +} + +func (s *Pl_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPl_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Pl_block() (localctx IPl_blockContext) { + localctx = NewPl_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1960, RedshiftParserRULE_pl_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14358) + p.Decl_sect() + } + { + p.SetState(14359) + p.Match(RedshiftParserBEGIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14360) + p.Proc_sect() + } + p.SetState(14362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserEXCEPTION { + { + p.SetState(14361) + p.Exception_sect() + } + + } + { + p.SetState(14364) + p.Match(RedshiftParserEND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(14365) + p.Opt_label() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_sectContext is an interface to support dynamic dispatch. +type IDecl_sectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_block_label() IOpt_block_labelContext + Decl_start() IDecl_startContext + Decl_stmts() IDecl_stmtsContext + + // IsDecl_sectContext differentiates from other interfaces. + IsDecl_sectContext() +} + +type Decl_sectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_sectContext() *Decl_sectContext { + var p = new(Decl_sectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_sect + return p +} + +func InitEmptyDecl_sectContext(p *Decl_sectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_sect +} + +func (*Decl_sectContext) IsDecl_sectContext() {} + +func NewDecl_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_sectContext { + var p = new(Decl_sectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_sect + + return p +} + +func (s *Decl_sectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_sectContext) Opt_block_label() IOpt_block_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_block_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_block_labelContext) +} + +func (s *Decl_sectContext) Decl_start() IDecl_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_startContext) +} + +func (s *Decl_sectContext) Decl_stmts() IDecl_stmtsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_stmtsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_stmtsContext) +} + +func (s *Decl_sectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_sectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_sect(s) + } +} + +func (s *Decl_sectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_sect(s) + } +} + +func (s *Decl_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_sect(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_sect() (localctx IDecl_sectContext) { + localctx = NewDecl_sectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1962, RedshiftParserRULE_decl_sect) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLESS_LESS { + { + p.SetState(14368) + p.Opt_block_label() + } + + } + p.SetState(14375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserDECLARE { + { + p.SetState(14371) + p.Decl_start() + } + p.SetState(14373) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1396, p.GetParserRuleContext()) == 1 { + { + p.SetState(14372) + p.Decl_stmts() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_startContext is an interface to support dynamic dispatch. +type IDecl_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECLARE() antlr.TerminalNode + + // IsDecl_startContext differentiates from other interfaces. + IsDecl_startContext() +} + +type Decl_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_startContext() *Decl_startContext { + var p = new(Decl_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_start + return p +} + +func InitEmptyDecl_startContext(p *Decl_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_start +} + +func (*Decl_startContext) IsDecl_startContext() {} + +func NewDecl_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_startContext { + var p = new(Decl_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_start + + return p +} + +func (s *Decl_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_startContext) DECLARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDECLARE, 0) +} + +func (s *Decl_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_start(s) + } +} + +func (s *Decl_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_start(s) + } +} + +func (s *Decl_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_start() (localctx IDecl_startContext) { + localctx = NewDecl_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1964, RedshiftParserRULE_decl_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14377) + p.Match(RedshiftParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_stmtsContext is an interface to support dynamic dispatch. +type IDecl_stmtsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDecl_stmt() []IDecl_stmtContext + Decl_stmt(i int) IDecl_stmtContext + + // IsDecl_stmtsContext differentiates from other interfaces. + IsDecl_stmtsContext() +} + +type Decl_stmtsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_stmtsContext() *Decl_stmtsContext { + var p = new(Decl_stmtsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_stmts + return p +} + +func InitEmptyDecl_stmtsContext(p *Decl_stmtsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_stmts +} + +func (*Decl_stmtsContext) IsDecl_stmtsContext() {} + +func NewDecl_stmtsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_stmtsContext { + var p = new(Decl_stmtsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_stmts + + return p +} + +func (s *Decl_stmtsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_stmtsContext) AllDecl_stmt() []IDecl_stmtContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecl_stmtContext); ok { + len++ + } + } + + tst := make([]IDecl_stmtContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecl_stmtContext); ok { + tst[i] = t.(IDecl_stmtContext) + i++ + } + } + + return tst +} + +func (s *Decl_stmtsContext) Decl_stmt(i int) IDecl_stmtContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_stmtContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecl_stmtContext) +} + +func (s *Decl_stmtsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_stmtsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_stmtsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_stmts(s) + } +} + +func (s *Decl_stmtsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_stmts(s) + } +} + +func (s *Decl_stmtsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_stmts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_stmts() (localctx IDecl_stmtsContext) { + localctx = NewDecl_stmtsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1966, RedshiftParserRULE_decl_stmts) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14380) + 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(14379) + p.Decl_stmt() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14382) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1398, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_declContext is an interface to support dynamic dispatch. +type ILabel_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LESS_LESS() antlr.TerminalNode + Any_identifier() IAny_identifierContext + GREATER_GREATER() antlr.TerminalNode + + // IsLabel_declContext differentiates from other interfaces. + IsLabel_declContext() +} + +type Label_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabel_declContext() *Label_declContext { + var p = new(Label_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_label_decl + return p +} + +func InitEmptyLabel_declContext(p *Label_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_label_decl +} + +func (*Label_declContext) IsLabel_declContext() {} + +func NewLabel_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_declContext { + var p = new(Label_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_label_decl + + return p +} + +func (s *Label_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_declContext) LESS_LESS() antlr.TerminalNode { + return s.GetToken(RedshiftParserLESS_LESS, 0) +} + +func (s *Label_declContext) Any_identifier() IAny_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_identifierContext) +} + +func (s *Label_declContext) GREATER_GREATER() antlr.TerminalNode { + return s.GetToken(RedshiftParserGREATER_GREATER, 0) +} + +func (s *Label_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLabel_decl(s) + } +} + +func (s *Label_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLabel_decl(s) + } +} + +func (s *Label_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLabel_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Label_decl() (localctx ILabel_declContext) { + localctx = NewLabel_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1968, RedshiftParserRULE_label_decl) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14384) + p.Match(RedshiftParserLESS_LESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14385) + p.Any_identifier() + } + { + p.SetState(14386) + p.Match(RedshiftParserGREATER_GREATER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_stmtContext is an interface to support dynamic dispatch. +type IDecl_stmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Decl_statement() IDecl_statementContext + DECLARE() antlr.TerminalNode + Label_decl() ILabel_declContext + + // IsDecl_stmtContext differentiates from other interfaces. + IsDecl_stmtContext() +} + +type Decl_stmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_stmtContext() *Decl_stmtContext { + var p = new(Decl_stmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_stmt + return p +} + +func InitEmptyDecl_stmtContext(p *Decl_stmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_stmt +} + +func (*Decl_stmtContext) IsDecl_stmtContext() {} + +func NewDecl_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_stmtContext { + var p = new(Decl_stmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_stmt + + return p +} + +func (s *Decl_stmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_stmtContext) Decl_statement() IDecl_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_statementContext) +} + +func (s *Decl_stmtContext) DECLARE() antlr.TerminalNode { + return s.GetToken(RedshiftParserDECLARE, 0) +} + +func (s *Decl_stmtContext) Label_decl() ILabel_declContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declContext) +} + +func (s *Decl_stmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_stmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_stmt(s) + } +} + +func (s *Decl_stmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_stmt(s) + } +} + +func (s *Decl_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_stmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_stmt() (localctx IDecl_stmtContext) { + localctx = NewDecl_stmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1970, RedshiftParserRULE_decl_stmt) + p.SetState(14391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1399, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14388) + p.Decl_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14389) + p.Match(RedshiftParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14390) + p.Label_decl() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_statementContext is an interface to support dynamic dispatch. +type IDecl_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Decl_varname() IDecl_varnameContext + SEMI() antlr.TerminalNode + ALIAS() antlr.TerminalNode + FOR() antlr.TerminalNode + Decl_aliasitem() IDecl_aliasitemContext + Decl_datatype() IDecl_datatypeContext + CURSOR() antlr.TerminalNode + Decl_is_for() IDecl_is_forContext + Decl_cursor_query() IDecl_cursor_queryContext + Decl_const() IDecl_constContext + Decl_collate() IDecl_collateContext + Decl_notnull() IDecl_notnullContext + Decl_defval() IDecl_defvalContext + Opt_scrollable() IOpt_scrollableContext + Decl_cursor_args() IDecl_cursor_argsContext + + // IsDecl_statementContext differentiates from other interfaces. + IsDecl_statementContext() +} + +type Decl_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_statementContext() *Decl_statementContext { + var p = new(Decl_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_statement + return p +} + +func InitEmptyDecl_statementContext(p *Decl_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_statement +} + +func (*Decl_statementContext) IsDecl_statementContext() {} + +func NewDecl_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_statementContext { + var p = new(Decl_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_statement + + return p +} + +func (s *Decl_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_statementContext) Decl_varname() IDecl_varnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_varnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_varnameContext) +} + +func (s *Decl_statementContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Decl_statementContext) ALIAS() antlr.TerminalNode { + return s.GetToken(RedshiftParserALIAS, 0) +} + +func (s *Decl_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Decl_statementContext) Decl_aliasitem() IDecl_aliasitemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_aliasitemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_aliasitemContext) +} + +func (s *Decl_statementContext) Decl_datatype() IDecl_datatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_datatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_datatypeContext) +} + +func (s *Decl_statementContext) CURSOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURSOR, 0) +} + +func (s *Decl_statementContext) Decl_is_for() IDecl_is_forContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_is_forContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_is_forContext) +} + +func (s *Decl_statementContext) Decl_cursor_query() IDecl_cursor_queryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_cursor_queryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_cursor_queryContext) +} + +func (s *Decl_statementContext) Decl_const() IDecl_constContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_constContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_constContext) +} + +func (s *Decl_statementContext) Decl_collate() IDecl_collateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_collateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_collateContext) +} + +func (s *Decl_statementContext) Decl_notnull() IDecl_notnullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_notnullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_notnullContext) +} + +func (s *Decl_statementContext) Decl_defval() IDecl_defvalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_defvalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_defvalContext) +} + +func (s *Decl_statementContext) Opt_scrollable() IOpt_scrollableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_scrollableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_scrollableContext) +} + +func (s *Decl_statementContext) Decl_cursor_args() IDecl_cursor_argsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_cursor_argsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_cursor_argsContext) +} + +func (s *Decl_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_statement(s) + } +} + +func (s *Decl_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_statement(s) + } +} + +func (s *Decl_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_statement() (localctx IDecl_statementContext) { + localctx = NewDecl_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1972, RedshiftParserRULE_decl_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14393) + p.Decl_varname() + } + p.SetState(14420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1406, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14394) + p.Match(RedshiftParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14395) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14396) + p.Decl_aliasitem() + } + + case 2: + p.SetState(14398) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1400, p.GetParserRuleContext()) == 1 { + { + p.SetState(14397) + p.Decl_const() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14400) + p.Decl_datatype() + } + p.SetState(14402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOLLATE { + { + p.SetState(14401) + p.Decl_collate() + } + + } + p.SetState(14405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNOT { + { + p.SetState(14404) + p.Decl_notnull() + } + + } + p.SetState(14408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&9007199255790592) != 0 { + { + p.SetState(14407) + p.Decl_defval() + } + + } + + case 3: + p.SetState(14411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO || _la == RedshiftParserSCROLL { + { + p.SetState(14410) + p.Opt_scrollable() + } + + } + { + p.SetState(14413) + p.Match(RedshiftParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(14414) + p.Decl_cursor_args() + } + + } + { + p.SetState(14417) + p.Decl_is_for() + } + { + p.SetState(14418) + p.Decl_cursor_query() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(14422) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_scrollableContext is an interface to support dynamic dispatch. +type IOpt_scrollableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + SCROLL() antlr.TerminalNode + + // IsOpt_scrollableContext differentiates from other interfaces. + IsOpt_scrollableContext() +} + +type Opt_scrollableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_scrollableContext() *Opt_scrollableContext { + var p = new(Opt_scrollableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_scrollable + return p +} + +func InitEmptyOpt_scrollableContext(p *Opt_scrollableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_scrollable +} + +func (*Opt_scrollableContext) IsOpt_scrollableContext() {} + +func NewOpt_scrollableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scrollableContext { + var p = new(Opt_scrollableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_scrollable + + return p +} + +func (s *Opt_scrollableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_scrollableContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_scrollableContext) SCROLL() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCROLL, 0) +} + +func (s *Opt_scrollableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_scrollableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_scrollableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_scrollable(s) + } +} + +func (s *Opt_scrollableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_scrollable(s) + } +} + +func (s *Opt_scrollableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_scrollable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_scrollable() (localctx IOpt_scrollableContext) { + localctx = NewOpt_scrollableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1974, RedshiftParserRULE_opt_scrollable) + p.SetState(14427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserNO: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14424) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14425) + p.Match(RedshiftParserSCROLL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserSCROLL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14426) + p.Match(RedshiftParserSCROLL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_cursor_queryContext is an interface to support dynamic dispatch. +type IDecl_cursor_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Selectstmt() ISelectstmtContext + + // IsDecl_cursor_queryContext differentiates from other interfaces. + IsDecl_cursor_queryContext() +} + +type Decl_cursor_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_cursor_queryContext() *Decl_cursor_queryContext { + var p = new(Decl_cursor_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_query + return p +} + +func InitEmptyDecl_cursor_queryContext(p *Decl_cursor_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_query +} + +func (*Decl_cursor_queryContext) IsDecl_cursor_queryContext() {} + +func NewDecl_cursor_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_queryContext { + var p = new(Decl_cursor_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_cursor_query + + return p +} + +func (s *Decl_cursor_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_cursor_queryContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *Decl_cursor_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_cursor_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_cursor_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_cursor_query(s) + } +} + +func (s *Decl_cursor_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_cursor_query(s) + } +} + +func (s *Decl_cursor_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_cursor_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_cursor_query() (localctx IDecl_cursor_queryContext) { + localctx = NewDecl_cursor_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1976, RedshiftParserRULE_decl_cursor_query) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14429) + p.Selectstmt() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_cursor_argsContext is an interface to support dynamic dispatch. +type IDecl_cursor_argsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + Decl_cursor_arglist() IDecl_cursor_arglistContext + CLOSE_PAREN() antlr.TerminalNode + + // IsDecl_cursor_argsContext differentiates from other interfaces. + IsDecl_cursor_argsContext() +} + +type Decl_cursor_argsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_cursor_argsContext() *Decl_cursor_argsContext { + var p = new(Decl_cursor_argsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_args + return p +} + +func InitEmptyDecl_cursor_argsContext(p *Decl_cursor_argsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_args +} + +func (*Decl_cursor_argsContext) IsDecl_cursor_argsContext() {} + +func NewDecl_cursor_argsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_argsContext { + var p = new(Decl_cursor_argsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_cursor_args + + return p +} + +func (s *Decl_cursor_argsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_cursor_argsContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Decl_cursor_argsContext) Decl_cursor_arglist() IDecl_cursor_arglistContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_cursor_arglistContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_cursor_arglistContext) +} + +func (s *Decl_cursor_argsContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Decl_cursor_argsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_cursor_argsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_cursor_argsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_cursor_args(s) + } +} + +func (s *Decl_cursor_argsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_cursor_args(s) + } +} + +func (s *Decl_cursor_argsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_cursor_args(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_cursor_args() (localctx IDecl_cursor_argsContext) { + localctx = NewDecl_cursor_argsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1978, RedshiftParserRULE_decl_cursor_args) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14431) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14432) + p.Decl_cursor_arglist() + } + { + p.SetState(14433) + p.Match(RedshiftParserCLOSE_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 +} + +// IDecl_cursor_arglistContext is an interface to support dynamic dispatch. +type IDecl_cursor_arglistContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDecl_cursor_arg() []IDecl_cursor_argContext + Decl_cursor_arg(i int) IDecl_cursor_argContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDecl_cursor_arglistContext differentiates from other interfaces. + IsDecl_cursor_arglistContext() +} + +type Decl_cursor_arglistContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_cursor_arglistContext() *Decl_cursor_arglistContext { + var p = new(Decl_cursor_arglistContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_arglist + return p +} + +func InitEmptyDecl_cursor_arglistContext(p *Decl_cursor_arglistContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_arglist +} + +func (*Decl_cursor_arglistContext) IsDecl_cursor_arglistContext() {} + +func NewDecl_cursor_arglistContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_arglistContext { + var p = new(Decl_cursor_arglistContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_cursor_arglist + + return p +} + +func (s *Decl_cursor_arglistContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_cursor_arglistContext) AllDecl_cursor_arg() []IDecl_cursor_argContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDecl_cursor_argContext); ok { + len++ + } + } + + tst := make([]IDecl_cursor_argContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDecl_cursor_argContext); ok { + tst[i] = t.(IDecl_cursor_argContext) + i++ + } + } + + return tst +} + +func (s *Decl_cursor_arglistContext) Decl_cursor_arg(i int) IDecl_cursor_argContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_cursor_argContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDecl_cursor_argContext) +} + +func (s *Decl_cursor_arglistContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Decl_cursor_arglistContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Decl_cursor_arglistContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_cursor_arglistContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_cursor_arglistContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_cursor_arglist(s) + } +} + +func (s *Decl_cursor_arglistContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_cursor_arglist(s) + } +} + +func (s *Decl_cursor_arglistContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_cursor_arglist(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_cursor_arglist() (localctx IDecl_cursor_arglistContext) { + localctx = NewDecl_cursor_arglistContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1980, RedshiftParserRULE_decl_cursor_arglist) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14435) + p.Decl_cursor_arg() + } + p.SetState(14440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14436) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14437) + p.Decl_cursor_arg() + } + + p.SetState(14442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_cursor_argContext is an interface to support dynamic dispatch. +type IDecl_cursor_argContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Decl_varname() IDecl_varnameContext + Decl_datatype() IDecl_datatypeContext + + // IsDecl_cursor_argContext differentiates from other interfaces. + IsDecl_cursor_argContext() +} + +type Decl_cursor_argContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_cursor_argContext() *Decl_cursor_argContext { + var p = new(Decl_cursor_argContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_arg + return p +} + +func InitEmptyDecl_cursor_argContext(p *Decl_cursor_argContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_cursor_arg +} + +func (*Decl_cursor_argContext) IsDecl_cursor_argContext() {} + +func NewDecl_cursor_argContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_cursor_argContext { + var p = new(Decl_cursor_argContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_cursor_arg + + return p +} + +func (s *Decl_cursor_argContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_cursor_argContext) Decl_varname() IDecl_varnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_varnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_varnameContext) +} + +func (s *Decl_cursor_argContext) Decl_datatype() IDecl_datatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_datatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_datatypeContext) +} + +func (s *Decl_cursor_argContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_cursor_argContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_cursor_argContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_cursor_arg(s) + } +} + +func (s *Decl_cursor_argContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_cursor_arg(s) + } +} + +func (s *Decl_cursor_argContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_cursor_arg(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_cursor_arg() (localctx IDecl_cursor_argContext) { + localctx = NewDecl_cursor_argContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1982, RedshiftParserRULE_decl_cursor_arg) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14443) + p.Decl_varname() + } + { + p.SetState(14444) + p.Decl_datatype() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_is_forContext is an interface to support dynamic dispatch. +type IDecl_is_forContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS() antlr.TerminalNode + FOR() antlr.TerminalNode + + // IsDecl_is_forContext differentiates from other interfaces. + IsDecl_is_forContext() +} + +type Decl_is_forContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_is_forContext() *Decl_is_forContext { + var p = new(Decl_is_forContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_is_for + return p +} + +func InitEmptyDecl_is_forContext(p *Decl_is_forContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_is_for +} + +func (*Decl_is_forContext) IsDecl_is_forContext() {} + +func NewDecl_is_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_is_forContext { + var p = new(Decl_is_forContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_is_for + + return p +} + +func (s *Decl_is_forContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_is_forContext) IS() antlr.TerminalNode { + return s.GetToken(RedshiftParserIS, 0) +} + +func (s *Decl_is_forContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Decl_is_forContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_is_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_is_forContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_is_for(s) + } +} + +func (s *Decl_is_forContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_is_for(s) + } +} + +func (s *Decl_is_forContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_is_for(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_is_for() (localctx IDecl_is_forContext) { + localctx = NewDecl_is_forContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1984, RedshiftParserRULE_decl_is_for) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14446) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFOR || _la == RedshiftParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_aliasitemContext is an interface to support dynamic dispatch. +type IDecl_aliasitemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARAM() antlr.TerminalNode + Colid() IColidContext + + // IsDecl_aliasitemContext differentiates from other interfaces. + IsDecl_aliasitemContext() +} + +type Decl_aliasitemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_aliasitemContext() *Decl_aliasitemContext { + var p = new(Decl_aliasitemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_aliasitem + return p +} + +func InitEmptyDecl_aliasitemContext(p *Decl_aliasitemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_aliasitem +} + +func (*Decl_aliasitemContext) IsDecl_aliasitemContext() {} + +func NewDecl_aliasitemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_aliasitemContext { + var p = new(Decl_aliasitemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_aliasitem + + return p +} + +func (s *Decl_aliasitemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_aliasitemContext) PARAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAM, 0) +} + +func (s *Decl_aliasitemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Decl_aliasitemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_aliasitemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_aliasitemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_aliasitem(s) + } +} + +func (s *Decl_aliasitemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_aliasitem(s) + } +} + +func (s *Decl_aliasitemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_aliasitem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_aliasitem() (localctx IDecl_aliasitemContext) { + localctx = NewDecl_aliasitemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1986, RedshiftParserRULE_decl_aliasitem) + p.SetState(14450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserPARAM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14448) + p.Match(RedshiftParserPARAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14449) + p.Colid() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_varnameContext is an interface to support dynamic dispatch. +type IDecl_varnameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Any_identifier() IAny_identifierContext + + // IsDecl_varnameContext differentiates from other interfaces. + IsDecl_varnameContext() +} + +type Decl_varnameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_varnameContext() *Decl_varnameContext { + var p = new(Decl_varnameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_varname + return p +} + +func InitEmptyDecl_varnameContext(p *Decl_varnameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_varname +} + +func (*Decl_varnameContext) IsDecl_varnameContext() {} + +func NewDecl_varnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_varnameContext { + var p = new(Decl_varnameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_varname + + return p +} + +func (s *Decl_varnameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_varnameContext) Any_identifier() IAny_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_identifierContext) +} + +func (s *Decl_varnameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_varnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_varnameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_varname(s) + } +} + +func (s *Decl_varnameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_varname(s) + } +} + +func (s *Decl_varnameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_varname(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_varname() (localctx IDecl_varnameContext) { + localctx = NewDecl_varnameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1988, RedshiftParserRULE_decl_varname) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14452) + p.Any_identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_constContext is an interface to support dynamic dispatch. +type IDecl_constContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTANT() antlr.TerminalNode + + // IsDecl_constContext differentiates from other interfaces. + IsDecl_constContext() +} + +type Decl_constContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_constContext() *Decl_constContext { + var p = new(Decl_constContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_const + return p +} + +func InitEmptyDecl_constContext(p *Decl_constContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_const +} + +func (*Decl_constContext) IsDecl_constContext() {} + +func NewDecl_constContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_constContext { + var p = new(Decl_constContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_const + + return p +} + +func (s *Decl_constContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_constContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTANT, 0) +} + +func (s *Decl_constContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_constContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_constContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_const(s) + } +} + +func (s *Decl_constContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_const(s) + } +} + +func (s *Decl_constContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_const(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_const() (localctx IDecl_constContext) { + localctx = NewDecl_constContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1990, RedshiftParserRULE_decl_const) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14454) + p.Match(RedshiftParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_datatypeContext is an interface to support dynamic dispatch. +type IDecl_datatypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Typename() ITypenameContext + + // IsDecl_datatypeContext differentiates from other interfaces. + IsDecl_datatypeContext() +} + +type Decl_datatypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_datatypeContext() *Decl_datatypeContext { + var p = new(Decl_datatypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_datatype + return p +} + +func InitEmptyDecl_datatypeContext(p *Decl_datatypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_datatype +} + +func (*Decl_datatypeContext) IsDecl_datatypeContext() {} + +func NewDecl_datatypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_datatypeContext { + var p = new(Decl_datatypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_datatype + + return p +} + +func (s *Decl_datatypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_datatypeContext) Typename() ITypenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITypenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITypenameContext) +} + +func (s *Decl_datatypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_datatypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_datatypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_datatype(s) + } +} + +func (s *Decl_datatypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_datatype(s) + } +} + +func (s *Decl_datatypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_datatype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_datatype() (localctx IDecl_datatypeContext) { + localctx = NewDecl_datatypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1992, RedshiftParserRULE_decl_datatype) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14456) + p.Typename() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_collateContext is an interface to support dynamic dispatch. +type IDecl_collateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLLATE() antlr.TerminalNode + Any_name() IAny_nameContext + + // IsDecl_collateContext differentiates from other interfaces. + IsDecl_collateContext() +} + +type Decl_collateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_collateContext() *Decl_collateContext { + var p = new(Decl_collateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_collate + return p +} + +func InitEmptyDecl_collateContext(p *Decl_collateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_collate +} + +func (*Decl_collateContext) IsDecl_collateContext() {} + +func NewDecl_collateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_collateContext { + var p = new(Decl_collateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_collate + + return p +} + +func (s *Decl_collateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_collateContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Decl_collateContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Decl_collateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_collateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_collateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_collate(s) + } +} + +func (s *Decl_collateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_collate(s) + } +} + +func (s *Decl_collateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_collate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_collate() (localctx IDecl_collateContext) { + localctx = NewDecl_collateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1994, RedshiftParserRULE_decl_collate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14458) + p.Match(RedshiftParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14459) + p.Any_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_notnullContext is an interface to support dynamic dispatch. +type IDecl_notnullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT() antlr.TerminalNode + NULL_P() antlr.TerminalNode + + // IsDecl_notnullContext differentiates from other interfaces. + IsDecl_notnullContext() +} + +type Decl_notnullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_notnullContext() *Decl_notnullContext { + var p = new(Decl_notnullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_notnull + return p +} + +func InitEmptyDecl_notnullContext(p *Decl_notnullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_notnull +} + +func (*Decl_notnullContext) IsDecl_notnullContext() {} + +func NewDecl_notnullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_notnullContext { + var p = new(Decl_notnullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_notnull + + return p +} + +func (s *Decl_notnullContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_notnullContext) NOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOT, 0) +} + +func (s *Decl_notnullContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Decl_notnullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_notnullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_notnullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_notnull(s) + } +} + +func (s *Decl_notnullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_notnull(s) + } +} + +func (s *Decl_notnullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_notnull(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_notnull() (localctx IDecl_notnullContext) { + localctx = NewDecl_notnullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1996, RedshiftParserRULE_decl_notnull) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14461) + p.Match(RedshiftParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14462) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_defvalContext is an interface to support dynamic dispatch. +type IDecl_defvalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Decl_defkey() IDecl_defkeyContext + Sql_expression() ISql_expressionContext + + // IsDecl_defvalContext differentiates from other interfaces. + IsDecl_defvalContext() +} + +type Decl_defvalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_defvalContext() *Decl_defvalContext { + var p = new(Decl_defvalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_defval + return p +} + +func InitEmptyDecl_defvalContext(p *Decl_defvalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_defval +} + +func (*Decl_defvalContext) IsDecl_defvalContext() {} + +func NewDecl_defvalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_defvalContext { + var p = new(Decl_defvalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_defval + + return p +} + +func (s *Decl_defvalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_defvalContext) Decl_defkey() IDecl_defkeyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDecl_defkeyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDecl_defkeyContext) +} + +func (s *Decl_defvalContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Decl_defvalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_defvalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_defvalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_defval(s) + } +} + +func (s *Decl_defvalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_defval(s) + } +} + +func (s *Decl_defvalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_defval(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_defval() (localctx IDecl_defvalContext) { + localctx = NewDecl_defvalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1998, RedshiftParserRULE_decl_defval) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14464) + p.Decl_defkey() + } + { + p.SetState(14465) + p.Sql_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDecl_defkeyContext is an interface to support dynamic dispatch. +type IDecl_defkeyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Assign_operator() IAssign_operatorContext + DEFAULT() antlr.TerminalNode + + // IsDecl_defkeyContext differentiates from other interfaces. + IsDecl_defkeyContext() +} + +type Decl_defkeyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDecl_defkeyContext() *Decl_defkeyContext { + var p = new(Decl_defkeyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_defkey + return p +} + +func InitEmptyDecl_defkeyContext(p *Decl_defkeyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_decl_defkey +} + +func (*Decl_defkeyContext) IsDecl_defkeyContext() {} + +func NewDecl_defkeyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Decl_defkeyContext { + var p = new(Decl_defkeyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_decl_defkey + + return p +} + +func (s *Decl_defkeyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Decl_defkeyContext) Assign_operator() IAssign_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssign_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssign_operatorContext) +} + +func (s *Decl_defkeyContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Decl_defkeyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Decl_defkeyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Decl_defkeyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterDecl_defkey(s) + } +} + +func (s *Decl_defkeyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitDecl_defkey(s) + } +} + +func (s *Decl_defkeyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitDecl_defkey(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Decl_defkey() (localctx IDecl_defkeyContext) { + localctx = NewDecl_defkeyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2000, RedshiftParserRULE_decl_defkey) + p.SetState(14469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserEQUAL, RedshiftParserCOLON_EQUALS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14467) + p.Assign_operator() + } + + case RedshiftParserDEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14468) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssign_operatorContext is an interface to support dynamic dispatch. +type IAssign_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUAL() antlr.TerminalNode + COLON_EQUALS() antlr.TerminalNode + + // IsAssign_operatorContext differentiates from other interfaces. + IsAssign_operatorContext() +} + +type Assign_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssign_operatorContext() *Assign_operatorContext { + var p = new(Assign_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_assign_operator + return p +} + +func InitEmptyAssign_operatorContext(p *Assign_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_assign_operator +} + +func (*Assign_operatorContext) IsAssign_operatorContext() {} + +func NewAssign_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assign_operatorContext { + var p = new(Assign_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_assign_operator + + return p +} + +func (s *Assign_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assign_operatorContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Assign_operatorContext) COLON_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLON_EQUALS, 0) +} + +func (s *Assign_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assign_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assign_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAssign_operator(s) + } +} + +func (s *Assign_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAssign_operator(s) + } +} + +func (s *Assign_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAssign_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Assign_operator() (localctx IAssign_operatorContext) { + localctx = NewAssign_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2002, RedshiftParserRULE_assign_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14471) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserEQUAL || _la == RedshiftParserCOLON_EQUALS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_sectContext is an interface to support dynamic dispatch. +type IProc_sectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllProc_stmt() []IProc_stmtContext + Proc_stmt(i int) IProc_stmtContext + + // IsProc_sectContext differentiates from other interfaces. + IsProc_sectContext() +} + +type Proc_sectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_sectContext() *Proc_sectContext { + var p = new(Proc_sectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_sect + return p +} + +func InitEmptyProc_sectContext(p *Proc_sectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_sect +} + +func (*Proc_sectContext) IsProc_sectContext() {} + +func NewProc_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_sectContext { + var p = new(Proc_sectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_proc_sect + + return p +} + +func (s *Proc_sectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_sectContext) AllProc_stmt() []IProc_stmtContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProc_stmtContext); ok { + len++ + } + } + + tst := make([]IProc_stmtContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProc_stmtContext); ok { + tst[i] = t.(IProc_stmtContext) + i++ + } + } + + return tst +} + +func (s *Proc_sectContext) Proc_stmt(i int) IProc_stmtContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_stmtContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProc_stmtContext) +} + +func (s *Proc_sectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_sectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProc_sect(s) + } +} + +func (s *Proc_sectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProc_sect(s) + } +} + +func (s *Proc_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProc_sect(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Proc_sect() (localctx IProc_sectContext) { + localctx = NewProc_sectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2004, RedshiftParserRULE_proc_sect) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1411, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14473) + p.Proc_stmt() + } + + } + p.SetState(14478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1411, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_stmtContext is an interface to support dynamic dispatch. +type IProc_stmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pl_block() IPl_blockContext + SEMI() antlr.TerminalNode + Stmt_return() IStmt_returnContext + Stmt_raise() IStmt_raiseContext + Stmt_assign() IStmt_assignContext + Stmt_if() IStmt_ifContext + Stmt_case() IStmt_caseContext + Stmt_loop() IStmt_loopContext + Stmt_while() IStmt_whileContext + Stmt_for() IStmt_forContext + Stmt_foreach_a() IStmt_foreach_aContext + Stmt_exit() IStmt_exitContext + Stmt_assert() IStmt_assertContext + Stmt_execsql() IStmt_execsqlContext + Stmt_dynexecute() IStmt_dynexecuteContext + Stmt_perform() IStmt_performContext + Stmt_call() IStmt_callContext + Stmt_getdiag() IStmt_getdiagContext + Stmt_open() IStmt_openContext + Stmt_fetch() IStmt_fetchContext + Stmt_move() IStmt_moveContext + Stmt_close() IStmt_closeContext + Stmt_null() IStmt_nullContext + Stmt_commit() IStmt_commitContext + Stmt_rollback() IStmt_rollbackContext + Stmt_set() IStmt_setContext + + // IsProc_stmtContext differentiates from other interfaces. + IsProc_stmtContext() +} + +type Proc_stmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_stmtContext() *Proc_stmtContext { + var p = new(Proc_stmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_stmt + return p +} + +func InitEmptyProc_stmtContext(p *Proc_stmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_stmt +} + +func (*Proc_stmtContext) IsProc_stmtContext() {} + +func NewProc_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_stmtContext { + var p = new(Proc_stmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_proc_stmt + + return p +} + +func (s *Proc_stmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_stmtContext) Pl_block() IPl_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPl_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPl_blockContext) +} + +func (s *Proc_stmtContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Proc_stmtContext) Stmt_return() IStmt_returnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_returnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_returnContext) +} + +func (s *Proc_stmtContext) Stmt_raise() IStmt_raiseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_raiseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_raiseContext) +} + +func (s *Proc_stmtContext) Stmt_assign() IStmt_assignContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_assignContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_assignContext) +} + +func (s *Proc_stmtContext) Stmt_if() IStmt_ifContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_ifContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_ifContext) +} + +func (s *Proc_stmtContext) Stmt_case() IStmt_caseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_caseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_caseContext) +} + +func (s *Proc_stmtContext) Stmt_loop() IStmt_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_loopContext) +} + +func (s *Proc_stmtContext) Stmt_while() IStmt_whileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_whileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_whileContext) +} + +func (s *Proc_stmtContext) Stmt_for() IStmt_forContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_forContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_forContext) +} + +func (s *Proc_stmtContext) Stmt_foreach_a() IStmt_foreach_aContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_foreach_aContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_foreach_aContext) +} + +func (s *Proc_stmtContext) Stmt_exit() IStmt_exitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_exitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_exitContext) +} + +func (s *Proc_stmtContext) Stmt_assert() IStmt_assertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_assertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_assertContext) +} + +func (s *Proc_stmtContext) Stmt_execsql() IStmt_execsqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_execsqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_execsqlContext) +} + +func (s *Proc_stmtContext) Stmt_dynexecute() IStmt_dynexecuteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_dynexecuteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_dynexecuteContext) +} + +func (s *Proc_stmtContext) Stmt_perform() IStmt_performContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_performContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_performContext) +} + +func (s *Proc_stmtContext) Stmt_call() IStmt_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_callContext) +} + +func (s *Proc_stmtContext) Stmt_getdiag() IStmt_getdiagContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_getdiagContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_getdiagContext) +} + +func (s *Proc_stmtContext) Stmt_open() IStmt_openContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_openContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_openContext) +} + +func (s *Proc_stmtContext) Stmt_fetch() IStmt_fetchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_fetchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_fetchContext) +} + +func (s *Proc_stmtContext) Stmt_move() IStmt_moveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_moveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_moveContext) +} + +func (s *Proc_stmtContext) Stmt_close() IStmt_closeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_closeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_closeContext) +} + +func (s *Proc_stmtContext) Stmt_null() IStmt_nullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_nullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_nullContext) +} + +func (s *Proc_stmtContext) Stmt_commit() IStmt_commitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_commitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_commitContext) +} + +func (s *Proc_stmtContext) Stmt_rollback() IStmt_rollbackContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_rollbackContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_rollbackContext) +} + +func (s *Proc_stmtContext) Stmt_set() IStmt_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_setContext) +} + +func (s *Proc_stmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_stmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProc_stmt(s) + } +} + +func (s *Proc_stmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProc_stmt(s) + } +} + +func (s *Proc_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProc_stmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Proc_stmt() (localctx IProc_stmtContext) { + localctx = NewProc_stmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2006, RedshiftParserRULE_proc_stmt) + p.SetState(14506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1412, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14479) + p.Pl_block() + } + { + p.SetState(14480) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14482) + p.Stmt_return() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14483) + p.Stmt_raise() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14484) + p.Stmt_assign() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14485) + p.Stmt_if() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14486) + p.Stmt_case() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14487) + p.Stmt_loop() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14488) + p.Stmt_while() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14489) + p.Stmt_for() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(14490) + p.Stmt_foreach_a() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(14491) + p.Stmt_exit() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(14492) + p.Stmt_assert() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(14493) + p.Stmt_execsql() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(14494) + p.Stmt_dynexecute() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(14495) + p.Stmt_perform() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(14496) + p.Stmt_call() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(14497) + p.Stmt_getdiag() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(14498) + p.Stmt_open() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(14499) + p.Stmt_fetch() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(14500) + p.Stmt_move() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(14501) + p.Stmt_close() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(14502) + p.Stmt_null() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(14503) + p.Stmt_commit() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(14504) + p.Stmt_rollback() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(14505) + p.Stmt_set() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_performContext is an interface to support dynamic dispatch. +type IStmt_performContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PERFORM() antlr.TerminalNode + Expr_until_semi() IExpr_until_semiContext + SEMI() antlr.TerminalNode + + // IsStmt_performContext differentiates from other interfaces. + IsStmt_performContext() +} + +type Stmt_performContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_performContext() *Stmt_performContext { + var p = new(Stmt_performContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_perform + return p +} + +func InitEmptyStmt_performContext(p *Stmt_performContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_perform +} + +func (*Stmt_performContext) IsStmt_performContext() {} + +func NewStmt_performContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_performContext { + var p = new(Stmt_performContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_perform + + return p +} + +func (s *Stmt_performContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_performContext) PERFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERFORM, 0) +} + +func (s *Stmt_performContext) Expr_until_semi() IExpr_until_semiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_until_semiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_until_semiContext) +} + +func (s *Stmt_performContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_performContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_performContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_performContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_perform(s) + } +} + +func (s *Stmt_performContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_perform(s) + } +} + +func (s *Stmt_performContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_perform(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_perform() (localctx IStmt_performContext) { + localctx = NewStmt_performContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2008, RedshiftParserRULE_stmt_perform) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14508) + p.Match(RedshiftParserPERFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14509) + p.Expr_until_semi() + } + { + p.SetState(14510) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_callContext is an interface to support dynamic dispatch. +type IStmt_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALL() antlr.TerminalNode + Any_identifier() IAny_identifierContext + OPEN_PAREN() antlr.TerminalNode + CLOSE_PAREN() antlr.TerminalNode + SEMI() antlr.TerminalNode + Opt_expr_list() IOpt_expr_listContext + DO() antlr.TerminalNode + + // IsStmt_callContext differentiates from other interfaces. + IsStmt_callContext() +} + +type Stmt_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_callContext() *Stmt_callContext { + var p = new(Stmt_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_call + return p +} + +func InitEmptyStmt_callContext(p *Stmt_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_call +} + +func (*Stmt_callContext) IsStmt_callContext() {} + +func NewStmt_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_callContext { + var p = new(Stmt_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_call + + return p +} + +func (s *Stmt_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_callContext) CALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCALL, 0) +} + +func (s *Stmt_callContext) Any_identifier() IAny_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_identifierContext) +} + +func (s *Stmt_callContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Stmt_callContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Stmt_callContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_callContext) Opt_expr_list() IOpt_expr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_expr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_expr_listContext) +} + +func (s *Stmt_callContext) DO() antlr.TerminalNode { + return s.GetToken(RedshiftParserDO, 0) +} + +func (s *Stmt_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_call(s) + } +} + +func (s *Stmt_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_call(s) + } +} + +func (s *Stmt_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_call(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_call() (localctx IStmt_callContext) { + localctx = NewStmt_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2010, RedshiftParserRULE_stmt_call) + var _la int + + p.SetState(14530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserCALL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14512) + p.Match(RedshiftParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14513) + p.Any_identifier() + } + { + p.SetState(14514) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(14515) + p.Opt_expr_list() + } + + } + { + p.SetState(14518) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14519) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserDO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14521) + p.Match(RedshiftParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14522) + p.Any_identifier() + } + { + p.SetState(14523) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858553860) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(14524) + p.Opt_expr_list() + } + + } + { + p.SetState(14527) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14528) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_expr_listContext is an interface to support dynamic dispatch. +type IOpt_expr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expr_list() IExpr_listContext + + // IsOpt_expr_listContext differentiates from other interfaces. + IsOpt_expr_listContext() +} + +type Opt_expr_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_expr_listContext() *Opt_expr_listContext { + var p = new(Opt_expr_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_expr_list + return p +} + +func InitEmptyOpt_expr_listContext(p *Opt_expr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_expr_list +} + +func (*Opt_expr_listContext) IsOpt_expr_listContext() {} + +func NewOpt_expr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_expr_listContext { + var p = new(Opt_expr_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_expr_list + + return p +} + +func (s *Opt_expr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_expr_listContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Opt_expr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_expr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_expr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_expr_list(s) + } +} + +func (s *Opt_expr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_expr_list(s) + } +} + +func (s *Opt_expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_expr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_expr_list() (localctx IOpt_expr_listContext) { + localctx = NewOpt_expr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2012, RedshiftParserRULE_opt_expr_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14532) + p.Expr_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_assignContext is an interface to support dynamic dispatch. +type IStmt_assignContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Assign_var() IAssign_varContext + Assign_operator() IAssign_operatorContext + Sql_expression() ISql_expressionContext + SEMI() antlr.TerminalNode + + // IsStmt_assignContext differentiates from other interfaces. + IsStmt_assignContext() +} + +type Stmt_assignContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_assignContext() *Stmt_assignContext { + var p = new(Stmt_assignContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_assign + return p +} + +func InitEmptyStmt_assignContext(p *Stmt_assignContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_assign +} + +func (*Stmt_assignContext) IsStmt_assignContext() {} + +func NewStmt_assignContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_assignContext { + var p = new(Stmt_assignContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_assign + + return p +} + +func (s *Stmt_assignContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_assignContext) Assign_var() IAssign_varContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssign_varContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssign_varContext) +} + +func (s *Stmt_assignContext) Assign_operator() IAssign_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssign_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssign_operatorContext) +} + +func (s *Stmt_assignContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Stmt_assignContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_assignContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_assignContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_assignContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_assign(s) + } +} + +func (s *Stmt_assignContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_assign(s) + } +} + +func (s *Stmt_assignContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_assign(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_assign() (localctx IStmt_assignContext) { + localctx = NewStmt_assignContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2014, RedshiftParserRULE_stmt_assign) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14534) + p.Assign_var() + } + { + p.SetState(14535) + p.Assign_operator() + } + { + p.SetState(14536) + p.Sql_expression() + } + { + p.SetState(14537) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_getdiagContext is an interface to support dynamic dispatch. +type IStmt_getdiagContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GET() antlr.TerminalNode + DIAGNOSTICS() antlr.TerminalNode + Getdiag_list() IGetdiag_listContext + SEMI() antlr.TerminalNode + Getdiag_area_opt() IGetdiag_area_optContext + + // IsStmt_getdiagContext differentiates from other interfaces. + IsStmt_getdiagContext() +} + +type Stmt_getdiagContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_getdiagContext() *Stmt_getdiagContext { + var p = new(Stmt_getdiagContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_getdiag + return p +} + +func InitEmptyStmt_getdiagContext(p *Stmt_getdiagContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_getdiag +} + +func (*Stmt_getdiagContext) IsStmt_getdiagContext() {} + +func NewStmt_getdiagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_getdiagContext { + var p = new(Stmt_getdiagContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_getdiag + + return p +} + +func (s *Stmt_getdiagContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_getdiagContext) GET() antlr.TerminalNode { + return s.GetToken(RedshiftParserGET, 0) +} + +func (s *Stmt_getdiagContext) DIAGNOSTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDIAGNOSTICS, 0) +} + +func (s *Stmt_getdiagContext) Getdiag_list() IGetdiag_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGetdiag_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGetdiag_listContext) +} + +func (s *Stmt_getdiagContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_getdiagContext) Getdiag_area_opt() IGetdiag_area_optContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGetdiag_area_optContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGetdiag_area_optContext) +} + +func (s *Stmt_getdiagContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_getdiagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_getdiagContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_getdiag(s) + } +} + +func (s *Stmt_getdiagContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_getdiag(s) + } +} + +func (s *Stmt_getdiagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_getdiag(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_getdiag() (localctx IStmt_getdiagContext) { + localctx = NewStmt_getdiagContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2016, RedshiftParserRULE_stmt_getdiag) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14539) + p.Match(RedshiftParserGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCURRENT_P || _la == RedshiftParserSTACKED { + { + p.SetState(14540) + p.Getdiag_area_opt() + } + + } + { + p.SetState(14543) + p.Match(RedshiftParserDIAGNOSTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14544) + p.Getdiag_list() + } + { + p.SetState(14545) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGetdiag_area_optContext is an interface to support dynamic dispatch. +type IGetdiag_area_optContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURRENT_P() antlr.TerminalNode + STACKED() antlr.TerminalNode + + // IsGetdiag_area_optContext differentiates from other interfaces. + IsGetdiag_area_optContext() +} + +type Getdiag_area_optContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGetdiag_area_optContext() *Getdiag_area_optContext { + var p = new(Getdiag_area_optContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_area_opt + return p +} + +func InitEmptyGetdiag_area_optContext(p *Getdiag_area_optContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_area_opt +} + +func (*Getdiag_area_optContext) IsGetdiag_area_optContext() {} + +func NewGetdiag_area_optContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_area_optContext { + var p = new(Getdiag_area_optContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_getdiag_area_opt + + return p +} + +func (s *Getdiag_area_optContext) GetParser() antlr.Parser { return s.parser } + +func (s *Getdiag_area_optContext) CURRENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_P, 0) +} + +func (s *Getdiag_area_optContext) STACKED() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTACKED, 0) +} + +func (s *Getdiag_area_optContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Getdiag_area_optContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Getdiag_area_optContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGetdiag_area_opt(s) + } +} + +func (s *Getdiag_area_optContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGetdiag_area_opt(s) + } +} + +func (s *Getdiag_area_optContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGetdiag_area_opt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Getdiag_area_opt() (localctx IGetdiag_area_optContext) { + localctx = NewGetdiag_area_optContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2018, RedshiftParserRULE_getdiag_area_opt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14547) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCURRENT_P || _la == RedshiftParserSTACKED) { + 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 +} + +// IGetdiag_listContext is an interface to support dynamic dispatch. +type IGetdiag_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGetdiag_list_item() []IGetdiag_list_itemContext + Getdiag_list_item(i int) IGetdiag_list_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGetdiag_listContext differentiates from other interfaces. + IsGetdiag_listContext() +} + +type Getdiag_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGetdiag_listContext() *Getdiag_listContext { + var p = new(Getdiag_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_list + return p +} + +func InitEmptyGetdiag_listContext(p *Getdiag_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_list +} + +func (*Getdiag_listContext) IsGetdiag_listContext() {} + +func NewGetdiag_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_listContext { + var p = new(Getdiag_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_getdiag_list + + return p +} + +func (s *Getdiag_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Getdiag_listContext) AllGetdiag_list_item() []IGetdiag_list_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGetdiag_list_itemContext); ok { + len++ + } + } + + tst := make([]IGetdiag_list_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGetdiag_list_itemContext); ok { + tst[i] = t.(IGetdiag_list_itemContext) + i++ + } + } + + return tst +} + +func (s *Getdiag_listContext) Getdiag_list_item(i int) IGetdiag_list_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGetdiag_list_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGetdiag_list_itemContext) +} + +func (s *Getdiag_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Getdiag_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Getdiag_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Getdiag_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Getdiag_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGetdiag_list(s) + } +} + +func (s *Getdiag_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGetdiag_list(s) + } +} + +func (s *Getdiag_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGetdiag_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Getdiag_list() (localctx IGetdiag_listContext) { + localctx = NewGetdiag_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2020, RedshiftParserRULE_getdiag_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14549) + p.Getdiag_list_item() + } + p.SetState(14554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14550) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14551) + p.Getdiag_list_item() + } + + p.SetState(14556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGetdiag_list_itemContext is an interface to support dynamic dispatch. +type IGetdiag_list_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Getdiag_target() IGetdiag_targetContext + Assign_operator() IAssign_operatorContext + Getdiag_item() IGetdiag_itemContext + + // IsGetdiag_list_itemContext differentiates from other interfaces. + IsGetdiag_list_itemContext() +} + +type Getdiag_list_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGetdiag_list_itemContext() *Getdiag_list_itemContext { + var p = new(Getdiag_list_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_list_item + return p +} + +func InitEmptyGetdiag_list_itemContext(p *Getdiag_list_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_list_item +} + +func (*Getdiag_list_itemContext) IsGetdiag_list_itemContext() {} + +func NewGetdiag_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_list_itemContext { + var p = new(Getdiag_list_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_getdiag_list_item + + return p +} + +func (s *Getdiag_list_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Getdiag_list_itemContext) Getdiag_target() IGetdiag_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGetdiag_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGetdiag_targetContext) +} + +func (s *Getdiag_list_itemContext) Assign_operator() IAssign_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssign_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssign_operatorContext) +} + +func (s *Getdiag_list_itemContext) Getdiag_item() IGetdiag_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGetdiag_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGetdiag_itemContext) +} + +func (s *Getdiag_list_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Getdiag_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Getdiag_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGetdiag_list_item(s) + } +} + +func (s *Getdiag_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGetdiag_list_item(s) + } +} + +func (s *Getdiag_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGetdiag_list_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Getdiag_list_item() (localctx IGetdiag_list_itemContext) { + localctx = NewGetdiag_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2022, RedshiftParserRULE_getdiag_list_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14557) + p.Getdiag_target() + } + { + p.SetState(14558) + p.Assign_operator() + } + { + p.SetState(14559) + p.Getdiag_item() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGetdiag_itemContext is an interface to support dynamic dispatch. +type IGetdiag_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + + // IsGetdiag_itemContext differentiates from other interfaces. + IsGetdiag_itemContext() +} + +type Getdiag_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGetdiag_itemContext() *Getdiag_itemContext { + var p = new(Getdiag_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_item + return p +} + +func InitEmptyGetdiag_itemContext(p *Getdiag_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_item +} + +func (*Getdiag_itemContext) IsGetdiag_itemContext() {} + +func NewGetdiag_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_itemContext { + var p = new(Getdiag_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_getdiag_item + + return p +} + +func (s *Getdiag_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Getdiag_itemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Getdiag_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Getdiag_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Getdiag_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGetdiag_item(s) + } +} + +func (s *Getdiag_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGetdiag_item(s) + } +} + +func (s *Getdiag_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGetdiag_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Getdiag_item() (localctx IGetdiag_itemContext) { + localctx = NewGetdiag_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2024, RedshiftParserRULE_getdiag_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14561) + p.Colid() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGetdiag_targetContext is an interface to support dynamic dispatch. +type IGetdiag_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Assign_var() IAssign_varContext + + // IsGetdiag_targetContext differentiates from other interfaces. + IsGetdiag_targetContext() +} + +type Getdiag_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGetdiag_targetContext() *Getdiag_targetContext { + var p = new(Getdiag_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_target + return p +} + +func InitEmptyGetdiag_targetContext(p *Getdiag_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_getdiag_target +} + +func (*Getdiag_targetContext) IsGetdiag_targetContext() {} + +func NewGetdiag_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Getdiag_targetContext { + var p = new(Getdiag_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_getdiag_target + + return p +} + +func (s *Getdiag_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Getdiag_targetContext) Assign_var() IAssign_varContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssign_varContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssign_varContext) +} + +func (s *Getdiag_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Getdiag_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Getdiag_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterGetdiag_target(s) + } +} + +func (s *Getdiag_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitGetdiag_target(s) + } +} + +func (s *Getdiag_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitGetdiag_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Getdiag_target() (localctx IGetdiag_targetContext) { + localctx = NewGetdiag_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2026, RedshiftParserRULE_getdiag_target) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14563) + p.Assign_var() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAssign_varContext is an interface to support dynamic dispatch. +type IAssign_varContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Any_name() IAny_nameContext + PARAM() antlr.TerminalNode + AllOPEN_BRACKET() []antlr.TerminalNode + OPEN_BRACKET(i int) antlr.TerminalNode + AllExpr_until_rightbracket() []IExpr_until_rightbracketContext + Expr_until_rightbracket(i int) IExpr_until_rightbracketContext + AllCLOSE_BRACKET() []antlr.TerminalNode + CLOSE_BRACKET(i int) antlr.TerminalNode + + // IsAssign_varContext differentiates from other interfaces. + IsAssign_varContext() +} + +type Assign_varContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssign_varContext() *Assign_varContext { + var p = new(Assign_varContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_assign_var + return p +} + +func InitEmptyAssign_varContext(p *Assign_varContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_assign_var +} + +func (*Assign_varContext) IsAssign_varContext() {} + +func NewAssign_varContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assign_varContext { + var p = new(Assign_varContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_assign_var + + return p +} + +func (s *Assign_varContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assign_varContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Assign_varContext) PARAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAM, 0) +} + +func (s *Assign_varContext) AllOPEN_BRACKET() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOPEN_BRACKET) +} + +func (s *Assign_varContext) OPEN_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_BRACKET, i) +} + +func (s *Assign_varContext) AllExpr_until_rightbracket() []IExpr_until_rightbracketContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpr_until_rightbracketContext); ok { + len++ + } + } + + tst := make([]IExpr_until_rightbracketContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpr_until_rightbracketContext); ok { + tst[i] = t.(IExpr_until_rightbracketContext) + i++ + } + } + + return tst +} + +func (s *Assign_varContext) Expr_until_rightbracket(i int) IExpr_until_rightbracketContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_until_rightbracketContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpr_until_rightbracketContext) +} + +func (s *Assign_varContext) AllCLOSE_BRACKET() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCLOSE_BRACKET) +} + +func (s *Assign_varContext) CLOSE_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_BRACKET, i) +} + +func (s *Assign_varContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assign_varContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assign_varContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAssign_var(s) + } +} + +func (s *Assign_varContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAssign_var(s) + } +} + +func (s *Assign_varContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAssign_var(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Assign_var() (localctx IAssign_varContext) { + localctx = NewAssign_varContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2028, RedshiftParserRULE_assign_var) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(14565) + p.Any_name() + } + + case RedshiftParserPARAM: + { + p.SetState(14566) + p.Match(RedshiftParserPARAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserOPEN_BRACKET { + { + p.SetState(14569) + p.Match(RedshiftParserOPEN_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14570) + p.Expr_until_rightbracket() + } + { + p.SetState(14571) + p.Match(RedshiftParserCLOSE_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(14577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_ifContext is an interface to support dynamic dispatch. +type IStmt_ifContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIF_P() []antlr.TerminalNode + IF_P(i int) antlr.TerminalNode + Expr_until_then() IExpr_until_thenContext + THEN() antlr.TerminalNode + Proc_sect() IProc_sectContext + Stmt_elsifs() IStmt_elsifsContext + END_P() antlr.TerminalNode + SEMI() antlr.TerminalNode + Stmt_else() IStmt_elseContext + + // IsStmt_ifContext differentiates from other interfaces. + IsStmt_ifContext() +} + +type Stmt_ifContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_ifContext() *Stmt_ifContext { + var p = new(Stmt_ifContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_if + return p +} + +func InitEmptyStmt_ifContext(p *Stmt_ifContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_if +} + +func (*Stmt_ifContext) IsStmt_ifContext() {} + +func NewStmt_ifContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_ifContext { + var p = new(Stmt_ifContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_if + + return p +} + +func (s *Stmt_ifContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_ifContext) AllIF_P() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserIF_P) +} + +func (s *Stmt_ifContext) IF_P(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserIF_P, i) +} + +func (s *Stmt_ifContext) Expr_until_then() IExpr_until_thenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_until_thenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_until_thenContext) +} + +func (s *Stmt_ifContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *Stmt_ifContext) Proc_sect() IProc_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Stmt_ifContext) Stmt_elsifs() IStmt_elsifsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_elsifsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_elsifsContext) +} + +func (s *Stmt_ifContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *Stmt_ifContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_ifContext) Stmt_else() IStmt_elseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmt_elseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmt_elseContext) +} + +func (s *Stmt_ifContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_ifContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_ifContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_if(s) + } +} + +func (s *Stmt_ifContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_if(s) + } +} + +func (s *Stmt_ifContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_if(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_if() (localctx IStmt_ifContext) { + localctx = NewStmt_ifContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2030, RedshiftParserRULE_stmt_if) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14578) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14579) + p.Expr_until_then() + } + { + p.SetState(14580) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14581) + p.Proc_sect() + } + { + p.SetState(14582) + p.Stmt_elsifs() + } + p.SetState(14584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserELSE { + { + p.SetState(14583) + p.Stmt_else() + } + + } + { + p.SetState(14586) + p.Match(RedshiftParserEND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14587) + p.Match(RedshiftParserIF_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14588) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_elsifsContext is an interface to support dynamic dispatch. +type IStmt_elsifsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllELSIF() []antlr.TerminalNode + ELSIF(i int) antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + AllTHEN() []antlr.TerminalNode + THEN(i int) antlr.TerminalNode + AllProc_sect() []IProc_sectContext + Proc_sect(i int) IProc_sectContext + + // IsStmt_elsifsContext differentiates from other interfaces. + IsStmt_elsifsContext() +} + +type Stmt_elsifsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_elsifsContext() *Stmt_elsifsContext { + var p = new(Stmt_elsifsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_elsifs + return p +} + +func InitEmptyStmt_elsifsContext(p *Stmt_elsifsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_elsifs +} + +func (*Stmt_elsifsContext) IsStmt_elsifsContext() {} + +func NewStmt_elsifsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_elsifsContext { + var p = new(Stmt_elsifsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_elsifs + + return p +} + +func (s *Stmt_elsifsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_elsifsContext) AllELSIF() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserELSIF) +} + +func (s *Stmt_elsifsContext) ELSIF(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserELSIF, i) +} + +func (s *Stmt_elsifsContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Stmt_elsifsContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Stmt_elsifsContext) AllTHEN() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserTHEN) +} + +func (s *Stmt_elsifsContext) THEN(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, i) +} + +func (s *Stmt_elsifsContext) AllProc_sect() []IProc_sectContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProc_sectContext); ok { + len++ + } + } + + tst := make([]IProc_sectContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProc_sectContext); ok { + tst[i] = t.(IProc_sectContext) + i++ + } + } + + return tst +} + +func (s *Stmt_elsifsContext) Proc_sect(i int) IProc_sectContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Stmt_elsifsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_elsifsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_elsifsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_elsifs(s) + } +} + +func (s *Stmt_elsifsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_elsifs(s) + } +} + +func (s *Stmt_elsifsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_elsifs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_elsifs() (localctx IStmt_elsifsContext) { + localctx = NewStmt_elsifsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2032, RedshiftParserRULE_stmt_elsifs) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserELSIF { + { + p.SetState(14590) + p.Match(RedshiftParserELSIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14591) + p.A_expr() + } + { + p.SetState(14592) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14593) + p.Proc_sect() + } + + p.SetState(14599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_elseContext is an interface to support dynamic dispatch. +type IStmt_elseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + Proc_sect() IProc_sectContext + + // IsStmt_elseContext differentiates from other interfaces. + IsStmt_elseContext() +} + +type Stmt_elseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_elseContext() *Stmt_elseContext { + var p = new(Stmt_elseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_else + return p +} + +func InitEmptyStmt_elseContext(p *Stmt_elseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_else +} + +func (*Stmt_elseContext) IsStmt_elseContext() {} + +func NewStmt_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_elseContext { + var p = new(Stmt_elseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_else + + return p +} + +func (s *Stmt_elseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_elseContext) ELSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserELSE, 0) +} + +func (s *Stmt_elseContext) Proc_sect() IProc_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Stmt_elseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_elseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_else(s) + } +} + +func (s *Stmt_elseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_else(s) + } +} + +func (s *Stmt_elseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_else(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_else() (localctx IStmt_elseContext) { + localctx = NewStmt_elseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2034, RedshiftParserRULE_stmt_else) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14600) + p.Match(RedshiftParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14601) + p.Proc_sect() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_caseContext is an interface to support dynamic dispatch. +type IStmt_caseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + Case_when_list() ICase_when_listContext + END_P() antlr.TerminalNode + SEMI() antlr.TerminalNode + Opt_expr_until_when() IOpt_expr_until_whenContext + Opt_case_else() IOpt_case_elseContext + + // IsStmt_caseContext differentiates from other interfaces. + IsStmt_caseContext() +} + +type Stmt_caseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_caseContext() *Stmt_caseContext { + var p = new(Stmt_caseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_case + return p +} + +func InitEmptyStmt_caseContext(p *Stmt_caseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_case +} + +func (*Stmt_caseContext) IsStmt_caseContext() {} + +func NewStmt_caseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_caseContext { + var p = new(Stmt_caseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_case + + return p +} + +func (s *Stmt_caseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_caseContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCASE) +} + +func (s *Stmt_caseContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCASE, i) +} + +func (s *Stmt_caseContext) Case_when_list() ICase_when_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_when_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_when_listContext) +} + +func (s *Stmt_caseContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *Stmt_caseContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_caseContext) Opt_expr_until_when() IOpt_expr_until_whenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_expr_until_whenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_expr_until_whenContext) +} + +func (s *Stmt_caseContext) Opt_case_else() IOpt_case_elseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_case_elseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_case_elseContext) +} + +func (s *Stmt_caseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_caseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_caseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_case(s) + } +} + +func (s *Stmt_caseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_case(s) + } +} + +func (s *Stmt_caseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_case(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_case() (localctx IStmt_caseContext) { + localctx = NewStmt_caseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2036, RedshiftParserRULE_stmt_case) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14603) + p.Match(RedshiftParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14605) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1422, p.GetParserRuleContext()) == 1 { + { + p.SetState(14604) + p.Opt_expr_until_when() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14607) + p.Case_when_list() + } + p.SetState(14609) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserELSE { + { + p.SetState(14608) + p.Opt_case_else() + } + + } + { + p.SetState(14611) + p.Match(RedshiftParserEND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14612) + p.Match(RedshiftParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14613) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_expr_until_whenContext is an interface to support dynamic dispatch. +type IOpt_expr_until_whenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_expression() ISql_expressionContext + + // IsOpt_expr_until_whenContext differentiates from other interfaces. + IsOpt_expr_until_whenContext() +} + +type Opt_expr_until_whenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_expr_until_whenContext() *Opt_expr_until_whenContext { + var p = new(Opt_expr_until_whenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_expr_until_when + return p +} + +func InitEmptyOpt_expr_until_whenContext(p *Opt_expr_until_whenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_expr_until_when +} + +func (*Opt_expr_until_whenContext) IsOpt_expr_until_whenContext() {} + +func NewOpt_expr_until_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_expr_until_whenContext { + var p = new(Opt_expr_until_whenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_expr_until_when + + return p +} + +func (s *Opt_expr_until_whenContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_expr_until_whenContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Opt_expr_until_whenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_expr_until_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_expr_until_whenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_expr_until_when(s) + } +} + +func (s *Opt_expr_until_whenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_expr_until_when(s) + } +} + +func (s *Opt_expr_until_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_expr_until_when(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_expr_until_when() (localctx IOpt_expr_until_whenContext) { + localctx = NewOpt_expr_until_whenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2038, RedshiftParserRULE_opt_expr_until_when) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14615) + p.Sql_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_when_listContext is an interface to support dynamic dispatch. +type ICase_when_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCase_when() []ICase_whenContext + Case_when(i int) ICase_whenContext + + // IsCase_when_listContext differentiates from other interfaces. + IsCase_when_listContext() +} + +type Case_when_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_when_listContext() *Case_when_listContext { + var p = new(Case_when_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_when_list + return p +} + +func InitEmptyCase_when_listContext(p *Case_when_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_when_list +} + +func (*Case_when_listContext) IsCase_when_listContext() {} + +func NewCase_when_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_when_listContext { + var p = new(Case_when_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_case_when_list + + return p +} + +func (s *Case_when_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_when_listContext) AllCase_when() []ICase_whenContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICase_whenContext); ok { + len++ + } + } + + tst := make([]ICase_whenContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICase_whenContext); ok { + tst[i] = t.(ICase_whenContext) + i++ + } + } + + return tst +} + +func (s *Case_when_listContext) Case_when(i int) ICase_whenContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_whenContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICase_whenContext) +} + +func (s *Case_when_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_when_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_when_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCase_when_list(s) + } +} + +func (s *Case_when_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCase_when_list(s) + } +} + +func (s *Case_when_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCase_when_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Case_when_list() (localctx ICase_when_listContext) { + localctx = NewCase_when_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2040, RedshiftParserRULE_case_when_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserWHEN { + { + p.SetState(14617) + p.Case_when() + } + + p.SetState(14620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_whenContext is an interface to support dynamic dispatch. +type ICase_whenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Expr_list() IExpr_listContext + THEN() antlr.TerminalNode + Proc_sect() IProc_sectContext + + // IsCase_whenContext differentiates from other interfaces. + IsCase_whenContext() +} + +type Case_whenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_whenContext() *Case_whenContext { + var p = new(Case_whenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_when + return p +} + +func InitEmptyCase_whenContext(p *Case_whenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_case_when +} + +func (*Case_whenContext) IsCase_whenContext() {} + +func NewCase_whenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_whenContext { + var p = new(Case_whenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_case_when + + return p +} + +func (s *Case_whenContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_whenContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *Case_whenContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Case_whenContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *Case_whenContext) Proc_sect() IProc_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Case_whenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_whenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_whenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCase_when(s) + } +} + +func (s *Case_whenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCase_when(s) + } +} + +func (s *Case_whenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCase_when(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Case_when() (localctx ICase_whenContext) { + localctx = NewCase_whenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2042, RedshiftParserRULE_case_when) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14622) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14623) + p.Expr_list() + } + { + p.SetState(14624) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14625) + p.Proc_sect() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_case_elseContext is an interface to support dynamic dispatch. +type IOpt_case_elseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + Proc_sect() IProc_sectContext + + // IsOpt_case_elseContext differentiates from other interfaces. + IsOpt_case_elseContext() +} + +type Opt_case_elseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_case_elseContext() *Opt_case_elseContext { + var p = new(Opt_case_elseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_case_else + return p +} + +func InitEmptyOpt_case_elseContext(p *Opt_case_elseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_case_else +} + +func (*Opt_case_elseContext) IsOpt_case_elseContext() {} + +func NewOpt_case_elseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_case_elseContext { + var p = new(Opt_case_elseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_case_else + + return p +} + +func (s *Opt_case_elseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_case_elseContext) ELSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserELSE, 0) +} + +func (s *Opt_case_elseContext) Proc_sect() IProc_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Opt_case_elseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_case_elseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_case_elseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_case_else(s) + } +} + +func (s *Opt_case_elseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_case_else(s) + } +} + +func (s *Opt_case_elseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_case_else(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_case_else() (localctx IOpt_case_elseContext) { + localctx = NewOpt_case_elseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2044, RedshiftParserRULE_opt_case_else) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14627) + p.Match(RedshiftParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14628) + p.Proc_sect() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_loopContext is an interface to support dynamic dispatch. +type IStmt_loopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Loop_body() ILoop_bodyContext + Opt_loop_label() IOpt_loop_labelContext + + // IsStmt_loopContext differentiates from other interfaces. + IsStmt_loopContext() +} + +type Stmt_loopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_loopContext() *Stmt_loopContext { + var p = new(Stmt_loopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_loop + return p +} + +func InitEmptyStmt_loopContext(p *Stmt_loopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_loop +} + +func (*Stmt_loopContext) IsStmt_loopContext() {} + +func NewStmt_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_loopContext { + var p = new(Stmt_loopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_loop + + return p +} + +func (s *Stmt_loopContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_loopContext) Loop_body() ILoop_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoop_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoop_bodyContext) +} + +func (s *Stmt_loopContext) Opt_loop_label() IOpt_loop_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_loop_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_loop_labelContext) +} + +func (s *Stmt_loopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_loopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_loop(s) + } +} + +func (s *Stmt_loopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_loop(s) + } +} + +func (s *Stmt_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_loop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_loop() (localctx IStmt_loopContext) { + localctx = NewStmt_loopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2046, RedshiftParserRULE_stmt_loop) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLESS_LESS { + { + p.SetState(14630) + p.Opt_loop_label() + } + + } + { + p.SetState(14633) + p.Loop_body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_whileContext is an interface to support dynamic dispatch. +type IStmt_whileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHILE() antlr.TerminalNode + Expr_until_loop() IExpr_until_loopContext + Loop_body() ILoop_bodyContext + Opt_loop_label() IOpt_loop_labelContext + + // IsStmt_whileContext differentiates from other interfaces. + IsStmt_whileContext() +} + +type Stmt_whileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_whileContext() *Stmt_whileContext { + var p = new(Stmt_whileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_while + return p +} + +func InitEmptyStmt_whileContext(p *Stmt_whileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_while +} + +func (*Stmt_whileContext) IsStmt_whileContext() {} + +func NewStmt_whileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_whileContext { + var p = new(Stmt_whileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_while + + return p +} + +func (s *Stmt_whileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_whileContext) WHILE() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHILE, 0) +} + +func (s *Stmt_whileContext) Expr_until_loop() IExpr_until_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_until_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_until_loopContext) +} + +func (s *Stmt_whileContext) Loop_body() ILoop_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoop_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoop_bodyContext) +} + +func (s *Stmt_whileContext) Opt_loop_label() IOpt_loop_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_loop_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_loop_labelContext) +} + +func (s *Stmt_whileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_whileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_whileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_while(s) + } +} + +func (s *Stmt_whileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_while(s) + } +} + +func (s *Stmt_whileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_while(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_while() (localctx IStmt_whileContext) { + localctx = NewStmt_whileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2048, RedshiftParserRULE_stmt_while) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLESS_LESS { + { + p.SetState(14635) + p.Opt_loop_label() + } + + } + { + p.SetState(14638) + p.Match(RedshiftParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14639) + p.Expr_until_loop() + } + { + p.SetState(14640) + p.Loop_body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_forContext is an interface to support dynamic dispatch. +type IStmt_forContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + For_control() IFor_controlContext + Loop_body() ILoop_bodyContext + Opt_loop_label() IOpt_loop_labelContext + + // IsStmt_forContext differentiates from other interfaces. + IsStmt_forContext() +} + +type Stmt_forContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_forContext() *Stmt_forContext { + var p = new(Stmt_forContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_for + return p +} + +func InitEmptyStmt_forContext(p *Stmt_forContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_for +} + +func (*Stmt_forContext) IsStmt_forContext() {} + +func NewStmt_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_forContext { + var p = new(Stmt_forContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_for + + return p +} + +func (s *Stmt_forContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_forContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Stmt_forContext) For_control() IFor_controlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_controlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_controlContext) +} + +func (s *Stmt_forContext) Loop_body() ILoop_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoop_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoop_bodyContext) +} + +func (s *Stmt_forContext) Opt_loop_label() IOpt_loop_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_loop_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_loop_labelContext) +} + +func (s *Stmt_forContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_forContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_for(s) + } +} + +func (s *Stmt_forContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_for(s) + } +} + +func (s *Stmt_forContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_for(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_for() (localctx IStmt_forContext) { + localctx = NewStmt_forContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2050, RedshiftParserRULE_stmt_for) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLESS_LESS { + { + p.SetState(14642) + p.Opt_loop_label() + } + + } + { + p.SetState(14645) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14646) + p.For_control() + } + { + p.SetState(14647) + p.Loop_body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_controlContext is an interface to support dynamic dispatch. +type IFor_controlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + For_variable() IFor_variableContext + IN_P() antlr.TerminalNode + Cursor_name() ICursor_nameContext + Selectstmt() ISelectstmtContext + Explainstmt() IExplainstmtContext + EXECUTE() antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + DOT_DOT() antlr.TerminalNode + Opt_cursor_parameters() IOpt_cursor_parametersContext + Opt_for_using_expression() IOpt_for_using_expressionContext + Opt_reverse() IOpt_reverseContext + Opt_by_expression() IOpt_by_expressionContext + + // IsFor_controlContext differentiates from other interfaces. + IsFor_controlContext() +} + +type For_controlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_controlContext() *For_controlContext { + var p = new(For_controlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_control + return p +} + +func InitEmptyFor_controlContext(p *For_controlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_control +} + +func (*For_controlContext) IsFor_controlContext() {} + +func NewFor_controlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_controlContext { + var p = new(For_controlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_for_control + + return p +} + +func (s *For_controlContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_controlContext) For_variable() IFor_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_variableContext) +} + +func (s *For_controlContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *For_controlContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *For_controlContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *For_controlContext) Explainstmt() IExplainstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainstmtContext) +} + +func (s *For_controlContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *For_controlContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *For_controlContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *For_controlContext) DOT_DOT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDOT_DOT, 0) +} + +func (s *For_controlContext) Opt_cursor_parameters() IOpt_cursor_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_cursor_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_cursor_parametersContext) +} + +func (s *For_controlContext) Opt_for_using_expression() IOpt_for_using_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_for_using_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_for_using_expressionContext) +} + +func (s *For_controlContext) Opt_reverse() IOpt_reverseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_reverseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_reverseContext) +} + +func (s *For_controlContext) Opt_by_expression() IOpt_by_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_by_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_by_expressionContext) +} + +func (s *For_controlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_controlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_controlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFor_control(s) + } +} + +func (s *For_controlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFor_control(s) + } +} + +func (s *For_controlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFor_control(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) For_control() (localctx IFor_controlContext) { + localctx = NewFor_controlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2052, RedshiftParserRULE_for_control) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14649) + p.For_variable() + } + { + p.SetState(14650) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1432, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14651) + p.Cursor_name() + } + p.SetState(14653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(14652) + p.Opt_cursor_parameters() + } + + } + + case 2: + { + p.SetState(14655) + p.Selectstmt() + } + + case 3: + { + p.SetState(14656) + p.Explainstmt() + } + + case 4: + { + p.SetState(14657) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14658) + p.A_expr() + } + p.SetState(14660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14659) + p.Opt_for_using_expression() + } + + } + + case 5: + p.SetState(14663) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1430, p.GetParserRuleContext()) == 1 { + { + p.SetState(14662) + p.Opt_reverse() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14665) + p.A_expr() + } + { + p.SetState(14666) + p.Match(RedshiftParserDOT_DOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14667) + p.A_expr() + } + p.SetState(14669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserBY { + { + p.SetState(14668) + p.Opt_by_expression() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_for_using_expressionContext is an interface to support dynamic dispatch. +type IOpt_for_using_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsOpt_for_using_expressionContext differentiates from other interfaces. + IsOpt_for_using_expressionContext() +} + +type Opt_for_using_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_for_using_expressionContext() *Opt_for_using_expressionContext { + var p = new(Opt_for_using_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_for_using_expression + return p +} + +func InitEmptyOpt_for_using_expressionContext(p *Opt_for_using_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_for_using_expression +} + +func (*Opt_for_using_expressionContext) IsOpt_for_using_expressionContext() {} + +func NewOpt_for_using_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_for_using_expressionContext { + var p = new(Opt_for_using_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_for_using_expression + + return p +} + +func (s *Opt_for_using_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_for_using_expressionContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Opt_for_using_expressionContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Opt_for_using_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_for_using_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_for_using_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_for_using_expression(s) + } +} + +func (s *Opt_for_using_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_for_using_expression(s) + } +} + +func (s *Opt_for_using_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_for_using_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_for_using_expression() (localctx IOpt_for_using_expressionContext) { + localctx = NewOpt_for_using_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2054, RedshiftParserRULE_opt_for_using_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14673) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14674) + p.Expr_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_cursor_parametersContext is an interface to support dynamic dispatch. +type IOpt_cursor_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN_PAREN() antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + CLOSE_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOpt_cursor_parametersContext differentiates from other interfaces. + IsOpt_cursor_parametersContext() +} + +type Opt_cursor_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_cursor_parametersContext() *Opt_cursor_parametersContext { + var p = new(Opt_cursor_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_cursor_parameters + return p +} + +func InitEmptyOpt_cursor_parametersContext(p *Opt_cursor_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_cursor_parameters +} + +func (*Opt_cursor_parametersContext) IsOpt_cursor_parametersContext() {} + +func NewOpt_cursor_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_cursor_parametersContext { + var p = new(Opt_cursor_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_cursor_parameters + + return p +} + +func (s *Opt_cursor_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_cursor_parametersContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Opt_cursor_parametersContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Opt_cursor_parametersContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_cursor_parametersContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Opt_cursor_parametersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Opt_cursor_parametersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Opt_cursor_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_cursor_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_cursor_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_cursor_parameters(s) + } +} + +func (s *Opt_cursor_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_cursor_parameters(s) + } +} + +func (s *Opt_cursor_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_cursor_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_cursor_parameters() (localctx IOpt_cursor_parametersContext) { + localctx = NewOpt_cursor_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2056, RedshiftParserRULE_opt_cursor_parameters) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14676) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14677) + p.A_expr() + } + p.SetState(14682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14678) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14679) + p.A_expr() + } + + p.SetState(14684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14685) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_reverseContext is an interface to support dynamic dispatch. +type IOpt_reverseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVERSE() antlr.TerminalNode + + // IsOpt_reverseContext differentiates from other interfaces. + IsOpt_reverseContext() +} + +type Opt_reverseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_reverseContext() *Opt_reverseContext { + var p = new(Opt_reverseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_reverse + return p +} + +func InitEmptyOpt_reverseContext(p *Opt_reverseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_reverse +} + +func (*Opt_reverseContext) IsOpt_reverseContext() {} + +func NewOpt_reverseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_reverseContext { + var p = new(Opt_reverseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_reverse + + return p +} + +func (s *Opt_reverseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_reverseContext) REVERSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserREVERSE, 0) +} + +func (s *Opt_reverseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_reverseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_reverseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_reverse(s) + } +} + +func (s *Opt_reverseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_reverse(s) + } +} + +func (s *Opt_reverseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_reverse(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_reverse() (localctx IOpt_reverseContext) { + localctx = NewOpt_reverseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2058, RedshiftParserRULE_opt_reverse) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14687) + p.Match(RedshiftParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_by_expressionContext is an interface to support dynamic dispatch. +type IOpt_by_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + A_expr() IA_exprContext + + // IsOpt_by_expressionContext differentiates from other interfaces. + IsOpt_by_expressionContext() +} + +type Opt_by_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_by_expressionContext() *Opt_by_expressionContext { + var p = new(Opt_by_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_by_expression + return p +} + +func InitEmptyOpt_by_expressionContext(p *Opt_by_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_by_expression +} + +func (*Opt_by_expressionContext) IsOpt_by_expressionContext() {} + +func NewOpt_by_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_by_expressionContext { + var p = new(Opt_by_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_by_expression + + return p +} + +func (s *Opt_by_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_by_expressionContext) BY() antlr.TerminalNode { + return s.GetToken(RedshiftParserBY, 0) +} + +func (s *Opt_by_expressionContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_by_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_by_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_by_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_by_expression(s) + } +} + +func (s *Opt_by_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_by_expression(s) + } +} + +func (s *Opt_by_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_by_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_by_expression() (localctx IOpt_by_expressionContext) { + localctx = NewOpt_by_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2060, RedshiftParserRULE_opt_by_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14689) + p.Match(RedshiftParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14690) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_variableContext is an interface to support dynamic dispatch. +type IFor_variableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Any_name_list() IAny_name_listContext + + // IsFor_variableContext differentiates from other interfaces. + IsFor_variableContext() +} + +type For_variableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_variableContext() *For_variableContext { + var p = new(For_variableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_variable + return p +} + +func InitEmptyFor_variableContext(p *For_variableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_for_variable +} + +func (*For_variableContext) IsFor_variableContext() {} + +func NewFor_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_variableContext { + var p = new(For_variableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_for_variable + + return p +} + +func (s *For_variableContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_variableContext) Any_name_list() IAny_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_name_listContext) +} + +func (s *For_variableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_variableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterFor_variable(s) + } +} + +func (s *For_variableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitFor_variable(s) + } +} + +func (s *For_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitFor_variable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) For_variable() (localctx IFor_variableContext) { + localctx = NewFor_variableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2062, RedshiftParserRULE_for_variable) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14692) + p.Any_name_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_foreach_aContext is an interface to support dynamic dispatch. +type IStmt_foreach_aContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOREACH() antlr.TerminalNode + For_variable() IFor_variableContext + IN_P() antlr.TerminalNode + ARRAY() antlr.TerminalNode + A_expr() IA_exprContext + Loop_body() ILoop_bodyContext + Opt_loop_label() IOpt_loop_labelContext + Foreach_slice() IForeach_sliceContext + + // IsStmt_foreach_aContext differentiates from other interfaces. + IsStmt_foreach_aContext() +} + +type Stmt_foreach_aContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_foreach_aContext() *Stmt_foreach_aContext { + var p = new(Stmt_foreach_aContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_foreach_a + return p +} + +func InitEmptyStmt_foreach_aContext(p *Stmt_foreach_aContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_foreach_a +} + +func (*Stmt_foreach_aContext) IsStmt_foreach_aContext() {} + +func NewStmt_foreach_aContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_foreach_aContext { + var p = new(Stmt_foreach_aContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_foreach_a + + return p +} + +func (s *Stmt_foreach_aContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_foreach_aContext) FOREACH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOREACH, 0) +} + +func (s *Stmt_foreach_aContext) For_variable() IFor_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_variableContext) +} + +func (s *Stmt_foreach_aContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Stmt_foreach_aContext) ARRAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserARRAY, 0) +} + +func (s *Stmt_foreach_aContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Stmt_foreach_aContext) Loop_body() ILoop_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoop_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoop_bodyContext) +} + +func (s *Stmt_foreach_aContext) Opt_loop_label() IOpt_loop_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_loop_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_loop_labelContext) +} + +func (s *Stmt_foreach_aContext) Foreach_slice() IForeach_sliceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeach_sliceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeach_sliceContext) +} + +func (s *Stmt_foreach_aContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_foreach_aContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_foreach_aContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_foreach_a(s) + } +} + +func (s *Stmt_foreach_aContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_foreach_a(s) + } +} + +func (s *Stmt_foreach_aContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_foreach_a(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_foreach_a() (localctx IStmt_foreach_aContext) { + localctx = NewStmt_foreach_aContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2064, RedshiftParserRULE_stmt_foreach_a) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserLESS_LESS { + { + p.SetState(14694) + p.Opt_loop_label() + } + + } + { + p.SetState(14697) + p.Match(RedshiftParserFOREACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14698) + p.For_variable() + } + p.SetState(14700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserSLICE { + { + p.SetState(14699) + p.Foreach_slice() + } + + } + { + p.SetState(14702) + p.Match(RedshiftParserIN_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14703) + p.Match(RedshiftParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14704) + p.A_expr() + } + { + p.SetState(14705) + p.Loop_body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForeach_sliceContext is an interface to support dynamic dispatch. +type IForeach_sliceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SLICE() antlr.TerminalNode + Iconst() IIconstContext + + // IsForeach_sliceContext differentiates from other interfaces. + IsForeach_sliceContext() +} + +type Foreach_sliceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeach_sliceContext() *Foreach_sliceContext { + var p = new(Foreach_sliceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_foreach_slice + return p +} + +func InitEmptyForeach_sliceContext(p *Foreach_sliceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_foreach_slice +} + +func (*Foreach_sliceContext) IsForeach_sliceContext() {} + +func NewForeach_sliceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreach_sliceContext { + var p = new(Foreach_sliceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_foreach_slice + + return p +} + +func (s *Foreach_sliceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreach_sliceContext) SLICE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSLICE, 0) +} + +func (s *Foreach_sliceContext) Iconst() IIconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIconstContext) +} + +func (s *Foreach_sliceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreach_sliceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreach_sliceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterForeach_slice(s) + } +} + +func (s *Foreach_sliceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitForeach_slice(s) + } +} + +func (s *Foreach_sliceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitForeach_slice(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Foreach_slice() (localctx IForeach_sliceContext) { + localctx = NewForeach_sliceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2066, RedshiftParserRULE_foreach_slice) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14707) + p.Match(RedshiftParserSLICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14708) + p.Iconst() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_exitContext is an interface to support dynamic dispatch. +type IStmt_exitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Exit_type() IExit_typeContext + SEMI() antlr.TerminalNode + Opt_label() IOpt_labelContext + Opt_exitcond() IOpt_exitcondContext + + // IsStmt_exitContext differentiates from other interfaces. + IsStmt_exitContext() +} + +type Stmt_exitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_exitContext() *Stmt_exitContext { + var p = new(Stmt_exitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_exit + return p +} + +func InitEmptyStmt_exitContext(p *Stmt_exitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_exit +} + +func (*Stmt_exitContext) IsStmt_exitContext() {} + +func NewStmt_exitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_exitContext { + var p = new(Stmt_exitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_exit + + return p +} + +func (s *Stmt_exitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_exitContext) Exit_type() IExit_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExit_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExit_typeContext) +} + +func (s *Stmt_exitContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_exitContext) Opt_label() IOpt_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_labelContext) +} + +func (s *Stmt_exitContext) Opt_exitcond() IOpt_exitcondContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_exitcondContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_exitcondContext) +} + +func (s *Stmt_exitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_exitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_exitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_exit(s) + } +} + +func (s *Stmt_exitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_exit(s) + } +} + +func (s *Stmt_exitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_exit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_exit() (localctx IStmt_exitContext) { + localctx = NewStmt_exitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2068, RedshiftParserRULE_stmt_exit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14710) + p.Exit_type() + } + p.SetState(14712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(14711) + p.Opt_label() + } + + } + p.SetState(14715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHEN { + { + p.SetState(14714) + p.Opt_exitcond() + } + + } + { + p.SetState(14717) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExit_typeContext is an interface to support dynamic dispatch. +type IExit_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXIT() antlr.TerminalNode + CONTINUE_P() antlr.TerminalNode + + // IsExit_typeContext differentiates from other interfaces. + IsExit_typeContext() +} + +type Exit_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExit_typeContext() *Exit_typeContext { + var p = new(Exit_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exit_type + return p +} + +func InitEmptyExit_typeContext(p *Exit_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exit_type +} + +func (*Exit_typeContext) IsExit_typeContext() {} + +func NewExit_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exit_typeContext { + var p = new(Exit_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_exit_type + + return p +} + +func (s *Exit_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exit_typeContext) EXIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXIT, 0) +} + +func (s *Exit_typeContext) CONTINUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONTINUE_P, 0) +} + +func (s *Exit_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exit_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exit_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExit_type(s) + } +} + +func (s *Exit_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExit_type(s) + } +} + +func (s *Exit_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExit_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Exit_type() (localctx IExit_typeContext) { + localctx = NewExit_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2070, RedshiftParserRULE_exit_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14719) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserCONTINUE_P || _la == RedshiftParserEXIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_returnContext is an interface to support dynamic dispatch. +type IStmt_returnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN() antlr.TerminalNode + SEMI() antlr.TerminalNode + NEXT() antlr.TerminalNode + Sql_expression() ISql_expressionContext + QUERY() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + A_expr() IA_exprContext + Selectstmt() ISelectstmtContext + Opt_return_result() IOpt_return_resultContext + Opt_for_using_expression() IOpt_for_using_expressionContext + + // IsStmt_returnContext differentiates from other interfaces. + IsStmt_returnContext() +} + +type Stmt_returnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_returnContext() *Stmt_returnContext { + var p = new(Stmt_returnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_return + return p +} + +func InitEmptyStmt_returnContext(p *Stmt_returnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_return +} + +func (*Stmt_returnContext) IsStmt_returnContext() {} + +func NewStmt_returnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_returnContext { + var p = new(Stmt_returnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_return + + return p +} + +func (s *Stmt_returnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_returnContext) RETURN() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURN, 0) +} + +func (s *Stmt_returnContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_returnContext) NEXT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEXT, 0) +} + +func (s *Stmt_returnContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Stmt_returnContext) QUERY() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUERY, 0) +} + +func (s *Stmt_returnContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *Stmt_returnContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Stmt_returnContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *Stmt_returnContext) Opt_return_result() IOpt_return_resultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_return_resultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_return_resultContext) +} + +func (s *Stmt_returnContext) Opt_for_using_expression() IOpt_for_using_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_for_using_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_for_using_expressionContext) +} + +func (s *Stmt_returnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_returnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_returnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_return(s) + } +} + +func (s *Stmt_returnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_return(s) + } +} + +func (s *Stmt_returnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_return(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_return() (localctx IStmt_returnContext) { + localctx = NewStmt_returnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2072, RedshiftParserRULE_stmt_return) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14721) + p.Match(RedshiftParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1441, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14722) + p.Match(RedshiftParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14723) + p.Sql_expression() + } + + case 2: + { + p.SetState(14724) + p.Match(RedshiftParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserEXECUTE: + { + p.SetState(14725) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14726) + p.A_expr() + } + p.SetState(14728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14727) + p.Opt_for_using_expression() + } + + } + + case RedshiftParserOPEN_PAREN, RedshiftParserSELECT, RedshiftParserTABLE, RedshiftParserWITH, RedshiftParserVALUES: + { + p.SetState(14730) + p.Selectstmt() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.SetState(14734) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1440, p.GetParserRuleContext()) == 1 { + { + p.SetState(14733) + p.Opt_return_result() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(14738) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_return_resultContext is an interface to support dynamic dispatch. +type IOpt_return_resultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_expression() ISql_expressionContext + + // IsOpt_return_resultContext differentiates from other interfaces. + IsOpt_return_resultContext() +} + +type Opt_return_resultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_return_resultContext() *Opt_return_resultContext { + var p = new(Opt_return_resultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_return_result + return p +} + +func InitEmptyOpt_return_resultContext(p *Opt_return_resultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_return_result +} + +func (*Opt_return_resultContext) IsOpt_return_resultContext() {} + +func NewOpt_return_resultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_return_resultContext { + var p = new(Opt_return_resultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_return_result + + return p +} + +func (s *Opt_return_resultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_return_resultContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Opt_return_resultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_return_resultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_return_resultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_return_result(s) + } +} + +func (s *Opt_return_resultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_return_result(s) + } +} + +func (s *Opt_return_resultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_return_result(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_return_result() (localctx IOpt_return_resultContext) { + localctx = NewOpt_return_resultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2074, RedshiftParserRULE_opt_return_result) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14740) + p.Sql_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_raiseContext is an interface to support dynamic dispatch. +type IStmt_raiseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RAISE() antlr.TerminalNode + Sconst() ISconstContext + SEMI() antlr.TerminalNode + Opt_stmt_raise_level() IOpt_stmt_raise_levelContext + Opt_raise_list() IOpt_raise_listContext + Opt_raise_using() IOpt_raise_usingContext + Identifier() IIdentifierContext + SQLSTATE() antlr.TerminalNode + + // IsStmt_raiseContext differentiates from other interfaces. + IsStmt_raiseContext() +} + +type Stmt_raiseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_raiseContext() *Stmt_raiseContext { + var p = new(Stmt_raiseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_raise + return p +} + +func InitEmptyStmt_raiseContext(p *Stmt_raiseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_raise +} + +func (*Stmt_raiseContext) IsStmt_raiseContext() {} + +func NewStmt_raiseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_raiseContext { + var p = new(Stmt_raiseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_raise + + return p +} + +func (s *Stmt_raiseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_raiseContext) RAISE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRAISE, 0) +} + +func (s *Stmt_raiseContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Stmt_raiseContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_raiseContext) Opt_stmt_raise_level() IOpt_stmt_raise_levelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_stmt_raise_levelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_stmt_raise_levelContext) +} + +func (s *Stmt_raiseContext) Opt_raise_list() IOpt_raise_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_raise_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_raise_listContext) +} + +func (s *Stmt_raiseContext) Opt_raise_using() IOpt_raise_usingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_raise_usingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_raise_usingContext) +} + +func (s *Stmt_raiseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Stmt_raiseContext) SQLSTATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSQLSTATE, 0) +} + +func (s *Stmt_raiseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_raiseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_raiseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_raise(s) + } +} + +func (s *Stmt_raiseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_raise(s) + } +} + +func (s *Stmt_raiseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_raise(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_raise() (localctx IStmt_raiseContext) { + localctx = NewStmt_raiseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2076, RedshiftParserRULE_stmt_raise) + var _la int + + p.SetState(14785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1451, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14742) + p.Match(RedshiftParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-711)) & ^0x3f) == 0 && ((int64(1)<<(_la-711))&63) != 0 { + { + p.SetState(14743) + p.Opt_stmt_raise_level() + } + + } + { + p.SetState(14746) + p.Sconst() + } + p.SetState(14748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(14747) + p.Opt_raise_list() + } + + } + p.SetState(14751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14750) + p.Opt_raise_using() + } + + } + { + p.SetState(14753) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14755) + p.Match(RedshiftParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14757) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1445, p.GetParserRuleContext()) == 1 { + { + p.SetState(14756) + p.Opt_stmt_raise_level() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14759) + p.Identifier() + } + p.SetState(14761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14760) + p.Opt_raise_using() + } + + } + { + p.SetState(14763) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14765) + p.Match(RedshiftParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14767) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-711)) & ^0x3f) == 0 && ((int64(1)<<(_la-711))&63) != 0 { + { + p.SetState(14766) + p.Opt_stmt_raise_level() + } + + } + { + p.SetState(14769) + p.Match(RedshiftParserSQLSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14770) + p.Sconst() + } + p.SetState(14772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14771) + p.Opt_raise_using() + } + + } + { + p.SetState(14774) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14776) + p.Match(RedshiftParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if (int64((_la-711)) & ^0x3f) == 0 && ((int64(1)<<(_la-711))&63) != 0 { + { + p.SetState(14777) + p.Opt_stmt_raise_level() + } + + } + p.SetState(14781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14780) + p.Opt_raise_using() + } + + } + { + p.SetState(14783) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14784) + p.Match(RedshiftParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_stmt_raise_levelContext is an interface to support dynamic dispatch. +type IOpt_stmt_raise_levelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEBUG() antlr.TerminalNode + LOG() antlr.TerminalNode + INFO() antlr.TerminalNode + NOTICE() antlr.TerminalNode + WARNING() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + + // IsOpt_stmt_raise_levelContext differentiates from other interfaces. + IsOpt_stmt_raise_levelContext() +} + +type Opt_stmt_raise_levelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_stmt_raise_levelContext() *Opt_stmt_raise_levelContext { + var p = new(Opt_stmt_raise_levelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_stmt_raise_level + return p +} + +func InitEmptyOpt_stmt_raise_levelContext(p *Opt_stmt_raise_levelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_stmt_raise_level +} + +func (*Opt_stmt_raise_levelContext) IsOpt_stmt_raise_levelContext() {} + +func NewOpt_stmt_raise_levelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_stmt_raise_levelContext { + var p = new(Opt_stmt_raise_levelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_stmt_raise_level + + return p +} + +func (s *Opt_stmt_raise_levelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_stmt_raise_levelContext) DEBUG() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEBUG, 0) +} + +func (s *Opt_stmt_raise_levelContext) LOG() antlr.TerminalNode { + return s.GetToken(RedshiftParserLOG, 0) +} + +func (s *Opt_stmt_raise_levelContext) INFO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINFO, 0) +} + +func (s *Opt_stmt_raise_levelContext) NOTICE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTICE, 0) +} + +func (s *Opt_stmt_raise_levelContext) WARNING() antlr.TerminalNode { + return s.GetToken(RedshiftParserWARNING, 0) +} + +func (s *Opt_stmt_raise_levelContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCEPTION, 0) +} + +func (s *Opt_stmt_raise_levelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_stmt_raise_levelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_stmt_raise_levelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_stmt_raise_level(s) + } +} + +func (s *Opt_stmt_raise_levelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_stmt_raise_level(s) + } +} + +func (s *Opt_stmt_raise_levelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_stmt_raise_level(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_stmt_raise_level() (localctx IOpt_stmt_raise_levelContext) { + localctx = NewOpt_stmt_raise_levelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2078, RedshiftParserRULE_opt_stmt_raise_level) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14787) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-711)) & ^0x3f) == 0 && ((int64(1)<<(_la-711))&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 +} + +// IOpt_raise_listContext is an interface to support dynamic dispatch. +type IOpt_raise_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + + // IsOpt_raise_listContext differentiates from other interfaces. + IsOpt_raise_listContext() +} + +type Opt_raise_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_raise_listContext() *Opt_raise_listContext { + var p = new(Opt_raise_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_list + return p +} + +func InitEmptyOpt_raise_listContext(p *Opt_raise_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_list +} + +func (*Opt_raise_listContext) IsOpt_raise_listContext() {} + +func NewOpt_raise_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_listContext { + var p = new(Opt_raise_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_raise_list + + return p +} + +func (s *Opt_raise_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_raise_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Opt_raise_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Opt_raise_listContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Opt_raise_listContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_raise_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_raise_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_raise_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_raise_list(s) + } +} + +func (s *Opt_raise_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_raise_list(s) + } +} + +func (s *Opt_raise_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_raise_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_raise_list() (localctx IOpt_raise_listContext) { + localctx = NewOpt_raise_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2080, RedshiftParserRULE_opt_raise_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserCOMMA { + { + p.SetState(14789) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14790) + p.A_expr() + } + + p.SetState(14793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_raise_usingContext is an interface to support dynamic dispatch. +type IOpt_raise_usingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Opt_raise_using_elem_list() IOpt_raise_using_elem_listContext + + // IsOpt_raise_usingContext differentiates from other interfaces. + IsOpt_raise_usingContext() +} + +type Opt_raise_usingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_raise_usingContext() *Opt_raise_usingContext { + var p = new(Opt_raise_usingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_using + return p +} + +func InitEmptyOpt_raise_usingContext(p *Opt_raise_usingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_using +} + +func (*Opt_raise_usingContext) IsOpt_raise_usingContext() {} + +func NewOpt_raise_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_usingContext { + var p = new(Opt_raise_usingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_raise_using + + return p +} + +func (s *Opt_raise_usingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_raise_usingContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Opt_raise_usingContext) Opt_raise_using_elem_list() IOpt_raise_using_elem_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_raise_using_elem_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_raise_using_elem_listContext) +} + +func (s *Opt_raise_usingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_raise_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_raise_usingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_raise_using(s) + } +} + +func (s *Opt_raise_usingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_raise_using(s) + } +} + +func (s *Opt_raise_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_raise_using(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_raise_using() (localctx IOpt_raise_usingContext) { + localctx = NewOpt_raise_usingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2082, RedshiftParserRULE_opt_raise_using) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14795) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14796) + p.Opt_raise_using_elem_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_raise_using_elemContext is an interface to support dynamic dispatch. +type IOpt_raise_using_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + EQUAL() antlr.TerminalNode + A_expr() IA_exprContext + + // IsOpt_raise_using_elemContext differentiates from other interfaces. + IsOpt_raise_using_elemContext() +} + +type Opt_raise_using_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_raise_using_elemContext() *Opt_raise_using_elemContext { + var p = new(Opt_raise_using_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_using_elem + return p +} + +func InitEmptyOpt_raise_using_elemContext(p *Opt_raise_using_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_using_elem +} + +func (*Opt_raise_using_elemContext) IsOpt_raise_using_elemContext() {} + +func NewOpt_raise_using_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_using_elemContext { + var p = new(Opt_raise_using_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_raise_using_elem + + return p +} + +func (s *Opt_raise_using_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_raise_using_elemContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Opt_raise_using_elemContext) EQUAL() antlr.TerminalNode { + return s.GetToken(RedshiftParserEQUAL, 0) +} + +func (s *Opt_raise_using_elemContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_raise_using_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_raise_using_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_raise_using_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_raise_using_elem(s) + } +} + +func (s *Opt_raise_using_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_raise_using_elem(s) + } +} + +func (s *Opt_raise_using_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_raise_using_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_raise_using_elem() (localctx IOpt_raise_using_elemContext) { + localctx = NewOpt_raise_using_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2084, RedshiftParserRULE_opt_raise_using_elem) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14798) + p.Identifier() + } + { + p.SetState(14799) + p.Match(RedshiftParserEQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14800) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_raise_using_elem_listContext is an interface to support dynamic dispatch. +type IOpt_raise_using_elem_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOpt_raise_using_elem() []IOpt_raise_using_elemContext + Opt_raise_using_elem(i int) IOpt_raise_using_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOpt_raise_using_elem_listContext differentiates from other interfaces. + IsOpt_raise_using_elem_listContext() +} + +type Opt_raise_using_elem_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_raise_using_elem_listContext() *Opt_raise_using_elem_listContext { + var p = new(Opt_raise_using_elem_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_using_elem_list + return p +} + +func InitEmptyOpt_raise_using_elem_listContext(p *Opt_raise_using_elem_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_raise_using_elem_list +} + +func (*Opt_raise_using_elem_listContext) IsOpt_raise_using_elem_listContext() {} + +func NewOpt_raise_using_elem_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_raise_using_elem_listContext { + var p = new(Opt_raise_using_elem_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_raise_using_elem_list + + return p +} + +func (s *Opt_raise_using_elem_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_raise_using_elem_listContext) AllOpt_raise_using_elem() []IOpt_raise_using_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpt_raise_using_elemContext); ok { + len++ + } + } + + tst := make([]IOpt_raise_using_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpt_raise_using_elemContext); ok { + tst[i] = t.(IOpt_raise_using_elemContext) + i++ + } + } + + return tst +} + +func (s *Opt_raise_using_elem_listContext) Opt_raise_using_elem(i int) IOpt_raise_using_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_raise_using_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpt_raise_using_elemContext) +} + +func (s *Opt_raise_using_elem_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Opt_raise_using_elem_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Opt_raise_using_elem_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_raise_using_elem_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_raise_using_elem_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_raise_using_elem_list(s) + } +} + +func (s *Opt_raise_using_elem_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_raise_using_elem_list(s) + } +} + +func (s *Opt_raise_using_elem_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_raise_using_elem_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_raise_using_elem_list() (localctx IOpt_raise_using_elem_listContext) { + localctx = NewOpt_raise_using_elem_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2086, RedshiftParserRULE_opt_raise_using_elem_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14802) + p.Opt_raise_using_elem() + } + p.SetState(14807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14803) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14804) + p.Opt_raise_using_elem() + } + + p.SetState(14809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_assertContext is an interface to support dynamic dispatch. +type IStmt_assertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASSERT() antlr.TerminalNode + Sql_expression() ISql_expressionContext + SEMI() antlr.TerminalNode + Opt_stmt_assert_message() IOpt_stmt_assert_messageContext + + // IsStmt_assertContext differentiates from other interfaces. + IsStmt_assertContext() +} + +type Stmt_assertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_assertContext() *Stmt_assertContext { + var p = new(Stmt_assertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_assert + return p +} + +func InitEmptyStmt_assertContext(p *Stmt_assertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_assert +} + +func (*Stmt_assertContext) IsStmt_assertContext() {} + +func NewStmt_assertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_assertContext { + var p = new(Stmt_assertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_assert + + return p +} + +func (s *Stmt_assertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_assertContext) ASSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSERT, 0) +} + +func (s *Stmt_assertContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Stmt_assertContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_assertContext) Opt_stmt_assert_message() IOpt_stmt_assert_messageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_stmt_assert_messageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_stmt_assert_messageContext) +} + +func (s *Stmt_assertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_assertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_assertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_assert(s) + } +} + +func (s *Stmt_assertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_assert(s) + } +} + +func (s *Stmt_assertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_assert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_assert() (localctx IStmt_assertContext) { + localctx = NewStmt_assertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2088, RedshiftParserRULE_stmt_assert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14810) + p.Match(RedshiftParserASSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14811) + p.Sql_expression() + } + p.SetState(14813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserCOMMA { + { + p.SetState(14812) + p.Opt_stmt_assert_message() + } + + } + { + p.SetState(14815) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_stmt_assert_messageContext is an interface to support dynamic dispatch. +type IOpt_stmt_assert_messageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMA() antlr.TerminalNode + Sql_expression() ISql_expressionContext + + // IsOpt_stmt_assert_messageContext differentiates from other interfaces. + IsOpt_stmt_assert_messageContext() +} + +type Opt_stmt_assert_messageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_stmt_assert_messageContext() *Opt_stmt_assert_messageContext { + var p = new(Opt_stmt_assert_messageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_stmt_assert_message + return p +} + +func InitEmptyOpt_stmt_assert_messageContext(p *Opt_stmt_assert_messageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_stmt_assert_message +} + +func (*Opt_stmt_assert_messageContext) IsOpt_stmt_assert_messageContext() {} + +func NewOpt_stmt_assert_messageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_stmt_assert_messageContext { + var p = new(Opt_stmt_assert_messageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_stmt_assert_message + + return p +} + +func (s *Opt_stmt_assert_messageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_stmt_assert_messageContext) COMMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, 0) +} + +func (s *Opt_stmt_assert_messageContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Opt_stmt_assert_messageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_stmt_assert_messageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_stmt_assert_messageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_stmt_assert_message(s) + } +} + +func (s *Opt_stmt_assert_messageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_stmt_assert_message(s) + } +} + +func (s *Opt_stmt_assert_messageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_stmt_assert_message(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_stmt_assert_message() (localctx IOpt_stmt_assert_messageContext) { + localctx = NewOpt_stmt_assert_messageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2090, RedshiftParserRULE_opt_stmt_assert_message) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14817) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14818) + p.Sql_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoop_bodyContext is an interface to support dynamic dispatch. +type ILoop_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLOOP() []antlr.TerminalNode + LOOP(i int) antlr.TerminalNode + Proc_sect() IProc_sectContext + END_P() antlr.TerminalNode + SEMI() antlr.TerminalNode + Opt_label() IOpt_labelContext + + // IsLoop_bodyContext differentiates from other interfaces. + IsLoop_bodyContext() +} + +type Loop_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoop_bodyContext() *Loop_bodyContext { + var p = new(Loop_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_loop_body + return p +} + +func InitEmptyLoop_bodyContext(p *Loop_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_loop_body +} + +func (*Loop_bodyContext) IsLoop_bodyContext() {} + +func NewLoop_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Loop_bodyContext { + var p = new(Loop_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_loop_body + + return p +} + +func (s *Loop_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Loop_bodyContext) AllLOOP() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserLOOP) +} + +func (s *Loop_bodyContext) LOOP(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserLOOP, i) +} + +func (s *Loop_bodyContext) Proc_sect() IProc_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Loop_bodyContext) END_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserEND_P, 0) +} + +func (s *Loop_bodyContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Loop_bodyContext) Opt_label() IOpt_labelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_labelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_labelContext) +} + +func (s *Loop_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Loop_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Loop_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterLoop_body(s) + } +} + +func (s *Loop_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitLoop_body(s) + } +} + +func (s *Loop_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitLoop_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Loop_body() (localctx ILoop_bodyContext) { + localctx = NewLoop_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2092, RedshiftParserRULE_loop_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14820) + p.Match(RedshiftParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14821) + p.Proc_sect() + } + { + p.SetState(14822) + p.Match(RedshiftParserEND_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14823) + p.Match(RedshiftParserLOOP) + 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 ((int64((_la-33)) & ^0x3f) == 0 && ((int64(1)<<(_la-33))&1161999072892558341) != 0) || ((int64((_la-118)) & ^0x3f) == 0 && ((int64(1)<<(_la-118))&-1152921504606853751) != 0) || ((int64((_la-182)) & ^0x3f) == 0 && ((int64(1)<<(_la-182))&-1) != 0) || ((int64((_la-246)) & ^0x3f) == 0 && ((int64(1)<<(_la-246))&-2199023257857) != 0) || ((int64((_la-310)) & ^0x3f) == 0 && ((int64(1)<<(_la-310))&-1) != 0) || ((int64((_la-374)) & ^0x3f) == 0 && ((int64(1)<<(_la-374))&-653313) != 0) || ((int64((_la-438)) & ^0x3f) == 0 && ((int64(1)<<(_la-438))&-1) != 0) || ((int64((_la-502)) & ^0x3f) == 0 && ((int64(1)<<(_la-502))&-1) != 0) || ((int64((_la-566)) & ^0x3f) == 0 && ((int64(1)<<(_la-566))&35184372088831) != 0) || ((int64((_la-639)) & ^0x3f) == 0 && ((int64(1)<<(_la-639))&9223372032559792127) != 0) || ((int64((_la-703)) & ^0x3f) == 0 && ((int64(1)<<(_la-703))&-32771) != 0) || ((int64((_la-767)) & ^0x3f) == 0 && ((int64(1)<<(_la-767))&-1) != 0) || ((int64((_la-831)) & ^0x3f) == 0 && ((int64(1)<<(_la-831))&422212608720911) != 0) { + { + p.SetState(14824) + p.Opt_label() + } + + } + { + p.SetState(14827) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_execsqlContext is an interface to support dynamic dispatch. +type IStmt_execsqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Make_execsql_stmt() IMake_execsql_stmtContext + SEMI() antlr.TerminalNode + + // IsStmt_execsqlContext differentiates from other interfaces. + IsStmt_execsqlContext() +} + +type Stmt_execsqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_execsqlContext() *Stmt_execsqlContext { + var p = new(Stmt_execsqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_execsql + return p +} + +func InitEmptyStmt_execsqlContext(p *Stmt_execsqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_execsql +} + +func (*Stmt_execsqlContext) IsStmt_execsqlContext() {} + +func NewStmt_execsqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_execsqlContext { + var p = new(Stmt_execsqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_execsql + + return p +} + +func (s *Stmt_execsqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_execsqlContext) Make_execsql_stmt() IMake_execsql_stmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMake_execsql_stmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMake_execsql_stmtContext) +} + +func (s *Stmt_execsqlContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_execsqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_execsqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_execsqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_execsql(s) + } +} + +func (s *Stmt_execsqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_execsql(s) + } +} + +func (s *Stmt_execsqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_execsql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_execsql() (localctx IStmt_execsqlContext) { + localctx = NewStmt_execsqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2094, RedshiftParserRULE_stmt_execsql) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14829) + p.Make_execsql_stmt() + } + { + p.SetState(14830) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_dynexecuteContext is an interface to support dynamic dispatch. +type IStmt_dynexecuteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + A_expr() IA_exprContext + SEMI() antlr.TerminalNode + Opt_execute_into() IOpt_execute_intoContext + Opt_execute_using() IOpt_execute_usingContext + + // IsStmt_dynexecuteContext differentiates from other interfaces. + IsStmt_dynexecuteContext() +} + +type Stmt_dynexecuteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_dynexecuteContext() *Stmt_dynexecuteContext { + var p = new(Stmt_dynexecuteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_dynexecute + return p +} + +func InitEmptyStmt_dynexecuteContext(p *Stmt_dynexecuteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_dynexecute +} + +func (*Stmt_dynexecuteContext) IsStmt_dynexecuteContext() {} + +func NewStmt_dynexecuteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_dynexecuteContext { + var p = new(Stmt_dynexecuteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_dynexecute + + return p +} + +func (s *Stmt_dynexecuteContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_dynexecuteContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *Stmt_dynexecuteContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Stmt_dynexecuteContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_dynexecuteContext) Opt_execute_into() IOpt_execute_intoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_execute_intoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_execute_intoContext) +} + +func (s *Stmt_dynexecuteContext) Opt_execute_using() IOpt_execute_usingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_execute_usingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_execute_usingContext) +} + +func (s *Stmt_dynexecuteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_dynexecuteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_dynexecuteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_dynexecute(s) + } +} + +func (s *Stmt_dynexecuteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_dynexecute(s) + } +} + +func (s *Stmt_dynexecuteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_dynexecute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_dynexecute() (localctx IStmt_dynexecuteContext) { + localctx = NewStmt_dynexecuteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2096, RedshiftParserRULE_stmt_dynexecute) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14832) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14833) + p.A_expr() + } + p.SetState(14847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1460, p.GetParserRuleContext()) { + case 1: + p.SetState(14835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINTO { + { + p.SetState(14834) + p.Opt_execute_into() + } + + } + p.SetState(14838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14837) + p.Opt_execute_using() + } + + } + + case 2: + p.SetState(14841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14840) + p.Opt_execute_using() + } + + } + p.SetState(14844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINTO { + { + p.SetState(14843) + p.Opt_execute_into() + } + + } + + case 3: + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(14849) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_execute_usingContext is an interface to support dynamic dispatch. +type IOpt_execute_usingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Opt_execute_using_list() IOpt_execute_using_listContext + + // IsOpt_execute_usingContext differentiates from other interfaces. + IsOpt_execute_usingContext() +} + +type Opt_execute_usingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_execute_usingContext() *Opt_execute_usingContext { + var p = new(Opt_execute_usingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_execute_using + return p +} + +func InitEmptyOpt_execute_usingContext(p *Opt_execute_usingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_execute_using +} + +func (*Opt_execute_usingContext) IsOpt_execute_usingContext() {} + +func NewOpt_execute_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_usingContext { + var p = new(Opt_execute_usingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_execute_using + + return p +} + +func (s *Opt_execute_usingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_execute_usingContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Opt_execute_usingContext) Opt_execute_using_list() IOpt_execute_using_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_execute_using_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_execute_using_listContext) +} + +func (s *Opt_execute_usingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_execute_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_execute_usingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_execute_using(s) + } +} + +func (s *Opt_execute_usingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_execute_using(s) + } +} + +func (s *Opt_execute_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_execute_using(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_execute_using() (localctx IOpt_execute_usingContext) { + localctx = NewOpt_execute_usingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2098, RedshiftParserRULE_opt_execute_using) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14851) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14852) + p.Opt_execute_using_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_execute_using_listContext is an interface to support dynamic dispatch. +type IOpt_execute_using_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllA_expr() []IA_exprContext + A_expr(i int) IA_exprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOpt_execute_using_listContext differentiates from other interfaces. + IsOpt_execute_using_listContext() +} + +type Opt_execute_using_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_execute_using_listContext() *Opt_execute_using_listContext { + var p = new(Opt_execute_using_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_execute_using_list + return p +} + +func InitEmptyOpt_execute_using_listContext(p *Opt_execute_using_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_execute_using_list +} + +func (*Opt_execute_using_listContext) IsOpt_execute_using_listContext() {} + +func NewOpt_execute_using_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_using_listContext { + var p = new(Opt_execute_using_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_execute_using_list + + return p +} + +func (s *Opt_execute_using_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_execute_using_listContext) AllA_expr() []IA_exprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IA_exprContext); ok { + len++ + } + } + + tst := make([]IA_exprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IA_exprContext); ok { + tst[i] = t.(IA_exprContext) + i++ + } + } + + return tst +} + +func (s *Opt_execute_using_listContext) A_expr(i int) IA_exprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_execute_using_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Opt_execute_using_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Opt_execute_using_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_execute_using_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_execute_using_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_execute_using_list(s) + } +} + +func (s *Opt_execute_using_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_execute_using_list(s) + } +} + +func (s *Opt_execute_using_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_execute_using_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_execute_using_list() (localctx IOpt_execute_using_listContext) { + localctx = NewOpt_execute_using_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2100, RedshiftParserRULE_opt_execute_using_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14854) + p.A_expr() + } + p.SetState(14859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14855) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14856) + p.A_expr() + } + + p.SetState(14861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_execute_intoContext is an interface to support dynamic dispatch. +type IOpt_execute_intoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + Into_target() IInto_targetContext + STRICT_P() antlr.TerminalNode + + // IsOpt_execute_intoContext differentiates from other interfaces. + IsOpt_execute_intoContext() +} + +type Opt_execute_intoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_execute_intoContext() *Opt_execute_intoContext { + var p = new(Opt_execute_intoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_execute_into + return p +} + +func InitEmptyOpt_execute_intoContext(p *Opt_execute_intoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_execute_into +} + +func (*Opt_execute_intoContext) IsOpt_execute_intoContext() {} + +func NewOpt_execute_intoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_execute_intoContext { + var p = new(Opt_execute_intoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_execute_into + + return p +} + +func (s *Opt_execute_intoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_execute_intoContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *Opt_execute_intoContext) Into_target() IInto_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_targetContext) +} + +func (s *Opt_execute_intoContext) STRICT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTRICT_P, 0) +} + +func (s *Opt_execute_intoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_execute_intoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_execute_intoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_execute_into(s) + } +} + +func (s *Opt_execute_intoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_execute_into(s) + } +} + +func (s *Opt_execute_intoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_execute_into(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_execute_into() (localctx IOpt_execute_intoContext) { + localctx = NewOpt_execute_intoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2102, RedshiftParserRULE_opt_execute_into) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14862) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14864) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1462, p.GetParserRuleContext()) == 1 { + { + p.SetState(14863) + p.Match(RedshiftParserSTRICT_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14866) + p.Into_target() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_openContext is an interface to support dynamic dispatch. +type IStmt_openContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN() antlr.TerminalNode + SEMI() antlr.TerminalNode + Cursor_variable() ICursor_variableContext + FOR() antlr.TerminalNode + Colid() IColidContext + Selectstmt() ISelectstmtContext + EXECUTE() antlr.TerminalNode + Sql_expression() ISql_expressionContext + Opt_scroll_option() IOpt_scroll_optionContext + OPEN_PAREN() antlr.TerminalNode + Opt_open_bound_list() IOpt_open_bound_listContext + CLOSE_PAREN() antlr.TerminalNode + Opt_open_using() IOpt_open_usingContext + + // IsStmt_openContext differentiates from other interfaces. + IsStmt_openContext() +} + +type Stmt_openContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_openContext() *Stmt_openContext { + var p = new(Stmt_openContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_open + return p +} + +func InitEmptyStmt_openContext(p *Stmt_openContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_open +} + +func (*Stmt_openContext) IsStmt_openContext() {} + +func NewStmt_openContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_openContext { + var p = new(Stmt_openContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_open + + return p +} + +func (s *Stmt_openContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_openContext) OPEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN, 0) +} + +func (s *Stmt_openContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_openContext) Cursor_variable() ICursor_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_variableContext) +} + +func (s *Stmt_openContext) FOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserFOR, 0) +} + +func (s *Stmt_openContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Stmt_openContext) Selectstmt() ISelectstmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelectstmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelectstmtContext) +} + +func (s *Stmt_openContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXECUTE, 0) +} + +func (s *Stmt_openContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Stmt_openContext) Opt_scroll_option() IOpt_scroll_optionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_scroll_optionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_scroll_optionContext) +} + +func (s *Stmt_openContext) OPEN_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN_PAREN, 0) +} + +func (s *Stmt_openContext) Opt_open_bound_list() IOpt_open_bound_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_open_bound_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_open_bound_listContext) +} + +func (s *Stmt_openContext) CLOSE_PAREN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE_PAREN, 0) +} + +func (s *Stmt_openContext) Opt_open_using() IOpt_open_usingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_open_usingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_open_usingContext) +} + +func (s *Stmt_openContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_openContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_openContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_open(s) + } +} + +func (s *Stmt_openContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_open(s) + } +} + +func (s *Stmt_openContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_open(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_open() (localctx IStmt_openContext) { + localctx = NewStmt_openContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2104, RedshiftParserRULE_stmt_open) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14868) + p.Match(RedshiftParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1467, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14869) + p.Cursor_variable() + } + p.SetState(14871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO || _la == RedshiftParserSCROLL { + { + p.SetState(14870) + p.Opt_scroll_option() + } + + } + { + p.SetState(14873) + p.Match(RedshiftParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserOPEN_PAREN, RedshiftParserSELECT, RedshiftParserTABLE, RedshiftParserWITH, RedshiftParserVALUES: + { + p.SetState(14874) + p.Selectstmt() + } + + case RedshiftParserEXECUTE: + { + p.SetState(14875) + p.Match(RedshiftParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14876) + p.Sql_expression() + } + p.SetState(14878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserUSING { + { + p.SetState(14877) + p.Opt_open_using() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + { + p.SetState(14882) + p.Colid() + } + p.SetState(14887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserOPEN_PAREN { + { + p.SetState(14883) + p.Match(RedshiftParserOPEN_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14884) + p.Opt_open_bound_list() + } + { + p.SetState(14885) + p.Match(RedshiftParserCLOSE_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(14891) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_open_bound_list_itemContext is an interface to support dynamic dispatch. +type IOpt_open_bound_list_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + COLON_EQUALS() antlr.TerminalNode + A_expr() IA_exprContext + + // IsOpt_open_bound_list_itemContext differentiates from other interfaces. + IsOpt_open_bound_list_itemContext() +} + +type Opt_open_bound_list_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_open_bound_list_itemContext() *Opt_open_bound_list_itemContext { + var p = new(Opt_open_bound_list_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_open_bound_list_item + return p +} + +func InitEmptyOpt_open_bound_list_itemContext(p *Opt_open_bound_list_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_open_bound_list_item +} + +func (*Opt_open_bound_list_itemContext) IsOpt_open_bound_list_itemContext() {} + +func NewOpt_open_bound_list_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_bound_list_itemContext { + var p = new(Opt_open_bound_list_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_open_bound_list_item + + return p +} + +func (s *Opt_open_bound_list_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_open_bound_list_itemContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Opt_open_bound_list_itemContext) COLON_EQUALS() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLON_EQUALS, 0) +} + +func (s *Opt_open_bound_list_itemContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_open_bound_list_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_open_bound_list_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_open_bound_list_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_open_bound_list_item(s) + } +} + +func (s *Opt_open_bound_list_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_open_bound_list_item(s) + } +} + +func (s *Opt_open_bound_list_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_open_bound_list_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_open_bound_list_item() (localctx IOpt_open_bound_list_itemContext) { + localctx = NewOpt_open_bound_list_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2106, RedshiftParserRULE_opt_open_bound_list_item) + p.SetState(14898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1468, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14893) + p.Colid() + } + { + p.SetState(14894) + p.Match(RedshiftParserCOLON_EQUALS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14895) + p.A_expr() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14897) + p.A_expr() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_open_bound_listContext is an interface to support dynamic dispatch. +type IOpt_open_bound_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllOpt_open_bound_list_item() []IOpt_open_bound_list_itemContext + Opt_open_bound_list_item(i int) IOpt_open_bound_list_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOpt_open_bound_listContext differentiates from other interfaces. + IsOpt_open_bound_listContext() +} + +type Opt_open_bound_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_open_bound_listContext() *Opt_open_bound_listContext { + var p = new(Opt_open_bound_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_open_bound_list + return p +} + +func InitEmptyOpt_open_bound_listContext(p *Opt_open_bound_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_open_bound_list +} + +func (*Opt_open_bound_listContext) IsOpt_open_bound_listContext() {} + +func NewOpt_open_bound_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_bound_listContext { + var p = new(Opt_open_bound_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_open_bound_list + + return p +} + +func (s *Opt_open_bound_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_open_bound_listContext) AllOpt_open_bound_list_item() []IOpt_open_bound_list_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOpt_open_bound_list_itemContext); ok { + len++ + } + } + + tst := make([]IOpt_open_bound_list_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOpt_open_bound_list_itemContext); ok { + tst[i] = t.(IOpt_open_bound_list_itemContext) + i++ + } + } + + return tst +} + +func (s *Opt_open_bound_listContext) Opt_open_bound_list_item(i int) IOpt_open_bound_list_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_open_bound_list_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOpt_open_bound_list_itemContext) +} + +func (s *Opt_open_bound_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserCOMMA) +} + +func (s *Opt_open_bound_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMA, i) +} + +func (s *Opt_open_bound_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_open_bound_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_open_bound_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_open_bound_list(s) + } +} + +func (s *Opt_open_bound_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_open_bound_list(s) + } +} + +func (s *Opt_open_bound_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_open_bound_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_open_bound_list() (localctx IOpt_open_bound_listContext) { + localctx = NewOpt_open_bound_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2108, RedshiftParserRULE_opt_open_bound_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14900) + p.Opt_open_bound_list_item() + } + p.SetState(14905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserCOMMA { + { + p.SetState(14901) + p.Match(RedshiftParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14902) + p.Opt_open_bound_list_item() + } + + p.SetState(14907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_open_usingContext is an interface to support dynamic dispatch. +type IOpt_open_usingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsOpt_open_usingContext differentiates from other interfaces. + IsOpt_open_usingContext() +} + +type Opt_open_usingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_open_usingContext() *Opt_open_usingContext { + var p = new(Opt_open_usingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_open_using + return p +} + +func InitEmptyOpt_open_usingContext(p *Opt_open_usingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_open_using +} + +func (*Opt_open_usingContext) IsOpt_open_usingContext() {} + +func NewOpt_open_usingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_open_usingContext { + var p = new(Opt_open_usingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_open_using + + return p +} + +func (s *Opt_open_usingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_open_usingContext) USING() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSING, 0) +} + +func (s *Opt_open_usingContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Opt_open_usingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_open_usingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_open_usingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_open_using(s) + } +} + +func (s *Opt_open_usingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_open_using(s) + } +} + +func (s *Opt_open_usingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_open_using(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_open_using() (localctx IOpt_open_usingContext) { + localctx = NewOpt_open_usingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2110, RedshiftParserRULE_opt_open_using) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14908) + p.Match(RedshiftParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14909) + p.Expr_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_scroll_optionContext is an interface to support dynamic dispatch. +type IOpt_scroll_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCROLL() antlr.TerminalNode + Opt_scroll_option_no() IOpt_scroll_option_noContext + + // IsOpt_scroll_optionContext differentiates from other interfaces. + IsOpt_scroll_optionContext() +} + +type Opt_scroll_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_scroll_optionContext() *Opt_scroll_optionContext { + var p = new(Opt_scroll_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_scroll_option + return p +} + +func InitEmptyOpt_scroll_optionContext(p *Opt_scroll_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_scroll_option +} + +func (*Opt_scroll_optionContext) IsOpt_scroll_optionContext() {} + +func NewOpt_scroll_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scroll_optionContext { + var p = new(Opt_scroll_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_scroll_option + + return p +} + +func (s *Opt_scroll_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_scroll_optionContext) SCROLL() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCROLL, 0) +} + +func (s *Opt_scroll_optionContext) Opt_scroll_option_no() IOpt_scroll_option_noContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_scroll_option_noContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_scroll_option_noContext) +} + +func (s *Opt_scroll_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_scroll_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_scroll_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_scroll_option(s) + } +} + +func (s *Opt_scroll_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_scroll_option(s) + } +} + +func (s *Opt_scroll_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_scroll_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_scroll_option() (localctx IOpt_scroll_optionContext) { + localctx = NewOpt_scroll_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2112, RedshiftParserRULE_opt_scroll_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(14911) + p.Opt_scroll_option_no() + } + + } + { + p.SetState(14914) + p.Match(RedshiftParserSCROLL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_scroll_option_noContext is an interface to support dynamic dispatch. +type IOpt_scroll_option_noContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + + // IsOpt_scroll_option_noContext differentiates from other interfaces. + IsOpt_scroll_option_noContext() +} + +type Opt_scroll_option_noContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_scroll_option_noContext() *Opt_scroll_option_noContext { + var p = new(Opt_scroll_option_noContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_scroll_option_no + return p +} + +func InitEmptyOpt_scroll_option_noContext(p *Opt_scroll_option_noContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_scroll_option_no +} + +func (*Opt_scroll_option_noContext) IsOpt_scroll_option_noContext() {} + +func NewOpt_scroll_option_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_scroll_option_noContext { + var p = new(Opt_scroll_option_noContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_scroll_option_no + + return p +} + +func (s *Opt_scroll_option_noContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_scroll_option_noContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Opt_scroll_option_noContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_scroll_option_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_scroll_option_noContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_scroll_option_no(s) + } +} + +func (s *Opt_scroll_option_noContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_scroll_option_no(s) + } +} + +func (s *Opt_scroll_option_noContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_scroll_option_no(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_scroll_option_no() (localctx IOpt_scroll_option_noContext) { + localctx = NewOpt_scroll_option_noContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2114, RedshiftParserRULE_opt_scroll_option_no) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14916) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_fetchContext is an interface to support dynamic dispatch. +type IStmt_fetchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDirection returns the direction rule contexts. + GetDirection() IOpt_fetch_directionContext + + // SetDirection sets the direction rule contexts. + SetDirection(IOpt_fetch_directionContext) + + // Getter signatures + FETCH() antlr.TerminalNode + Cursor_variable() ICursor_variableContext + INTO() antlr.TerminalNode + Into_target() IInto_targetContext + SEMI() antlr.TerminalNode + Opt_cursor_from() IOpt_cursor_fromContext + Opt_fetch_direction() IOpt_fetch_directionContext + + // IsStmt_fetchContext differentiates from other interfaces. + IsStmt_fetchContext() +} + +type Stmt_fetchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + direction IOpt_fetch_directionContext +} + +func NewEmptyStmt_fetchContext() *Stmt_fetchContext { + var p = new(Stmt_fetchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_fetch + return p +} + +func InitEmptyStmt_fetchContext(p *Stmt_fetchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_fetch +} + +func (*Stmt_fetchContext) IsStmt_fetchContext() {} + +func NewStmt_fetchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_fetchContext { + var p = new(Stmt_fetchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_fetch + + return p +} + +func (s *Stmt_fetchContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_fetchContext) GetDirection() IOpt_fetch_directionContext { return s.direction } + +func (s *Stmt_fetchContext) SetDirection(v IOpt_fetch_directionContext) { s.direction = v } + +func (s *Stmt_fetchContext) FETCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFETCH, 0) +} + +func (s *Stmt_fetchContext) Cursor_variable() ICursor_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_variableContext) +} + +func (s *Stmt_fetchContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *Stmt_fetchContext) Into_target() IInto_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_targetContext) +} + +func (s *Stmt_fetchContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_fetchContext) Opt_cursor_from() IOpt_cursor_fromContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_cursor_fromContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_cursor_fromContext) +} + +func (s *Stmt_fetchContext) Opt_fetch_direction() IOpt_fetch_directionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_fetch_directionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_fetch_directionContext) +} + +func (s *Stmt_fetchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_fetchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_fetchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_fetch(s) + } +} + +func (s *Stmt_fetchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_fetch(s) + } +} + +func (s *Stmt_fetchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_fetch(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_fetch() (localctx IStmt_fetchContext) { + localctx = NewStmt_fetchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2116, RedshiftParserRULE_stmt_fetch) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14918) + p.Match(RedshiftParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14920) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1471, p.GetParserRuleContext()) == 1 { + { + p.SetState(14919) + + var _x = p.Opt_fetch_direction() + + localctx.(*Stmt_fetchContext).direction = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM || _la == RedshiftParserIN_P { + { + p.SetState(14922) + p.Opt_cursor_from() + } + + } + { + p.SetState(14925) + p.Cursor_variable() + } + { + p.SetState(14926) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14927) + p.Into_target() + } + { + p.SetState(14928) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInto_targetContext is an interface to support dynamic dispatch. +type IInto_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expr_list() IExpr_listContext + + // IsInto_targetContext differentiates from other interfaces. + IsInto_targetContext() +} + +type Into_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInto_targetContext() *Into_targetContext { + var p = new(Into_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_into_target + return p +} + +func InitEmptyInto_targetContext(p *Into_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_into_target +} + +func (*Into_targetContext) IsInto_targetContext() {} + +func NewInto_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_targetContext { + var p = new(Into_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_into_target + + return p +} + +func (s *Into_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Into_targetContext) Expr_list() IExpr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_listContext) +} + +func (s *Into_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Into_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Into_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterInto_target(s) + } +} + +func (s *Into_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitInto_target(s) + } +} + +func (s *Into_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitInto_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Into_target() (localctx IInto_targetContext) { + localctx = NewInto_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2118, RedshiftParserRULE_into_target) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14930) + p.Expr_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_cursor_fromContext is an interface to support dynamic dispatch. +type IOpt_cursor_fromContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + IN_P() antlr.TerminalNode + + // IsOpt_cursor_fromContext differentiates from other interfaces. + IsOpt_cursor_fromContext() +} + +type Opt_cursor_fromContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_cursor_fromContext() *Opt_cursor_fromContext { + var p = new(Opt_cursor_fromContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_cursor_from + return p +} + +func InitEmptyOpt_cursor_fromContext(p *Opt_cursor_fromContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_cursor_from +} + +func (*Opt_cursor_fromContext) IsOpt_cursor_fromContext() {} + +func NewOpt_cursor_fromContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_cursor_fromContext { + var p = new(Opt_cursor_fromContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_cursor_from + + return p +} + +func (s *Opt_cursor_fromContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_cursor_fromContext) FROM() antlr.TerminalNode { + return s.GetToken(RedshiftParserFROM, 0) +} + +func (s *Opt_cursor_fromContext) IN_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserIN_P, 0) +} + +func (s *Opt_cursor_fromContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_cursor_fromContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_cursor_fromContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_cursor_from(s) + } +} + +func (s *Opt_cursor_fromContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_cursor_from(s) + } +} + +func (s *Opt_cursor_fromContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_cursor_from(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_cursor_from() (localctx IOpt_cursor_fromContext) { + localctx = NewOpt_cursor_fromContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2120, RedshiftParserRULE_opt_cursor_from) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14932) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserFROM || _la == RedshiftParserIN_P) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_fetch_directionContext is an interface to support dynamic dispatch. +type IOpt_fetch_directionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEXT() antlr.TerminalNode + PRIOR() antlr.TerminalNode + FIRST_P() antlr.TerminalNode + LAST_P() antlr.TerminalNode + ABSOLUTE_P() antlr.TerminalNode + A_expr() IA_exprContext + RELATIVE_P() antlr.TerminalNode + ALL() antlr.TerminalNode + FORWARD() antlr.TerminalNode + BACKWARD() antlr.TerminalNode + + // IsOpt_fetch_directionContext differentiates from other interfaces. + IsOpt_fetch_directionContext() +} + +type Opt_fetch_directionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_fetch_directionContext() *Opt_fetch_directionContext { + var p = new(Opt_fetch_directionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_fetch_direction + return p +} + +func InitEmptyOpt_fetch_directionContext(p *Opt_fetch_directionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_fetch_direction +} + +func (*Opt_fetch_directionContext) IsOpt_fetch_directionContext() {} + +func NewOpt_fetch_directionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_fetch_directionContext { + var p = new(Opt_fetch_directionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_fetch_direction + + return p +} + +func (s *Opt_fetch_directionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_fetch_directionContext) NEXT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEXT, 0) +} + +func (s *Opt_fetch_directionContext) PRIOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIOR, 0) +} + +func (s *Opt_fetch_directionContext) FIRST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIRST_P, 0) +} + +func (s *Opt_fetch_directionContext) LAST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLAST_P, 0) +} + +func (s *Opt_fetch_directionContext) ABSOLUTE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserABSOLUTE_P, 0) +} + +func (s *Opt_fetch_directionContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Opt_fetch_directionContext) RELATIVE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserRELATIVE_P, 0) +} + +func (s *Opt_fetch_directionContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Opt_fetch_directionContext) FORWARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORWARD, 0) +} + +func (s *Opt_fetch_directionContext) BACKWARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserBACKWARD, 0) +} + +func (s *Opt_fetch_directionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_fetch_directionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_fetch_directionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_fetch_direction(s) + } +} + +func (s *Opt_fetch_directionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_fetch_direction(s) + } +} + +func (s *Opt_fetch_directionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_fetch_direction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_fetch_direction() (localctx IOpt_fetch_directionContext) { + localctx = NewOpt_fetch_directionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2122, RedshiftParserRULE_opt_fetch_direction) + var _la int + + p.SetState(14949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1474, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14934) + p.Match(RedshiftParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14935) + p.Match(RedshiftParserPRIOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14936) + p.Match(RedshiftParserFIRST_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14937) + p.Match(RedshiftParserLAST_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14938) + p.Match(RedshiftParserABSOLUTE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14939) + p.A_expr() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14940) + p.Match(RedshiftParserRELATIVE_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14941) + p.A_expr() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14942) + p.A_expr() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14943) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14944) + _la = p.GetTokenStream().LA(1) + + if !(_la == RedshiftParserBACKWARD || _la == RedshiftParserFORWARD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14947) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1473, p.GetParserRuleContext()) == 1 { + { + p.SetState(14945) + p.A_expr() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1473, p.GetParserRuleContext()) == 2 { + { + p.SetState(14946) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_moveContext is an interface to support dynamic dispatch. +type IStmt_moveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + Cursor_variable() ICursor_variableContext + SEMI() antlr.TerminalNode + Opt_fetch_direction() IOpt_fetch_directionContext + + // IsStmt_moveContext differentiates from other interfaces. + IsStmt_moveContext() +} + +type Stmt_moveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_moveContext() *Stmt_moveContext { + var p = new(Stmt_moveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_move + return p +} + +func InitEmptyStmt_moveContext(p *Stmt_moveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_move +} + +func (*Stmt_moveContext) IsStmt_moveContext() {} + +func NewStmt_moveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_moveContext { + var p = new(Stmt_moveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_move + + return p +} + +func (s *Stmt_moveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_moveContext) MOVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMOVE, 0) +} + +func (s *Stmt_moveContext) Cursor_variable() ICursor_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_variableContext) +} + +func (s *Stmt_moveContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_moveContext) Opt_fetch_direction() IOpt_fetch_directionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_fetch_directionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_fetch_directionContext) +} + +func (s *Stmt_moveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_moveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_moveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_move(s) + } +} + +func (s *Stmt_moveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_move(s) + } +} + +func (s *Stmt_moveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_move(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_move() (localctx IStmt_moveContext) { + localctx = NewStmt_moveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2124, RedshiftParserRULE_stmt_move) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14951) + p.Match(RedshiftParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14953) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1475, p.GetParserRuleContext()) == 1 { + { + p.SetState(14952) + p.Opt_fetch_direction() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14955) + p.Cursor_variable() + } + { + p.SetState(14956) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_closeContext is an interface to support dynamic dispatch. +type IStmt_closeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLOSE() antlr.TerminalNode + Cursor_variable() ICursor_variableContext + SEMI() antlr.TerminalNode + + // IsStmt_closeContext differentiates from other interfaces. + IsStmt_closeContext() +} + +type Stmt_closeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_closeContext() *Stmt_closeContext { + var p = new(Stmt_closeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_close + return p +} + +func InitEmptyStmt_closeContext(p *Stmt_closeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_close +} + +func (*Stmt_closeContext) IsStmt_closeContext() {} + +func NewStmt_closeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_closeContext { + var p = new(Stmt_closeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_close + + return p +} + +func (s *Stmt_closeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_closeContext) CLOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE, 0) +} + +func (s *Stmt_closeContext) Cursor_variable() ICursor_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_variableContext) +} + +func (s *Stmt_closeContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_closeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_closeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_closeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_close(s) + } +} + +func (s *Stmt_closeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_close(s) + } +} + +func (s *Stmt_closeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_close(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_close() (localctx IStmt_closeContext) { + localctx = NewStmt_closeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2126, RedshiftParserRULE_stmt_close) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14958) + p.Match(RedshiftParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14959) + p.Cursor_variable() + } + { + p.SetState(14960) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_nullContext is an interface to support dynamic dispatch. +type IStmt_nullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_P() antlr.TerminalNode + SEMI() antlr.TerminalNode + + // IsStmt_nullContext differentiates from other interfaces. + IsStmt_nullContext() +} + +type Stmt_nullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_nullContext() *Stmt_nullContext { + var p = new(Stmt_nullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_null + return p +} + +func InitEmptyStmt_nullContext(p *Stmt_nullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_null +} + +func (*Stmt_nullContext) IsStmt_nullContext() {} + +func NewStmt_nullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_nullContext { + var p = new(Stmt_nullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_null + + return p +} + +func (s *Stmt_nullContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_nullContext) NULL_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserNULL_P, 0) +} + +func (s *Stmt_nullContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_nullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_nullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_nullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_null(s) + } +} + +func (s *Stmt_nullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_null(s) + } +} + +func (s *Stmt_nullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_null(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_null() (localctx IStmt_nullContext) { + localctx = NewStmt_nullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2128, RedshiftParserRULE_stmt_null) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14962) + p.Match(RedshiftParserNULL_P) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14963) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_commitContext is an interface to support dynamic dispatch. +type IStmt_commitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMIT() antlr.TerminalNode + SEMI() antlr.TerminalNode + Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext + + // IsStmt_commitContext differentiates from other interfaces. + IsStmt_commitContext() +} + +type Stmt_commitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_commitContext() *Stmt_commitContext { + var p = new(Stmt_commitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_commit + return p +} + +func InitEmptyStmt_commitContext(p *Stmt_commitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_commit +} + +func (*Stmt_commitContext) IsStmt_commitContext() {} + +func NewStmt_commitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_commitContext { + var p = new(Stmt_commitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_commit + + return p +} + +func (s *Stmt_commitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_commitContext) COMMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMIT, 0) +} + +func (s *Stmt_commitContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_commitContext) Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_opt_transaction_chainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_opt_transaction_chainContext) +} + +func (s *Stmt_commitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_commitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_commitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_commit(s) + } +} + +func (s *Stmt_commitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_commit(s) + } +} + +func (s *Stmt_commitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_commit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_commit() (localctx IStmt_commitContext) { + localctx = NewStmt_commitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2130, RedshiftParserRULE_stmt_commit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14965) + p.Match(RedshiftParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(14966) + p.Plsql_opt_transaction_chain() + } + + } + { + p.SetState(14969) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_rollbackContext is an interface to support dynamic dispatch. +type IStmt_rollbackContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLBACK() antlr.TerminalNode + SEMI() antlr.TerminalNode + Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext + + // IsStmt_rollbackContext differentiates from other interfaces. + IsStmt_rollbackContext() +} + +type Stmt_rollbackContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_rollbackContext() *Stmt_rollbackContext { + var p = new(Stmt_rollbackContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_rollback + return p +} + +func InitEmptyStmt_rollbackContext(p *Stmt_rollbackContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_rollback +} + +func (*Stmt_rollbackContext) IsStmt_rollbackContext() {} + +func NewStmt_rollbackContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_rollbackContext { + var p = new(Stmt_rollbackContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_rollback + + return p +} + +func (s *Stmt_rollbackContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_rollbackContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLLBACK, 0) +} + +func (s *Stmt_rollbackContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_rollbackContext) Plsql_opt_transaction_chain() IPlsql_opt_transaction_chainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_opt_transaction_chainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_opt_transaction_chainContext) +} + +func (s *Stmt_rollbackContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_rollbackContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_rollbackContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_rollback(s) + } +} + +func (s *Stmt_rollbackContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_rollback(s) + } +} + +func (s *Stmt_rollbackContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_rollback(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_rollback() (localctx IStmt_rollbackContext) { + localctx = NewStmt_rollbackContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2132, RedshiftParserRULE_stmt_rollback) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14971) + p.Match(RedshiftParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserAND { + { + p.SetState(14972) + p.Plsql_opt_transaction_chain() + } + + } + { + p.SetState(14975) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsql_opt_transaction_chainContext is an interface to support dynamic dispatch. +type IPlsql_opt_transaction_chainContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AND() antlr.TerminalNode + CHAIN() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsPlsql_opt_transaction_chainContext differentiates from other interfaces. + IsPlsql_opt_transaction_chainContext() +} + +type Plsql_opt_transaction_chainContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsql_opt_transaction_chainContext() *Plsql_opt_transaction_chainContext { + var p = new(Plsql_opt_transaction_chainContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsql_opt_transaction_chain + return p +} + +func InitEmptyPlsql_opt_transaction_chainContext(p *Plsql_opt_transaction_chainContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsql_opt_transaction_chain +} + +func (*Plsql_opt_transaction_chainContext) IsPlsql_opt_transaction_chainContext() {} + +func NewPlsql_opt_transaction_chainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_opt_transaction_chainContext { + var p = new(Plsql_opt_transaction_chainContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_plsql_opt_transaction_chain + + return p +} + +func (s *Plsql_opt_transaction_chainContext) GetParser() antlr.Parser { return s.parser } + +func (s *Plsql_opt_transaction_chainContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Plsql_opt_transaction_chainContext) CHAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHAIN, 0) +} + +func (s *Plsql_opt_transaction_chainContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Plsql_opt_transaction_chainContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Plsql_opt_transaction_chainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Plsql_opt_transaction_chainContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPlsql_opt_transaction_chain(s) + } +} + +func (s *Plsql_opt_transaction_chainContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPlsql_opt_transaction_chain(s) + } +} + +func (s *Plsql_opt_transaction_chainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPlsql_opt_transaction_chain(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Plsql_opt_transaction_chain() (localctx IPlsql_opt_transaction_chainContext) { + localctx = NewPlsql_opt_transaction_chainContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2134, RedshiftParserRULE_plsql_opt_transaction_chain) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14977) + p.Match(RedshiftParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserNO { + { + p.SetState(14978) + p.Match(RedshiftParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14981) + p.Match(RedshiftParserCHAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStmt_setContext is an interface to support dynamic dispatch. +type IStmt_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + Any_name() IAny_nameContext + TO() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + SEMI() antlr.TerminalNode + RESET() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsStmt_setContext differentiates from other interfaces. + IsStmt_setContext() +} + +type Stmt_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStmt_setContext() *Stmt_setContext { + var p = new(Stmt_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_set + return p +} + +func InitEmptyStmt_setContext(p *Stmt_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_stmt_set +} + +func (*Stmt_setContext) IsStmt_setContext() {} + +func NewStmt_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stmt_setContext { + var p = new(Stmt_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_stmt_set + + return p +} + +func (s *Stmt_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stmt_setContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Stmt_setContext) Any_name() IAny_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_nameContext) +} + +func (s *Stmt_setContext) TO() antlr.TerminalNode { + return s.GetToken(RedshiftParserTO, 0) +} + +func (s *Stmt_setContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Stmt_setContext) SEMI() antlr.TerminalNode { + return s.GetToken(RedshiftParserSEMI, 0) +} + +func (s *Stmt_setContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *Stmt_setContext) ALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserALL, 0) +} + +func (s *Stmt_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stmt_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stmt_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterStmt_set(s) + } +} + +func (s *Stmt_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitStmt_set(s) + } +} + +func (s *Stmt_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitStmt_set(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Stmt_set() (localctx IStmt_setContext) { + localctx = NewStmt_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2136, RedshiftParserRULE_stmt_set) + p.SetState(14995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14983) + p.Match(RedshiftParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14984) + p.Any_name() + } + { + p.SetState(14985) + p.Match(RedshiftParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14986) + p.Match(RedshiftParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14987) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case RedshiftParserRESET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14989) + p.Match(RedshiftParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + { + p.SetState(14990) + p.Any_name() + } + + case RedshiftParserALL: + { + p.SetState(14991) + p.Match(RedshiftParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(14994) + p.Match(RedshiftParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICursor_variableContext is an interface to support dynamic dispatch. +type ICursor_variableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + PARAM() antlr.TerminalNode + + // IsCursor_variableContext differentiates from other interfaces. + IsCursor_variableContext() +} + +type Cursor_variableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_variableContext() *Cursor_variableContext { + var p = new(Cursor_variableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cursor_variable + return p +} + +func InitEmptyCursor_variableContext(p *Cursor_variableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_cursor_variable +} + +func (*Cursor_variableContext) IsCursor_variableContext() {} + +func NewCursor_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_variableContext { + var p = new(Cursor_variableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_cursor_variable + + return p +} + +func (s *Cursor_variableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_variableContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Cursor_variableContext) PARAM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPARAM, 0) +} + +func (s *Cursor_variableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_variableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterCursor_variable(s) + } +} + +func (s *Cursor_variableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitCursor_variable(s) + } +} + +func (s *Cursor_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitCursor_variable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Cursor_variable() (localctx ICursor_variableContext) { + localctx = NewCursor_variableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2138, RedshiftParserRULE_cursor_variable) + p.SetState(14999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case RedshiftParserAND, RedshiftParserARRAY, RedshiftParserCOLLATE, RedshiftParserCOLUMN, RedshiftParserCONSTRAINT, RedshiftParserCURRENT_USER, RedshiftParserDEFAULT, RedshiftParserDO, RedshiftParserFETCH, RedshiftParserOFFSET, RedshiftParserPUBLIC, RedshiftParserTABLE, RedshiftParserIS, RedshiftParserLEFT, RedshiftParserOUTER_P, RedshiftParserOVER, RedshiftParserRIGHT, RedshiftParserABORT_P, RedshiftParserABSOLUTE_P, RedshiftParserACCESS, RedshiftParserACTION, RedshiftParserADD_P, RedshiftParserADMIN, RedshiftParserAFTER, RedshiftParserAGGREGATE, RedshiftParserALSO, RedshiftParserALTER, RedshiftParserALWAYS, RedshiftParserASSERTION, RedshiftParserASSIGNMENT, RedshiftParserAT, RedshiftParserATTRIBUTE, RedshiftParserBACKWARD, RedshiftParserBEFORE, RedshiftParserBEGIN_P, RedshiftParserBY, RedshiftParserCACHE, RedshiftParserCALLED, RedshiftParserCASCADE, RedshiftParserCASCADED, RedshiftParserCATALOG, RedshiftParserCHAIN, RedshiftParserCHARACTERISTICS, RedshiftParserCHECKPOINT, RedshiftParserCLASS, RedshiftParserCLOSE, RedshiftParserCLUSTER, RedshiftParserCOMMENT, RedshiftParserCOMMENTS, RedshiftParserCOMMIT, RedshiftParserCOMMITTED, RedshiftParserCONFIGURATION, RedshiftParserCONNECTION, RedshiftParserCONSTRAINTS, RedshiftParserCONTENT_P, RedshiftParserCONTINUE_P, RedshiftParserCONVERSION_P, RedshiftParserCOPY, RedshiftParserCOST, RedshiftParserCSV, RedshiftParserJSON, RedshiftParserCURSOR, RedshiftParserCYCLE, RedshiftParserDATA_P, RedshiftParserDATABASE, RedshiftParserDAY_P, RedshiftParserDEALLOCATE, RedshiftParserDECLARE, RedshiftParserDEFAULTS, RedshiftParserDEFERRED, RedshiftParserDEFINER, RedshiftParserDELETE_P, RedshiftParserDELIMITER, RedshiftParserDELIMITERS, RedshiftParserDICTIONARY, RedshiftParserDISABLE_P, RedshiftParserDISCARD, RedshiftParserDOCUMENT_P, RedshiftParserDOMAIN_P, RedshiftParserDOUBLE_P, RedshiftParserDROP, RedshiftParserEACH, RedshiftParserENABLE_P, RedshiftParserENCODING, RedshiftParserENCRYPTED, RedshiftParserENUM_P, RedshiftParserESCAPE, RedshiftParserEVENT, RedshiftParserEXCLUDE, RedshiftParserEXCLUDING, RedshiftParserEXCLUSIVE, RedshiftParserEXECUTE, RedshiftParserEXPLAIN, RedshiftParserEXTENSION, RedshiftParserEXTERNAL, RedshiftParserFAMILY, RedshiftParserFIRST_P, RedshiftParserFOLLOWING, RedshiftParserFORCE, RedshiftParserFORWARD, RedshiftParserFUNCTION, RedshiftParserFUNCTIONS, RedshiftParserGLOBAL, RedshiftParserGRANTED, RedshiftParserHANDLER, RedshiftParserHEADER_P, RedshiftParserHOLD, RedshiftParserHOUR_P, RedshiftParserIDENTITY_P, RedshiftParserIF_P, RedshiftParserIMMEDIATE, RedshiftParserIMMUTABLE, RedshiftParserIMPLICIT_P, RedshiftParserINCLUDING, RedshiftParserINCREMENT, RedshiftParserINDEX, RedshiftParserINDEXES, RedshiftParserINHERIT, RedshiftParserINHERITS, RedshiftParserINLINE_P, RedshiftParserINSENSITIVE, RedshiftParserINSERT, RedshiftParserINSTEAD, RedshiftParserINVOKER, RedshiftParserISOLATION, RedshiftParserKEY, RedshiftParserLABEL, RedshiftParserLANGUAGE, RedshiftParserLARGE_P, RedshiftParserLAST_P, RedshiftParserLEAKPROOF, RedshiftParserLEVEL, RedshiftParserLISTEN, RedshiftParserLOAD, RedshiftParserLOCAL, RedshiftParserLOCATION, RedshiftParserLOCK_P, RedshiftParserMAPPING, RedshiftParserMATCH, RedshiftParserMATERIALIZED, RedshiftParserMAXVALUE, RedshiftParserMINUTE_P, RedshiftParserMINVALUE, RedshiftParserMODE, RedshiftParserMONTH_P, RedshiftParserMOVE, RedshiftParserNAME_P, RedshiftParserNAMES, RedshiftParserNEXT, RedshiftParserNO, RedshiftParserNOTHING, RedshiftParserNOTIFY, RedshiftParserNOWAIT, RedshiftParserNULLS_P, RedshiftParserOBJECT_P, RedshiftParserOF, RedshiftParserOFF, RedshiftParserOIDS, RedshiftParserOPERATOR, RedshiftParserOPTION, RedshiftParserOPTIONS, RedshiftParserOWNED, RedshiftParserOWNER, RedshiftParserPARSER, RedshiftParserPARTIAL, RedshiftParserPARTITION, RedshiftParserPASSING, RedshiftParserPASSWORD, RedshiftParserPLANS, RedshiftParserPRECEDING, RedshiftParserPREPARE, RedshiftParserPREPARED, RedshiftParserPRESERVE, RedshiftParserPRIOR, RedshiftParserPRIVILEGES, RedshiftParserPROCEDURAL, RedshiftParserPROCEDURE, RedshiftParserPROGRAM, RedshiftParserQUOTE, RedshiftParserRANGE, RedshiftParserREAD, RedshiftParserREASSIGN, RedshiftParserRECHECK, RedshiftParserRECURSIVE, RedshiftParserREF, RedshiftParserREFRESH, RedshiftParserREINDEX, RedshiftParserRELATIVE_P, RedshiftParserRELEASE, RedshiftParserRENAME, RedshiftParserREPEATABLE, RedshiftParserREPLACE, RedshiftParserREPLICA, RedshiftParserRESET, RedshiftParserRESTART, RedshiftParserRESTRICT, RedshiftParserRETURNS, RedshiftParserREVOKE, RedshiftParserROLE, RedshiftParserROLLBACK, RedshiftParserROWS, RedshiftParserRULE, RedshiftParserSAVEPOINT, RedshiftParserSCHEMA, RedshiftParserSCROLL, RedshiftParserSEARCH, RedshiftParserSECOND_P, RedshiftParserSECURITY, RedshiftParserSEQUENCE, RedshiftParserSEQUENCES, RedshiftParserSERIALIZABLE, RedshiftParserSERVER, RedshiftParserSESSION, RedshiftParserSET, RedshiftParserSHARE, RedshiftParserSHOW, RedshiftParserSIMPLE, RedshiftParserSNAPSHOT, RedshiftParserSTABLE, RedshiftParserSTANDALONE_P, RedshiftParserSTART, RedshiftParserSTATEMENT, RedshiftParserSTATISTICS, RedshiftParserSTDIN, RedshiftParserSTDOUT, RedshiftParserSTORAGE, RedshiftParserSTRICT_P, RedshiftParserSTRIP_P, RedshiftParserSYSID, RedshiftParserSYSTEM_P, RedshiftParserTABLES, RedshiftParserTABLESPACE, RedshiftParserTEMP, RedshiftParserTEMPLATE, RedshiftParserTEMPORARY, RedshiftParserTEXT_P, RedshiftParserTRANSACTION, RedshiftParserTRIGGER, RedshiftParserTRUNCATE, RedshiftParserTRUSTED, RedshiftParserTYPE_P, RedshiftParserTYPES_P, RedshiftParserUNBOUNDED, RedshiftParserUNCOMMITTED, RedshiftParserUNENCRYPTED, RedshiftParserUNKNOWN, RedshiftParserUNLISTEN, RedshiftParserUNLOGGED, RedshiftParserUNTIL, RedshiftParserUPDATE, RedshiftParserVACUUM, RedshiftParserVALID, RedshiftParserVALIDATE, RedshiftParserVALIDATOR, RedshiftParserVARYING, RedshiftParserVERSION_P, RedshiftParserVIEW, RedshiftParserVOLATILE, RedshiftParserWHITESPACE_P, RedshiftParserWITHOUT, RedshiftParserWORK, RedshiftParserWRAPPER, RedshiftParserWRITE, RedshiftParserXML_P, RedshiftParserYEAR_P, RedshiftParserYES_P, RedshiftParserZONE, RedshiftParserDEFINITION, RedshiftParserDATASHARE, RedshiftParserPUBLICACCESSIBLE, RedshiftParserINCLUDENEW, RedshiftParserIAM_ROLE, RedshiftParserCATALOG_ROLE, RedshiftParserCATALOG_ID, RedshiftParserHIVE, RedshiftParserMETASTORE, RedshiftParserURI, RedshiftParserPOSTGRES, RedshiftParserMYSQL, RedshiftParserSECRET_ARN, RedshiftParserKINESIS, RedshiftParserKAFKA, RedshiftParserMSK, RedshiftParserAUTHENTICATION, RedshiftParserAUTHENTICATION_ARN, RedshiftParserSESSION_TOKEN, RedshiftParserMTLS, RedshiftParserMASKING, RedshiftParserRLS, RedshiftParserIDENTITY, RedshiftParserPROVIDER, RedshiftParserPROTECTED, RedshiftParserMODEL, RedshiftParserTARGET, RedshiftParserSAGEMAKER, RedshiftParserAUTO, RedshiftParserMODEL_TYPE, RedshiftParserPROBLEM_TYPE, RedshiftParserOBJECTIVE, RedshiftParserPREPROCESSORS, RedshiftParserHYPERPARAMETERS, RedshiftParserXGBOOST, RedshiftParserMLP, RedshiftParserLINEAR_LEARNER, RedshiftParserKMEANS, RedshiftParserFORECAST, RedshiftParserREGRESSION, RedshiftParserBINARY_CLASSIFICATION, RedshiftParserMULTICLASS_CLASSIFICATION, RedshiftParserS3_BUCKET, RedshiftParserTAGS, RedshiftParserKMS_KEY_ID, RedshiftParserS3_GARBAGE_COLLECT, RedshiftParserMAX_CELLS, RedshiftParserMAX_RUNTIME, RedshiftParserHORIZON, RedshiftParserFREQUENCY, RedshiftParserPERCENTILES, RedshiftParserMAX_BATCH_ROWS, RedshiftParserUNLOAD, RedshiftParserMANIFEST, RedshiftParserADDQUOTES, RedshiftParserALLOWOVERWRITE, RedshiftParserCLEANPATH, RedshiftParserMAXFILESIZE, RedshiftParserROWGROUPSIZE, RedshiftParserBZIP2, RedshiftParserGZIP, RedshiftParserZSTD, RedshiftParserDATABASES, RedshiftParserDATASHARES, RedshiftParserGRANTS, RedshiftParserUSE, RedshiftParserCANCEL, RedshiftParserSESSION_AUTHORIZATION, RedshiftParserSESSION_CHARACTERISTICS, RedshiftParserCOMPRESSION, RedshiftParserLIBRARY, RedshiftParserAPPEND, RedshiftParserMB, RedshiftParserGB, RedshiftParserACCOUNT, RedshiftParserNAMESPACE, RedshiftParserDESCRIBE, RedshiftParserNONATOMIC, RedshiftParserMANAGEDBY, RedshiftParserADX, RedshiftParserREMOVE, RedshiftParserDUPLICATES, RedshiftParserBEDROCK, RedshiftParserMODEL_ID, RedshiftParserPROMPT, RedshiftParserSUFFIX, RedshiftParserREQUEST_TYPE, RedshiftParserRESPONSE_TYPE, RedshiftParserRAW, RedshiftParserUNIFIED, RedshiftParserSUPER, RedshiftParserCI, RedshiftParserCS, RedshiftParserPLPYTHONU, RedshiftParserFILLTARGET, RedshiftParserIGNOREEXTRA, RedshiftParserCREATEUSER, RedshiftParserNOCREATEUSER, RedshiftParserREGION, RedshiftParserPORT, RedshiftParserREDSHIFT, RedshiftParserIAM, RedshiftParserCREATEDB, RedshiftParserNOCREATEDB, RedshiftParserRESTRICTED, RedshiftParserUNLIMITED, RedshiftParserEXTERNALID, RedshiftParserTIMEOUT, RedshiftParserSYSLOG, RedshiftParserCREDENTIALS, RedshiftParserUNRESTRICTED, RedshiftParserPARAMETERS, RedshiftParserAPPLICATION_ARN, RedshiftParserAUTO_CREATE_ROLES, RedshiftParserCOMPROWS, RedshiftParserPROVIDER_URL, RedshiftParserPROVIDER_URL_PORT, RedshiftParserATTRIBUTE_MAP, RedshiftParserPROVIDER_ARN, RedshiftParserASSUME_ROLE_ARN, RedshiftParserPROPERTIES, RedshiftParserAVRO, RedshiftParserRCFILE, RedshiftParserSEQUENCEFILE, RedshiftParserTEXTFILE, RedshiftParserORC, RedshiftParserION, RedshiftParserLAMBDA, RedshiftParserFIXEDWIDTH, RedshiftParserPARQUET, RedshiftParserLZOP, RedshiftParserREMOVEQUOTES, RedshiftParserTRUNCATECOLUMNS, RedshiftParserFILLRECORD, RedshiftParserBLANKSASNULL, RedshiftParserEMPTYASNULL, RedshiftParserMAXERROR, RedshiftParserDATEFORMAT, RedshiftParserTIMEFORMAT, RedshiftParserACCEPTINVCHARS, RedshiftParserACCEPTANYDATE, RedshiftParserIGNOREHEADER, RedshiftParserIGNOREBLANKLINES, RedshiftParserCOMPUPDATE, RedshiftParserSTATUPDATE, RedshiftParserEXPLICIT_IDS, RedshiftParserREADRATIO, RedshiftParserROUNDEC, RedshiftParserTRIMBLANKS, RedshiftParserPRESET, RedshiftParserACCESS_KEY_ID, RedshiftParserSECRET_ACCESS_KEY, RedshiftParserSESSION_TOKEN_KW, RedshiftParserHEADER, RedshiftParserSETTINGS, RedshiftParserFUNCTION_NAME, RedshiftParserATOMIC_P, RedshiftParserBETWEEN, RedshiftParserBIGINT, RedshiftParserBIT, RedshiftParserBOOLEAN_P, RedshiftParserCHAR_P, RedshiftParserCHARACTER, RedshiftParserCOALESCE, RedshiftParserDEC, RedshiftParserDECIMAL_P, RedshiftParserEXISTS, RedshiftParserEXTRACT, RedshiftParserFLOAT_P, RedshiftParserGREATEST, RedshiftParserINOUT, RedshiftParserINT_P, RedshiftParserINTEGER, RedshiftParserINTERVAL, RedshiftParserLEAST, RedshiftParserNATIONAL, RedshiftParserNCHAR, RedshiftParserNONE, RedshiftParserNULLIF, RedshiftParserNUMERIC, RedshiftParserOVERLAY, RedshiftParserPARAMETER, RedshiftParserPOSITION, RedshiftParserPRECISION, RedshiftParserREAL, RedshiftParserROW, RedshiftParserSETOF, RedshiftParserSMALLINT, RedshiftParserSUBSTRING, RedshiftParserTIME, RedshiftParserTIMESTAMP, RedshiftParserTREAT, RedshiftParserTRIM, RedshiftParserVALUES, RedshiftParserVARCHAR, RedshiftParserXMLATTRIBUTES, RedshiftParserXMLCOMMENT, RedshiftParserXMLAGG, RedshiftParserXML_IS_WELL_FORMED, RedshiftParserXML_IS_WELL_FORMED_DOCUMENT, RedshiftParserXML_IS_WELL_FORMED_CONTENT, RedshiftParserXPATH, RedshiftParserXPATH_EXISTS, RedshiftParserXMLCONCAT, RedshiftParserXMLELEMENT, RedshiftParserXMLEXISTS, RedshiftParserXMLFOREST, RedshiftParserXMLPARSE, RedshiftParserXMLPI, RedshiftParserXMLROOT, RedshiftParserXMLSERIALIZE, RedshiftParserCALL, RedshiftParserCURRENT_P, RedshiftParserATTACH, RedshiftParserDETACH, RedshiftParserEXPRESSION, RedshiftParserGENERATED, RedshiftParserLOGGED, RedshiftParserSTORED, RedshiftParserINCLUDE, RedshiftParserROUTINE, RedshiftParserTRANSFORM, RedshiftParserIMPORT_P, RedshiftParserPOLICY, RedshiftParserPRIORITY, RedshiftParserMETHOD, RedshiftParserREFERENCING, RedshiftParserNEW, RedshiftParserOLD, RedshiftParserVALUE_P, RedshiftParserSUBSCRIPTION, RedshiftParserPUBLICATION, RedshiftParserOUT_P, RedshiftParserROUTINES, RedshiftParserSCHEMAS, RedshiftParserPROCEDURES, RedshiftParserINPUT_P, RedshiftParserSUPPORT, RedshiftParserPARALLEL, RedshiftParserSQL_P, RedshiftParserDEPENDS, RedshiftParserOVERRIDING, RedshiftParserCONFLICT, RedshiftParserSKIP_P, RedshiftParserLOCKED, RedshiftParserTIES, RedshiftParserROLLUP, RedshiftParserCUBE, RedshiftParserGROUPING, RedshiftParserSETS, RedshiftParserORDINALITY, RedshiftParserXMLTABLE, RedshiftParserCOLUMNS, RedshiftParserXMLNAMESPACES, RedshiftParserROWTYPE, RedshiftParserNORMALIZED, RedshiftParserWITHIN, RedshiftParserFILTER, RedshiftParserGROUPS, RedshiftParserOTHERS, RedshiftParserNFC, RedshiftParserNFD, RedshiftParserNFKC, RedshiftParserNFKD, RedshiftParserUESCAPE, RedshiftParserVIEWS, RedshiftParserNORMALIZE, RedshiftParserDUMP, RedshiftParserPRINT_STRICT_PARAMS, RedshiftParserVARIABLE_CONFLICT, RedshiftParserERROR, RedshiftParserUSE_VARIABLE, RedshiftParserUSE_COLUMN, RedshiftParserALIAS, RedshiftParserCONSTANT, RedshiftParserPERFORM, RedshiftParserGET, RedshiftParserDIAGNOSTICS, RedshiftParserSTACKED, RedshiftParserELSIF, RedshiftParserREVERSE, RedshiftParserSLICE, RedshiftParserEXIT, RedshiftParserRETURN, RedshiftParserQUERY, RedshiftParserRAISE, RedshiftParserSQLSTATE, RedshiftParserDEBUG, RedshiftParserLOG, RedshiftParserINFO, RedshiftParserNOTICE, RedshiftParserWARNING, RedshiftParserEXCEPTION, RedshiftParserASSERT, RedshiftParserOPEN, RedshiftParserABS, RedshiftParserCBRT, RedshiftParserCEIL, RedshiftParserCEILING, RedshiftParserDEGREES, RedshiftParserDIV, RedshiftParserEXP, RedshiftParserFACTORIAL, RedshiftParserFLOOR, RedshiftParserGCD, RedshiftParserLCM, RedshiftParserLN, RedshiftParserLOG10, RedshiftParserMIN_SCALE, RedshiftParserMOD, RedshiftParserPI, RedshiftParserPOWER, RedshiftParserRADIANS, RedshiftParserROUND, RedshiftParserSCALE, RedshiftParserSIGN, RedshiftParserSQRT, RedshiftParserTRIM_SCALE, RedshiftParserTRUNC, RedshiftParserWIDTH_BUCKET, RedshiftParserRANDOM, RedshiftParserSETSEED, RedshiftParserACOS, RedshiftParserACOSD, RedshiftParserASIN, RedshiftParserASIND, RedshiftParserATAN, RedshiftParserATAND, RedshiftParserATAN2, RedshiftParserATAN2D, RedshiftParserCOS, RedshiftParserCOSD, RedshiftParserCOT, RedshiftParserCOTD, RedshiftParserSIN, RedshiftParserSIND, RedshiftParserTAN, RedshiftParserTAND, RedshiftParserSINH, RedshiftParserCOSH, RedshiftParserTANH, RedshiftParserASINH, RedshiftParserACOSH, RedshiftParserATANH, RedshiftParserBIT_LENGTH, RedshiftParserCHAR_LENGTH, RedshiftParserCHARACTER_LENGTH, RedshiftParserLOWER, RedshiftParserOCTET_LENGTH, RedshiftParserUPPER, RedshiftParserASCII, RedshiftParserBTRIM, RedshiftParserCHR, RedshiftParserCONCAT, RedshiftParserCONCAT_WS, RedshiftParserFORMAT, RedshiftParserINITCAP, RedshiftParserLENGTH, RedshiftParserLPAD, RedshiftParserLTRIM, RedshiftParserMD5, RedshiftParserPARSE_IDENT, RedshiftParserPG_CLIENT_ENCODING, RedshiftParserQUOTE_IDENT, RedshiftParserQUOTE_LITERAL, RedshiftParserQUOTE_NULLABLE, RedshiftParserREGEXP_COUNT, RedshiftParserREGEXP_INSTR, RedshiftParserREGEXP_LIKE, RedshiftParserREGEXP_MATCH, RedshiftParserREGEXP_MATCHES, RedshiftParserREGEXP_REPLACE, RedshiftParserREGEXP_SPLIT_TO_ARRAY, RedshiftParserREGEXP_SPLIT_TO_TABLE, RedshiftParserREGEXP_SUBSTR, RedshiftParserREPEAT, RedshiftParserRPAD, RedshiftParserRTRIM, RedshiftParserSPLIT_PART, RedshiftParserSTARTS_WITH, RedshiftParserSTRING_TO_ARRAY, RedshiftParserSTRING_TO_TABLE, RedshiftParserSTRPOS, RedshiftParserSUBSTR, RedshiftParserTO_ASCII, RedshiftParserTO_HEX, RedshiftParserTRANSLATE, RedshiftParserUNISTR, RedshiftParserAGE, RedshiftParserCLOCK_TIMESTAMP, RedshiftParserDATE_BIN, RedshiftParserDATE_PART, RedshiftParserDATE_TRUNC, RedshiftParserISFINITE, RedshiftParserJUSTIFY_DAYS, RedshiftParserJUSTIFY_HOURS, RedshiftParserJUSTIFY_INTERVAL, RedshiftParserMAKE_DATE, RedshiftParserMAKE_INTERVAL, RedshiftParserMAKE_TIME, RedshiftParserMAKE_TIMESTAMP, RedshiftParserMAKE_TIMESTAMPTZ, RedshiftParserNOW, RedshiftParserSTATEMENT_TIMESTAMP, RedshiftParserTIMEOFDAY, RedshiftParserTRANSACTION_TIMESTAMP, RedshiftParserTO_TIMESTAMP, RedshiftParserTO_CHAR, RedshiftParserTO_DATE, RedshiftParserTO_NUMBER, RedshiftParserIdentifier, RedshiftParserQuotedIdentifier, RedshiftParserUnicodeQuotedIdentifier, RedshiftParserPLSQLVARIABLENAME, RedshiftParserPLSQLIDENTIFIER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14997) + p.Colid() + } + + case RedshiftParserPARAM: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14998) + p.Match(RedshiftParserPARAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IException_sectContext is an interface to support dynamic dispatch. +type IException_sectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPTION() antlr.TerminalNode + Proc_exceptions() IProc_exceptionsContext + + // IsException_sectContext differentiates from other interfaces. + IsException_sectContext() +} + +type Exception_sectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyException_sectContext() *Exception_sectContext { + var p = new(Exception_sectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exception_sect + return p +} + +func InitEmptyException_sectContext(p *Exception_sectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_exception_sect +} + +func (*Exception_sectContext) IsException_sectContext() {} + +func NewException_sectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_sectContext { + var p = new(Exception_sectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_exception_sect + + return p +} + +func (s *Exception_sectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exception_sectContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCEPTION, 0) +} + +func (s *Exception_sectContext) Proc_exceptions() IProc_exceptionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_exceptionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_exceptionsContext) +} + +func (s *Exception_sectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exception_sectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exception_sectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterException_sect(s) + } +} + +func (s *Exception_sectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitException_sect(s) + } +} + +func (s *Exception_sectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitException_sect(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Exception_sect() (localctx IException_sectContext) { + localctx = NewException_sectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2140, RedshiftParserRULE_exception_sect) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15001) + p.Match(RedshiftParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15002) + p.Proc_exceptions() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_exceptionsContext is an interface to support dynamic dispatch. +type IProc_exceptionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllProc_exception() []IProc_exceptionContext + Proc_exception(i int) IProc_exceptionContext + + // IsProc_exceptionsContext differentiates from other interfaces. + IsProc_exceptionsContext() +} + +type Proc_exceptionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_exceptionsContext() *Proc_exceptionsContext { + var p = new(Proc_exceptionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_exceptions + return p +} + +func InitEmptyProc_exceptionsContext(p *Proc_exceptionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_exceptions +} + +func (*Proc_exceptionsContext) IsProc_exceptionsContext() {} + +func NewProc_exceptionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_exceptionsContext { + var p = new(Proc_exceptionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_proc_exceptions + + return p +} + +func (s *Proc_exceptionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_exceptionsContext) AllProc_exception() []IProc_exceptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProc_exceptionContext); ok { + len++ + } + } + + tst := make([]IProc_exceptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProc_exceptionContext); ok { + tst[i] = t.(IProc_exceptionContext) + i++ + } + } + + return tst +} + +func (s *Proc_exceptionsContext) Proc_exception(i int) IProc_exceptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_exceptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProc_exceptionContext) +} + +func (s *Proc_exceptionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_exceptionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_exceptionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProc_exceptions(s) + } +} + +func (s *Proc_exceptionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProc_exceptions(s) + } +} + +func (s *Proc_exceptionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProc_exceptions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Proc_exceptions() (localctx IProc_exceptionsContext) { + localctx = NewProc_exceptionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2142, RedshiftParserRULE_proc_exceptions) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == RedshiftParserWHEN { + { + p.SetState(15004) + p.Proc_exception() + } + + p.SetState(15007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_exceptionContext is an interface to support dynamic dispatch. +type IProc_exceptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Proc_conditions() IProc_conditionsContext + THEN() antlr.TerminalNode + Proc_sect() IProc_sectContext + + // IsProc_exceptionContext differentiates from other interfaces. + IsProc_exceptionContext() +} + +type Proc_exceptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_exceptionContext() *Proc_exceptionContext { + var p = new(Proc_exceptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_exception + return p +} + +func InitEmptyProc_exceptionContext(p *Proc_exceptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_exception +} + +func (*Proc_exceptionContext) IsProc_exceptionContext() {} + +func NewProc_exceptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_exceptionContext { + var p = new(Proc_exceptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_proc_exception + + return p +} + +func (s *Proc_exceptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_exceptionContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *Proc_exceptionContext) Proc_conditions() IProc_conditionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_conditionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_conditionsContext) +} + +func (s *Proc_exceptionContext) THEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserTHEN, 0) +} + +func (s *Proc_exceptionContext) Proc_sect() IProc_sectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_sectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_sectContext) +} + +func (s *Proc_exceptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_exceptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_exceptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProc_exception(s) + } +} + +func (s *Proc_exceptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProc_exception(s) + } +} + +func (s *Proc_exceptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProc_exception(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Proc_exception() (localctx IProc_exceptionContext) { + localctx = NewProc_exceptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2144, RedshiftParserRULE_proc_exception) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15009) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15010) + p.Proc_conditions() + } + { + p.SetState(15011) + p.Match(RedshiftParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15012) + p.Proc_sect() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_conditionsContext is an interface to support dynamic dispatch. +type IProc_conditionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllProc_condition() []IProc_conditionContext + Proc_condition(i int) IProc_conditionContext + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + + // IsProc_conditionsContext differentiates from other interfaces. + IsProc_conditionsContext() +} + +type Proc_conditionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_conditionsContext() *Proc_conditionsContext { + var p = new(Proc_conditionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_conditions + return p +} + +func InitEmptyProc_conditionsContext(p *Proc_conditionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_conditions +} + +func (*Proc_conditionsContext) IsProc_conditionsContext() {} + +func NewProc_conditionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_conditionsContext { + var p = new(Proc_conditionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_proc_conditions + + return p +} + +func (s *Proc_conditionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_conditionsContext) AllProc_condition() []IProc_conditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProc_conditionContext); ok { + len++ + } + } + + tst := make([]IProc_conditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProc_conditionContext); ok { + tst[i] = t.(IProc_conditionContext) + i++ + } + } + + return tst +} + +func (s *Proc_conditionsContext) Proc_condition(i int) IProc_conditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_conditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProc_conditionContext) +} + +func (s *Proc_conditionsContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(RedshiftParserOR) +} + +func (s *Proc_conditionsContext) OR(i int) antlr.TerminalNode { + return s.GetToken(RedshiftParserOR, i) +} + +func (s *Proc_conditionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_conditionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_conditionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProc_conditions(s) + } +} + +func (s *Proc_conditionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProc_conditions(s) + } +} + +func (s *Proc_conditionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProc_conditions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Proc_conditions() (localctx IProc_conditionsContext) { + localctx = NewProc_conditionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2146, RedshiftParserRULE_proc_conditions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15014) + p.Proc_condition() + } + p.SetState(15019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == RedshiftParserOR { + { + p.SetState(15015) + p.Match(RedshiftParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15016) + p.Proc_condition() + } + + p.SetState(15021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_conditionContext is an interface to support dynamic dispatch. +type IProc_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Any_identifier() IAny_identifierContext + SQLSTATE() antlr.TerminalNode + Sconst() ISconstContext + + // IsProc_conditionContext differentiates from other interfaces. + IsProc_conditionContext() +} + +type Proc_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_conditionContext() *Proc_conditionContext { + var p = new(Proc_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_condition + return p +} + +func InitEmptyProc_conditionContext(p *Proc_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_proc_condition +} + +func (*Proc_conditionContext) IsProc_conditionContext() {} + +func NewProc_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_conditionContext { + var p = new(Proc_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_proc_condition + + return p +} + +func (s *Proc_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_conditionContext) Any_identifier() IAny_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_identifierContext) +} + +func (s *Proc_conditionContext) SQLSTATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSQLSTATE, 0) +} + +func (s *Proc_conditionContext) Sconst() ISconstContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISconstContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISconstContext) +} + +func (s *Proc_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterProc_condition(s) + } +} + +func (s *Proc_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitProc_condition(s) + } +} + +func (s *Proc_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitProc_condition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Proc_condition() (localctx IProc_conditionContext) { + localctx = NewProc_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2148, RedshiftParserRULE_proc_condition) + p.SetState(15025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1484, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15022) + p.Any_identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15023) + p.Match(RedshiftParserSQLSTATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15024) + p.Sconst() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_block_labelContext is an interface to support dynamic dispatch. +type IOpt_block_labelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Label_decl() ILabel_declContext + + // IsOpt_block_labelContext differentiates from other interfaces. + IsOpt_block_labelContext() +} + +type Opt_block_labelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_block_labelContext() *Opt_block_labelContext { + var p = new(Opt_block_labelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_block_label + return p +} + +func InitEmptyOpt_block_labelContext(p *Opt_block_labelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_block_label +} + +func (*Opt_block_labelContext) IsOpt_block_labelContext() {} + +func NewOpt_block_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_block_labelContext { + var p = new(Opt_block_labelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_block_label + + return p +} + +func (s *Opt_block_labelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_block_labelContext) Label_decl() ILabel_declContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declContext) +} + +func (s *Opt_block_labelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_block_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_block_labelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_block_label(s) + } +} + +func (s *Opt_block_labelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_block_label(s) + } +} + +func (s *Opt_block_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_block_label(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_block_label() (localctx IOpt_block_labelContext) { + localctx = NewOpt_block_labelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2150, RedshiftParserRULE_opt_block_label) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15027) + p.Label_decl() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_loop_labelContext is an interface to support dynamic dispatch. +type IOpt_loop_labelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Label_decl() ILabel_declContext + + // IsOpt_loop_labelContext differentiates from other interfaces. + IsOpt_loop_labelContext() +} + +type Opt_loop_labelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_loop_labelContext() *Opt_loop_labelContext { + var p = new(Opt_loop_labelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_loop_label + return p +} + +func InitEmptyOpt_loop_labelContext(p *Opt_loop_labelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_loop_label +} + +func (*Opt_loop_labelContext) IsOpt_loop_labelContext() {} + +func NewOpt_loop_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_loop_labelContext { + var p = new(Opt_loop_labelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_loop_label + + return p +} + +func (s *Opt_loop_labelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_loop_labelContext) Label_decl() ILabel_declContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declContext) +} + +func (s *Opt_loop_labelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_loop_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_loop_labelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_loop_label(s) + } +} + +func (s *Opt_loop_labelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_loop_label(s) + } +} + +func (s *Opt_loop_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_loop_label(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_loop_label() (localctx IOpt_loop_labelContext) { + localctx = NewOpt_loop_labelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2152, RedshiftParserRULE_opt_loop_label) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15029) + p.Label_decl() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_labelContext is an interface to support dynamic dispatch. +type IOpt_labelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Any_identifier() IAny_identifierContext + + // IsOpt_labelContext differentiates from other interfaces. + IsOpt_labelContext() +} + +type Opt_labelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_labelContext() *Opt_labelContext { + var p = new(Opt_labelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_label + return p +} + +func InitEmptyOpt_labelContext(p *Opt_labelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_label +} + +func (*Opt_labelContext) IsOpt_labelContext() {} + +func NewOpt_labelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_labelContext { + var p = new(Opt_labelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_label + + return p +} + +func (s *Opt_labelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_labelContext) Any_identifier() IAny_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAny_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAny_identifierContext) +} + +func (s *Opt_labelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_labelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_labelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_label(s) + } +} + +func (s *Opt_labelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_label(s) + } +} + +func (s *Opt_labelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_label(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_label() (localctx IOpt_labelContext) { + localctx = NewOpt_labelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2154, RedshiftParserRULE_opt_label) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15031) + p.Any_identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_exitcondContext is an interface to support dynamic dispatch. +type IOpt_exitcondContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Expr_until_semi() IExpr_until_semiContext + + // IsOpt_exitcondContext differentiates from other interfaces. + IsOpt_exitcondContext() +} + +type Opt_exitcondContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_exitcondContext() *Opt_exitcondContext { + var p = new(Opt_exitcondContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_exitcond + return p +} + +func InitEmptyOpt_exitcondContext(p *Opt_exitcondContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_exitcond +} + +func (*Opt_exitcondContext) IsOpt_exitcondContext() {} + +func NewOpt_exitcondContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_exitcondContext { + var p = new(Opt_exitcondContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_exitcond + + return p +} + +func (s *Opt_exitcondContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_exitcondContext) WHEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserWHEN, 0) +} + +func (s *Opt_exitcondContext) Expr_until_semi() IExpr_until_semiContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_until_semiContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_until_semiContext) +} + +func (s *Opt_exitcondContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_exitcondContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_exitcondContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_exitcond(s) + } +} + +func (s *Opt_exitcondContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_exitcond(s) + } +} + +func (s *Opt_exitcondContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_exitcond(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_exitcond() (localctx IOpt_exitcondContext) { + localctx = NewOpt_exitcondContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2156, RedshiftParserRULE_opt_exitcond) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15033) + p.Match(RedshiftParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15034) + p.Expr_until_semi() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAny_identifierContext is an interface to support dynamic dispatch. +type IAny_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Colid() IColidContext + Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext + + // IsAny_identifierContext differentiates from other interfaces. + IsAny_identifierContext() +} + +type Any_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAny_identifierContext() *Any_identifierContext { + var p = new(Any_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_identifier + return p +} + +func InitEmptyAny_identifierContext(p *Any_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_any_identifier +} + +func (*Any_identifierContext) IsAny_identifierContext() {} + +func NewAny_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Any_identifierContext { + var p = new(Any_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_any_identifier + + return p +} + +func (s *Any_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Any_identifierContext) Colid() IColidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColidContext) +} + +func (s *Any_identifierContext) Plsql_unreserved_keyword() IPlsql_unreserved_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_unreserved_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_unreserved_keywordContext) +} + +func (s *Any_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Any_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Any_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterAny_identifier(s) + } +} + +func (s *Any_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitAny_identifier(s) + } +} + +func (s *Any_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitAny_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Any_identifier() (localctx IAny_identifierContext) { + localctx = NewAny_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2158, RedshiftParserRULE_any_identifier) + p.SetState(15038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1485, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15036) + p.Colid() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15037) + p.Plsql_unreserved_keyword() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsql_unreserved_keywordContext is an interface to support dynamic dispatch. +type IPlsql_unreserved_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABSOLUTE_P() antlr.TerminalNode + ALIAS() antlr.TerminalNode + AND() antlr.TerminalNode + ARRAY() antlr.TerminalNode + ASSERT() antlr.TerminalNode + BACKWARD() antlr.TerminalNode + CALL() antlr.TerminalNode + CHAIN() antlr.TerminalNode + CLOSE() antlr.TerminalNode + COLLATE() antlr.TerminalNode + COLUMN() antlr.TerminalNode + COMMIT() antlr.TerminalNode + CONSTANT() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + CONTINUE_P() antlr.TerminalNode + CURRENT_P() antlr.TerminalNode + CURSOR() antlr.TerminalNode + DEBUG() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + DIAGNOSTICS() antlr.TerminalNode + DO() antlr.TerminalNode + DUMP() antlr.TerminalNode + ELSIF() antlr.TerminalNode + ERROR() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + EXIT() antlr.TerminalNode + FETCH() antlr.TerminalNode + FIRST_P() antlr.TerminalNode + FORWARD() antlr.TerminalNode + GET() antlr.TerminalNode + INFO() antlr.TerminalNode + INSERT() antlr.TerminalNode + IS() antlr.TerminalNode + LAST_P() antlr.TerminalNode + MOVE() antlr.TerminalNode + NEXT() antlr.TerminalNode + NO() antlr.TerminalNode + NOTICE() antlr.TerminalNode + OPEN() antlr.TerminalNode + OPTION() antlr.TerminalNode + PERFORM() antlr.TerminalNode + PRINT_STRICT_PARAMS() antlr.TerminalNode + PRIOR() antlr.TerminalNode + QUERY() antlr.TerminalNode + RAISE() antlr.TerminalNode + RELATIVE_P() antlr.TerminalNode + RESET() antlr.TerminalNode + RETURN() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + ROWTYPE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SCROLL() antlr.TerminalNode + SET() antlr.TerminalNode + SLICE() antlr.TerminalNode + SQLSTATE() antlr.TerminalNode + STACKED() antlr.TerminalNode + TABLE() antlr.TerminalNode + TYPE_P() antlr.TerminalNode + USE_COLUMN() antlr.TerminalNode + USE_VARIABLE() antlr.TerminalNode + VARIABLE_CONFLICT() antlr.TerminalNode + WARNING() antlr.TerminalNode + OUTER_P() antlr.TerminalNode + + // IsPlsql_unreserved_keywordContext differentiates from other interfaces. + IsPlsql_unreserved_keywordContext() +} + +type Plsql_unreserved_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsql_unreserved_keywordContext() *Plsql_unreserved_keywordContext { + var p = new(Plsql_unreserved_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsql_unreserved_keyword + return p +} + +func InitEmptyPlsql_unreserved_keywordContext(p *Plsql_unreserved_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_plsql_unreserved_keyword +} + +func (*Plsql_unreserved_keywordContext) IsPlsql_unreserved_keywordContext() {} + +func NewPlsql_unreserved_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_unreserved_keywordContext { + var p = new(Plsql_unreserved_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_plsql_unreserved_keyword + + return p +} + +func (s *Plsql_unreserved_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Plsql_unreserved_keywordContext) ABSOLUTE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserABSOLUTE_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) ALIAS() antlr.TerminalNode { + return s.GetToken(RedshiftParserALIAS, 0) +} + +func (s *Plsql_unreserved_keywordContext) AND() antlr.TerminalNode { + return s.GetToken(RedshiftParserAND, 0) +} + +func (s *Plsql_unreserved_keywordContext) ARRAY() antlr.TerminalNode { + return s.GetToken(RedshiftParserARRAY, 0) +} + +func (s *Plsql_unreserved_keywordContext) ASSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserASSERT, 0) +} + +func (s *Plsql_unreserved_keywordContext) BACKWARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserBACKWARD, 0) +} + +func (s *Plsql_unreserved_keywordContext) CALL() antlr.TerminalNode { + return s.GetToken(RedshiftParserCALL, 0) +} + +func (s *Plsql_unreserved_keywordContext) CHAIN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCHAIN, 0) +} + +func (s *Plsql_unreserved_keywordContext) CLOSE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCLOSE, 0) +} + +func (s *Plsql_unreserved_keywordContext) COLLATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLLATE, 0) +} + +func (s *Plsql_unreserved_keywordContext) COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOLUMN, 0) +} + +func (s *Plsql_unreserved_keywordContext) COMMIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCOMMIT, 0) +} + +func (s *Plsql_unreserved_keywordContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTANT, 0) +} + +func (s *Plsql_unreserved_keywordContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONSTRAINT, 0) +} + +func (s *Plsql_unreserved_keywordContext) CONTINUE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCONTINUE_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) CURRENT_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURRENT_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) CURSOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserCURSOR, 0) +} + +func (s *Plsql_unreserved_keywordContext) DEBUG() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEBUG, 0) +} + +func (s *Plsql_unreserved_keywordContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(RedshiftParserDEFAULT, 0) +} + +func (s *Plsql_unreserved_keywordContext) DIAGNOSTICS() antlr.TerminalNode { + return s.GetToken(RedshiftParserDIAGNOSTICS, 0) +} + +func (s *Plsql_unreserved_keywordContext) DO() antlr.TerminalNode { + return s.GetToken(RedshiftParserDO, 0) +} + +func (s *Plsql_unreserved_keywordContext) DUMP() antlr.TerminalNode { + return s.GetToken(RedshiftParserDUMP, 0) +} + +func (s *Plsql_unreserved_keywordContext) ELSIF() antlr.TerminalNode { + return s.GetToken(RedshiftParserELSIF, 0) +} + +func (s *Plsql_unreserved_keywordContext) ERROR() antlr.TerminalNode { + return s.GetToken(RedshiftParserERROR, 0) +} + +func (s *Plsql_unreserved_keywordContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXCEPTION, 0) +} + +func (s *Plsql_unreserved_keywordContext) EXIT() antlr.TerminalNode { + return s.GetToken(RedshiftParserEXIT, 0) +} + +func (s *Plsql_unreserved_keywordContext) FETCH() antlr.TerminalNode { + return s.GetToken(RedshiftParserFETCH, 0) +} + +func (s *Plsql_unreserved_keywordContext) FIRST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserFIRST_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) FORWARD() antlr.TerminalNode { + return s.GetToken(RedshiftParserFORWARD, 0) +} + +func (s *Plsql_unreserved_keywordContext) GET() antlr.TerminalNode { + return s.GetToken(RedshiftParserGET, 0) +} + +func (s *Plsql_unreserved_keywordContext) INFO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINFO, 0) +} + +func (s *Plsql_unreserved_keywordContext) INSERT() antlr.TerminalNode { + return s.GetToken(RedshiftParserINSERT, 0) +} + +func (s *Plsql_unreserved_keywordContext) IS() antlr.TerminalNode { + return s.GetToken(RedshiftParserIS, 0) +} + +func (s *Plsql_unreserved_keywordContext) LAST_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserLAST_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) MOVE() antlr.TerminalNode { + return s.GetToken(RedshiftParserMOVE, 0) +} + +func (s *Plsql_unreserved_keywordContext) NEXT() antlr.TerminalNode { + return s.GetToken(RedshiftParserNEXT, 0) +} + +func (s *Plsql_unreserved_keywordContext) NO() antlr.TerminalNode { + return s.GetToken(RedshiftParserNO, 0) +} + +func (s *Plsql_unreserved_keywordContext) NOTICE() antlr.TerminalNode { + return s.GetToken(RedshiftParserNOTICE, 0) +} + +func (s *Plsql_unreserved_keywordContext) OPEN() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPEN, 0) +} + +func (s *Plsql_unreserved_keywordContext) OPTION() antlr.TerminalNode { + return s.GetToken(RedshiftParserOPTION, 0) +} + +func (s *Plsql_unreserved_keywordContext) PERFORM() antlr.TerminalNode { + return s.GetToken(RedshiftParserPERFORM, 0) +} + +func (s *Plsql_unreserved_keywordContext) PRINT_STRICT_PARAMS() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRINT_STRICT_PARAMS, 0) +} + +func (s *Plsql_unreserved_keywordContext) PRIOR() antlr.TerminalNode { + return s.GetToken(RedshiftParserPRIOR, 0) +} + +func (s *Plsql_unreserved_keywordContext) QUERY() antlr.TerminalNode { + return s.GetToken(RedshiftParserQUERY, 0) +} + +func (s *Plsql_unreserved_keywordContext) RAISE() antlr.TerminalNode { + return s.GetToken(RedshiftParserRAISE, 0) +} + +func (s *Plsql_unreserved_keywordContext) RELATIVE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserRELATIVE_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) RESET() antlr.TerminalNode { + return s.GetToken(RedshiftParserRESET, 0) +} + +func (s *Plsql_unreserved_keywordContext) RETURN() antlr.TerminalNode { + return s.GetToken(RedshiftParserRETURN, 0) +} + +func (s *Plsql_unreserved_keywordContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(RedshiftParserROLLBACK, 0) +} + +func (s *Plsql_unreserved_keywordContext) ROWTYPE() antlr.TerminalNode { + return s.GetToken(RedshiftParserROWTYPE, 0) +} + +func (s *Plsql_unreserved_keywordContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCHEMA, 0) +} + +func (s *Plsql_unreserved_keywordContext) SCROLL() antlr.TerminalNode { + return s.GetToken(RedshiftParserSCROLL, 0) +} + +func (s *Plsql_unreserved_keywordContext) SET() antlr.TerminalNode { + return s.GetToken(RedshiftParserSET, 0) +} + +func (s *Plsql_unreserved_keywordContext) SLICE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSLICE, 0) +} + +func (s *Plsql_unreserved_keywordContext) SQLSTATE() antlr.TerminalNode { + return s.GetToken(RedshiftParserSQLSTATE, 0) +} + +func (s *Plsql_unreserved_keywordContext) STACKED() antlr.TerminalNode { + return s.GetToken(RedshiftParserSTACKED, 0) +} + +func (s *Plsql_unreserved_keywordContext) TABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserTABLE, 0) +} + +func (s *Plsql_unreserved_keywordContext) TYPE_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserTYPE_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) USE_COLUMN() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSE_COLUMN, 0) +} + +func (s *Plsql_unreserved_keywordContext) USE_VARIABLE() antlr.TerminalNode { + return s.GetToken(RedshiftParserUSE_VARIABLE, 0) +} + +func (s *Plsql_unreserved_keywordContext) VARIABLE_CONFLICT() antlr.TerminalNode { + return s.GetToken(RedshiftParserVARIABLE_CONFLICT, 0) +} + +func (s *Plsql_unreserved_keywordContext) WARNING() antlr.TerminalNode { + return s.GetToken(RedshiftParserWARNING, 0) +} + +func (s *Plsql_unreserved_keywordContext) OUTER_P() antlr.TerminalNode { + return s.GetToken(RedshiftParserOUTER_P, 0) +} + +func (s *Plsql_unreserved_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Plsql_unreserved_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Plsql_unreserved_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterPlsql_unreserved_keyword(s) + } +} + +func (s *Plsql_unreserved_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitPlsql_unreserved_keyword(s) + } +} + +func (s *Plsql_unreserved_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitPlsql_unreserved_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Plsql_unreserved_keyword() (localctx IPlsql_unreserved_keywordContext) { + localctx = NewPlsql_unreserved_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2160, RedshiftParserRULE_plsql_unreserved_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15040) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&2459027012145119232) != 0) || ((int64((_la-93)) & ^0x3f) == 0 && ((int64(1)<<(_la-93))&4620693771766464513) != 0) || ((int64((_la-159)) & ^0x3f) == 0 && ((int64(1)<<(_la-159))&40532396646401041) != 0) || ((int64((_la-236)) & ^0x3f) == 0 && ((int64(1)<<(_la-236))&36029898208313601) != 0) || ((int64((_la-305)) & ^0x3f) == 0 && ((int64(1)<<(_la-305))&9007199322050625) != 0) || _la == RedshiftParserCALL || _la == RedshiftParserCURRENT_P || ((int64((_la-676)) & ^0x3f) == 0 && ((int64(1)<<(_la-676))&13124950286337) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_expressionContext is an interface to support dynamic dispatch. +type ISql_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Opt_target_list() IOpt_target_listContext + Into_clause() IInto_clauseContext + From_clause() IFrom_clauseContext + Where_clause() IWhere_clauseContext + Group_clause() IGroup_clauseContext + Having_clause() IHaving_clauseContext + Window_clause() IWindow_clauseContext + + // IsSql_expressionContext differentiates from other interfaces. + IsSql_expressionContext() +} + +type Sql_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_expressionContext() *Sql_expressionContext { + var p = new(Sql_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sql_expression + return p +} + +func InitEmptySql_expressionContext(p *Sql_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_sql_expression +} + +func (*Sql_expressionContext) IsSql_expressionContext() {} + +func NewSql_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_expressionContext { + var p = new(Sql_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_sql_expression + + return p +} + +func (s *Sql_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_expressionContext) Opt_target_list() IOpt_target_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_target_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_target_listContext) +} + +func (s *Sql_expressionContext) Into_clause() IInto_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Sql_expressionContext) From_clause() IFrom_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrom_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrom_clauseContext) +} + +func (s *Sql_expressionContext) Where_clause() IWhere_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhere_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhere_clauseContext) +} + +func (s *Sql_expressionContext) Group_clause() IGroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_clauseContext) +} + +func (s *Sql_expressionContext) Having_clause() IHaving_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHaving_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHaving_clauseContext) +} + +func (s *Sql_expressionContext) Window_clause() IWindow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindow_clauseContext) +} + +func (s *Sql_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterSql_expression(s) + } +} + +func (s *Sql_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitSql_expression(s) + } +} + +func (s *Sql_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitSql_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Sql_expression() (localctx ISql_expressionContext) { + localctx = NewSql_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2162, RedshiftParserRULE_sql_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&3620818277858554372) != 0) || ((int64((_la-75)) & ^0x3f) == 0 && ((int64(1)<<(_la-75))&-21420013537) != 0) || ((int64((_la-139)) & ^0x3f) == 0 && ((int64(1)<<(_la-139))&-549755813889) != 0) || ((int64((_la-203)) & ^0x3f) == 0 && ((int64(1)<<(_la-203))&-20266198323167233) != 0) || ((int64((_la-267)) & ^0x3f) == 0 && ((int64(1)<<(_la-267))&-1048577) != 0) || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&-5746593124524752897) != 0) || ((int64((_la-395)) & ^0x3f) == 0 && ((int64(1)<<(_la-395))&-1) != 0) || ((int64((_la-459)) & ^0x3f) == 0 && ((int64(1)<<(_la-459))&-1) != 0) || ((int64((_la-523)) & ^0x3f) == 0 && ((int64(1)<<(_la-523))&-1) != 0) || ((int64((_la-587)) & ^0x3f) == 0 && ((int64(1)<<(_la-587))&-4503599610593281) != 0) || ((int64((_la-651)) & ^0x3f) == 0 && ((int64(1)<<(_la-651))&-11258999068426245) != 0) || ((int64((_la-715)) & ^0x3f) == 0 && ((int64(1)<<(_la-715))&-9) != 0) || ((int64((_la-779)) & ^0x3f) == 0 && ((int64(1)<<(_la-779))&72057594037927935) != 0) || ((int64((_la-851)) & ^0x3f) == 0 && ((int64(1)<<(_la-851))&137926649993) != 0) { + { + p.SetState(15042) + p.Opt_target_list() + } + + } + p.SetState(15046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINTO { + { + p.SetState(15045) + p.Into_clause() + } + + } + p.SetState(15049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserFROM { + { + p.SetState(15048) + p.From_clause() + } + + } + p.SetState(15052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWHERE { + { + p.SetState(15051) + p.Where_clause() + } + + } + p.SetState(15055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserGROUP_P { + { + p.SetState(15054) + p.Group_clause() + } + + } + p.SetState(15058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserHAVING { + { + p.SetState(15057) + p.Having_clause() + } + + } + p.SetState(15061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserWINDOW { + { + p.SetState(15060) + p.Window_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpr_until_thenContext is an interface to support dynamic dispatch. +type IExpr_until_thenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_expression() ISql_expressionContext + + // IsExpr_until_thenContext differentiates from other interfaces. + IsExpr_until_thenContext() +} + +type Expr_until_thenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_until_thenContext() *Expr_until_thenContext { + var p = new(Expr_until_thenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_then + return p +} + +func InitEmptyExpr_until_thenContext(p *Expr_until_thenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_then +} + +func (*Expr_until_thenContext) IsExpr_until_thenContext() {} + +func NewExpr_until_thenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_thenContext { + var p = new(Expr_until_thenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_expr_until_then + + return p +} + +func (s *Expr_until_thenContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_until_thenContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Expr_until_thenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_until_thenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_until_thenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExpr_until_then(s) + } +} + +func (s *Expr_until_thenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExpr_until_then(s) + } +} + +func (s *Expr_until_thenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExpr_until_then(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Expr_until_then() (localctx IExpr_until_thenContext) { + localctx = NewExpr_until_thenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2164, RedshiftParserRULE_expr_until_then) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15063) + p.Sql_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpr_until_semiContext is an interface to support dynamic dispatch. +type IExpr_until_semiContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_expression() ISql_expressionContext + + // IsExpr_until_semiContext differentiates from other interfaces. + IsExpr_until_semiContext() +} + +type Expr_until_semiContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_until_semiContext() *Expr_until_semiContext { + var p = new(Expr_until_semiContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_semi + return p +} + +func InitEmptyExpr_until_semiContext(p *Expr_until_semiContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_semi +} + +func (*Expr_until_semiContext) IsExpr_until_semiContext() {} + +func NewExpr_until_semiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_semiContext { + var p = new(Expr_until_semiContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_expr_until_semi + + return p +} + +func (s *Expr_until_semiContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_until_semiContext) Sql_expression() ISql_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_expressionContext) +} + +func (s *Expr_until_semiContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_until_semiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_until_semiContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExpr_until_semi(s) + } +} + +func (s *Expr_until_semiContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExpr_until_semi(s) + } +} + +func (s *Expr_until_semiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExpr_until_semi(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Expr_until_semi() (localctx IExpr_until_semiContext) { + localctx = NewExpr_until_semiContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2166, RedshiftParserRULE_expr_until_semi) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15065) + p.Sql_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpr_until_rightbracketContext is an interface to support dynamic dispatch. +type IExpr_until_rightbracketContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + + // IsExpr_until_rightbracketContext differentiates from other interfaces. + IsExpr_until_rightbracketContext() +} + +type Expr_until_rightbracketContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_until_rightbracketContext() *Expr_until_rightbracketContext { + var p = new(Expr_until_rightbracketContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_rightbracket + return p +} + +func InitEmptyExpr_until_rightbracketContext(p *Expr_until_rightbracketContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_rightbracket +} + +func (*Expr_until_rightbracketContext) IsExpr_until_rightbracketContext() {} + +func NewExpr_until_rightbracketContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_rightbracketContext { + var p = new(Expr_until_rightbracketContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_expr_until_rightbracket + + return p +} + +func (s *Expr_until_rightbracketContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_until_rightbracketContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Expr_until_rightbracketContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_until_rightbracketContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_until_rightbracketContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExpr_until_rightbracket(s) + } +} + +func (s *Expr_until_rightbracketContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExpr_until_rightbracket(s) + } +} + +func (s *Expr_until_rightbracketContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExpr_until_rightbracket(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Expr_until_rightbracket() (localctx IExpr_until_rightbracketContext) { + localctx = NewExpr_until_rightbracketContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2168, RedshiftParserRULE_expr_until_rightbracket) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15067) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpr_until_loopContext is an interface to support dynamic dispatch. +type IExpr_until_loopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + A_expr() IA_exprContext + + // IsExpr_until_loopContext differentiates from other interfaces. + IsExpr_until_loopContext() +} + +type Expr_until_loopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_until_loopContext() *Expr_until_loopContext { + var p = new(Expr_until_loopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_loop + return p +} + +func InitEmptyExpr_until_loopContext(p *Expr_until_loopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_expr_until_loop +} + +func (*Expr_until_loopContext) IsExpr_until_loopContext() {} + +func NewExpr_until_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_until_loopContext { + var p = new(Expr_until_loopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_expr_until_loop + + return p +} + +func (s *Expr_until_loopContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_until_loopContext) A_expr() IA_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IA_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IA_exprContext) +} + +func (s *Expr_until_loopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_until_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_until_loopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterExpr_until_loop(s) + } +} + +func (s *Expr_until_loopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitExpr_until_loop(s) + } +} + +func (s *Expr_until_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitExpr_until_loop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Expr_until_loop() (localctx IExpr_until_loopContext) { + localctx = NewExpr_until_loopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2170, RedshiftParserRULE_expr_until_loop) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15069) + p.A_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMake_execsql_stmtContext is an interface to support dynamic dispatch. +type IMake_execsql_stmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Stmt() IStmtContext + Opt_returning_clause_into() IOpt_returning_clause_intoContext + + // IsMake_execsql_stmtContext differentiates from other interfaces. + IsMake_execsql_stmtContext() +} + +type Make_execsql_stmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMake_execsql_stmtContext() *Make_execsql_stmtContext { + var p = new(Make_execsql_stmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_make_execsql_stmt + return p +} + +func InitEmptyMake_execsql_stmtContext(p *Make_execsql_stmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_make_execsql_stmt +} + +func (*Make_execsql_stmtContext) IsMake_execsql_stmtContext() {} + +func NewMake_execsql_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Make_execsql_stmtContext { + var p = new(Make_execsql_stmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_make_execsql_stmt + + return p +} + +func (s *Make_execsql_stmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *Make_execsql_stmtContext) Stmt() IStmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStmtContext) +} + +func (s *Make_execsql_stmtContext) Opt_returning_clause_into() IOpt_returning_clause_intoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_returning_clause_intoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_returning_clause_intoContext) +} + +func (s *Make_execsql_stmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Make_execsql_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Make_execsql_stmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterMake_execsql_stmt(s) + } +} + +func (s *Make_execsql_stmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitMake_execsql_stmt(s) + } +} + +func (s *Make_execsql_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitMake_execsql_stmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Make_execsql_stmt() (localctx IMake_execsql_stmtContext) { + localctx = NewMake_execsql_stmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2172, RedshiftParserRULE_make_execsql_stmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15071) + p.Stmt() + } + p.SetState(15073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == RedshiftParserINTO { + { + p.SetState(15072) + p.Opt_returning_clause_into() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpt_returning_clause_intoContext is an interface to support dynamic dispatch. +type IOpt_returning_clause_intoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + Into_target() IInto_targetContext + Opt_strict() IOpt_strictContext + + // IsOpt_returning_clause_intoContext differentiates from other interfaces. + IsOpt_returning_clause_intoContext() +} + +type Opt_returning_clause_intoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpt_returning_clause_intoContext() *Opt_returning_clause_intoContext { + var p = new(Opt_returning_clause_intoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_returning_clause_into + return p +} + +func InitEmptyOpt_returning_clause_intoContext(p *Opt_returning_clause_intoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = RedshiftParserRULE_opt_returning_clause_into +} + +func (*Opt_returning_clause_intoContext) IsOpt_returning_clause_intoContext() {} + +func NewOpt_returning_clause_intoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opt_returning_clause_intoContext { + var p = new(Opt_returning_clause_intoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = RedshiftParserRULE_opt_returning_clause_into + + return p +} + +func (s *Opt_returning_clause_intoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opt_returning_clause_intoContext) INTO() antlr.TerminalNode { + return s.GetToken(RedshiftParserINTO, 0) +} + +func (s *Opt_returning_clause_intoContext) Into_target() IInto_targetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_targetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_targetContext) +} + +func (s *Opt_returning_clause_intoContext) Opt_strict() IOpt_strictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpt_strictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpt_strictContext) +} + +func (s *Opt_returning_clause_intoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opt_returning_clause_intoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opt_returning_clause_intoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.EnterOpt_returning_clause_into(s) + } +} + +func (s *Opt_returning_clause_intoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(RedshiftParserListener); ok { + listenerT.ExitOpt_returning_clause_into(s) + } +} + +func (s *Opt_returning_clause_intoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case RedshiftParserVisitor: + return t.VisitOpt_returning_clause_into(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *RedshiftParser) Opt_returning_clause_into() (localctx IOpt_returning_clause_intoContext) { + localctx = NewOpt_returning_clause_intoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2174, RedshiftParserRULE_opt_returning_clause_into) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15075) + p.Match(RedshiftParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15077) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1494, p.GetParserRuleContext()) == 1 { + { + p.SetState(15076) + p.Opt_strict() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(15079) + p.Into_target() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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 *RedshiftParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 877: + var t *B_exprContext = nil + if localctx != nil { + t = localctx.(*B_exprContext) + } + return p.B_expr_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *RedshiftParser) B_expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.Precpred(p.GetParserRuleContext(), 8) + + case 1: + return p.Precpred(p.GetParserRuleContext(), 7) + + case 2: + return p.Precpred(p.GetParserRuleContext(), 6) + + case 3: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 4: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 5: + return p.Precpred(p.GetParserRuleContext(), 10) + + case 6: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 7: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/redshift/redshift_parser_base.go b/redshift/redshift_parser_base.go new file mode 100644 index 0000000..527571f --- /dev/null +++ b/redshift/redshift_parser_base.go @@ -0,0 +1,194 @@ +package redshift + +import ( + "strings" + + "github.com/antlr4-go/antlr/v4" +) + +type RedshiftParserBase struct { + *antlr.BaseParser + + parseErrors []*RedshiftParseError +} + +func NewRedshiftParserBase(input antlr.TokenStream) *RedshiftParserBase { + return &RedshiftParserBase{ + BaseParser: antlr.NewBaseParser(input), + } +} + +func (receiver *RedshiftParserBase) GetParsedSqlTree(script string, line int) antlr.ParserRuleContext { + parser := getRedshiftParser(script) + result := parser.Root() + for _, err := range parser.parseErrors { + receiver.parseErrors = append(receiver.parseErrors, &RedshiftParseError{ + Number: err.Number, + Offset: err.Offset, + Line: err.Line + line, + Column: err.Column, + Message: err.Message, + }) + } + return result +} + +func (receiver *RedshiftParserBase) ParseRoutineBody(localContextInterface ICreatefunc_opt_listContext) { + localContext, ok := localContextInterface.(*Createfunc_opt_listContext) + if !ok { + return + } + + var lang string + for _, coi := range localContext.AllCreatefunc_opt_item() { + createFuncOptItemContext, ok := coi.(*Createfunc_opt_itemContext) + if !ok || createFuncOptItemContext.LANGUAGE() == nil { + continue + } + nonReservedWordOrSConstContextInterface := createFuncOptItemContext.Nonreservedword_or_sconst() + if nonReservedWordOrSConstContextInterface == nil { + continue + } + nonReservedWordOrSConstContext, ok := nonReservedWordOrSConstContextInterface.(*Nonreservedword_or_sconstContext) + if !ok { + continue + } + nonReservedWordContextInterface := nonReservedWordOrSConstContext.Nonreservedword() + if nonReservedWordContextInterface == nil { + continue + } + nonReservedWordContext, ok := nonReservedWordContextInterface.(*NonreservedwordContext) + if !ok { + continue + } + identifierInterface := nonReservedWordContext.Identifier() + if identifierInterface == nil { + continue + } + identifier, ok := identifierInterface.(*IdentifierContext) + if !ok { + continue + } + node := identifier.Identifier() + if node == nil { + continue + } + lang = node.GetText() + break + } + if lang == "" { + return + } + + var funcAs *Createfunc_opt_itemContext + for _, coi := range localContext.AllCreatefunc_opt_item() { + ctx, ok := coi.(*Createfunc_opt_itemContext) + if !ok || ctx.AS() == nil { + continue + } + as := ctx.Func_as() + if as != nil { + funcAs = ctx + break + } + } + if funcAs == nil { + return + } + + funcAsContextInterface := funcAs.Func_as() + if funcAsContextInterface == nil { + return + } + funcAsContext, ok := funcAsContextInterface.(*Func_asContext) + if !ok { + return + } + sConstContextInterface := funcAsContext.Sconst(0) + if sConstContextInterface == nil { + return + } + sConstContext, ok := sConstContextInterface.(*SconstContext) + if !ok { + return + } + text := GetRoutineBodyString(sConstContext) + line := sConstContext.GetStart().GetLine() + parser := getRedshiftParser(text) + switch lang { + case "plpgsql": + funcAs.Func_as().(*Func_asContext).Definition = parser.Plsqlroot() + case "sql": + funcAs.Func_as().(*Func_asContext).Definition = parser.Root() + } + for _, err := range parser.parseErrors { + receiver.parseErrors = append(receiver.parseErrors, &RedshiftParseError{ + Number: err.Number, + Offset: err.Offset, + Line: err.Line + line, + Column: err.Column, + Message: err.Message, + }) + } +} + +func TrimQuotes(s string) string { + if s == "" { + return s + } + return s[1 : len(s)-2] +} + +func unquote(s string) string { + result := strings.Builder{} + length := len(s) + index := 0 + for index < length { + c := s[index] + result.WriteByte(c) + if c == '\'' && index < length-1 && (s[index+1] == '\'') { + index++ + } + index++ + } + return result.String() +} + +func GetRoutineBodyString(rule *SconstContext) string { + if rule.Anysconst() == nil { + return "" + } + anySConstContext := rule.Anysconst().(*AnysconstContext) + + stringConstant := anySConstContext.StringConstant() + if stringConstant != nil { + return unquote(TrimQuotes(stringConstant.GetText())) + } + + unicodeEscapeStringConstant := anySConstContext.UnicodeEscapeStringConstant() + if unicodeEscapeStringConstant != nil { + return TrimQuotes(unicodeEscapeStringConstant.GetText()) + } + + escapeStringConstant := anySConstContext.EscapeStringConstant() + if escapeStringConstant != nil { + return TrimQuotes(escapeStringConstant.GetText()) + } + + result := strings.Builder{} + for _, node := range anySConstContext.AllDollarText() { + result.WriteString(node.GetText()) + } + return result.String() +} + +func getRedshiftParser(script string) *RedshiftParser { + stream := antlr.NewInputStream(script) + lexer := NewRedshiftLexer(stream) + tokenStream := antlr.NewCommonTokenStream(lexer, 0) + parser := NewRedshiftParser(tokenStream) + errorListener := new(RedshiftParserErrorListener) + errorListener.grammar = parser + parser.AddErrorListener(errorListener) + return parser +} diff --git a/redshift/redshift_parser_error_listener.go b/redshift/redshift_parser_error_listener.go new file mode 100644 index 0000000..a72007d --- /dev/null +++ b/redshift/redshift_parser_error_listener.go @@ -0,0 +1,31 @@ +package redshift + +import "github.com/antlr4-go/antlr/v4" + +type RedshiftParserErrorListener struct { + grammar *RedshiftParser +} + +var _ antlr.ErrorListener = &RedshiftParserErrorListener{} + +func (receiver RedshiftParserErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + receiver.grammar.parseErrors = append(receiver.grammar.parseErrors, &RedshiftParseError{ + Number: 0, + Offset: 0, + Line: line, + Column: column, + Message: msg, + }) +} + +func (receiver RedshiftParserErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + // ignore +} + +func (receiver RedshiftParserErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + // ignore +} + +func (receiver RedshiftParserErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + // ignore +} diff --git a/redshift/redshiftparser_base_listener.go b/redshift/redshiftparser_base_listener.go new file mode 100644 index 0000000..0f05df4 --- /dev/null +++ b/redshift/redshiftparser_base_listener.go @@ -0,0 +1,6907 @@ +// Code generated from RedshiftParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package redshift // RedshiftParser +import "github.com/antlr4-go/antlr/v4" + +// BaseRedshiftParserListener is a complete listener for a parse tree produced by RedshiftParser. +type BaseRedshiftParserListener struct{} + +var _ RedshiftParserListener = &BaseRedshiftParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseRedshiftParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseRedshiftParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseRedshiftParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseRedshiftParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterRoot is called when production root is entered. +func (s *BaseRedshiftParserListener) EnterRoot(ctx *RootContext) {} + +// ExitRoot is called when production root is exited. +func (s *BaseRedshiftParserListener) ExitRoot(ctx *RootContext) {} + +// EnterPlsqlroot is called when production plsqlroot is entered. +func (s *BaseRedshiftParserListener) EnterPlsqlroot(ctx *PlsqlrootContext) {} + +// ExitPlsqlroot is called when production plsqlroot is exited. +func (s *BaseRedshiftParserListener) ExitPlsqlroot(ctx *PlsqlrootContext) {} + +// EnterStmtblock is called when production stmtblock is entered. +func (s *BaseRedshiftParserListener) EnterStmtblock(ctx *StmtblockContext) {} + +// ExitStmtblock is called when production stmtblock is exited. +func (s *BaseRedshiftParserListener) ExitStmtblock(ctx *StmtblockContext) {} + +// EnterStmtmulti is called when production stmtmulti is entered. +func (s *BaseRedshiftParserListener) EnterStmtmulti(ctx *StmtmultiContext) {} + +// ExitStmtmulti is called when production stmtmulti is exited. +func (s *BaseRedshiftParserListener) ExitStmtmulti(ctx *StmtmultiContext) {} + +// EnterStmt is called when production stmt is entered. +func (s *BaseRedshiftParserListener) EnterStmt(ctx *StmtContext) {} + +// ExitStmt is called when production stmt is exited. +func (s *BaseRedshiftParserListener) ExitStmt(ctx *StmtContext) {} + +// EnterPlsqlconsolecommand is called when production plsqlconsolecommand is entered. +func (s *BaseRedshiftParserListener) EnterPlsqlconsolecommand(ctx *PlsqlconsolecommandContext) {} + +// ExitPlsqlconsolecommand is called when production plsqlconsolecommand is exited. +func (s *BaseRedshiftParserListener) ExitPlsqlconsolecommand(ctx *PlsqlconsolecommandContext) {} + +// EnterCallstmt is called when production callstmt is entered. +func (s *BaseRedshiftParserListener) EnterCallstmt(ctx *CallstmtContext) {} + +// ExitCallstmt is called when production callstmt is exited. +func (s *BaseRedshiftParserListener) ExitCallstmt(ctx *CallstmtContext) {} + +// EnterCreaterolestmt is called when production createrolestmt is entered. +func (s *BaseRedshiftParserListener) EnterCreaterolestmt(ctx *CreaterolestmtContext) {} + +// ExitCreaterolestmt is called when production createrolestmt is exited. +func (s *BaseRedshiftParserListener) ExitCreaterolestmt(ctx *CreaterolestmtContext) {} + +// EnterOpt_with is called when production opt_with is entered. +func (s *BaseRedshiftParserListener) EnterOpt_with(ctx *Opt_withContext) {} + +// ExitOpt_with is called when production opt_with is exited. +func (s *BaseRedshiftParserListener) ExitOpt_with(ctx *Opt_withContext) {} + +// EnterOptrolelist is called when production optrolelist is entered. +func (s *BaseRedshiftParserListener) EnterOptrolelist(ctx *OptrolelistContext) {} + +// ExitOptrolelist is called when production optrolelist is exited. +func (s *BaseRedshiftParserListener) ExitOptrolelist(ctx *OptrolelistContext) {} + +// EnterAlteroptrolelist is called when production alteroptrolelist is entered. +func (s *BaseRedshiftParserListener) EnterAlteroptrolelist(ctx *AlteroptrolelistContext) {} + +// ExitAlteroptrolelist is called when production alteroptrolelist is exited. +func (s *BaseRedshiftParserListener) ExitAlteroptrolelist(ctx *AlteroptrolelistContext) {} + +// EnterAlteroptroleelem is called when production alteroptroleelem is entered. +func (s *BaseRedshiftParserListener) EnterAlteroptroleelem(ctx *AlteroptroleelemContext) {} + +// ExitAlteroptroleelem is called when production alteroptroleelem is exited. +func (s *BaseRedshiftParserListener) ExitAlteroptroleelem(ctx *AlteroptroleelemContext) {} + +// EnterCreateoptroleelem is called when production createoptroleelem is entered. +func (s *BaseRedshiftParserListener) EnterCreateoptroleelem(ctx *CreateoptroleelemContext) {} + +// ExitCreateoptroleelem is called when production createoptroleelem is exited. +func (s *BaseRedshiftParserListener) ExitCreateoptroleelem(ctx *CreateoptroleelemContext) {} + +// EnterCreateuserstmt is called when production createuserstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateuserstmt(ctx *CreateuserstmtContext) {} + +// ExitCreateuserstmt is called when production createuserstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateuserstmt(ctx *CreateuserstmtContext) {} + +// EnterAlterrolestmt is called when production alterrolestmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterrolestmt(ctx *AlterrolestmtContext) {} + +// ExitAlterrolestmt is called when production alterrolestmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterrolestmt(ctx *AlterrolestmtContext) {} + +// EnterAlterroleaction is called when production alterroleaction is entered. +func (s *BaseRedshiftParserListener) EnterAlterroleaction(ctx *AlterroleactionContext) {} + +// ExitAlterroleaction is called when production alterroleaction is exited. +func (s *BaseRedshiftParserListener) ExitAlterroleaction(ctx *AlterroleactionContext) {} + +// EnterOpt_in_database is called when production opt_in_database is entered. +func (s *BaseRedshiftParserListener) EnterOpt_in_database(ctx *Opt_in_databaseContext) {} + +// ExitOpt_in_database is called when production opt_in_database is exited. +func (s *BaseRedshiftParserListener) ExitOpt_in_database(ctx *Opt_in_databaseContext) {} + +// EnterAlterrolesetstmt is called when production alterrolesetstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterrolesetstmt(ctx *AlterrolesetstmtContext) {} + +// ExitAlterrolesetstmt is called when production alterrolesetstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterrolesetstmt(ctx *AlterrolesetstmtContext) {} + +// EnterAlterschemastmt is called when production alterschemastmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterschemastmt(ctx *AlterschemastmtContext) {} + +// ExitAlterschemastmt is called when production alterschemastmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterschemastmt(ctx *AlterschemastmtContext) {} + +// EnterDroprolestmt is called when production droprolestmt is entered. +func (s *BaseRedshiftParserListener) EnterDroprolestmt(ctx *DroprolestmtContext) {} + +// ExitDroprolestmt is called when production droprolestmt is exited. +func (s *BaseRedshiftParserListener) ExitDroprolestmt(ctx *DroprolestmtContext) {} + +// EnterDropuserstmt is called when production dropuserstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropuserstmt(ctx *DropuserstmtContext) {} + +// ExitDropuserstmt is called when production dropuserstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropuserstmt(ctx *DropuserstmtContext) {} + +// EnterDropgroupstmt is called when production dropgroupstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropgroupstmt(ctx *DropgroupstmtContext) {} + +// ExitDropgroupstmt is called when production dropgroupstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropgroupstmt(ctx *DropgroupstmtContext) {} + +// EnterCreategroupstmt is called when production creategroupstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreategroupstmt(ctx *CreategroupstmtContext) {} + +// ExitCreategroupstmt is called when production creategroupstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreategroupstmt(ctx *CreategroupstmtContext) {} + +// EnterAltergroupstmt is called when production altergroupstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltergroupstmt(ctx *AltergroupstmtContext) {} + +// ExitAltergroupstmt is called when production altergroupstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltergroupstmt(ctx *AltergroupstmtContext) {} + +// EnterAdd_drop is called when production add_drop is entered. +func (s *BaseRedshiftParserListener) EnterAdd_drop(ctx *Add_dropContext) {} + +// ExitAdd_drop is called when production add_drop is exited. +func (s *BaseRedshiftParserListener) ExitAdd_drop(ctx *Add_dropContext) {} + +// EnterCreateschemastmt is called when production createschemastmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateschemastmt(ctx *CreateschemastmtContext) {} + +// ExitCreateschemastmt is called when production createschemastmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateschemastmt(ctx *CreateschemastmtContext) {} + +// EnterOpt_auth_clause is called when production opt_auth_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_auth_clause(ctx *Opt_auth_clauseContext) {} + +// ExitOpt_auth_clause is called when production opt_auth_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_auth_clause(ctx *Opt_auth_clauseContext) {} + +// EnterOpt_quota is called when production opt_quota is entered. +func (s *BaseRedshiftParserListener) EnterOpt_quota(ctx *Opt_quotaContext) {} + +// ExitOpt_quota is called when production opt_quota is exited. +func (s *BaseRedshiftParserListener) ExitOpt_quota(ctx *Opt_quotaContext) {} + +// EnterOptschemaeltlist is called when production optschemaeltlist is entered. +func (s *BaseRedshiftParserListener) EnterOptschemaeltlist(ctx *OptschemaeltlistContext) {} + +// ExitOptschemaeltlist is called when production optschemaeltlist is exited. +func (s *BaseRedshiftParserListener) ExitOptschemaeltlist(ctx *OptschemaeltlistContext) {} + +// EnterSchema_stmt is called when production schema_stmt is entered. +func (s *BaseRedshiftParserListener) EnterSchema_stmt(ctx *Schema_stmtContext) {} + +// ExitSchema_stmt is called when production schema_stmt is exited. +func (s *BaseRedshiftParserListener) ExitSchema_stmt(ctx *Schema_stmtContext) {} + +// EnterVariablesetstmt is called when production variablesetstmt is entered. +func (s *BaseRedshiftParserListener) EnterVariablesetstmt(ctx *VariablesetstmtContext) {} + +// ExitVariablesetstmt is called when production variablesetstmt is exited. +func (s *BaseRedshiftParserListener) ExitVariablesetstmt(ctx *VariablesetstmtContext) {} + +// EnterSet_rest is called when production set_rest is entered. +func (s *BaseRedshiftParserListener) EnterSet_rest(ctx *Set_restContext) {} + +// ExitSet_rest is called when production set_rest is exited. +func (s *BaseRedshiftParserListener) ExitSet_rest(ctx *Set_restContext) {} + +// EnterGeneric_set is called when production generic_set is entered. +func (s *BaseRedshiftParserListener) EnterGeneric_set(ctx *Generic_setContext) {} + +// ExitGeneric_set is called when production generic_set is exited. +func (s *BaseRedshiftParserListener) ExitGeneric_set(ctx *Generic_setContext) {} + +// EnterSet_rest_more is called when production set_rest_more is entered. +func (s *BaseRedshiftParserListener) EnterSet_rest_more(ctx *Set_rest_moreContext) {} + +// ExitSet_rest_more is called when production set_rest_more is exited. +func (s *BaseRedshiftParserListener) ExitSet_rest_more(ctx *Set_rest_moreContext) {} + +// EnterVar_name is called when production var_name is entered. +func (s *BaseRedshiftParserListener) EnterVar_name(ctx *Var_nameContext) {} + +// ExitVar_name is called when production var_name is exited. +func (s *BaseRedshiftParserListener) ExitVar_name(ctx *Var_nameContext) {} + +// EnterVar_list is called when production var_list is entered. +func (s *BaseRedshiftParserListener) EnterVar_list(ctx *Var_listContext) {} + +// ExitVar_list is called when production var_list is exited. +func (s *BaseRedshiftParserListener) ExitVar_list(ctx *Var_listContext) {} + +// EnterVar_value is called when production var_value is entered. +func (s *BaseRedshiftParserListener) EnterVar_value(ctx *Var_valueContext) {} + +// ExitVar_value is called when production var_value is exited. +func (s *BaseRedshiftParserListener) ExitVar_value(ctx *Var_valueContext) {} + +// EnterIso_level is called when production iso_level is entered. +func (s *BaseRedshiftParserListener) EnterIso_level(ctx *Iso_levelContext) {} + +// ExitIso_level is called when production iso_level is exited. +func (s *BaseRedshiftParserListener) ExitIso_level(ctx *Iso_levelContext) {} + +// EnterOpt_boolean_or_string is called when production opt_boolean_or_string is entered. +func (s *BaseRedshiftParserListener) EnterOpt_boolean_or_string(ctx *Opt_boolean_or_stringContext) {} + +// ExitOpt_boolean_or_string is called when production opt_boolean_or_string is exited. +func (s *BaseRedshiftParserListener) ExitOpt_boolean_or_string(ctx *Opt_boolean_or_stringContext) {} + +// EnterZone_value is called when production zone_value is entered. +func (s *BaseRedshiftParserListener) EnterZone_value(ctx *Zone_valueContext) {} + +// ExitZone_value is called when production zone_value is exited. +func (s *BaseRedshiftParserListener) ExitZone_value(ctx *Zone_valueContext) {} + +// EnterOpt_encoding is called when production opt_encoding is entered. +func (s *BaseRedshiftParserListener) EnterOpt_encoding(ctx *Opt_encodingContext) {} + +// ExitOpt_encoding is called when production opt_encoding is exited. +func (s *BaseRedshiftParserListener) ExitOpt_encoding(ctx *Opt_encodingContext) {} + +// EnterNonreservedword_or_sconst is called when production nonreservedword_or_sconst is entered. +func (s *BaseRedshiftParserListener) EnterNonreservedword_or_sconst(ctx *Nonreservedword_or_sconstContext) { +} + +// ExitNonreservedword_or_sconst is called when production nonreservedword_or_sconst is exited. +func (s *BaseRedshiftParserListener) ExitNonreservedword_or_sconst(ctx *Nonreservedword_or_sconstContext) { +} + +// EnterVariableresetstmt is called when production variableresetstmt is entered. +func (s *BaseRedshiftParserListener) EnterVariableresetstmt(ctx *VariableresetstmtContext) {} + +// ExitVariableresetstmt is called when production variableresetstmt is exited. +func (s *BaseRedshiftParserListener) ExitVariableresetstmt(ctx *VariableresetstmtContext) {} + +// EnterReset_rest is called when production reset_rest is entered. +func (s *BaseRedshiftParserListener) EnterReset_rest(ctx *Reset_restContext) {} + +// ExitReset_rest is called when production reset_rest is exited. +func (s *BaseRedshiftParserListener) ExitReset_rest(ctx *Reset_restContext) {} + +// EnterGeneric_reset is called when production generic_reset is entered. +func (s *BaseRedshiftParserListener) EnterGeneric_reset(ctx *Generic_resetContext) {} + +// ExitGeneric_reset is called when production generic_reset is exited. +func (s *BaseRedshiftParserListener) ExitGeneric_reset(ctx *Generic_resetContext) {} + +// EnterSetresetclause is called when production setresetclause is entered. +func (s *BaseRedshiftParserListener) EnterSetresetclause(ctx *SetresetclauseContext) {} + +// ExitSetresetclause is called when production setresetclause is exited. +func (s *BaseRedshiftParserListener) ExitSetresetclause(ctx *SetresetclauseContext) {} + +// EnterFunctionsetresetclause is called when production functionsetresetclause is entered. +func (s *BaseRedshiftParserListener) EnterFunctionsetresetclause(ctx *FunctionsetresetclauseContext) { +} + +// ExitFunctionsetresetclause is called when production functionsetresetclause is exited. +func (s *BaseRedshiftParserListener) ExitFunctionsetresetclause(ctx *FunctionsetresetclauseContext) {} + +// EnterVariableshowstmt is called when production variableshowstmt is entered. +func (s *BaseRedshiftParserListener) EnterVariableshowstmt(ctx *VariableshowstmtContext) {} + +// ExitVariableshowstmt is called when production variableshowstmt is exited. +func (s *BaseRedshiftParserListener) ExitVariableshowstmt(ctx *VariableshowstmtContext) {} + +// EnterConstraintssetstmt is called when production constraintssetstmt is entered. +func (s *BaseRedshiftParserListener) EnterConstraintssetstmt(ctx *ConstraintssetstmtContext) {} + +// ExitConstraintssetstmt is called when production constraintssetstmt is exited. +func (s *BaseRedshiftParserListener) ExitConstraintssetstmt(ctx *ConstraintssetstmtContext) {} + +// EnterConstraints_set_list is called when production constraints_set_list is entered. +func (s *BaseRedshiftParserListener) EnterConstraints_set_list(ctx *Constraints_set_listContext) {} + +// ExitConstraints_set_list is called when production constraints_set_list is exited. +func (s *BaseRedshiftParserListener) ExitConstraints_set_list(ctx *Constraints_set_listContext) {} + +// EnterConstraints_set_mode is called when production constraints_set_mode is entered. +func (s *BaseRedshiftParserListener) EnterConstraints_set_mode(ctx *Constraints_set_modeContext) {} + +// ExitConstraints_set_mode is called when production constraints_set_mode is exited. +func (s *BaseRedshiftParserListener) ExitConstraints_set_mode(ctx *Constraints_set_modeContext) {} + +// EnterCheckpointstmt is called when production checkpointstmt is entered. +func (s *BaseRedshiftParserListener) EnterCheckpointstmt(ctx *CheckpointstmtContext) {} + +// ExitCheckpointstmt is called when production checkpointstmt is exited. +func (s *BaseRedshiftParserListener) ExitCheckpointstmt(ctx *CheckpointstmtContext) {} + +// EnterDiscardstmt is called when production discardstmt is entered. +func (s *BaseRedshiftParserListener) EnterDiscardstmt(ctx *DiscardstmtContext) {} + +// ExitDiscardstmt is called when production discardstmt is exited. +func (s *BaseRedshiftParserListener) ExitDiscardstmt(ctx *DiscardstmtContext) {} + +// EnterAltertablestmt is called when production altertablestmt is entered. +func (s *BaseRedshiftParserListener) EnterAltertablestmt(ctx *AltertablestmtContext) {} + +// ExitAltertablestmt is called when production altertablestmt is exited. +func (s *BaseRedshiftParserListener) ExitAltertablestmt(ctx *AltertablestmtContext) {} + +// EnterAlter_table_cmds is called when production alter_table_cmds is entered. +func (s *BaseRedshiftParserListener) EnterAlter_table_cmds(ctx *Alter_table_cmdsContext) {} + +// ExitAlter_table_cmds is called when production alter_table_cmds is exited. +func (s *BaseRedshiftParserListener) ExitAlter_table_cmds(ctx *Alter_table_cmdsContext) {} + +// EnterTable_constraint is called when production table_constraint is entered. +func (s *BaseRedshiftParserListener) EnterTable_constraint(ctx *Table_constraintContext) {} + +// ExitTable_constraint is called when production table_constraint is exited. +func (s *BaseRedshiftParserListener) ExitTable_constraint(ctx *Table_constraintContext) {} + +// EnterPartition_cmd is called when production partition_cmd is entered. +func (s *BaseRedshiftParserListener) EnterPartition_cmd(ctx *Partition_cmdContext) {} + +// ExitPartition_cmd is called when production partition_cmd is exited. +func (s *BaseRedshiftParserListener) ExitPartition_cmd(ctx *Partition_cmdContext) {} + +// EnterIndex_partition_cmd is called when production index_partition_cmd is entered. +func (s *BaseRedshiftParserListener) EnterIndex_partition_cmd(ctx *Index_partition_cmdContext) {} + +// ExitIndex_partition_cmd is called when production index_partition_cmd is exited. +func (s *BaseRedshiftParserListener) ExitIndex_partition_cmd(ctx *Index_partition_cmdContext) {} + +// EnterAlter_table_cmd is called when production alter_table_cmd is entered. +func (s *BaseRedshiftParserListener) EnterAlter_table_cmd(ctx *Alter_table_cmdContext) {} + +// ExitAlter_table_cmd is called when production alter_table_cmd is exited. +func (s *BaseRedshiftParserListener) ExitAlter_table_cmd(ctx *Alter_table_cmdContext) {} + +// EnterAlter_column_default is called when production alter_column_default is entered. +func (s *BaseRedshiftParserListener) EnterAlter_column_default(ctx *Alter_column_defaultContext) {} + +// ExitAlter_column_default is called when production alter_column_default is exited. +func (s *BaseRedshiftParserListener) ExitAlter_column_default(ctx *Alter_column_defaultContext) {} + +// EnterOpt_drop_behavior is called when production opt_drop_behavior is entered. +func (s *BaseRedshiftParserListener) EnterOpt_drop_behavior(ctx *Opt_drop_behaviorContext) {} + +// ExitOpt_drop_behavior is called when production opt_drop_behavior is exited. +func (s *BaseRedshiftParserListener) ExitOpt_drop_behavior(ctx *Opt_drop_behaviorContext) {} + +// EnterOpt_collate_clause is called when production opt_collate_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_collate_clause(ctx *Opt_collate_clauseContext) {} + +// ExitOpt_collate_clause is called when production opt_collate_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_collate_clause(ctx *Opt_collate_clauseContext) {} + +// EnterAlter_using is called when production alter_using is entered. +func (s *BaseRedshiftParserListener) EnterAlter_using(ctx *Alter_usingContext) {} + +// ExitAlter_using is called when production alter_using is exited. +func (s *BaseRedshiftParserListener) ExitAlter_using(ctx *Alter_usingContext) {} + +// EnterReplica_identity is called when production replica_identity is entered. +func (s *BaseRedshiftParserListener) EnterReplica_identity(ctx *Replica_identityContext) {} + +// ExitReplica_identity is called when production replica_identity is exited. +func (s *BaseRedshiftParserListener) ExitReplica_identity(ctx *Replica_identityContext) {} + +// EnterReloptions is called when production reloptions is entered. +func (s *BaseRedshiftParserListener) EnterReloptions(ctx *ReloptionsContext) {} + +// ExitReloptions is called when production reloptions is exited. +func (s *BaseRedshiftParserListener) ExitReloptions(ctx *ReloptionsContext) {} + +// EnterOpt_reloptions is called when production opt_reloptions is entered. +func (s *BaseRedshiftParserListener) EnterOpt_reloptions(ctx *Opt_reloptionsContext) {} + +// ExitOpt_reloptions is called when production opt_reloptions is exited. +func (s *BaseRedshiftParserListener) ExitOpt_reloptions(ctx *Opt_reloptionsContext) {} + +// EnterReloption_list is called when production reloption_list is entered. +func (s *BaseRedshiftParserListener) EnterReloption_list(ctx *Reloption_listContext) {} + +// ExitReloption_list is called when production reloption_list is exited. +func (s *BaseRedshiftParserListener) ExitReloption_list(ctx *Reloption_listContext) {} + +// EnterReloption_elem is called when production reloption_elem is entered. +func (s *BaseRedshiftParserListener) EnterReloption_elem(ctx *Reloption_elemContext) {} + +// ExitReloption_elem is called when production reloption_elem is exited. +func (s *BaseRedshiftParserListener) ExitReloption_elem(ctx *Reloption_elemContext) {} + +// EnterAlter_identity_column_option_list is called when production alter_identity_column_option_list is entered. +func (s *BaseRedshiftParserListener) EnterAlter_identity_column_option_list(ctx *Alter_identity_column_option_listContext) { +} + +// ExitAlter_identity_column_option_list is called when production alter_identity_column_option_list is exited. +func (s *BaseRedshiftParserListener) ExitAlter_identity_column_option_list(ctx *Alter_identity_column_option_listContext) { +} + +// EnterAlter_identity_column_option is called when production alter_identity_column_option is entered. +func (s *BaseRedshiftParserListener) EnterAlter_identity_column_option(ctx *Alter_identity_column_optionContext) { +} + +// ExitAlter_identity_column_option is called when production alter_identity_column_option is exited. +func (s *BaseRedshiftParserListener) ExitAlter_identity_column_option(ctx *Alter_identity_column_optionContext) { +} + +// EnterPartitionboundspec is called when production partitionboundspec is entered. +func (s *BaseRedshiftParserListener) EnterPartitionboundspec(ctx *PartitionboundspecContext) {} + +// ExitPartitionboundspec is called when production partitionboundspec is exited. +func (s *BaseRedshiftParserListener) ExitPartitionboundspec(ctx *PartitionboundspecContext) {} + +// EnterHash_partbound_elem is called when production hash_partbound_elem is entered. +func (s *BaseRedshiftParserListener) EnterHash_partbound_elem(ctx *Hash_partbound_elemContext) {} + +// ExitHash_partbound_elem is called when production hash_partbound_elem is exited. +func (s *BaseRedshiftParserListener) ExitHash_partbound_elem(ctx *Hash_partbound_elemContext) {} + +// EnterHash_partbound is called when production hash_partbound is entered. +func (s *BaseRedshiftParserListener) EnterHash_partbound(ctx *Hash_partboundContext) {} + +// ExitHash_partbound is called when production hash_partbound is exited. +func (s *BaseRedshiftParserListener) ExitHash_partbound(ctx *Hash_partboundContext) {} + +// EnterAltercompositetypestmt is called when production altercompositetypestmt is entered. +func (s *BaseRedshiftParserListener) EnterAltercompositetypestmt(ctx *AltercompositetypestmtContext) { +} + +// ExitAltercompositetypestmt is called when production altercompositetypestmt is exited. +func (s *BaseRedshiftParserListener) ExitAltercompositetypestmt(ctx *AltercompositetypestmtContext) {} + +// EnterAlter_type_cmds is called when production alter_type_cmds is entered. +func (s *BaseRedshiftParserListener) EnterAlter_type_cmds(ctx *Alter_type_cmdsContext) {} + +// ExitAlter_type_cmds is called when production alter_type_cmds is exited. +func (s *BaseRedshiftParserListener) ExitAlter_type_cmds(ctx *Alter_type_cmdsContext) {} + +// EnterAlter_type_cmd is called when production alter_type_cmd is entered. +func (s *BaseRedshiftParserListener) EnterAlter_type_cmd(ctx *Alter_type_cmdContext) {} + +// ExitAlter_type_cmd is called when production alter_type_cmd is exited. +func (s *BaseRedshiftParserListener) ExitAlter_type_cmd(ctx *Alter_type_cmdContext) {} + +// EnterCloseportalstmt is called when production closeportalstmt is entered. +func (s *BaseRedshiftParserListener) EnterCloseportalstmt(ctx *CloseportalstmtContext) {} + +// ExitCloseportalstmt is called when production closeportalstmt is exited. +func (s *BaseRedshiftParserListener) ExitCloseportalstmt(ctx *CloseportalstmtContext) {} + +// EnterCopystmt is called when production copystmt is entered. +func (s *BaseRedshiftParserListener) EnterCopystmt(ctx *CopystmtContext) {} + +// ExitCopystmt is called when production copystmt is exited. +func (s *BaseRedshiftParserListener) ExitCopystmt(ctx *CopystmtContext) {} + +// EnterRedshift_copy_authorization is called when production redshift_copy_authorization is entered. +func (s *BaseRedshiftParserListener) EnterRedshift_copy_authorization(ctx *Redshift_copy_authorizationContext) { +} + +// ExitRedshift_copy_authorization is called when production redshift_copy_authorization is exited. +func (s *BaseRedshiftParserListener) ExitRedshift_copy_authorization(ctx *Redshift_copy_authorizationContext) { +} + +// EnterRedshift_copy_format is called when production redshift_copy_format is entered. +func (s *BaseRedshiftParserListener) EnterRedshift_copy_format(ctx *Redshift_copy_formatContext) {} + +// ExitRedshift_copy_format is called when production redshift_copy_format is exited. +func (s *BaseRedshiftParserListener) ExitRedshift_copy_format(ctx *Redshift_copy_formatContext) {} + +// EnterRedshift_copy_parameter is called when production redshift_copy_parameter is entered. +func (s *BaseRedshiftParserListener) EnterRedshift_copy_parameter(ctx *Redshift_copy_parameterContext) { +} + +// ExitRedshift_copy_parameter is called when production redshift_copy_parameter is exited. +func (s *BaseRedshiftParserListener) ExitRedshift_copy_parameter(ctx *Redshift_copy_parameterContext) { +} + +// EnterCopy_param_name is called when production copy_param_name is entered. +func (s *BaseRedshiftParserListener) EnterCopy_param_name(ctx *Copy_param_nameContext) {} + +// ExitCopy_param_name is called when production copy_param_name is exited. +func (s *BaseRedshiftParserListener) ExitCopy_param_name(ctx *Copy_param_nameContext) {} + +// EnterCopy_param_value is called when production copy_param_value is entered. +func (s *BaseRedshiftParserListener) EnterCopy_param_value(ctx *Copy_param_valueContext) {} + +// ExitCopy_param_value is called when production copy_param_value is exited. +func (s *BaseRedshiftParserListener) ExitCopy_param_value(ctx *Copy_param_valueContext) {} + +// EnterCopy_from is called when production copy_from is entered. +func (s *BaseRedshiftParserListener) EnterCopy_from(ctx *Copy_fromContext) {} + +// ExitCopy_from is called when production copy_from is exited. +func (s *BaseRedshiftParserListener) ExitCopy_from(ctx *Copy_fromContext) {} + +// EnterOpt_program is called when production opt_program is entered. +func (s *BaseRedshiftParserListener) EnterOpt_program(ctx *Opt_programContext) {} + +// ExitOpt_program is called when production opt_program is exited. +func (s *BaseRedshiftParserListener) ExitOpt_program(ctx *Opt_programContext) {} + +// EnterCopy_file_name is called when production copy_file_name is entered. +func (s *BaseRedshiftParserListener) EnterCopy_file_name(ctx *Copy_file_nameContext) {} + +// ExitCopy_file_name is called when production copy_file_name is exited. +func (s *BaseRedshiftParserListener) ExitCopy_file_name(ctx *Copy_file_nameContext) {} + +// EnterCopy_options is called when production copy_options is entered. +func (s *BaseRedshiftParserListener) EnterCopy_options(ctx *Copy_optionsContext) {} + +// ExitCopy_options is called when production copy_options is exited. +func (s *BaseRedshiftParserListener) ExitCopy_options(ctx *Copy_optionsContext) {} + +// EnterCopy_opt_list is called when production copy_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterCopy_opt_list(ctx *Copy_opt_listContext) {} + +// ExitCopy_opt_list is called when production copy_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitCopy_opt_list(ctx *Copy_opt_listContext) {} + +// EnterCopy_opt_item is called when production copy_opt_item is entered. +func (s *BaseRedshiftParserListener) EnterCopy_opt_item(ctx *Copy_opt_itemContext) {} + +// ExitCopy_opt_item is called when production copy_opt_item is exited. +func (s *BaseRedshiftParserListener) ExitCopy_opt_item(ctx *Copy_opt_itemContext) {} + +// EnterOpt_binary is called when production opt_binary is entered. +func (s *BaseRedshiftParserListener) EnterOpt_binary(ctx *Opt_binaryContext) {} + +// ExitOpt_binary is called when production opt_binary is exited. +func (s *BaseRedshiftParserListener) ExitOpt_binary(ctx *Opt_binaryContext) {} + +// EnterCopy_delimiter is called when production copy_delimiter is entered. +func (s *BaseRedshiftParserListener) EnterCopy_delimiter(ctx *Copy_delimiterContext) {} + +// ExitCopy_delimiter is called when production copy_delimiter is exited. +func (s *BaseRedshiftParserListener) ExitCopy_delimiter(ctx *Copy_delimiterContext) {} + +// EnterOpt_using is called when production opt_using is entered. +func (s *BaseRedshiftParserListener) EnterOpt_using(ctx *Opt_usingContext) {} + +// ExitOpt_using is called when production opt_using is exited. +func (s *BaseRedshiftParserListener) ExitOpt_using(ctx *Opt_usingContext) {} + +// EnterCopy_generic_opt_list is called when production copy_generic_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterCopy_generic_opt_list(ctx *Copy_generic_opt_listContext) {} + +// ExitCopy_generic_opt_list is called when production copy_generic_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitCopy_generic_opt_list(ctx *Copy_generic_opt_listContext) {} + +// EnterCopy_generic_opt_elem is called when production copy_generic_opt_elem is entered. +func (s *BaseRedshiftParserListener) EnterCopy_generic_opt_elem(ctx *Copy_generic_opt_elemContext) {} + +// ExitCopy_generic_opt_elem is called when production copy_generic_opt_elem is exited. +func (s *BaseRedshiftParserListener) ExitCopy_generic_opt_elem(ctx *Copy_generic_opt_elemContext) {} + +// EnterCopy_generic_opt_arg is called when production copy_generic_opt_arg is entered. +func (s *BaseRedshiftParserListener) EnterCopy_generic_opt_arg(ctx *Copy_generic_opt_argContext) {} + +// ExitCopy_generic_opt_arg is called when production copy_generic_opt_arg is exited. +func (s *BaseRedshiftParserListener) ExitCopy_generic_opt_arg(ctx *Copy_generic_opt_argContext) {} + +// EnterCopy_generic_opt_arg_list is called when production copy_generic_opt_arg_list is entered. +func (s *BaseRedshiftParserListener) EnterCopy_generic_opt_arg_list(ctx *Copy_generic_opt_arg_listContext) { +} + +// ExitCopy_generic_opt_arg_list is called when production copy_generic_opt_arg_list is exited. +func (s *BaseRedshiftParserListener) ExitCopy_generic_opt_arg_list(ctx *Copy_generic_opt_arg_listContext) { +} + +// EnterCopy_generic_opt_arg_list_item is called when production copy_generic_opt_arg_list_item is entered. +func (s *BaseRedshiftParserListener) EnterCopy_generic_opt_arg_list_item(ctx *Copy_generic_opt_arg_list_itemContext) { +} + +// ExitCopy_generic_opt_arg_list_item is called when production copy_generic_opt_arg_list_item is exited. +func (s *BaseRedshiftParserListener) ExitCopy_generic_opt_arg_list_item(ctx *Copy_generic_opt_arg_list_itemContext) { +} + +// EnterCreatestmt is called when production createstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatestmt(ctx *CreatestmtContext) {} + +// ExitCreatestmt is called when production createstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatestmt(ctx *CreatestmtContext) {} + +// EnterOpt_table_attributes is called when production opt_table_attributes is entered. +func (s *BaseRedshiftParserListener) EnterOpt_table_attributes(ctx *Opt_table_attributesContext) {} + +// ExitOpt_table_attributes is called when production opt_table_attributes is exited. +func (s *BaseRedshiftParserListener) ExitOpt_table_attributes(ctx *Opt_table_attributesContext) {} + +// EnterOpttemp is called when production opttemp is entered. +func (s *BaseRedshiftParserListener) EnterOpttemp(ctx *OpttempContext) {} + +// ExitOpttemp is called when production opttemp is exited. +func (s *BaseRedshiftParserListener) ExitOpttemp(ctx *OpttempContext) {} + +// EnterOpttableelementlist is called when production opttableelementlist is entered. +func (s *BaseRedshiftParserListener) EnterOpttableelementlist(ctx *OpttableelementlistContext) {} + +// ExitOpttableelementlist is called when production opttableelementlist is exited. +func (s *BaseRedshiftParserListener) ExitOpttableelementlist(ctx *OpttableelementlistContext) {} + +// EnterOpttypedtableelementlist is called when production opttypedtableelementlist is entered. +func (s *BaseRedshiftParserListener) EnterOpttypedtableelementlist(ctx *OpttypedtableelementlistContext) { +} + +// ExitOpttypedtableelementlist is called when production opttypedtableelementlist is exited. +func (s *BaseRedshiftParserListener) ExitOpttypedtableelementlist(ctx *OpttypedtableelementlistContext) { +} + +// EnterTableelementlist is called when production tableelementlist is entered. +func (s *BaseRedshiftParserListener) EnterTableelementlist(ctx *TableelementlistContext) {} + +// ExitTableelementlist is called when production tableelementlist is exited. +func (s *BaseRedshiftParserListener) ExitTableelementlist(ctx *TableelementlistContext) {} + +// EnterTypedtableelementlist is called when production typedtableelementlist is entered. +func (s *BaseRedshiftParserListener) EnterTypedtableelementlist(ctx *TypedtableelementlistContext) {} + +// ExitTypedtableelementlist is called when production typedtableelementlist is exited. +func (s *BaseRedshiftParserListener) ExitTypedtableelementlist(ctx *TypedtableelementlistContext) {} + +// EnterTableelement is called when production tableelement is entered. +func (s *BaseRedshiftParserListener) EnterTableelement(ctx *TableelementContext) {} + +// ExitTableelement is called when production tableelement is exited. +func (s *BaseRedshiftParserListener) ExitTableelement(ctx *TableelementContext) {} + +// EnterTypedtableelement is called when production typedtableelement is entered. +func (s *BaseRedshiftParserListener) EnterTypedtableelement(ctx *TypedtableelementContext) {} + +// ExitTypedtableelement is called when production typedtableelement is exited. +func (s *BaseRedshiftParserListener) ExitTypedtableelement(ctx *TypedtableelementContext) {} + +// EnterColumnDef is called when production columnDef is entered. +func (s *BaseRedshiftParserListener) EnterColumnDef(ctx *ColumnDefContext) {} + +// ExitColumnDef is called when production columnDef is exited. +func (s *BaseRedshiftParserListener) ExitColumnDef(ctx *ColumnDefContext) {} + +// EnterRs_colattributes is called when production rs_colattributes is entered. +func (s *BaseRedshiftParserListener) EnterRs_colattributes(ctx *Rs_colattributesContext) {} + +// ExitRs_colattributes is called when production rs_colattributes is exited. +func (s *BaseRedshiftParserListener) ExitRs_colattributes(ctx *Rs_colattributesContext) {} + +// EnterRs_colattribute is called when production rs_colattribute is entered. +func (s *BaseRedshiftParserListener) EnterRs_colattribute(ctx *Rs_colattributeContext) {} + +// ExitRs_colattribute is called when production rs_colattribute is exited. +func (s *BaseRedshiftParserListener) ExitRs_colattribute(ctx *Rs_colattributeContext) {} + +// EnterColumnOptions is called when production columnOptions is entered. +func (s *BaseRedshiftParserListener) EnterColumnOptions(ctx *ColumnOptionsContext) {} + +// ExitColumnOptions is called when production columnOptions is exited. +func (s *BaseRedshiftParserListener) ExitColumnOptions(ctx *ColumnOptionsContext) {} + +// EnterColquallist is called when production colquallist is entered. +func (s *BaseRedshiftParserListener) EnterColquallist(ctx *ColquallistContext) {} + +// ExitColquallist is called when production colquallist is exited. +func (s *BaseRedshiftParserListener) ExitColquallist(ctx *ColquallistContext) {} + +// EnterColconstraint is called when production colconstraint is entered. +func (s *BaseRedshiftParserListener) EnterColconstraint(ctx *ColconstraintContext) {} + +// ExitColconstraint is called when production colconstraint is exited. +func (s *BaseRedshiftParserListener) ExitColconstraint(ctx *ColconstraintContext) {} + +// EnterColconstraintelem is called when production colconstraintelem is entered. +func (s *BaseRedshiftParserListener) EnterColconstraintelem(ctx *ColconstraintelemContext) {} + +// ExitColconstraintelem is called when production colconstraintelem is exited. +func (s *BaseRedshiftParserListener) ExitColconstraintelem(ctx *ColconstraintelemContext) {} + +// EnterOpt_unique_null_treatment is called when production opt_unique_null_treatment is entered. +func (s *BaseRedshiftParserListener) EnterOpt_unique_null_treatment(ctx *Opt_unique_null_treatmentContext) { +} + +// ExitOpt_unique_null_treatment is called when production opt_unique_null_treatment is exited. +func (s *BaseRedshiftParserListener) ExitOpt_unique_null_treatment(ctx *Opt_unique_null_treatmentContext) { +} + +// EnterGenerated_when is called when production generated_when is entered. +func (s *BaseRedshiftParserListener) EnterGenerated_when(ctx *Generated_whenContext) {} + +// ExitGenerated_when is called when production generated_when is exited. +func (s *BaseRedshiftParserListener) ExitGenerated_when(ctx *Generated_whenContext) {} + +// EnterConstraintattr is called when production constraintattr is entered. +func (s *BaseRedshiftParserListener) EnterConstraintattr(ctx *ConstraintattrContext) {} + +// ExitConstraintattr is called when production constraintattr is exited. +func (s *BaseRedshiftParserListener) ExitConstraintattr(ctx *ConstraintattrContext) {} + +// EnterTablelikeclause is called when production tablelikeclause is entered. +func (s *BaseRedshiftParserListener) EnterTablelikeclause(ctx *TablelikeclauseContext) {} + +// ExitTablelikeclause is called when production tablelikeclause is exited. +func (s *BaseRedshiftParserListener) ExitTablelikeclause(ctx *TablelikeclauseContext) {} + +// EnterTablelikeoptionlist is called when production tablelikeoptionlist is entered. +func (s *BaseRedshiftParserListener) EnterTablelikeoptionlist(ctx *TablelikeoptionlistContext) {} + +// ExitTablelikeoptionlist is called when production tablelikeoptionlist is exited. +func (s *BaseRedshiftParserListener) ExitTablelikeoptionlist(ctx *TablelikeoptionlistContext) {} + +// EnterTablelikeoption is called when production tablelikeoption is entered. +func (s *BaseRedshiftParserListener) EnterTablelikeoption(ctx *TablelikeoptionContext) {} + +// ExitTablelikeoption is called when production tablelikeoption is exited. +func (s *BaseRedshiftParserListener) ExitTablelikeoption(ctx *TablelikeoptionContext) {} + +// EnterTableconstraint is called when production tableconstraint is entered. +func (s *BaseRedshiftParserListener) EnterTableconstraint(ctx *TableconstraintContext) {} + +// ExitTableconstraint is called when production tableconstraint is exited. +func (s *BaseRedshiftParserListener) ExitTableconstraint(ctx *TableconstraintContext) {} + +// EnterConstraintelem is called when production constraintelem is entered. +func (s *BaseRedshiftParserListener) EnterConstraintelem(ctx *ConstraintelemContext) {} + +// ExitConstraintelem is called when production constraintelem is exited. +func (s *BaseRedshiftParserListener) ExitConstraintelem(ctx *ConstraintelemContext) {} + +// EnterOpt_no_inherit is called when production opt_no_inherit is entered. +func (s *BaseRedshiftParserListener) EnterOpt_no_inherit(ctx *Opt_no_inheritContext) {} + +// ExitOpt_no_inherit is called when production opt_no_inherit is exited. +func (s *BaseRedshiftParserListener) ExitOpt_no_inherit(ctx *Opt_no_inheritContext) {} + +// EnterOpt_column_list is called when production opt_column_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_column_list(ctx *Opt_column_listContext) {} + +// ExitOpt_column_list is called when production opt_column_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_column_list(ctx *Opt_column_listContext) {} + +// EnterColumnlist is called when production columnlist is entered. +func (s *BaseRedshiftParserListener) EnterColumnlist(ctx *ColumnlistContext) {} + +// ExitColumnlist is called when production columnlist is exited. +func (s *BaseRedshiftParserListener) ExitColumnlist(ctx *ColumnlistContext) {} + +// EnterColumnElem is called when production columnElem is entered. +func (s *BaseRedshiftParserListener) EnterColumnElem(ctx *ColumnElemContext) {} + +// ExitColumnElem is called when production columnElem is exited. +func (s *BaseRedshiftParserListener) ExitColumnElem(ctx *ColumnElemContext) {} + +// EnterOpt_c_include is called when production opt_c_include is entered. +func (s *BaseRedshiftParserListener) EnterOpt_c_include(ctx *Opt_c_includeContext) {} + +// ExitOpt_c_include is called when production opt_c_include is exited. +func (s *BaseRedshiftParserListener) ExitOpt_c_include(ctx *Opt_c_includeContext) {} + +// EnterKey_match is called when production key_match is entered. +func (s *BaseRedshiftParserListener) EnterKey_match(ctx *Key_matchContext) {} + +// ExitKey_match is called when production key_match is exited. +func (s *BaseRedshiftParserListener) ExitKey_match(ctx *Key_matchContext) {} + +// EnterExclusionconstraintlist is called when production exclusionconstraintlist is entered. +func (s *BaseRedshiftParserListener) EnterExclusionconstraintlist(ctx *ExclusionconstraintlistContext) { +} + +// ExitExclusionconstraintlist is called when production exclusionconstraintlist is exited. +func (s *BaseRedshiftParserListener) ExitExclusionconstraintlist(ctx *ExclusionconstraintlistContext) { +} + +// EnterExclusionconstraintelem is called when production exclusionconstraintelem is entered. +func (s *BaseRedshiftParserListener) EnterExclusionconstraintelem(ctx *ExclusionconstraintelemContext) { +} + +// ExitExclusionconstraintelem is called when production exclusionconstraintelem is exited. +func (s *BaseRedshiftParserListener) ExitExclusionconstraintelem(ctx *ExclusionconstraintelemContext) { +} + +// EnterExclusionwhereclause is called when production exclusionwhereclause is entered. +func (s *BaseRedshiftParserListener) EnterExclusionwhereclause(ctx *ExclusionwhereclauseContext) {} + +// ExitExclusionwhereclause is called when production exclusionwhereclause is exited. +func (s *BaseRedshiftParserListener) ExitExclusionwhereclause(ctx *ExclusionwhereclauseContext) {} + +// EnterKey_actions is called when production key_actions is entered. +func (s *BaseRedshiftParserListener) EnterKey_actions(ctx *Key_actionsContext) {} + +// ExitKey_actions is called when production key_actions is exited. +func (s *BaseRedshiftParserListener) ExitKey_actions(ctx *Key_actionsContext) {} + +// EnterKey_update is called when production key_update is entered. +func (s *BaseRedshiftParserListener) EnterKey_update(ctx *Key_updateContext) {} + +// ExitKey_update is called when production key_update is exited. +func (s *BaseRedshiftParserListener) ExitKey_update(ctx *Key_updateContext) {} + +// EnterKey_delete is called when production key_delete is entered. +func (s *BaseRedshiftParserListener) EnterKey_delete(ctx *Key_deleteContext) {} + +// ExitKey_delete is called when production key_delete is exited. +func (s *BaseRedshiftParserListener) ExitKey_delete(ctx *Key_deleteContext) {} + +// EnterKey_action is called when production key_action is entered. +func (s *BaseRedshiftParserListener) EnterKey_action(ctx *Key_actionContext) {} + +// ExitKey_action is called when production key_action is exited. +func (s *BaseRedshiftParserListener) ExitKey_action(ctx *Key_actionContext) {} + +// EnterOptinherit is called when production optinherit is entered. +func (s *BaseRedshiftParserListener) EnterOptinherit(ctx *OptinheritContext) {} + +// ExitOptinherit is called when production optinherit is exited. +func (s *BaseRedshiftParserListener) ExitOptinherit(ctx *OptinheritContext) {} + +// EnterOptpartitionspec is called when production optpartitionspec is entered. +func (s *BaseRedshiftParserListener) EnterOptpartitionspec(ctx *OptpartitionspecContext) {} + +// ExitOptpartitionspec is called when production optpartitionspec is exited. +func (s *BaseRedshiftParserListener) ExitOptpartitionspec(ctx *OptpartitionspecContext) {} + +// EnterPartitionspec is called when production partitionspec is entered. +func (s *BaseRedshiftParserListener) EnterPartitionspec(ctx *PartitionspecContext) {} + +// ExitPartitionspec is called when production partitionspec is exited. +func (s *BaseRedshiftParserListener) ExitPartitionspec(ctx *PartitionspecContext) {} + +// EnterPart_params is called when production part_params is entered. +func (s *BaseRedshiftParserListener) EnterPart_params(ctx *Part_paramsContext) {} + +// ExitPart_params is called when production part_params is exited. +func (s *BaseRedshiftParserListener) ExitPart_params(ctx *Part_paramsContext) {} + +// EnterPart_elem is called when production part_elem is entered. +func (s *BaseRedshiftParserListener) EnterPart_elem(ctx *Part_elemContext) {} + +// ExitPart_elem is called when production part_elem is exited. +func (s *BaseRedshiftParserListener) ExitPart_elem(ctx *Part_elemContext) {} + +// EnterTable_access_method_clause is called when production table_access_method_clause is entered. +func (s *BaseRedshiftParserListener) EnterTable_access_method_clause(ctx *Table_access_method_clauseContext) { +} + +// ExitTable_access_method_clause is called when production table_access_method_clause is exited. +func (s *BaseRedshiftParserListener) ExitTable_access_method_clause(ctx *Table_access_method_clauseContext) { +} + +// EnterOptwith is called when production optwith is entered. +func (s *BaseRedshiftParserListener) EnterOptwith(ctx *OptwithContext) {} + +// ExitOptwith is called when production optwith is exited. +func (s *BaseRedshiftParserListener) ExitOptwith(ctx *OptwithContext) {} + +// EnterOncommitoption is called when production oncommitoption is entered. +func (s *BaseRedshiftParserListener) EnterOncommitoption(ctx *OncommitoptionContext) {} + +// ExitOncommitoption is called when production oncommitoption is exited. +func (s *BaseRedshiftParserListener) ExitOncommitoption(ctx *OncommitoptionContext) {} + +// EnterOpttablespace is called when production opttablespace is entered. +func (s *BaseRedshiftParserListener) EnterOpttablespace(ctx *OpttablespaceContext) {} + +// ExitOpttablespace is called when production opttablespace is exited. +func (s *BaseRedshiftParserListener) ExitOpttablespace(ctx *OpttablespaceContext) {} + +// EnterOptredshifttableoptions is called when production optredshifttableoptions is entered. +func (s *BaseRedshiftParserListener) EnterOptredshifttableoptions(ctx *OptredshifttableoptionsContext) { +} + +// ExitOptredshifttableoptions is called when production optredshifttableoptions is exited. +func (s *BaseRedshiftParserListener) ExitOptredshifttableoptions(ctx *OptredshifttableoptionsContext) { +} + +// EnterRedshifttableoption is called when production redshifttableoption is entered. +func (s *BaseRedshiftParserListener) EnterRedshifttableoption(ctx *RedshifttableoptionContext) {} + +// ExitRedshifttableoption is called when production redshifttableoption is exited. +func (s *BaseRedshiftParserListener) ExitRedshifttableoption(ctx *RedshifttableoptionContext) {} + +// EnterSortkeyclause is called when production sortkeyclause is entered. +func (s *BaseRedshiftParserListener) EnterSortkeyclause(ctx *SortkeyclauseContext) {} + +// ExitSortkeyclause is called when production sortkeyclause is exited. +func (s *BaseRedshiftParserListener) ExitSortkeyclause(ctx *SortkeyclauseContext) {} + +// EnterSortkeyclausetype is called when production sortkeyclausetype is entered. +func (s *BaseRedshiftParserListener) EnterSortkeyclausetype(ctx *SortkeyclausetypeContext) {} + +// ExitSortkeyclausetype is called when production sortkeyclausetype is exited. +func (s *BaseRedshiftParserListener) ExitSortkeyclausetype(ctx *SortkeyclausetypeContext) {} + +// EnterOptconstablespace is called when production optconstablespace is entered. +func (s *BaseRedshiftParserListener) EnterOptconstablespace(ctx *OptconstablespaceContext) {} + +// ExitOptconstablespace is called when production optconstablespace is exited. +func (s *BaseRedshiftParserListener) ExitOptconstablespace(ctx *OptconstablespaceContext) {} + +// EnterExistingindex is called when production existingindex is entered. +func (s *BaseRedshiftParserListener) EnterExistingindex(ctx *ExistingindexContext) {} + +// ExitExistingindex is called when production existingindex is exited. +func (s *BaseRedshiftParserListener) ExitExistingindex(ctx *ExistingindexContext) {} + +// EnterCreatestatsstmt is called when production createstatsstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatestatsstmt(ctx *CreatestatsstmtContext) {} + +// ExitCreatestatsstmt is called when production createstatsstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatestatsstmt(ctx *CreatestatsstmtContext) {} + +// EnterAlterstatsstmt is called when production alterstatsstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterstatsstmt(ctx *AlterstatsstmtContext) {} + +// ExitAlterstatsstmt is called when production alterstatsstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterstatsstmt(ctx *AlterstatsstmtContext) {} + +// EnterCreateasstmt is called when production createasstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateasstmt(ctx *CreateasstmtContext) {} + +// ExitCreateasstmt is called when production createasstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateasstmt(ctx *CreateasstmtContext) {} + +// EnterCreate_as_target is called when production create_as_target is entered. +func (s *BaseRedshiftParserListener) EnterCreate_as_target(ctx *Create_as_targetContext) {} + +// ExitCreate_as_target is called when production create_as_target is exited. +func (s *BaseRedshiftParserListener) ExitCreate_as_target(ctx *Create_as_targetContext) {} + +// EnterOpt_backup_clause_table_attributes is called when production opt_backup_clause_table_attributes is entered. +func (s *BaseRedshiftParserListener) EnterOpt_backup_clause_table_attributes(ctx *Opt_backup_clause_table_attributesContext) { +} + +// ExitOpt_backup_clause_table_attributes is called when production opt_backup_clause_table_attributes is exited. +func (s *BaseRedshiftParserListener) ExitOpt_backup_clause_table_attributes(ctx *Opt_backup_clause_table_attributesContext) { +} + +// EnterTable_attributes is called when production table_attributes is entered. +func (s *BaseRedshiftParserListener) EnterTable_attributes(ctx *Table_attributesContext) {} + +// ExitTable_attributes is called when production table_attributes is exited. +func (s *BaseRedshiftParserListener) ExitTable_attributes(ctx *Table_attributesContext) {} + +// EnterOpt_backup_clause is called when production opt_backup_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_backup_clause(ctx *Opt_backup_clauseContext) {} + +// ExitOpt_backup_clause is called when production opt_backup_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_backup_clause(ctx *Opt_backup_clauseContext) {} + +// EnterOpt_with_data is called when production opt_with_data is entered. +func (s *BaseRedshiftParserListener) EnterOpt_with_data(ctx *Opt_with_dataContext) {} + +// ExitOpt_with_data is called when production opt_with_data is exited. +func (s *BaseRedshiftParserListener) ExitOpt_with_data(ctx *Opt_with_dataContext) {} + +// EnterCreatematviewstmt is called when production creatematviewstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatematviewstmt(ctx *CreatematviewstmtContext) {} + +// ExitCreatematviewstmt is called when production creatematviewstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatematviewstmt(ctx *CreatematviewstmtContext) {} + +// EnterOpt_auto_refresh is called when production opt_auto_refresh is entered. +func (s *BaseRedshiftParserListener) EnterOpt_auto_refresh(ctx *Opt_auto_refreshContext) {} + +// ExitOpt_auto_refresh is called when production opt_auto_refresh is exited. +func (s *BaseRedshiftParserListener) ExitOpt_auto_refresh(ctx *Opt_auto_refreshContext) {} + +// EnterRefreshmatviewstmt is called when production refreshmatviewstmt is entered. +func (s *BaseRedshiftParserListener) EnterRefreshmatviewstmt(ctx *RefreshmatviewstmtContext) {} + +// ExitRefreshmatviewstmt is called when production refreshmatviewstmt is exited. +func (s *BaseRedshiftParserListener) ExitRefreshmatviewstmt(ctx *RefreshmatviewstmtContext) {} + +// EnterCreateseqstmt is called when production createseqstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateseqstmt(ctx *CreateseqstmtContext) {} + +// ExitCreateseqstmt is called when production createseqstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateseqstmt(ctx *CreateseqstmtContext) {} + +// EnterAlterseqstmt is called when production alterseqstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterseqstmt(ctx *AlterseqstmtContext) {} + +// ExitAlterseqstmt is called when production alterseqstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterseqstmt(ctx *AlterseqstmtContext) {} + +// EnterOptseqoptlist is called when production optseqoptlist is entered. +func (s *BaseRedshiftParserListener) EnterOptseqoptlist(ctx *OptseqoptlistContext) {} + +// ExitOptseqoptlist is called when production optseqoptlist is exited. +func (s *BaseRedshiftParserListener) ExitOptseqoptlist(ctx *OptseqoptlistContext) {} + +// EnterOptparenthesizedseqoptlist is called when production optparenthesizedseqoptlist is entered. +func (s *BaseRedshiftParserListener) EnterOptparenthesizedseqoptlist(ctx *OptparenthesizedseqoptlistContext) { +} + +// ExitOptparenthesizedseqoptlist is called when production optparenthesizedseqoptlist is exited. +func (s *BaseRedshiftParserListener) ExitOptparenthesizedseqoptlist(ctx *OptparenthesizedseqoptlistContext) { +} + +// EnterSeqoptlist is called when production seqoptlist is entered. +func (s *BaseRedshiftParserListener) EnterSeqoptlist(ctx *SeqoptlistContext) {} + +// ExitSeqoptlist is called when production seqoptlist is exited. +func (s *BaseRedshiftParserListener) ExitSeqoptlist(ctx *SeqoptlistContext) {} + +// EnterSeqoptelem is called when production seqoptelem is entered. +func (s *BaseRedshiftParserListener) EnterSeqoptelem(ctx *SeqoptelemContext) {} + +// ExitSeqoptelem is called when production seqoptelem is exited. +func (s *BaseRedshiftParserListener) ExitSeqoptelem(ctx *SeqoptelemContext) {} + +// EnterOpt_by is called when production opt_by is entered. +func (s *BaseRedshiftParserListener) EnterOpt_by(ctx *Opt_byContext) {} + +// ExitOpt_by is called when production opt_by is exited. +func (s *BaseRedshiftParserListener) ExitOpt_by(ctx *Opt_byContext) {} + +// EnterNumericonly is called when production numericonly is entered. +func (s *BaseRedshiftParserListener) EnterNumericonly(ctx *NumericonlyContext) {} + +// ExitNumericonly is called when production numericonly is exited. +func (s *BaseRedshiftParserListener) ExitNumericonly(ctx *NumericonlyContext) {} + +// EnterNumericonly_list is called when production numericonly_list is entered. +func (s *BaseRedshiftParserListener) EnterNumericonly_list(ctx *Numericonly_listContext) {} + +// ExitNumericonly_list is called when production numericonly_list is exited. +func (s *BaseRedshiftParserListener) ExitNumericonly_list(ctx *Numericonly_listContext) {} + +// EnterCreateplangstmt is called when production createplangstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateplangstmt(ctx *CreateplangstmtContext) {} + +// ExitCreateplangstmt is called when production createplangstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateplangstmt(ctx *CreateplangstmtContext) {} + +// EnterOpt_trusted is called when production opt_trusted is entered. +func (s *BaseRedshiftParserListener) EnterOpt_trusted(ctx *Opt_trustedContext) {} + +// ExitOpt_trusted is called when production opt_trusted is exited. +func (s *BaseRedshiftParserListener) ExitOpt_trusted(ctx *Opt_trustedContext) {} + +// EnterHandler_name is called when production handler_name is entered. +func (s *BaseRedshiftParserListener) EnterHandler_name(ctx *Handler_nameContext) {} + +// ExitHandler_name is called when production handler_name is exited. +func (s *BaseRedshiftParserListener) ExitHandler_name(ctx *Handler_nameContext) {} + +// EnterOpt_inline_handler is called when production opt_inline_handler is entered. +func (s *BaseRedshiftParserListener) EnterOpt_inline_handler(ctx *Opt_inline_handlerContext) {} + +// ExitOpt_inline_handler is called when production opt_inline_handler is exited. +func (s *BaseRedshiftParserListener) ExitOpt_inline_handler(ctx *Opt_inline_handlerContext) {} + +// EnterValidator_clause is called when production validator_clause is entered. +func (s *BaseRedshiftParserListener) EnterValidator_clause(ctx *Validator_clauseContext) {} + +// ExitValidator_clause is called when production validator_clause is exited. +func (s *BaseRedshiftParserListener) ExitValidator_clause(ctx *Validator_clauseContext) {} + +// EnterOpt_validator is called when production opt_validator is entered. +func (s *BaseRedshiftParserListener) EnterOpt_validator(ctx *Opt_validatorContext) {} + +// ExitOpt_validator is called when production opt_validator is exited. +func (s *BaseRedshiftParserListener) ExitOpt_validator(ctx *Opt_validatorContext) {} + +// EnterOpt_procedural is called when production opt_procedural is entered. +func (s *BaseRedshiftParserListener) EnterOpt_procedural(ctx *Opt_proceduralContext) {} + +// ExitOpt_procedural is called when production opt_procedural is exited. +func (s *BaseRedshiftParserListener) ExitOpt_procedural(ctx *Opt_proceduralContext) {} + +// EnterCreatetablespacestmt is called when production createtablespacestmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatetablespacestmt(ctx *CreatetablespacestmtContext) {} + +// ExitCreatetablespacestmt is called when production createtablespacestmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatetablespacestmt(ctx *CreatetablespacestmtContext) {} + +// EnterOpttablespaceowner is called when production opttablespaceowner is entered. +func (s *BaseRedshiftParserListener) EnterOpttablespaceowner(ctx *OpttablespaceownerContext) {} + +// ExitOpttablespaceowner is called when production opttablespaceowner is exited. +func (s *BaseRedshiftParserListener) ExitOpttablespaceowner(ctx *OpttablespaceownerContext) {} + +// EnterDroptablespacestmt is called when production droptablespacestmt is entered. +func (s *BaseRedshiftParserListener) EnterDroptablespacestmt(ctx *DroptablespacestmtContext) {} + +// ExitDroptablespacestmt is called when production droptablespacestmt is exited. +func (s *BaseRedshiftParserListener) ExitDroptablespacestmt(ctx *DroptablespacestmtContext) {} + +// EnterCreateextensionstmt is called when production createextensionstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateextensionstmt(ctx *CreateextensionstmtContext) {} + +// ExitCreateextensionstmt is called when production createextensionstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateextensionstmt(ctx *CreateextensionstmtContext) {} + +// EnterCreate_extension_opt_list is called when production create_extension_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterCreate_extension_opt_list(ctx *Create_extension_opt_listContext) { +} + +// ExitCreate_extension_opt_list is called when production create_extension_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitCreate_extension_opt_list(ctx *Create_extension_opt_listContext) { +} + +// EnterCreate_extension_opt_item is called when production create_extension_opt_item is entered. +func (s *BaseRedshiftParserListener) EnterCreate_extension_opt_item(ctx *Create_extension_opt_itemContext) { +} + +// ExitCreate_extension_opt_item is called when production create_extension_opt_item is exited. +func (s *BaseRedshiftParserListener) ExitCreate_extension_opt_item(ctx *Create_extension_opt_itemContext) { +} + +// EnterAlterextensionstmt is called when production alterextensionstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterextensionstmt(ctx *AlterextensionstmtContext) {} + +// ExitAlterextensionstmt is called when production alterextensionstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterextensionstmt(ctx *AlterextensionstmtContext) {} + +// EnterAlter_extension_opt_list is called when production alter_extension_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterAlter_extension_opt_list(ctx *Alter_extension_opt_listContext) { +} + +// ExitAlter_extension_opt_list is called when production alter_extension_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitAlter_extension_opt_list(ctx *Alter_extension_opt_listContext) { +} + +// EnterAlter_extension_opt_item is called when production alter_extension_opt_item is entered. +func (s *BaseRedshiftParserListener) EnterAlter_extension_opt_item(ctx *Alter_extension_opt_itemContext) { +} + +// ExitAlter_extension_opt_item is called when production alter_extension_opt_item is exited. +func (s *BaseRedshiftParserListener) ExitAlter_extension_opt_item(ctx *Alter_extension_opt_itemContext) { +} + +// EnterAlterextensioncontentsstmt is called when production alterextensioncontentsstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterextensioncontentsstmt(ctx *AlterextensioncontentsstmtContext) { +} + +// ExitAlterextensioncontentsstmt is called when production alterextensioncontentsstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterextensioncontentsstmt(ctx *AlterextensioncontentsstmtContext) { +} + +// EnterCreatefdwstmt is called when production createfdwstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatefdwstmt(ctx *CreatefdwstmtContext) {} + +// ExitCreatefdwstmt is called when production createfdwstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatefdwstmt(ctx *CreatefdwstmtContext) {} + +// EnterFdw_option is called when production fdw_option is entered. +func (s *BaseRedshiftParserListener) EnterFdw_option(ctx *Fdw_optionContext) {} + +// ExitFdw_option is called when production fdw_option is exited. +func (s *BaseRedshiftParserListener) ExitFdw_option(ctx *Fdw_optionContext) {} + +// EnterFdw_options is called when production fdw_options is entered. +func (s *BaseRedshiftParserListener) EnterFdw_options(ctx *Fdw_optionsContext) {} + +// ExitFdw_options is called when production fdw_options is exited. +func (s *BaseRedshiftParserListener) ExitFdw_options(ctx *Fdw_optionsContext) {} + +// EnterOpt_fdw_options is called when production opt_fdw_options is entered. +func (s *BaseRedshiftParserListener) EnterOpt_fdw_options(ctx *Opt_fdw_optionsContext) {} + +// ExitOpt_fdw_options is called when production opt_fdw_options is exited. +func (s *BaseRedshiftParserListener) ExitOpt_fdw_options(ctx *Opt_fdw_optionsContext) {} + +// EnterAlterfdwstmt is called when production alterfdwstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterfdwstmt(ctx *AlterfdwstmtContext) {} + +// ExitAlterfdwstmt is called when production alterfdwstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterfdwstmt(ctx *AlterfdwstmtContext) {} + +// EnterCreate_generic_options is called when production create_generic_options is entered. +func (s *BaseRedshiftParserListener) EnterCreate_generic_options(ctx *Create_generic_optionsContext) { +} + +// ExitCreate_generic_options is called when production create_generic_options is exited. +func (s *BaseRedshiftParserListener) ExitCreate_generic_options(ctx *Create_generic_optionsContext) {} + +// EnterGeneric_option_list is called when production generic_option_list is entered. +func (s *BaseRedshiftParserListener) EnterGeneric_option_list(ctx *Generic_option_listContext) {} + +// ExitGeneric_option_list is called when production generic_option_list is exited. +func (s *BaseRedshiftParserListener) ExitGeneric_option_list(ctx *Generic_option_listContext) {} + +// EnterAlter_generic_options is called when production alter_generic_options is entered. +func (s *BaseRedshiftParserListener) EnterAlter_generic_options(ctx *Alter_generic_optionsContext) {} + +// ExitAlter_generic_options is called when production alter_generic_options is exited. +func (s *BaseRedshiftParserListener) ExitAlter_generic_options(ctx *Alter_generic_optionsContext) {} + +// EnterAlter_generic_option_list is called when production alter_generic_option_list is entered. +func (s *BaseRedshiftParserListener) EnterAlter_generic_option_list(ctx *Alter_generic_option_listContext) { +} + +// ExitAlter_generic_option_list is called when production alter_generic_option_list is exited. +func (s *BaseRedshiftParserListener) ExitAlter_generic_option_list(ctx *Alter_generic_option_listContext) { +} + +// EnterAlter_generic_option_elem is called when production alter_generic_option_elem is entered. +func (s *BaseRedshiftParserListener) EnterAlter_generic_option_elem(ctx *Alter_generic_option_elemContext) { +} + +// ExitAlter_generic_option_elem is called when production alter_generic_option_elem is exited. +func (s *BaseRedshiftParserListener) ExitAlter_generic_option_elem(ctx *Alter_generic_option_elemContext) { +} + +// EnterGeneric_option_elem is called when production generic_option_elem is entered. +func (s *BaseRedshiftParserListener) EnterGeneric_option_elem(ctx *Generic_option_elemContext) {} + +// ExitGeneric_option_elem is called when production generic_option_elem is exited. +func (s *BaseRedshiftParserListener) ExitGeneric_option_elem(ctx *Generic_option_elemContext) {} + +// EnterGeneric_option_name is called when production generic_option_name is entered. +func (s *BaseRedshiftParserListener) EnterGeneric_option_name(ctx *Generic_option_nameContext) {} + +// ExitGeneric_option_name is called when production generic_option_name is exited. +func (s *BaseRedshiftParserListener) ExitGeneric_option_name(ctx *Generic_option_nameContext) {} + +// EnterGeneric_option_arg is called when production generic_option_arg is entered. +func (s *BaseRedshiftParserListener) EnterGeneric_option_arg(ctx *Generic_option_argContext) {} + +// ExitGeneric_option_arg is called when production generic_option_arg is exited. +func (s *BaseRedshiftParserListener) ExitGeneric_option_arg(ctx *Generic_option_argContext) {} + +// EnterCreateforeignserverstmt is called when production createforeignserverstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateforeignserverstmt(ctx *CreateforeignserverstmtContext) { +} + +// ExitCreateforeignserverstmt is called when production createforeignserverstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateforeignserverstmt(ctx *CreateforeignserverstmtContext) { +} + +// EnterOpt_type is called when production opt_type is entered. +func (s *BaseRedshiftParserListener) EnterOpt_type(ctx *Opt_typeContext) {} + +// ExitOpt_type is called when production opt_type is exited. +func (s *BaseRedshiftParserListener) ExitOpt_type(ctx *Opt_typeContext) {} + +// EnterForeign_server_version is called when production foreign_server_version is entered. +func (s *BaseRedshiftParserListener) EnterForeign_server_version(ctx *Foreign_server_versionContext) { +} + +// ExitForeign_server_version is called when production foreign_server_version is exited. +func (s *BaseRedshiftParserListener) ExitForeign_server_version(ctx *Foreign_server_versionContext) {} + +// EnterOpt_foreign_server_version is called when production opt_foreign_server_version is entered. +func (s *BaseRedshiftParserListener) EnterOpt_foreign_server_version(ctx *Opt_foreign_server_versionContext) { +} + +// ExitOpt_foreign_server_version is called when production opt_foreign_server_version is exited. +func (s *BaseRedshiftParserListener) ExitOpt_foreign_server_version(ctx *Opt_foreign_server_versionContext) { +} + +// EnterAlterforeignserverstmt is called when production alterforeignserverstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterforeignserverstmt(ctx *AlterforeignserverstmtContext) { +} + +// ExitAlterforeignserverstmt is called when production alterforeignserverstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterforeignserverstmt(ctx *AlterforeignserverstmtContext) {} + +// EnterCreateforeigntablestmt is called when production createforeigntablestmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateforeigntablestmt(ctx *CreateforeigntablestmtContext) { +} + +// ExitCreateforeigntablestmt is called when production createforeigntablestmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateforeigntablestmt(ctx *CreateforeigntablestmtContext) {} + +// EnterImportforeignschemastmt is called when production importforeignschemastmt is entered. +func (s *BaseRedshiftParserListener) EnterImportforeignschemastmt(ctx *ImportforeignschemastmtContext) { +} + +// ExitImportforeignschemastmt is called when production importforeignschemastmt is exited. +func (s *BaseRedshiftParserListener) ExitImportforeignschemastmt(ctx *ImportforeignschemastmtContext) { +} + +// EnterImport_qualification_type is called when production import_qualification_type is entered. +func (s *BaseRedshiftParserListener) EnterImport_qualification_type(ctx *Import_qualification_typeContext) { +} + +// ExitImport_qualification_type is called when production import_qualification_type is exited. +func (s *BaseRedshiftParserListener) ExitImport_qualification_type(ctx *Import_qualification_typeContext) { +} + +// EnterImport_qualification is called when production import_qualification is entered. +func (s *BaseRedshiftParserListener) EnterImport_qualification(ctx *Import_qualificationContext) {} + +// ExitImport_qualification is called when production import_qualification is exited. +func (s *BaseRedshiftParserListener) ExitImport_qualification(ctx *Import_qualificationContext) {} + +// EnterCreateusermappingstmt is called when production createusermappingstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateusermappingstmt(ctx *CreateusermappingstmtContext) {} + +// ExitCreateusermappingstmt is called when production createusermappingstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateusermappingstmt(ctx *CreateusermappingstmtContext) {} + +// EnterAuth_ident is called when production auth_ident is entered. +func (s *BaseRedshiftParserListener) EnterAuth_ident(ctx *Auth_identContext) {} + +// ExitAuth_ident is called when production auth_ident is exited. +func (s *BaseRedshiftParserListener) ExitAuth_ident(ctx *Auth_identContext) {} + +// EnterDropusermappingstmt is called when production dropusermappingstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropusermappingstmt(ctx *DropusermappingstmtContext) {} + +// ExitDropusermappingstmt is called when production dropusermappingstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropusermappingstmt(ctx *DropusermappingstmtContext) {} + +// EnterAlterusermappingstmt is called when production alterusermappingstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterusermappingstmt(ctx *AlterusermappingstmtContext) {} + +// ExitAlterusermappingstmt is called when production alterusermappingstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterusermappingstmt(ctx *AlterusermappingstmtContext) {} + +// EnterCreatepolicystmt is called when production createpolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatepolicystmt(ctx *CreatepolicystmtContext) {} + +// ExitCreatepolicystmt is called when production createpolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatepolicystmt(ctx *CreatepolicystmtContext) {} + +// EnterAlterpolicystmt is called when production alterpolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterpolicystmt(ctx *AlterpolicystmtContext) {} + +// ExitAlterpolicystmt is called when production alterpolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterpolicystmt(ctx *AlterpolicystmtContext) {} + +// EnterRowsecurityoptionalexpr is called when production rowsecurityoptionalexpr is entered. +func (s *BaseRedshiftParserListener) EnterRowsecurityoptionalexpr(ctx *RowsecurityoptionalexprContext) { +} + +// ExitRowsecurityoptionalexpr is called when production rowsecurityoptionalexpr is exited. +func (s *BaseRedshiftParserListener) ExitRowsecurityoptionalexpr(ctx *RowsecurityoptionalexprContext) { +} + +// EnterRowsecurityoptionalwithcheck is called when production rowsecurityoptionalwithcheck is entered. +func (s *BaseRedshiftParserListener) EnterRowsecurityoptionalwithcheck(ctx *RowsecurityoptionalwithcheckContext) { +} + +// ExitRowsecurityoptionalwithcheck is called when production rowsecurityoptionalwithcheck is exited. +func (s *BaseRedshiftParserListener) ExitRowsecurityoptionalwithcheck(ctx *RowsecurityoptionalwithcheckContext) { +} + +// EnterRowsecuritydefaulttorole is called when production rowsecuritydefaulttorole is entered. +func (s *BaseRedshiftParserListener) EnterRowsecuritydefaulttorole(ctx *RowsecuritydefaulttoroleContext) { +} + +// ExitRowsecuritydefaulttorole is called when production rowsecuritydefaulttorole is exited. +func (s *BaseRedshiftParserListener) ExitRowsecuritydefaulttorole(ctx *RowsecuritydefaulttoroleContext) { +} + +// EnterRowsecurityoptionaltorole is called when production rowsecurityoptionaltorole is entered. +func (s *BaseRedshiftParserListener) EnterRowsecurityoptionaltorole(ctx *RowsecurityoptionaltoroleContext) { +} + +// ExitRowsecurityoptionaltorole is called when production rowsecurityoptionaltorole is exited. +func (s *BaseRedshiftParserListener) ExitRowsecurityoptionaltorole(ctx *RowsecurityoptionaltoroleContext) { +} + +// EnterRowsecuritydefaultpermissive is called when production rowsecuritydefaultpermissive is entered. +func (s *BaseRedshiftParserListener) EnterRowsecuritydefaultpermissive(ctx *RowsecuritydefaultpermissiveContext) { +} + +// ExitRowsecuritydefaultpermissive is called when production rowsecuritydefaultpermissive is exited. +func (s *BaseRedshiftParserListener) ExitRowsecuritydefaultpermissive(ctx *RowsecuritydefaultpermissiveContext) { +} + +// EnterRowsecuritydefaultforcmd is called when production rowsecuritydefaultforcmd is entered. +func (s *BaseRedshiftParserListener) EnterRowsecuritydefaultforcmd(ctx *RowsecuritydefaultforcmdContext) { +} + +// ExitRowsecuritydefaultforcmd is called when production rowsecuritydefaultforcmd is exited. +func (s *BaseRedshiftParserListener) ExitRowsecuritydefaultforcmd(ctx *RowsecuritydefaultforcmdContext) { +} + +// EnterRow_security_cmd is called when production row_security_cmd is entered. +func (s *BaseRedshiftParserListener) EnterRow_security_cmd(ctx *Row_security_cmdContext) {} + +// ExitRow_security_cmd is called when production row_security_cmd is exited. +func (s *BaseRedshiftParserListener) ExitRow_security_cmd(ctx *Row_security_cmdContext) {} + +// EnterCreateamstmt is called when production createamstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateamstmt(ctx *CreateamstmtContext) {} + +// ExitCreateamstmt is called when production createamstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateamstmt(ctx *CreateamstmtContext) {} + +// EnterAm_type is called when production am_type is entered. +func (s *BaseRedshiftParserListener) EnterAm_type(ctx *Am_typeContext) {} + +// ExitAm_type is called when production am_type is exited. +func (s *BaseRedshiftParserListener) ExitAm_type(ctx *Am_typeContext) {} + +// EnterCreatetrigstmt is called when production createtrigstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatetrigstmt(ctx *CreatetrigstmtContext) {} + +// ExitCreatetrigstmt is called when production createtrigstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatetrigstmt(ctx *CreatetrigstmtContext) {} + +// EnterTriggeractiontime is called when production triggeractiontime is entered. +func (s *BaseRedshiftParserListener) EnterTriggeractiontime(ctx *TriggeractiontimeContext) {} + +// ExitTriggeractiontime is called when production triggeractiontime is exited. +func (s *BaseRedshiftParserListener) ExitTriggeractiontime(ctx *TriggeractiontimeContext) {} + +// EnterTriggerevents is called when production triggerevents is entered. +func (s *BaseRedshiftParserListener) EnterTriggerevents(ctx *TriggereventsContext) {} + +// ExitTriggerevents is called when production triggerevents is exited. +func (s *BaseRedshiftParserListener) ExitTriggerevents(ctx *TriggereventsContext) {} + +// EnterTriggeroneevent is called when production triggeroneevent is entered. +func (s *BaseRedshiftParserListener) EnterTriggeroneevent(ctx *TriggeroneeventContext) {} + +// ExitTriggeroneevent is called when production triggeroneevent is exited. +func (s *BaseRedshiftParserListener) ExitTriggeroneevent(ctx *TriggeroneeventContext) {} + +// EnterTriggerreferencing is called when production triggerreferencing is entered. +func (s *BaseRedshiftParserListener) EnterTriggerreferencing(ctx *TriggerreferencingContext) {} + +// ExitTriggerreferencing is called when production triggerreferencing is exited. +func (s *BaseRedshiftParserListener) ExitTriggerreferencing(ctx *TriggerreferencingContext) {} + +// EnterTriggertransitions is called when production triggertransitions is entered. +func (s *BaseRedshiftParserListener) EnterTriggertransitions(ctx *TriggertransitionsContext) {} + +// ExitTriggertransitions is called when production triggertransitions is exited. +func (s *BaseRedshiftParserListener) ExitTriggertransitions(ctx *TriggertransitionsContext) {} + +// EnterTriggertransition is called when production triggertransition is entered. +func (s *BaseRedshiftParserListener) EnterTriggertransition(ctx *TriggertransitionContext) {} + +// ExitTriggertransition is called when production triggertransition is exited. +func (s *BaseRedshiftParserListener) ExitTriggertransition(ctx *TriggertransitionContext) {} + +// EnterTransitionoldornew is called when production transitionoldornew is entered. +func (s *BaseRedshiftParserListener) EnterTransitionoldornew(ctx *TransitionoldornewContext) {} + +// ExitTransitionoldornew is called when production transitionoldornew is exited. +func (s *BaseRedshiftParserListener) ExitTransitionoldornew(ctx *TransitionoldornewContext) {} + +// EnterTransitionrowortable is called when production transitionrowortable is entered. +func (s *BaseRedshiftParserListener) EnterTransitionrowortable(ctx *TransitionrowortableContext) {} + +// ExitTransitionrowortable is called when production transitionrowortable is exited. +func (s *BaseRedshiftParserListener) ExitTransitionrowortable(ctx *TransitionrowortableContext) {} + +// EnterTransitionrelname is called when production transitionrelname is entered. +func (s *BaseRedshiftParserListener) EnterTransitionrelname(ctx *TransitionrelnameContext) {} + +// ExitTransitionrelname is called when production transitionrelname is exited. +func (s *BaseRedshiftParserListener) ExitTransitionrelname(ctx *TransitionrelnameContext) {} + +// EnterTriggerforspec is called when production triggerforspec is entered. +func (s *BaseRedshiftParserListener) EnterTriggerforspec(ctx *TriggerforspecContext) {} + +// ExitTriggerforspec is called when production triggerforspec is exited. +func (s *BaseRedshiftParserListener) ExitTriggerforspec(ctx *TriggerforspecContext) {} + +// EnterTriggerforopteach is called when production triggerforopteach is entered. +func (s *BaseRedshiftParserListener) EnterTriggerforopteach(ctx *TriggerforopteachContext) {} + +// ExitTriggerforopteach is called when production triggerforopteach is exited. +func (s *BaseRedshiftParserListener) ExitTriggerforopteach(ctx *TriggerforopteachContext) {} + +// EnterTriggerfortype is called when production triggerfortype is entered. +func (s *BaseRedshiftParserListener) EnterTriggerfortype(ctx *TriggerfortypeContext) {} + +// ExitTriggerfortype is called when production triggerfortype is exited. +func (s *BaseRedshiftParserListener) ExitTriggerfortype(ctx *TriggerfortypeContext) {} + +// EnterTriggerwhen is called when production triggerwhen is entered. +func (s *BaseRedshiftParserListener) EnterTriggerwhen(ctx *TriggerwhenContext) {} + +// ExitTriggerwhen is called when production triggerwhen is exited. +func (s *BaseRedshiftParserListener) ExitTriggerwhen(ctx *TriggerwhenContext) {} + +// EnterFunction_or_procedure is called when production function_or_procedure is entered. +func (s *BaseRedshiftParserListener) EnterFunction_or_procedure(ctx *Function_or_procedureContext) {} + +// ExitFunction_or_procedure is called when production function_or_procedure is exited. +func (s *BaseRedshiftParserListener) ExitFunction_or_procedure(ctx *Function_or_procedureContext) {} + +// EnterTriggerfuncargs is called when production triggerfuncargs is entered. +func (s *BaseRedshiftParserListener) EnterTriggerfuncargs(ctx *TriggerfuncargsContext) {} + +// ExitTriggerfuncargs is called when production triggerfuncargs is exited. +func (s *BaseRedshiftParserListener) ExitTriggerfuncargs(ctx *TriggerfuncargsContext) {} + +// EnterTriggerfuncarg is called when production triggerfuncarg is entered. +func (s *BaseRedshiftParserListener) EnterTriggerfuncarg(ctx *TriggerfuncargContext) {} + +// ExitTriggerfuncarg is called when production triggerfuncarg is exited. +func (s *BaseRedshiftParserListener) ExitTriggerfuncarg(ctx *TriggerfuncargContext) {} + +// EnterOptconstrfromtable is called when production optconstrfromtable is entered. +func (s *BaseRedshiftParserListener) EnterOptconstrfromtable(ctx *OptconstrfromtableContext) {} + +// ExitOptconstrfromtable is called when production optconstrfromtable is exited. +func (s *BaseRedshiftParserListener) ExitOptconstrfromtable(ctx *OptconstrfromtableContext) {} + +// EnterConstraintattributespec is called when production constraintattributespec is entered. +func (s *BaseRedshiftParserListener) EnterConstraintattributespec(ctx *ConstraintattributespecContext) { +} + +// ExitConstraintattributespec is called when production constraintattributespec is exited. +func (s *BaseRedshiftParserListener) ExitConstraintattributespec(ctx *ConstraintattributespecContext) { +} + +// EnterConstraintattributeElem is called when production constraintattributeElem is entered. +func (s *BaseRedshiftParserListener) EnterConstraintattributeElem(ctx *ConstraintattributeElemContext) { +} + +// ExitConstraintattributeElem is called when production constraintattributeElem is exited. +func (s *BaseRedshiftParserListener) ExitConstraintattributeElem(ctx *ConstraintattributeElemContext) { +} + +// EnterCreateeventtrigstmt is called when production createeventtrigstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateeventtrigstmt(ctx *CreateeventtrigstmtContext) {} + +// ExitCreateeventtrigstmt is called when production createeventtrigstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateeventtrigstmt(ctx *CreateeventtrigstmtContext) {} + +// EnterEvent_trigger_when_list is called when production event_trigger_when_list is entered. +func (s *BaseRedshiftParserListener) EnterEvent_trigger_when_list(ctx *Event_trigger_when_listContext) { +} + +// ExitEvent_trigger_when_list is called when production event_trigger_when_list is exited. +func (s *BaseRedshiftParserListener) ExitEvent_trigger_when_list(ctx *Event_trigger_when_listContext) { +} + +// EnterEvent_trigger_when_item is called when production event_trigger_when_item is entered. +func (s *BaseRedshiftParserListener) EnterEvent_trigger_when_item(ctx *Event_trigger_when_itemContext) { +} + +// ExitEvent_trigger_when_item is called when production event_trigger_when_item is exited. +func (s *BaseRedshiftParserListener) ExitEvent_trigger_when_item(ctx *Event_trigger_when_itemContext) { +} + +// EnterEvent_trigger_value_list is called when production event_trigger_value_list is entered. +func (s *BaseRedshiftParserListener) EnterEvent_trigger_value_list(ctx *Event_trigger_value_listContext) { +} + +// ExitEvent_trigger_value_list is called when production event_trigger_value_list is exited. +func (s *BaseRedshiftParserListener) ExitEvent_trigger_value_list(ctx *Event_trigger_value_listContext) { +} + +// EnterAltereventtrigstmt is called when production altereventtrigstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltereventtrigstmt(ctx *AltereventtrigstmtContext) {} + +// ExitAltereventtrigstmt is called when production altereventtrigstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltereventtrigstmt(ctx *AltereventtrigstmtContext) {} + +// EnterEnable_trigger is called when production enable_trigger is entered. +func (s *BaseRedshiftParserListener) EnterEnable_trigger(ctx *Enable_triggerContext) {} + +// ExitEnable_trigger is called when production enable_trigger is exited. +func (s *BaseRedshiftParserListener) ExitEnable_trigger(ctx *Enable_triggerContext) {} + +// EnterCreateassertionstmt is called when production createassertionstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateassertionstmt(ctx *CreateassertionstmtContext) {} + +// ExitCreateassertionstmt is called when production createassertionstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateassertionstmt(ctx *CreateassertionstmtContext) {} + +// EnterDefinestmt is called when production definestmt is entered. +func (s *BaseRedshiftParserListener) EnterDefinestmt(ctx *DefinestmtContext) {} + +// ExitDefinestmt is called when production definestmt is exited. +func (s *BaseRedshiftParserListener) ExitDefinestmt(ctx *DefinestmtContext) {} + +// EnterDefinition is called when production definition is entered. +func (s *BaseRedshiftParserListener) EnterDefinition(ctx *DefinitionContext) {} + +// ExitDefinition is called when production definition is exited. +func (s *BaseRedshiftParserListener) ExitDefinition(ctx *DefinitionContext) {} + +// EnterDef_list is called when production def_list is entered. +func (s *BaseRedshiftParserListener) EnterDef_list(ctx *Def_listContext) {} + +// ExitDef_list is called when production def_list is exited. +func (s *BaseRedshiftParserListener) ExitDef_list(ctx *Def_listContext) {} + +// EnterDef_elem is called when production def_elem is entered. +func (s *BaseRedshiftParserListener) EnterDef_elem(ctx *Def_elemContext) {} + +// ExitDef_elem is called when production def_elem is exited. +func (s *BaseRedshiftParserListener) ExitDef_elem(ctx *Def_elemContext) {} + +// EnterDef_arg is called when production def_arg is entered. +func (s *BaseRedshiftParserListener) EnterDef_arg(ctx *Def_argContext) {} + +// ExitDef_arg is called when production def_arg is exited. +func (s *BaseRedshiftParserListener) ExitDef_arg(ctx *Def_argContext) {} + +// EnterOld_aggr_definition is called when production old_aggr_definition is entered. +func (s *BaseRedshiftParserListener) EnterOld_aggr_definition(ctx *Old_aggr_definitionContext) {} + +// ExitOld_aggr_definition is called when production old_aggr_definition is exited. +func (s *BaseRedshiftParserListener) ExitOld_aggr_definition(ctx *Old_aggr_definitionContext) {} + +// EnterOld_aggr_list is called when production old_aggr_list is entered. +func (s *BaseRedshiftParserListener) EnterOld_aggr_list(ctx *Old_aggr_listContext) {} + +// ExitOld_aggr_list is called when production old_aggr_list is exited. +func (s *BaseRedshiftParserListener) ExitOld_aggr_list(ctx *Old_aggr_listContext) {} + +// EnterOld_aggr_elem is called when production old_aggr_elem is entered. +func (s *BaseRedshiftParserListener) EnterOld_aggr_elem(ctx *Old_aggr_elemContext) {} + +// ExitOld_aggr_elem is called when production old_aggr_elem is exited. +func (s *BaseRedshiftParserListener) ExitOld_aggr_elem(ctx *Old_aggr_elemContext) {} + +// EnterOpt_enum_val_list is called when production opt_enum_val_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_enum_val_list(ctx *Opt_enum_val_listContext) {} + +// ExitOpt_enum_val_list is called when production opt_enum_val_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_enum_val_list(ctx *Opt_enum_val_listContext) {} + +// EnterEnum_val_list is called when production enum_val_list is entered. +func (s *BaseRedshiftParserListener) EnterEnum_val_list(ctx *Enum_val_listContext) {} + +// ExitEnum_val_list is called when production enum_val_list is exited. +func (s *BaseRedshiftParserListener) ExitEnum_val_list(ctx *Enum_val_listContext) {} + +// EnterAlterenumstmt is called when production alterenumstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterenumstmt(ctx *AlterenumstmtContext) {} + +// ExitAlterenumstmt is called when production alterenumstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterenumstmt(ctx *AlterenumstmtContext) {} + +// EnterOpt_if_not_exists is called when production opt_if_not_exists is entered. +func (s *BaseRedshiftParserListener) EnterOpt_if_not_exists(ctx *Opt_if_not_existsContext) {} + +// ExitOpt_if_not_exists is called when production opt_if_not_exists is exited. +func (s *BaseRedshiftParserListener) ExitOpt_if_not_exists(ctx *Opt_if_not_existsContext) {} + +// EnterCreateopclassstmt is called when production createopclassstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateopclassstmt(ctx *CreateopclassstmtContext) {} + +// ExitCreateopclassstmt is called when production createopclassstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateopclassstmt(ctx *CreateopclassstmtContext) {} + +// EnterOpclass_item_list is called when production opclass_item_list is entered. +func (s *BaseRedshiftParserListener) EnterOpclass_item_list(ctx *Opclass_item_listContext) {} + +// ExitOpclass_item_list is called when production opclass_item_list is exited. +func (s *BaseRedshiftParserListener) ExitOpclass_item_list(ctx *Opclass_item_listContext) {} + +// EnterOpclass_item is called when production opclass_item is entered. +func (s *BaseRedshiftParserListener) EnterOpclass_item(ctx *Opclass_itemContext) {} + +// ExitOpclass_item is called when production opclass_item is exited. +func (s *BaseRedshiftParserListener) ExitOpclass_item(ctx *Opclass_itemContext) {} + +// EnterOpt_default is called when production opt_default is entered. +func (s *BaseRedshiftParserListener) EnterOpt_default(ctx *Opt_defaultContext) {} + +// ExitOpt_default is called when production opt_default is exited. +func (s *BaseRedshiftParserListener) ExitOpt_default(ctx *Opt_defaultContext) {} + +// EnterOpt_opfamily is called when production opt_opfamily is entered. +func (s *BaseRedshiftParserListener) EnterOpt_opfamily(ctx *Opt_opfamilyContext) {} + +// ExitOpt_opfamily is called when production opt_opfamily is exited. +func (s *BaseRedshiftParserListener) ExitOpt_opfamily(ctx *Opt_opfamilyContext) {} + +// EnterOpclass_purpose is called when production opclass_purpose is entered. +func (s *BaseRedshiftParserListener) EnterOpclass_purpose(ctx *Opclass_purposeContext) {} + +// ExitOpclass_purpose is called when production opclass_purpose is exited. +func (s *BaseRedshiftParserListener) ExitOpclass_purpose(ctx *Opclass_purposeContext) {} + +// EnterOpt_recheck is called when production opt_recheck is entered. +func (s *BaseRedshiftParserListener) EnterOpt_recheck(ctx *Opt_recheckContext) {} + +// ExitOpt_recheck is called when production opt_recheck is exited. +func (s *BaseRedshiftParserListener) ExitOpt_recheck(ctx *Opt_recheckContext) {} + +// EnterCreateopfamilystmt is called when production createopfamilystmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateopfamilystmt(ctx *CreateopfamilystmtContext) {} + +// ExitCreateopfamilystmt is called when production createopfamilystmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateopfamilystmt(ctx *CreateopfamilystmtContext) {} + +// EnterAlteropfamilystmt is called when production alteropfamilystmt is entered. +func (s *BaseRedshiftParserListener) EnterAlteropfamilystmt(ctx *AlteropfamilystmtContext) {} + +// ExitAlteropfamilystmt is called when production alteropfamilystmt is exited. +func (s *BaseRedshiftParserListener) ExitAlteropfamilystmt(ctx *AlteropfamilystmtContext) {} + +// EnterOpclass_drop_list is called when production opclass_drop_list is entered. +func (s *BaseRedshiftParserListener) EnterOpclass_drop_list(ctx *Opclass_drop_listContext) {} + +// ExitOpclass_drop_list is called when production opclass_drop_list is exited. +func (s *BaseRedshiftParserListener) ExitOpclass_drop_list(ctx *Opclass_drop_listContext) {} + +// EnterOpclass_drop is called when production opclass_drop is entered. +func (s *BaseRedshiftParserListener) EnterOpclass_drop(ctx *Opclass_dropContext) {} + +// ExitOpclass_drop is called when production opclass_drop is exited. +func (s *BaseRedshiftParserListener) ExitOpclass_drop(ctx *Opclass_dropContext) {} + +// EnterDropopclassstmt is called when production dropopclassstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropopclassstmt(ctx *DropopclassstmtContext) {} + +// ExitDropopclassstmt is called when production dropopclassstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropopclassstmt(ctx *DropopclassstmtContext) {} + +// EnterDropopfamilystmt is called when production dropopfamilystmt is entered. +func (s *BaseRedshiftParserListener) EnterDropopfamilystmt(ctx *DropopfamilystmtContext) {} + +// ExitDropopfamilystmt is called when production dropopfamilystmt is exited. +func (s *BaseRedshiftParserListener) ExitDropopfamilystmt(ctx *DropopfamilystmtContext) {} + +// EnterDropownedstmt is called when production dropownedstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropownedstmt(ctx *DropownedstmtContext) {} + +// ExitDropownedstmt is called when production dropownedstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropownedstmt(ctx *DropownedstmtContext) {} + +// EnterReassignownedstmt is called when production reassignownedstmt is entered. +func (s *BaseRedshiftParserListener) EnterReassignownedstmt(ctx *ReassignownedstmtContext) {} + +// ExitReassignownedstmt is called when production reassignownedstmt is exited. +func (s *BaseRedshiftParserListener) ExitReassignownedstmt(ctx *ReassignownedstmtContext) {} + +// EnterDropstmt is called when production dropstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropstmt(ctx *DropstmtContext) {} + +// ExitDropstmt is called when production dropstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropstmt(ctx *DropstmtContext) {} + +// EnterObject_type_any_name is called when production object_type_any_name is entered. +func (s *BaseRedshiftParserListener) EnterObject_type_any_name(ctx *Object_type_any_nameContext) {} + +// ExitObject_type_any_name is called when production object_type_any_name is exited. +func (s *BaseRedshiftParserListener) ExitObject_type_any_name(ctx *Object_type_any_nameContext) {} + +// EnterObject_type_name is called when production object_type_name is entered. +func (s *BaseRedshiftParserListener) EnterObject_type_name(ctx *Object_type_nameContext) {} + +// ExitObject_type_name is called when production object_type_name is exited. +func (s *BaseRedshiftParserListener) ExitObject_type_name(ctx *Object_type_nameContext) {} + +// EnterDrop_type_name is called when production drop_type_name is entered. +func (s *BaseRedshiftParserListener) EnterDrop_type_name(ctx *Drop_type_nameContext) {} + +// ExitDrop_type_name is called when production drop_type_name is exited. +func (s *BaseRedshiftParserListener) ExitDrop_type_name(ctx *Drop_type_nameContext) {} + +// EnterObject_type_name_on_any_name is called when production object_type_name_on_any_name is entered. +func (s *BaseRedshiftParserListener) EnterObject_type_name_on_any_name(ctx *Object_type_name_on_any_nameContext) { +} + +// ExitObject_type_name_on_any_name is called when production object_type_name_on_any_name is exited. +func (s *BaseRedshiftParserListener) ExitObject_type_name_on_any_name(ctx *Object_type_name_on_any_nameContext) { +} + +// EnterAny_name_list is called when production any_name_list is entered. +func (s *BaseRedshiftParserListener) EnterAny_name_list(ctx *Any_name_listContext) {} + +// ExitAny_name_list is called when production any_name_list is exited. +func (s *BaseRedshiftParserListener) ExitAny_name_list(ctx *Any_name_listContext) {} + +// EnterAny_name is called when production any_name is entered. +func (s *BaseRedshiftParserListener) EnterAny_name(ctx *Any_nameContext) {} + +// ExitAny_name is called when production any_name is exited. +func (s *BaseRedshiftParserListener) ExitAny_name(ctx *Any_nameContext) {} + +// EnterAttrs is called when production attrs is entered. +func (s *BaseRedshiftParserListener) EnterAttrs(ctx *AttrsContext) {} + +// ExitAttrs is called when production attrs is exited. +func (s *BaseRedshiftParserListener) ExitAttrs(ctx *AttrsContext) {} + +// EnterType_name_list is called when production type_name_list is entered. +func (s *BaseRedshiftParserListener) EnterType_name_list(ctx *Type_name_listContext) {} + +// ExitType_name_list is called when production type_name_list is exited. +func (s *BaseRedshiftParserListener) ExitType_name_list(ctx *Type_name_listContext) {} + +// EnterTruncatestmt is called when production truncatestmt is entered. +func (s *BaseRedshiftParserListener) EnterTruncatestmt(ctx *TruncatestmtContext) {} + +// ExitTruncatestmt is called when production truncatestmt is exited. +func (s *BaseRedshiftParserListener) ExitTruncatestmt(ctx *TruncatestmtContext) {} + +// EnterOpt_restart_seqs is called when production opt_restart_seqs is entered. +func (s *BaseRedshiftParserListener) EnterOpt_restart_seqs(ctx *Opt_restart_seqsContext) {} + +// ExitOpt_restart_seqs is called when production opt_restart_seqs is exited. +func (s *BaseRedshiftParserListener) ExitOpt_restart_seqs(ctx *Opt_restart_seqsContext) {} + +// EnterCommentstmt is called when production commentstmt is entered. +func (s *BaseRedshiftParserListener) EnterCommentstmt(ctx *CommentstmtContext) {} + +// ExitCommentstmt is called when production commentstmt is exited. +func (s *BaseRedshiftParserListener) ExitCommentstmt(ctx *CommentstmtContext) {} + +// EnterComment_text is called when production comment_text is entered. +func (s *BaseRedshiftParserListener) EnterComment_text(ctx *Comment_textContext) {} + +// ExitComment_text is called when production comment_text is exited. +func (s *BaseRedshiftParserListener) ExitComment_text(ctx *Comment_textContext) {} + +// EnterSeclabelstmt is called when production seclabelstmt is entered. +func (s *BaseRedshiftParserListener) EnterSeclabelstmt(ctx *SeclabelstmtContext) {} + +// ExitSeclabelstmt is called when production seclabelstmt is exited. +func (s *BaseRedshiftParserListener) ExitSeclabelstmt(ctx *SeclabelstmtContext) {} + +// EnterOpt_provider is called when production opt_provider is entered. +func (s *BaseRedshiftParserListener) EnterOpt_provider(ctx *Opt_providerContext) {} + +// ExitOpt_provider is called when production opt_provider is exited. +func (s *BaseRedshiftParserListener) ExitOpt_provider(ctx *Opt_providerContext) {} + +// EnterSecurity_label is called when production security_label is entered. +func (s *BaseRedshiftParserListener) EnterSecurity_label(ctx *Security_labelContext) {} + +// ExitSecurity_label is called when production security_label is exited. +func (s *BaseRedshiftParserListener) ExitSecurity_label(ctx *Security_labelContext) {} + +// EnterFetchstmt is called when production fetchstmt is entered. +func (s *BaseRedshiftParserListener) EnterFetchstmt(ctx *FetchstmtContext) {} + +// ExitFetchstmt is called when production fetchstmt is exited. +func (s *BaseRedshiftParserListener) ExitFetchstmt(ctx *FetchstmtContext) {} + +// EnterFetch_args is called when production fetch_args is entered. +func (s *BaseRedshiftParserListener) EnterFetch_args(ctx *Fetch_argsContext) {} + +// ExitFetch_args is called when production fetch_args is exited. +func (s *BaseRedshiftParserListener) ExitFetch_args(ctx *Fetch_argsContext) {} + +// EnterGrantstmt is called when production grantstmt is entered. +func (s *BaseRedshiftParserListener) EnterGrantstmt(ctx *GrantstmtContext) {} + +// ExitGrantstmt is called when production grantstmt is exited. +func (s *BaseRedshiftParserListener) ExitGrantstmt(ctx *GrantstmtContext) {} + +// EnterGrant_permissions_for_rls_lookup_tables is called when production grant_permissions_for_rls_lookup_tables is entered. +func (s *BaseRedshiftParserListener) EnterGrant_permissions_for_rls_lookup_tables(ctx *Grant_permissions_for_rls_lookup_tablesContext) { +} + +// ExitGrant_permissions_for_rls_lookup_tables is called when production grant_permissions_for_rls_lookup_tables is exited. +func (s *BaseRedshiftParserListener) ExitGrant_permissions_for_rls_lookup_tables(ctx *Grant_permissions_for_rls_lookup_tablesContext) { +} + +// EnterGrant_explain_permissions_for_row_level_security_policy_filters is called when production grant_explain_permissions_for_row_level_security_policy_filters is entered. +func (s *BaseRedshiftParserListener) EnterGrant_explain_permissions_for_row_level_security_policy_filters(ctx *Grant_explain_permissions_for_row_level_security_policy_filtersContext) { +} + +// ExitGrant_explain_permissions_for_row_level_security_policy_filters is called when production grant_explain_permissions_for_row_level_security_policy_filters is exited. +func (s *BaseRedshiftParserListener) ExitGrant_explain_permissions_for_row_level_security_policy_filters(ctx *Grant_explain_permissions_for_row_level_security_policy_filtersContext) { +} + +// EnterGrant_machine_learning_permissions is called when production grant_machine_learning_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_machine_learning_permissions(ctx *Grant_machine_learning_permissionsContext) { +} + +// ExitGrant_machine_learning_permissions is called when production grant_machine_learning_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_machine_learning_permissions(ctx *Grant_machine_learning_permissionsContext) { +} + +// EnterGrant_role_permissions is called when production grant_role_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_role_permissions(ctx *Grant_role_permissionsContext) { +} + +// ExitGrant_role_permissions is called when production grant_role_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_role_permissions(ctx *Grant_role_permissionsContext) {} + +// EnterGrant_role_permission_target_list is called when production grant_role_permission_target_list is entered. +func (s *BaseRedshiftParserListener) EnterGrant_role_permission_target_list(ctx *Grant_role_permission_target_listContext) { +} + +// ExitGrant_role_permission_target_list is called when production grant_role_permission_target_list is exited. +func (s *BaseRedshiftParserListener) ExitGrant_role_permission_target_list(ctx *Grant_role_permission_target_listContext) { +} + +// EnterGrant_role_permission_target_list_item is called when production grant_role_permission_target_list_item is entered. +func (s *BaseRedshiftParserListener) EnterGrant_role_permission_target_list_item(ctx *Grant_role_permission_target_list_itemContext) { +} + +// ExitGrant_role_permission_target_list_item is called when production grant_role_permission_target_list_item is exited. +func (s *BaseRedshiftParserListener) ExitGrant_role_permission_target_list_item(ctx *Grant_role_permission_target_list_itemContext) { +} + +// EnterSystem_permissions is called when production system_permissions is entered. +func (s *BaseRedshiftParserListener) EnterSystem_permissions(ctx *System_permissionsContext) {} + +// ExitSystem_permissions is called when production system_permissions is exited. +func (s *BaseRedshiftParserListener) ExitSystem_permissions(ctx *System_permissionsContext) {} + +// EnterSystem_permissions_item is called when production system_permissions_item is entered. +func (s *BaseRedshiftParserListener) EnterSystem_permissions_item(ctx *System_permissions_itemContext) { +} + +// ExitSystem_permissions_item is called when production system_permissions_item is exited. +func (s *BaseRedshiftParserListener) ExitSystem_permissions_item(ctx *System_permissions_itemContext) { +} + +// EnterOpt_with_admin_option is called when production opt_with_admin_option is entered. +func (s *BaseRedshiftParserListener) EnterOpt_with_admin_option(ctx *Opt_with_admin_optionContext) {} + +// ExitOpt_with_admin_option is called when production opt_with_admin_option is exited. +func (s *BaseRedshiftParserListener) ExitOpt_with_admin_option(ctx *Opt_with_admin_optionContext) {} + +// EnterGrant_scoped_permissions is called when production grant_scoped_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_scoped_permissions(ctx *Grant_scoped_permissionsContext) { +} + +// ExitGrant_scoped_permissions is called when production grant_scoped_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_scoped_permissions(ctx *Grant_scoped_permissionsContext) { +} + +// EnterGrant_scoped_schemas_permissions is called when production grant_scoped_schemas_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_scoped_schemas_permissions(ctx *Grant_scoped_schemas_permissionsContext) { +} + +// ExitGrant_scoped_schemas_permissions is called when production grant_scoped_schemas_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_scoped_schemas_permissions(ctx *Grant_scoped_schemas_permissionsContext) { +} + +// EnterGrant_scoped_tables_permissions is called when production grant_scoped_tables_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_scoped_tables_permissions(ctx *Grant_scoped_tables_permissionsContext) { +} + +// ExitGrant_scoped_tables_permissions is called when production grant_scoped_tables_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_scoped_tables_permissions(ctx *Grant_scoped_tables_permissionsContext) { +} + +// EnterGrant_scoped_functions_permissions is called when production grant_scoped_functions_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_scoped_functions_permissions(ctx *Grant_scoped_functions_permissionsContext) { +} + +// ExitGrant_scoped_functions_permissions is called when production grant_scoped_functions_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_scoped_functions_permissions(ctx *Grant_scoped_functions_permissionsContext) { +} + +// EnterGrant_scoped_procedures_permissions is called when production grant_scoped_procedures_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_scoped_procedures_permissions(ctx *Grant_scoped_procedures_permissionsContext) { +} + +// ExitGrant_scoped_procedures_permissions is called when production grant_scoped_procedures_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_scoped_procedures_permissions(ctx *Grant_scoped_procedures_permissionsContext) { +} + +// EnterGrant_scoped_languages_permissions is called when production grant_scoped_languages_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_scoped_languages_permissions(ctx *Grant_scoped_languages_permissionsContext) { +} + +// ExitGrant_scoped_languages_permissions is called when production grant_scoped_languages_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_scoped_languages_permissions(ctx *Grant_scoped_languages_permissionsContext) { +} + +// EnterGrant_scoped_copy_jobs_permissions is called when production grant_scoped_copy_jobs_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_scoped_copy_jobs_permissions(ctx *Grant_scoped_copy_jobs_permissionsContext) { +} + +// ExitGrant_scoped_copy_jobs_permissions is called when production grant_scoped_copy_jobs_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_scoped_copy_jobs_permissions(ctx *Grant_scoped_copy_jobs_permissionsContext) { +} + +// EnterGrantee_list_without_public is called when production grantee_list_without_public is entered. +func (s *BaseRedshiftParserListener) EnterGrantee_list_without_public(ctx *Grantee_list_without_publicContext) { +} + +// ExitGrantee_list_without_public is called when production grantee_list_without_public is exited. +func (s *BaseRedshiftParserListener) ExitGrantee_list_without_public(ctx *Grantee_list_without_publicContext) { +} + +// EnterGrantee_without_public is called when production grantee_without_public is entered. +func (s *BaseRedshiftParserListener) EnterGrantee_without_public(ctx *Grantee_without_publicContext) { +} + +// ExitGrantee_without_public is called when production grantee_without_public is exited. +func (s *BaseRedshiftParserListener) ExitGrantee_without_public(ctx *Grantee_without_publicContext) {} + +// EnterGrant_datashare_permissions is called when production grant_datashare_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_datashare_permissions(ctx *Grant_datashare_permissionsContext) { +} + +// ExitGrant_datashare_permissions is called when production grant_datashare_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_datashare_permissions(ctx *Grant_datashare_permissionsContext) { +} + +// EnterGrant_spectrum_integration_permissions is called when production grant_spectrum_integration_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_spectrum_integration_permissions(ctx *Grant_spectrum_integration_permissionsContext) { +} + +// ExitGrant_spectrum_integration_permissions is called when production grant_spectrum_integration_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_spectrum_integration_permissions(ctx *Grant_spectrum_integration_permissionsContext) { +} + +// EnterGrant_spectrum_integration_external_schema_permissions is called when production grant_spectrum_integration_external_schema_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_spectrum_integration_external_schema_permissions(ctx *Grant_spectrum_integration_external_schema_permissionsContext) { +} + +// ExitGrant_spectrum_integration_external_schema_permissions is called when production grant_spectrum_integration_external_schema_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_spectrum_integration_external_schema_permissions(ctx *Grant_spectrum_integration_external_schema_permissionsContext) { +} + +// EnterSpectrum_integration_external_schema_permission_list is called when production spectrum_integration_external_schema_permission_list is entered. +func (s *BaseRedshiftParserListener) EnterSpectrum_integration_external_schema_permission_list(ctx *Spectrum_integration_external_schema_permission_listContext) { +} + +// ExitSpectrum_integration_external_schema_permission_list is called when production spectrum_integration_external_schema_permission_list is exited. +func (s *BaseRedshiftParserListener) ExitSpectrum_integration_external_schema_permission_list(ctx *Spectrum_integration_external_schema_permission_listContext) { +} + +// EnterSpectrum_integration_external_schema_permission is called when production spectrum_integration_external_schema_permission is entered. +func (s *BaseRedshiftParserListener) EnterSpectrum_integration_external_schema_permission(ctx *Spectrum_integration_external_schema_permissionContext) { +} + +// ExitSpectrum_integration_external_schema_permission is called when production spectrum_integration_external_schema_permission is exited. +func (s *BaseRedshiftParserListener) ExitSpectrum_integration_external_schema_permission(ctx *Spectrum_integration_external_schema_permissionContext) { +} + +// EnterGrant_spectrum_integration_external_table_permissions is called when production grant_spectrum_integration_external_table_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_spectrum_integration_external_table_permissions(ctx *Grant_spectrum_integration_external_table_permissionsContext) { +} + +// ExitGrant_spectrum_integration_external_table_permissions is called when production grant_spectrum_integration_external_table_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_spectrum_integration_external_table_permissions(ctx *Grant_spectrum_integration_external_table_permissionsContext) { +} + +// EnterSpectrum_integration_external_table_permission is called when production spectrum_integration_external_table_permission is entered. +func (s *BaseRedshiftParserListener) EnterSpectrum_integration_external_table_permission(ctx *Spectrum_integration_external_table_permissionContext) { +} + +// ExitSpectrum_integration_external_table_permission is called when production spectrum_integration_external_table_permission is exited. +func (s *BaseRedshiftParserListener) ExitSpectrum_integration_external_table_permission(ctx *Spectrum_integration_external_table_permissionContext) { +} + +// EnterSpectrum_integration_external_table_permission_list is called when production spectrum_integration_external_table_permission_list is entered. +func (s *BaseRedshiftParserListener) EnterSpectrum_integration_external_table_permission_list(ctx *Spectrum_integration_external_table_permission_listContext) { +} + +// ExitSpectrum_integration_external_table_permission_list is called when production spectrum_integration_external_table_permission_list is exited. +func (s *BaseRedshiftParserListener) ExitSpectrum_integration_external_table_permission_list(ctx *Spectrum_integration_external_table_permission_listContext) { +} + +// EnterGrant_spectrum_integration_extenral_column_permissions is called when production grant_spectrum_integration_extenral_column_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_spectrum_integration_extenral_column_permissions(ctx *Grant_spectrum_integration_extenral_column_permissionsContext) { +} + +// ExitGrant_spectrum_integration_extenral_column_permissions is called when production grant_spectrum_integration_extenral_column_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_spectrum_integration_extenral_column_permissions(ctx *Grant_spectrum_integration_extenral_column_permissionsContext) { +} + +// EnterIamrolelist_or_public is called when production iamrolelist_or_public is entered. +func (s *BaseRedshiftParserListener) EnterIamrolelist_or_public(ctx *Iamrolelist_or_publicContext) {} + +// ExitIamrolelist_or_public is called when production iamrolelist_or_public is exited. +func (s *BaseRedshiftParserListener) ExitIamrolelist_or_public(ctx *Iamrolelist_or_publicContext) {} + +// EnterIamrolelist is called when production iamrolelist is entered. +func (s *BaseRedshiftParserListener) EnterIamrolelist(ctx *IamrolelistContext) {} + +// ExitIamrolelist is called when production iamrolelist is exited. +func (s *BaseRedshiftParserListener) ExitIamrolelist(ctx *IamrolelistContext) {} + +// EnterGrant_assume_role_permissions is called when production grant_assume_role_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_assume_role_permissions(ctx *Grant_assume_role_permissionsContext) { +} + +// ExitGrant_assume_role_permissions is called when production grant_assume_role_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_assume_role_permissions(ctx *Grant_assume_role_permissionsContext) { +} + +// EnterGrant_assume_role_for_list is called when production grant_assume_role_for_list is entered. +func (s *BaseRedshiftParserListener) EnterGrant_assume_role_for_list(ctx *Grant_assume_role_for_listContext) { +} + +// ExitGrant_assume_role_for_list is called when production grant_assume_role_for_list is exited. +func (s *BaseRedshiftParserListener) ExitGrant_assume_role_for_list(ctx *Grant_assume_role_for_listContext) { +} + +// EnterGrant_assume_role_for_item is called when production grant_assume_role_for_item is entered. +func (s *BaseRedshiftParserListener) EnterGrant_assume_role_for_item(ctx *Grant_assume_role_for_itemContext) { +} + +// ExitGrant_assume_role_for_item is called when production grant_assume_role_for_item is exited. +func (s *BaseRedshiftParserListener) ExitGrant_assume_role_for_item(ctx *Grant_assume_role_for_itemContext) { +} + +// EnterGrant_assume_role_target is called when production grant_assume_role_target is entered. +func (s *BaseRedshiftParserListener) EnterGrant_assume_role_target(ctx *Grant_assume_role_targetContext) { +} + +// ExitGrant_assume_role_target is called when production grant_assume_role_target is exited. +func (s *BaseRedshiftParserListener) ExitGrant_assume_role_target(ctx *Grant_assume_role_targetContext) { +} + +// EnterGrant_column_level_permissions is called when production grant_column_level_permissions is entered. +func (s *BaseRedshiftParserListener) EnterGrant_column_level_permissions(ctx *Grant_column_level_permissionsContext) { +} + +// ExitGrant_column_level_permissions is called when production grant_column_level_permissions is exited. +func (s *BaseRedshiftParserListener) ExitGrant_column_level_permissions(ctx *Grant_column_level_permissionsContext) { +} + +// EnterColumn_privilege_target is called when production column_privilege_target is entered. +func (s *BaseRedshiftParserListener) EnterColumn_privilege_target(ctx *Column_privilege_targetContext) { +} + +// ExitColumn_privilege_target is called when production column_privilege_target is exited. +func (s *BaseRedshiftParserListener) ExitColumn_privilege_target(ctx *Column_privilege_targetContext) { +} + +// EnterColumn_privilege_list is called when production column_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterColumn_privilege_list(ctx *Column_privilege_listContext) {} + +// ExitColumn_privilege_list is called when production column_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitColumn_privilege_list(ctx *Column_privilege_listContext) {} + +// EnterColumn_all_privilege is called when production column_all_privilege is entered. +func (s *BaseRedshiftParserListener) EnterColumn_all_privilege(ctx *Column_all_privilegeContext) {} + +// ExitColumn_all_privilege is called when production column_all_privilege is exited. +func (s *BaseRedshiftParserListener) ExitColumn_all_privilege(ctx *Column_all_privilegeContext) {} + +// EnterColumn_select_update_privilege is called when production column_select_update_privilege is entered. +func (s *BaseRedshiftParserListener) EnterColumn_select_update_privilege(ctx *Column_select_update_privilegeContext) { +} + +// ExitColumn_select_update_privilege is called when production column_select_update_privilege is exited. +func (s *BaseRedshiftParserListener) ExitColumn_select_update_privilege(ctx *Column_select_update_privilegeContext) { +} + +// EnterCommon_grant is called when production common_grant is entered. +func (s *BaseRedshiftParserListener) EnterCommon_grant(ctx *Common_grantContext) {} + +// ExitCommon_grant is called when production common_grant is exited. +func (s *BaseRedshiftParserListener) ExitCommon_grant(ctx *Common_grantContext) {} + +// EnterCopy_job_privilege_list is called when production copy_job_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterCopy_job_privilege_list(ctx *Copy_job_privilege_listContext) { +} + +// ExitCopy_job_privilege_list is called when production copy_job_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitCopy_job_privilege_list(ctx *Copy_job_privilege_listContext) { +} + +// EnterCopy_job_privilege is called when production copy_job_privilege is entered. +func (s *BaseRedshiftParserListener) EnterCopy_job_privilege(ctx *Copy_job_privilegeContext) {} + +// ExitCopy_job_privilege is called when production copy_job_privilege is exited. +func (s *BaseRedshiftParserListener) ExitCopy_job_privilege(ctx *Copy_job_privilegeContext) {} + +// EnterCopy_job_target is called when production copy_job_target is entered. +func (s *BaseRedshiftParserListener) EnterCopy_job_target(ctx *Copy_job_targetContext) {} + +// ExitCopy_job_target is called when production copy_job_target is exited. +func (s *BaseRedshiftParserListener) ExitCopy_job_target(ctx *Copy_job_targetContext) {} + +// EnterCopy_job_name is called when production copy_job_name is entered. +func (s *BaseRedshiftParserListener) EnterCopy_job_name(ctx *Copy_job_nameContext) {} + +// ExitCopy_job_name is called when production copy_job_name is exited. +func (s *BaseRedshiftParserListener) ExitCopy_job_name(ctx *Copy_job_nameContext) {} + +// EnterLanguage_privilege_list is called when production language_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterLanguage_privilege_list(ctx *Language_privilege_listContext) { +} + +// ExitLanguage_privilege_list is called when production language_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitLanguage_privilege_list(ctx *Language_privilege_listContext) { +} + +// EnterGrant_language_target is called when production grant_language_target is entered. +func (s *BaseRedshiftParserListener) EnterGrant_language_target(ctx *Grant_language_targetContext) {} + +// ExitGrant_language_target is called when production grant_language_target is exited. +func (s *BaseRedshiftParserListener) ExitGrant_language_target(ctx *Grant_language_targetContext) {} + +// EnterGrant_procedure_target is called when production grant_procedure_target is entered. +func (s *BaseRedshiftParserListener) EnterGrant_procedure_target(ctx *Grant_procedure_targetContext) { +} + +// ExitGrant_procedure_target is called when production grant_procedure_target is exited. +func (s *BaseRedshiftParserListener) ExitGrant_procedure_target(ctx *Grant_procedure_targetContext) {} + +// EnterProcedure_privilege_list is called when production procedure_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterProcedure_privilege_list(ctx *Procedure_privilege_listContext) { +} + +// ExitProcedure_privilege_list is called when production procedure_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitProcedure_privilege_list(ctx *Procedure_privilege_listContext) { +} + +// EnterProcedure_privilege is called when production procedure_privilege is entered. +func (s *BaseRedshiftParserListener) EnterProcedure_privilege(ctx *Procedure_privilegeContext) {} + +// ExitProcedure_privilege is called when production procedure_privilege is exited. +func (s *BaseRedshiftParserListener) ExitProcedure_privilege(ctx *Procedure_privilegeContext) {} + +// EnterFunction_privilege_list is called when production function_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterFunction_privilege_list(ctx *Function_privilege_listContext) { +} + +// ExitFunction_privilege_list is called when production function_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitFunction_privilege_list(ctx *Function_privilege_listContext) { +} + +// EnterFunction_privilege is called when production function_privilege is entered. +func (s *BaseRedshiftParserListener) EnterFunction_privilege(ctx *Function_privilegeContext) {} + +// ExitFunction_privilege is called when production function_privilege is exited. +func (s *BaseRedshiftParserListener) ExitFunction_privilege(ctx *Function_privilegeContext) {} + +// EnterGrant_function_target is called when production grant_function_target is entered. +func (s *BaseRedshiftParserListener) EnterGrant_function_target(ctx *Grant_function_targetContext) {} + +// ExitGrant_function_target is called when production grant_function_target is exited. +func (s *BaseRedshiftParserListener) ExitGrant_function_target(ctx *Grant_function_targetContext) {} + +// EnterGrant_schema_target is called when production grant_schema_target is entered. +func (s *BaseRedshiftParserListener) EnterGrant_schema_target(ctx *Grant_schema_targetContext) {} + +// ExitGrant_schema_target is called when production grant_schema_target is exited. +func (s *BaseRedshiftParserListener) ExitGrant_schema_target(ctx *Grant_schema_targetContext) {} + +// EnterRevoke_schema_target is called when production revoke_schema_target is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_schema_target(ctx *Revoke_schema_targetContext) {} + +// ExitRevoke_schema_target is called when production revoke_schema_target is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_schema_target(ctx *Revoke_schema_targetContext) {} + +// EnterSchema_privilege_list is called when production schema_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterSchema_privilege_list(ctx *Schema_privilege_listContext) {} + +// ExitSchema_privilege_list is called when production schema_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitSchema_privilege_list(ctx *Schema_privilege_listContext) {} + +// EnterSchema_privilege is called when production schema_privilege is entered. +func (s *BaseRedshiftParserListener) EnterSchema_privilege(ctx *Schema_privilegeContext) {} + +// ExitSchema_privilege is called when production schema_privilege is exited. +func (s *BaseRedshiftParserListener) ExitSchema_privilege(ctx *Schema_privilegeContext) {} + +// EnterDatabase_privilege_list is called when production database_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterDatabase_privilege_list(ctx *Database_privilege_listContext) { +} + +// ExitDatabase_privilege_list is called when production database_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitDatabase_privilege_list(ctx *Database_privilege_listContext) { +} + +// EnterDatabase_privilege is called when production database_privilege is entered. +func (s *BaseRedshiftParserListener) EnterDatabase_privilege(ctx *Database_privilegeContext) {} + +// ExitDatabase_privilege is called when production database_privilege is exited. +func (s *BaseRedshiftParserListener) ExitDatabase_privilege(ctx *Database_privilegeContext) {} + +// EnterGrant_database_target is called when production grant_database_target is entered. +func (s *BaseRedshiftParserListener) EnterGrant_database_target(ctx *Grant_database_targetContext) {} + +// ExitGrant_database_target is called when production grant_database_target is exited. +func (s *BaseRedshiftParserListener) ExitGrant_database_target(ctx *Grant_database_targetContext) {} + +// EnterGrant_table_target is called when production grant_table_target is entered. +func (s *BaseRedshiftParserListener) EnterGrant_table_target(ctx *Grant_table_targetContext) {} + +// ExitGrant_table_target is called when production grant_table_target is exited. +func (s *BaseRedshiftParserListener) ExitGrant_table_target(ctx *Grant_table_targetContext) {} + +// EnterRevoke_table_target is called when production revoke_table_target is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_table_target(ctx *Revoke_table_targetContext) {} + +// ExitRevoke_table_target is called when production revoke_table_target is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_table_target(ctx *Revoke_table_targetContext) {} + +// EnterAll_tables_in_schema_list is called when production all_tables_in_schema_list is entered. +func (s *BaseRedshiftParserListener) EnterAll_tables_in_schema_list(ctx *All_tables_in_schema_listContext) { +} + +// ExitAll_tables_in_schema_list is called when production all_tables_in_schema_list is exited. +func (s *BaseRedshiftParserListener) ExitAll_tables_in_schema_list(ctx *All_tables_in_schema_listContext) { +} + +// EnterAll_privileges is called when production all_privileges is entered. +func (s *BaseRedshiftParserListener) EnterAll_privileges(ctx *All_privilegesContext) {} + +// ExitAll_privileges is called when production all_privileges is exited. +func (s *BaseRedshiftParserListener) ExitAll_privileges(ctx *All_privilegesContext) {} + +// EnterGrantee_list is called when production grantee_list is entered. +func (s *BaseRedshiftParserListener) EnterGrantee_list(ctx *Grantee_listContext) {} + +// ExitGrantee_list is called when production grantee_list is exited. +func (s *BaseRedshiftParserListener) ExitGrantee_list(ctx *Grantee_listContext) {} + +// EnterGrantee is called when production grantee is entered. +func (s *BaseRedshiftParserListener) EnterGrantee(ctx *GranteeContext) {} + +// ExitGrantee is called when production grantee is exited. +func (s *BaseRedshiftParserListener) ExitGrantee(ctx *GranteeContext) {} + +// EnterOpt_with_grant_option is called when production opt_with_grant_option is entered. +func (s *BaseRedshiftParserListener) EnterOpt_with_grant_option(ctx *Opt_with_grant_optionContext) {} + +// ExitOpt_with_grant_option is called when production opt_with_grant_option is exited. +func (s *BaseRedshiftParserListener) ExitOpt_with_grant_option(ctx *Opt_with_grant_optionContext) {} + +// EnterTable_privilege is called when production table_privilege is entered. +func (s *BaseRedshiftParserListener) EnterTable_privilege(ctx *Table_privilegeContext) {} + +// ExitTable_privilege is called when production table_privilege is exited. +func (s *BaseRedshiftParserListener) ExitTable_privilege(ctx *Table_privilegeContext) {} + +// EnterTable_privilege_list is called when production table_privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterTable_privilege_list(ctx *Table_privilege_listContext) {} + +// ExitTable_privilege_list is called when production table_privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitTable_privilege_list(ctx *Table_privilege_listContext) {} + +// EnterRevokestmt is called when production revokestmt is entered. +func (s *BaseRedshiftParserListener) EnterRevokestmt(ctx *RevokestmtContext) {} + +// ExitRevokestmt is called when production revokestmt is exited. +func (s *BaseRedshiftParserListener) ExitRevokestmt(ctx *RevokestmtContext) {} + +// EnterRevoke_permissions_for_rls_lookup_tables is called when production revoke_permissions_for_rls_lookup_tables is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_permissions_for_rls_lookup_tables(ctx *Revoke_permissions_for_rls_lookup_tablesContext) { +} + +// ExitRevoke_permissions_for_rls_lookup_tables is called when production revoke_permissions_for_rls_lookup_tables is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_permissions_for_rls_lookup_tables(ctx *Revoke_permissions_for_rls_lookup_tablesContext) { +} + +// EnterRevoke_explain_permissions_for_row_level_security_policy_filters is called when production revoke_explain_permissions_for_row_level_security_policy_filters is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_explain_permissions_for_row_level_security_policy_filters(ctx *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) { +} + +// ExitRevoke_explain_permissions_for_row_level_security_policy_filters is called when production revoke_explain_permissions_for_row_level_security_policy_filters is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_explain_permissions_for_row_level_security_policy_filters(ctx *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) { +} + +// EnterRevoke_machine_learning_permissions is called when production revoke_machine_learning_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_machine_learning_permissions(ctx *Revoke_machine_learning_permissionsContext) { +} + +// ExitRevoke_machine_learning_permissions is called when production revoke_machine_learning_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_machine_learning_permissions(ctx *Revoke_machine_learning_permissionsContext) { +} + +// EnterRevoke_role_permissions is called when production revoke_role_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_role_permissions(ctx *Revoke_role_permissionsContext) { +} + +// ExitRevoke_role_permissions is called when production revoke_role_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_role_permissions(ctx *Revoke_role_permissionsContext) { +} + +// EnterRevoke_scoped_permissions is called when production revoke_scoped_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_scoped_permissions(ctx *Revoke_scoped_permissionsContext) { +} + +// ExitRevoke_scoped_permissions is called when production revoke_scoped_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_scoped_permissions(ctx *Revoke_scoped_permissionsContext) { +} + +// EnterRevoke_scoped_schemas_permissions is called when production revoke_scoped_schemas_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_scoped_schemas_permissions(ctx *Revoke_scoped_schemas_permissionsContext) { +} + +// ExitRevoke_scoped_schemas_permissions is called when production revoke_scoped_schemas_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_scoped_schemas_permissions(ctx *Revoke_scoped_schemas_permissionsContext) { +} + +// EnterRevoke_scoped_tables_permissions is called when production revoke_scoped_tables_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_scoped_tables_permissions(ctx *Revoke_scoped_tables_permissionsContext) { +} + +// ExitRevoke_scoped_tables_permissions is called when production revoke_scoped_tables_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_scoped_tables_permissions(ctx *Revoke_scoped_tables_permissionsContext) { +} + +// EnterRevoke_scoped_functions_permissions is called when production revoke_scoped_functions_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_scoped_functions_permissions(ctx *Revoke_scoped_functions_permissionsContext) { +} + +// ExitRevoke_scoped_functions_permissions is called when production revoke_scoped_functions_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_scoped_functions_permissions(ctx *Revoke_scoped_functions_permissionsContext) { +} + +// EnterRevoke_scoped_procedures_permissions is called when production revoke_scoped_procedures_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_scoped_procedures_permissions(ctx *Revoke_scoped_procedures_permissionsContext) { +} + +// ExitRevoke_scoped_procedures_permissions is called when production revoke_scoped_procedures_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_scoped_procedures_permissions(ctx *Revoke_scoped_procedures_permissionsContext) { +} + +// EnterRevoke_scoped_languages_permissions is called when production revoke_scoped_languages_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_scoped_languages_permissions(ctx *Revoke_scoped_languages_permissionsContext) { +} + +// ExitRevoke_scoped_languages_permissions is called when production revoke_scoped_languages_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_scoped_languages_permissions(ctx *Revoke_scoped_languages_permissionsContext) { +} + +// EnterRevoke_scoped_copy_jobs_permissions is called when production revoke_scoped_copy_jobs_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_scoped_copy_jobs_permissions(ctx *Revoke_scoped_copy_jobs_permissionsContext) { +} + +// ExitRevoke_scoped_copy_jobs_permissions is called when production revoke_scoped_copy_jobs_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_scoped_copy_jobs_permissions(ctx *Revoke_scoped_copy_jobs_permissionsContext) { +} + +// EnterRevoke_datashare_permissions is called when production revoke_datashare_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_datashare_permissions(ctx *Revoke_datashare_permissionsContext) { +} + +// ExitRevoke_datashare_permissions is called when production revoke_datashare_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_datashare_permissions(ctx *Revoke_datashare_permissionsContext) { +} + +// EnterRevoke_spectrum_integration_permissions is called when production revoke_spectrum_integration_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_spectrum_integration_permissions(ctx *Revoke_spectrum_integration_permissionsContext) { +} + +// ExitRevoke_spectrum_integration_permissions is called when production revoke_spectrum_integration_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_spectrum_integration_permissions(ctx *Revoke_spectrum_integration_permissionsContext) { +} + +// EnterRevoke_spectrum_integration_external_schema_permissions is called when production revoke_spectrum_integration_external_schema_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_spectrum_integration_external_schema_permissions(ctx *Revoke_spectrum_integration_external_schema_permissionsContext) { +} + +// ExitRevoke_spectrum_integration_external_schema_permissions is called when production revoke_spectrum_integration_external_schema_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_spectrum_integration_external_schema_permissions(ctx *Revoke_spectrum_integration_external_schema_permissionsContext) { +} + +// EnterRevoke_spectrum_integration_external_table_permissions is called when production revoke_spectrum_integration_external_table_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_spectrum_integration_external_table_permissions(ctx *Revoke_spectrum_integration_external_table_permissionsContext) { +} + +// ExitRevoke_spectrum_integration_external_table_permissions is called when production revoke_spectrum_integration_external_table_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_spectrum_integration_external_table_permissions(ctx *Revoke_spectrum_integration_external_table_permissionsContext) { +} + +// EnterRevoke_spectrum_integration_extenral_column_permissions is called when production revoke_spectrum_integration_extenral_column_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_spectrum_integration_extenral_column_permissions(ctx *Revoke_spectrum_integration_extenral_column_permissionsContext) { +} + +// ExitRevoke_spectrum_integration_extenral_column_permissions is called when production revoke_spectrum_integration_extenral_column_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_spectrum_integration_extenral_column_permissions(ctx *Revoke_spectrum_integration_extenral_column_permissionsContext) { +} + +// EnterRevoke_assume_role_permissions is called when production revoke_assume_role_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_assume_role_permissions(ctx *Revoke_assume_role_permissionsContext) { +} + +// ExitRevoke_assume_role_permissions is called when production revoke_assume_role_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_assume_role_permissions(ctx *Revoke_assume_role_permissionsContext) { +} + +// EnterRevoke_column_level_permissions is called when production revoke_column_level_permissions is entered. +func (s *BaseRedshiftParserListener) EnterRevoke_column_level_permissions(ctx *Revoke_column_level_permissionsContext) { +} + +// ExitRevoke_column_level_permissions is called when production revoke_column_level_permissions is exited. +func (s *BaseRedshiftParserListener) ExitRevoke_column_level_permissions(ctx *Revoke_column_level_permissionsContext) { +} + +// EnterCommon_revoke is called when production common_revoke is entered. +func (s *BaseRedshiftParserListener) EnterCommon_revoke(ctx *Common_revokeContext) {} + +// ExitCommon_revoke is called when production common_revoke is exited. +func (s *BaseRedshiftParserListener) ExitCommon_revoke(ctx *Common_revokeContext) {} + +// EnterPrivileges is called when production privileges is entered. +func (s *BaseRedshiftParserListener) EnterPrivileges(ctx *PrivilegesContext) {} + +// ExitPrivileges is called when production privileges is exited. +func (s *BaseRedshiftParserListener) ExitPrivileges(ctx *PrivilegesContext) {} + +// EnterPrivilege_list is called when production privilege_list is entered. +func (s *BaseRedshiftParserListener) EnterPrivilege_list(ctx *Privilege_listContext) {} + +// ExitPrivilege_list is called when production privilege_list is exited. +func (s *BaseRedshiftParserListener) ExitPrivilege_list(ctx *Privilege_listContext) {} + +// EnterPrivilege is called when production privilege is entered. +func (s *BaseRedshiftParserListener) EnterPrivilege(ctx *PrivilegeContext) {} + +// ExitPrivilege is called when production privilege is exited. +func (s *BaseRedshiftParserListener) ExitPrivilege(ctx *PrivilegeContext) {} + +// EnterPrivilege_target is called when production privilege_target is entered. +func (s *BaseRedshiftParserListener) EnterPrivilege_target(ctx *Privilege_targetContext) {} + +// ExitPrivilege_target is called when production privilege_target is exited. +func (s *BaseRedshiftParserListener) ExitPrivilege_target(ctx *Privilege_targetContext) {} + +// EnterParameter_name_list is called when production parameter_name_list is entered. +func (s *BaseRedshiftParserListener) EnterParameter_name_list(ctx *Parameter_name_listContext) {} + +// ExitParameter_name_list is called when production parameter_name_list is exited. +func (s *BaseRedshiftParserListener) ExitParameter_name_list(ctx *Parameter_name_listContext) {} + +// EnterParameter_name is called when production parameter_name is entered. +func (s *BaseRedshiftParserListener) EnterParameter_name(ctx *Parameter_nameContext) {} + +// ExitParameter_name is called when production parameter_name is exited. +func (s *BaseRedshiftParserListener) ExitParameter_name(ctx *Parameter_nameContext) {} + +// EnterOpt_grant_grant_option is called when production opt_grant_grant_option is entered. +func (s *BaseRedshiftParserListener) EnterOpt_grant_grant_option(ctx *Opt_grant_grant_optionContext) { +} + +// ExitOpt_grant_grant_option is called when production opt_grant_grant_option is exited. +func (s *BaseRedshiftParserListener) ExitOpt_grant_grant_option(ctx *Opt_grant_grant_optionContext) {} + +// EnterGrantrolestmt is called when production grantrolestmt is entered. +func (s *BaseRedshiftParserListener) EnterGrantrolestmt(ctx *GrantrolestmtContext) {} + +// ExitGrantrolestmt is called when production grantrolestmt is exited. +func (s *BaseRedshiftParserListener) ExitGrantrolestmt(ctx *GrantrolestmtContext) {} + +// EnterRevokerolestmt is called when production revokerolestmt is entered. +func (s *BaseRedshiftParserListener) EnterRevokerolestmt(ctx *RevokerolestmtContext) {} + +// ExitRevokerolestmt is called when production revokerolestmt is exited. +func (s *BaseRedshiftParserListener) ExitRevokerolestmt(ctx *RevokerolestmtContext) {} + +// EnterOpt_grant_admin_option is called when production opt_grant_admin_option is entered. +func (s *BaseRedshiftParserListener) EnterOpt_grant_admin_option(ctx *Opt_grant_admin_optionContext) { +} + +// ExitOpt_grant_admin_option is called when production opt_grant_admin_option is exited. +func (s *BaseRedshiftParserListener) ExitOpt_grant_admin_option(ctx *Opt_grant_admin_optionContext) {} + +// EnterOpt_granted_by is called when production opt_granted_by is entered. +func (s *BaseRedshiftParserListener) EnterOpt_granted_by(ctx *Opt_granted_byContext) {} + +// ExitOpt_granted_by is called when production opt_granted_by is exited. +func (s *BaseRedshiftParserListener) ExitOpt_granted_by(ctx *Opt_granted_byContext) {} + +// EnterAlterdefaultprivilegesstmt is called when production alterdefaultprivilegesstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterdefaultprivilegesstmt(ctx *AlterdefaultprivilegesstmtContext) { +} + +// ExitAlterdefaultprivilegesstmt is called when production alterdefaultprivilegesstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterdefaultprivilegesstmt(ctx *AlterdefaultprivilegesstmtContext) { +} + +// EnterDefacloptionlist is called when production defacloptionlist is entered. +func (s *BaseRedshiftParserListener) EnterDefacloptionlist(ctx *DefacloptionlistContext) {} + +// ExitDefacloptionlist is called when production defacloptionlist is exited. +func (s *BaseRedshiftParserListener) ExitDefacloptionlist(ctx *DefacloptionlistContext) {} + +// EnterDefacloption is called when production defacloption is entered. +func (s *BaseRedshiftParserListener) EnterDefacloption(ctx *DefacloptionContext) {} + +// ExitDefacloption is called when production defacloption is exited. +func (s *BaseRedshiftParserListener) ExitDefacloption(ctx *DefacloptionContext) {} + +// EnterDefaclaction is called when production defaclaction is entered. +func (s *BaseRedshiftParserListener) EnterDefaclaction(ctx *DefaclactionContext) {} + +// ExitDefaclaction is called when production defaclaction is exited. +func (s *BaseRedshiftParserListener) ExitDefaclaction(ctx *DefaclactionContext) {} + +// EnterDefacl_privilege_target is called when production defacl_privilege_target is entered. +func (s *BaseRedshiftParserListener) EnterDefacl_privilege_target(ctx *Defacl_privilege_targetContext) { +} + +// ExitDefacl_privilege_target is called when production defacl_privilege_target is exited. +func (s *BaseRedshiftParserListener) ExitDefacl_privilege_target(ctx *Defacl_privilege_targetContext) { +} + +// EnterIndexstmt is called when production indexstmt is entered. +func (s *BaseRedshiftParserListener) EnterIndexstmt(ctx *IndexstmtContext) {} + +// ExitIndexstmt is called when production indexstmt is exited. +func (s *BaseRedshiftParserListener) ExitIndexstmt(ctx *IndexstmtContext) {} + +// EnterOpt_unique is called when production opt_unique is entered. +func (s *BaseRedshiftParserListener) EnterOpt_unique(ctx *Opt_uniqueContext) {} + +// ExitOpt_unique is called when production opt_unique is exited. +func (s *BaseRedshiftParserListener) ExitOpt_unique(ctx *Opt_uniqueContext) {} + +// EnterOpt_concurrently is called when production opt_concurrently is entered. +func (s *BaseRedshiftParserListener) EnterOpt_concurrently(ctx *Opt_concurrentlyContext) {} + +// ExitOpt_concurrently is called when production opt_concurrently is exited. +func (s *BaseRedshiftParserListener) ExitOpt_concurrently(ctx *Opt_concurrentlyContext) {} + +// EnterOpt_index_name is called when production opt_index_name is entered. +func (s *BaseRedshiftParserListener) EnterOpt_index_name(ctx *Opt_index_nameContext) {} + +// ExitOpt_index_name is called when production opt_index_name is exited. +func (s *BaseRedshiftParserListener) ExitOpt_index_name(ctx *Opt_index_nameContext) {} + +// EnterAccess_method_clause is called when production access_method_clause is entered. +func (s *BaseRedshiftParserListener) EnterAccess_method_clause(ctx *Access_method_clauseContext) {} + +// ExitAccess_method_clause is called when production access_method_clause is exited. +func (s *BaseRedshiftParserListener) ExitAccess_method_clause(ctx *Access_method_clauseContext) {} + +// EnterIndex_params is called when production index_params is entered. +func (s *BaseRedshiftParserListener) EnterIndex_params(ctx *Index_paramsContext) {} + +// ExitIndex_params is called when production index_params is exited. +func (s *BaseRedshiftParserListener) ExitIndex_params(ctx *Index_paramsContext) {} + +// EnterIndex_elem_options is called when production index_elem_options is entered. +func (s *BaseRedshiftParserListener) EnterIndex_elem_options(ctx *Index_elem_optionsContext) {} + +// ExitIndex_elem_options is called when production index_elem_options is exited. +func (s *BaseRedshiftParserListener) ExitIndex_elem_options(ctx *Index_elem_optionsContext) {} + +// EnterIndex_elem is called when production index_elem is entered. +func (s *BaseRedshiftParserListener) EnterIndex_elem(ctx *Index_elemContext) {} + +// ExitIndex_elem is called when production index_elem is exited. +func (s *BaseRedshiftParserListener) ExitIndex_elem(ctx *Index_elemContext) {} + +// EnterOpt_include is called when production opt_include is entered. +func (s *BaseRedshiftParserListener) EnterOpt_include(ctx *Opt_includeContext) {} + +// ExitOpt_include is called when production opt_include is exited. +func (s *BaseRedshiftParserListener) ExitOpt_include(ctx *Opt_includeContext) {} + +// EnterIndex_including_params is called when production index_including_params is entered. +func (s *BaseRedshiftParserListener) EnterIndex_including_params(ctx *Index_including_paramsContext) { +} + +// ExitIndex_including_params is called when production index_including_params is exited. +func (s *BaseRedshiftParserListener) ExitIndex_including_params(ctx *Index_including_paramsContext) {} + +// EnterOpt_collate is called when production opt_collate is entered. +func (s *BaseRedshiftParserListener) EnterOpt_collate(ctx *Opt_collateContext) {} + +// ExitOpt_collate is called when production opt_collate is exited. +func (s *BaseRedshiftParserListener) ExitOpt_collate(ctx *Opt_collateContext) {} + +// EnterOpt_class is called when production opt_class is entered. +func (s *BaseRedshiftParserListener) EnterOpt_class(ctx *Opt_classContext) {} + +// ExitOpt_class is called when production opt_class is exited. +func (s *BaseRedshiftParserListener) ExitOpt_class(ctx *Opt_classContext) {} + +// EnterOpt_asc_desc is called when production opt_asc_desc is entered. +func (s *BaseRedshiftParserListener) EnterOpt_asc_desc(ctx *Opt_asc_descContext) {} + +// ExitOpt_asc_desc is called when production opt_asc_desc is exited. +func (s *BaseRedshiftParserListener) ExitOpt_asc_desc(ctx *Opt_asc_descContext) {} + +// EnterOpt_nulls_order is called when production opt_nulls_order is entered. +func (s *BaseRedshiftParserListener) EnterOpt_nulls_order(ctx *Opt_nulls_orderContext) {} + +// ExitOpt_nulls_order is called when production opt_nulls_order is exited. +func (s *BaseRedshiftParserListener) ExitOpt_nulls_order(ctx *Opt_nulls_orderContext) {} + +// EnterCreatefunctionstmt is called when production createfunctionstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatefunctionstmt(ctx *CreatefunctionstmtContext) {} + +// ExitCreatefunctionstmt is called when production createfunctionstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatefunctionstmt(ctx *CreatefunctionstmtContext) {} + +// EnterCreateprocedurestmt is called when production createprocedurestmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateprocedurestmt(ctx *CreateprocedurestmtContext) {} + +// ExitCreateprocedurestmt is called when production createprocedurestmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateprocedurestmt(ctx *CreateprocedurestmtContext) {} + +// EnterOpt_nonatomic is called when production opt_nonatomic is entered. +func (s *BaseRedshiftParserListener) EnterOpt_nonatomic(ctx *Opt_nonatomicContext) {} + +// ExitOpt_nonatomic is called when production opt_nonatomic is exited. +func (s *BaseRedshiftParserListener) ExitOpt_nonatomic(ctx *Opt_nonatomicContext) {} + +// EnterOpt_or_replace is called when production opt_or_replace is entered. +func (s *BaseRedshiftParserListener) EnterOpt_or_replace(ctx *Opt_or_replaceContext) {} + +// ExitOpt_or_replace is called when production opt_or_replace is exited. +func (s *BaseRedshiftParserListener) ExitOpt_or_replace(ctx *Opt_or_replaceContext) {} + +// EnterFunc_py_args_or_sql_args is called when production func_py_args_or_sql_args is entered. +func (s *BaseRedshiftParserListener) EnterFunc_py_args_or_sql_args(ctx *Func_py_args_or_sql_argsContext) { +} + +// ExitFunc_py_args_or_sql_args is called when production func_py_args_or_sql_args is exited. +func (s *BaseRedshiftParserListener) ExitFunc_py_args_or_sql_args(ctx *Func_py_args_or_sql_argsContext) { +} + +// EnterFunc_py_args_or_sql_args_list is called when production func_py_args_or_sql_args_list is entered. +func (s *BaseRedshiftParserListener) EnterFunc_py_args_or_sql_args_list(ctx *Func_py_args_or_sql_args_listContext) { +} + +// ExitFunc_py_args_or_sql_args_list is called when production func_py_args_or_sql_args_list is exited. +func (s *BaseRedshiftParserListener) ExitFunc_py_args_or_sql_args_list(ctx *Func_py_args_or_sql_args_listContext) { +} + +// EnterFunc_args is called when production func_args is entered. +func (s *BaseRedshiftParserListener) EnterFunc_args(ctx *Func_argsContext) {} + +// ExitFunc_args is called when production func_args is exited. +func (s *BaseRedshiftParserListener) ExitFunc_args(ctx *Func_argsContext) {} + +// EnterFunc_args_list is called when production func_args_list is entered. +func (s *BaseRedshiftParserListener) EnterFunc_args_list(ctx *Func_args_listContext) {} + +// ExitFunc_args_list is called when production func_args_list is exited. +func (s *BaseRedshiftParserListener) ExitFunc_args_list(ctx *Func_args_listContext) {} + +// EnterFunction_with_argtypes_list is called when production function_with_argtypes_list is entered. +func (s *BaseRedshiftParserListener) EnterFunction_with_argtypes_list(ctx *Function_with_argtypes_listContext) { +} + +// ExitFunction_with_argtypes_list is called when production function_with_argtypes_list is exited. +func (s *BaseRedshiftParserListener) ExitFunction_with_argtypes_list(ctx *Function_with_argtypes_listContext) { +} + +// EnterFunction_with_argtypes is called when production function_with_argtypes is entered. +func (s *BaseRedshiftParserListener) EnterFunction_with_argtypes(ctx *Function_with_argtypesContext) { +} + +// ExitFunction_with_argtypes is called when production function_with_argtypes is exited. +func (s *BaseRedshiftParserListener) ExitFunction_with_argtypes(ctx *Function_with_argtypesContext) {} + +// EnterFunc_args_with_defaults is called when production func_args_with_defaults is entered. +func (s *BaseRedshiftParserListener) EnterFunc_args_with_defaults(ctx *Func_args_with_defaultsContext) { +} + +// ExitFunc_args_with_defaults is called when production func_args_with_defaults is exited. +func (s *BaseRedshiftParserListener) ExitFunc_args_with_defaults(ctx *Func_args_with_defaultsContext) { +} + +// EnterFunc_args_with_defaults_list is called when production func_args_with_defaults_list is entered. +func (s *BaseRedshiftParserListener) EnterFunc_args_with_defaults_list(ctx *Func_args_with_defaults_listContext) { +} + +// ExitFunc_args_with_defaults_list is called when production func_args_with_defaults_list is exited. +func (s *BaseRedshiftParserListener) ExitFunc_args_with_defaults_list(ctx *Func_args_with_defaults_listContext) { +} + +// EnterFunc_arg is called when production func_arg is entered. +func (s *BaseRedshiftParserListener) EnterFunc_arg(ctx *Func_argContext) {} + +// ExitFunc_arg is called when production func_arg is exited. +func (s *BaseRedshiftParserListener) ExitFunc_arg(ctx *Func_argContext) {} + +// EnterArg_class is called when production arg_class is entered. +func (s *BaseRedshiftParserListener) EnterArg_class(ctx *Arg_classContext) {} + +// ExitArg_class is called when production arg_class is exited. +func (s *BaseRedshiftParserListener) ExitArg_class(ctx *Arg_classContext) {} + +// EnterParam_name is called when production param_name is entered. +func (s *BaseRedshiftParserListener) EnterParam_name(ctx *Param_nameContext) {} + +// ExitParam_name is called when production param_name is exited. +func (s *BaseRedshiftParserListener) ExitParam_name(ctx *Param_nameContext) {} + +// EnterFunc_return is called when production func_return is entered. +func (s *BaseRedshiftParserListener) EnterFunc_return(ctx *Func_returnContext) {} + +// ExitFunc_return is called when production func_return is exited. +func (s *BaseRedshiftParserListener) ExitFunc_return(ctx *Func_returnContext) {} + +// EnterFunc_type is called when production func_type is entered. +func (s *BaseRedshiftParserListener) EnterFunc_type(ctx *Func_typeContext) {} + +// ExitFunc_type is called when production func_type is exited. +func (s *BaseRedshiftParserListener) ExitFunc_type(ctx *Func_typeContext) {} + +// EnterFunc_arg_with_default is called when production func_arg_with_default is entered. +func (s *BaseRedshiftParserListener) EnterFunc_arg_with_default(ctx *Func_arg_with_defaultContext) {} + +// ExitFunc_arg_with_default is called when production func_arg_with_default is exited. +func (s *BaseRedshiftParserListener) ExitFunc_arg_with_default(ctx *Func_arg_with_defaultContext) {} + +// EnterAggr_arg is called when production aggr_arg is entered. +func (s *BaseRedshiftParserListener) EnterAggr_arg(ctx *Aggr_argContext) {} + +// ExitAggr_arg is called when production aggr_arg is exited. +func (s *BaseRedshiftParserListener) ExitAggr_arg(ctx *Aggr_argContext) {} + +// EnterAggr_args is called when production aggr_args is entered. +func (s *BaseRedshiftParserListener) EnterAggr_args(ctx *Aggr_argsContext) {} + +// ExitAggr_args is called when production aggr_args is exited. +func (s *BaseRedshiftParserListener) ExitAggr_args(ctx *Aggr_argsContext) {} + +// EnterAggr_args_list is called when production aggr_args_list is entered. +func (s *BaseRedshiftParserListener) EnterAggr_args_list(ctx *Aggr_args_listContext) {} + +// ExitAggr_args_list is called when production aggr_args_list is exited. +func (s *BaseRedshiftParserListener) ExitAggr_args_list(ctx *Aggr_args_listContext) {} + +// EnterAggregate_with_argtypes is called when production aggregate_with_argtypes is entered. +func (s *BaseRedshiftParserListener) EnterAggregate_with_argtypes(ctx *Aggregate_with_argtypesContext) { +} + +// ExitAggregate_with_argtypes is called when production aggregate_with_argtypes is exited. +func (s *BaseRedshiftParserListener) ExitAggregate_with_argtypes(ctx *Aggregate_with_argtypesContext) { +} + +// EnterAggregate_with_argtypes_list is called when production aggregate_with_argtypes_list is entered. +func (s *BaseRedshiftParserListener) EnterAggregate_with_argtypes_list(ctx *Aggregate_with_argtypes_listContext) { +} + +// ExitAggregate_with_argtypes_list is called when production aggregate_with_argtypes_list is exited. +func (s *BaseRedshiftParserListener) ExitAggregate_with_argtypes_list(ctx *Aggregate_with_argtypes_listContext) { +} + +// EnterCreatefunc_opt_list is called when production createfunc_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterCreatefunc_opt_list(ctx *Createfunc_opt_listContext) {} + +// ExitCreatefunc_opt_list is called when production createfunc_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitCreatefunc_opt_list(ctx *Createfunc_opt_listContext) {} + +// EnterCommon_func_opt_item is called when production common_func_opt_item is entered. +func (s *BaseRedshiftParserListener) EnterCommon_func_opt_item(ctx *Common_func_opt_itemContext) {} + +// ExitCommon_func_opt_item is called when production common_func_opt_item is exited. +func (s *BaseRedshiftParserListener) ExitCommon_func_opt_item(ctx *Common_func_opt_itemContext) {} + +// EnterCreatefunc_opt_item is called when production createfunc_opt_item is entered. +func (s *BaseRedshiftParserListener) EnterCreatefunc_opt_item(ctx *Createfunc_opt_itemContext) {} + +// ExitCreatefunc_opt_item is called when production createfunc_opt_item is exited. +func (s *BaseRedshiftParserListener) ExitCreatefunc_opt_item(ctx *Createfunc_opt_itemContext) {} + +// EnterFunc_as is called when production func_as is entered. +func (s *BaseRedshiftParserListener) EnterFunc_as(ctx *Func_asContext) {} + +// ExitFunc_as is called when production func_as is exited. +func (s *BaseRedshiftParserListener) ExitFunc_as(ctx *Func_asContext) {} + +// EnterTransform_type_list is called when production transform_type_list is entered. +func (s *BaseRedshiftParserListener) EnterTransform_type_list(ctx *Transform_type_listContext) {} + +// ExitTransform_type_list is called when production transform_type_list is exited. +func (s *BaseRedshiftParserListener) ExitTransform_type_list(ctx *Transform_type_listContext) {} + +// EnterOpt_definition is called when production opt_definition is entered. +func (s *BaseRedshiftParserListener) EnterOpt_definition(ctx *Opt_definitionContext) {} + +// ExitOpt_definition is called when production opt_definition is exited. +func (s *BaseRedshiftParserListener) ExitOpt_definition(ctx *Opt_definitionContext) {} + +// EnterTable_func_column is called when production table_func_column is entered. +func (s *BaseRedshiftParserListener) EnterTable_func_column(ctx *Table_func_columnContext) {} + +// ExitTable_func_column is called when production table_func_column is exited. +func (s *BaseRedshiftParserListener) ExitTable_func_column(ctx *Table_func_columnContext) {} + +// EnterTable_func_column_list is called when production table_func_column_list is entered. +func (s *BaseRedshiftParserListener) EnterTable_func_column_list(ctx *Table_func_column_listContext) { +} + +// ExitTable_func_column_list is called when production table_func_column_list is exited. +func (s *BaseRedshiftParserListener) ExitTable_func_column_list(ctx *Table_func_column_listContext) {} + +// EnterAlterfunctionstmt is called when production alterfunctionstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterfunctionstmt(ctx *AlterfunctionstmtContext) {} + +// ExitAlterfunctionstmt is called when production alterfunctionstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterfunctionstmt(ctx *AlterfunctionstmtContext) {} + +// EnterAlterprocedurestmt is called when production alterprocedurestmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterprocedurestmt(ctx *AlterprocedurestmtContext) {} + +// ExitAlterprocedurestmt is called when production alterprocedurestmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterprocedurestmt(ctx *AlterprocedurestmtContext) {} + +// EnterAlterfunc_opt_list is called when production alterfunc_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterAlterfunc_opt_list(ctx *Alterfunc_opt_listContext) {} + +// ExitAlterfunc_opt_list is called when production alterfunc_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitAlterfunc_opt_list(ctx *Alterfunc_opt_listContext) {} + +// EnterOpt_restrict is called when production opt_restrict is entered. +func (s *BaseRedshiftParserListener) EnterOpt_restrict(ctx *Opt_restrictContext) {} + +// ExitOpt_restrict is called when production opt_restrict is exited. +func (s *BaseRedshiftParserListener) ExitOpt_restrict(ctx *Opt_restrictContext) {} + +// EnterRemovefuncstmt is called when production removefuncstmt is entered. +func (s *BaseRedshiftParserListener) EnterRemovefuncstmt(ctx *RemovefuncstmtContext) {} + +// ExitRemovefuncstmt is called when production removefuncstmt is exited. +func (s *BaseRedshiftParserListener) ExitRemovefuncstmt(ctx *RemovefuncstmtContext) {} + +// EnterRemoveaggrstmt is called when production removeaggrstmt is entered. +func (s *BaseRedshiftParserListener) EnterRemoveaggrstmt(ctx *RemoveaggrstmtContext) {} + +// ExitRemoveaggrstmt is called when production removeaggrstmt is exited. +func (s *BaseRedshiftParserListener) ExitRemoveaggrstmt(ctx *RemoveaggrstmtContext) {} + +// EnterRemoveoperstmt is called when production removeoperstmt is entered. +func (s *BaseRedshiftParserListener) EnterRemoveoperstmt(ctx *RemoveoperstmtContext) {} + +// ExitRemoveoperstmt is called when production removeoperstmt is exited. +func (s *BaseRedshiftParserListener) ExitRemoveoperstmt(ctx *RemoveoperstmtContext) {} + +// EnterOper_argtypes is called when production oper_argtypes is entered. +func (s *BaseRedshiftParserListener) EnterOper_argtypes(ctx *Oper_argtypesContext) {} + +// ExitOper_argtypes is called when production oper_argtypes is exited. +func (s *BaseRedshiftParserListener) ExitOper_argtypes(ctx *Oper_argtypesContext) {} + +// EnterAny_operator is called when production any_operator is entered. +func (s *BaseRedshiftParserListener) EnterAny_operator(ctx *Any_operatorContext) {} + +// ExitAny_operator is called when production any_operator is exited. +func (s *BaseRedshiftParserListener) ExitAny_operator(ctx *Any_operatorContext) {} + +// EnterOperator_with_argtypes_list is called when production operator_with_argtypes_list is entered. +func (s *BaseRedshiftParserListener) EnterOperator_with_argtypes_list(ctx *Operator_with_argtypes_listContext) { +} + +// ExitOperator_with_argtypes_list is called when production operator_with_argtypes_list is exited. +func (s *BaseRedshiftParserListener) ExitOperator_with_argtypes_list(ctx *Operator_with_argtypes_listContext) { +} + +// EnterOperator_with_argtypes is called when production operator_with_argtypes is entered. +func (s *BaseRedshiftParserListener) EnterOperator_with_argtypes(ctx *Operator_with_argtypesContext) { +} + +// ExitOperator_with_argtypes is called when production operator_with_argtypes is exited. +func (s *BaseRedshiftParserListener) ExitOperator_with_argtypes(ctx *Operator_with_argtypesContext) {} + +// EnterDostmt is called when production dostmt is entered. +func (s *BaseRedshiftParserListener) EnterDostmt(ctx *DostmtContext) {} + +// ExitDostmt is called when production dostmt is exited. +func (s *BaseRedshiftParserListener) ExitDostmt(ctx *DostmtContext) {} + +// EnterDostmt_opt_list is called when production dostmt_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterDostmt_opt_list(ctx *Dostmt_opt_listContext) {} + +// ExitDostmt_opt_list is called when production dostmt_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitDostmt_opt_list(ctx *Dostmt_opt_listContext) {} + +// EnterDostmt_opt_item is called when production dostmt_opt_item is entered. +func (s *BaseRedshiftParserListener) EnterDostmt_opt_item(ctx *Dostmt_opt_itemContext) {} + +// ExitDostmt_opt_item is called when production dostmt_opt_item is exited. +func (s *BaseRedshiftParserListener) ExitDostmt_opt_item(ctx *Dostmt_opt_itemContext) {} + +// EnterCreatecaststmt is called when production createcaststmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatecaststmt(ctx *CreatecaststmtContext) {} + +// ExitCreatecaststmt is called when production createcaststmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatecaststmt(ctx *CreatecaststmtContext) {} + +// EnterCast_context is called when production cast_context is entered. +func (s *BaseRedshiftParserListener) EnterCast_context(ctx *Cast_contextContext) {} + +// ExitCast_context is called when production cast_context is exited. +func (s *BaseRedshiftParserListener) ExitCast_context(ctx *Cast_contextContext) {} + +// EnterDropcaststmt is called when production dropcaststmt is entered. +func (s *BaseRedshiftParserListener) EnterDropcaststmt(ctx *DropcaststmtContext) {} + +// ExitDropcaststmt is called when production dropcaststmt is exited. +func (s *BaseRedshiftParserListener) ExitDropcaststmt(ctx *DropcaststmtContext) {} + +// EnterOpt_if_exists is called when production opt_if_exists is entered. +func (s *BaseRedshiftParserListener) EnterOpt_if_exists(ctx *Opt_if_existsContext) {} + +// ExitOpt_if_exists is called when production opt_if_exists is exited. +func (s *BaseRedshiftParserListener) ExitOpt_if_exists(ctx *Opt_if_existsContext) {} + +// EnterCreatetransformstmt is called when production createtransformstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatetransformstmt(ctx *CreatetransformstmtContext) {} + +// ExitCreatetransformstmt is called when production createtransformstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatetransformstmt(ctx *CreatetransformstmtContext) {} + +// EnterTransform_element_list is called when production transform_element_list is entered. +func (s *BaseRedshiftParserListener) EnterTransform_element_list(ctx *Transform_element_listContext) { +} + +// ExitTransform_element_list is called when production transform_element_list is exited. +func (s *BaseRedshiftParserListener) ExitTransform_element_list(ctx *Transform_element_listContext) {} + +// EnterDroptransformstmt is called when production droptransformstmt is entered. +func (s *BaseRedshiftParserListener) EnterDroptransformstmt(ctx *DroptransformstmtContext) {} + +// ExitDroptransformstmt is called when production droptransformstmt is exited. +func (s *BaseRedshiftParserListener) ExitDroptransformstmt(ctx *DroptransformstmtContext) {} + +// EnterReindexstmt is called when production reindexstmt is entered. +func (s *BaseRedshiftParserListener) EnterReindexstmt(ctx *ReindexstmtContext) {} + +// ExitReindexstmt is called when production reindexstmt is exited. +func (s *BaseRedshiftParserListener) ExitReindexstmt(ctx *ReindexstmtContext) {} + +// EnterReindex_target_type is called when production reindex_target_type is entered. +func (s *BaseRedshiftParserListener) EnterReindex_target_type(ctx *Reindex_target_typeContext) {} + +// ExitReindex_target_type is called when production reindex_target_type is exited. +func (s *BaseRedshiftParserListener) ExitReindex_target_type(ctx *Reindex_target_typeContext) {} + +// EnterReindex_target_multitable is called when production reindex_target_multitable is entered. +func (s *BaseRedshiftParserListener) EnterReindex_target_multitable(ctx *Reindex_target_multitableContext) { +} + +// ExitReindex_target_multitable is called when production reindex_target_multitable is exited. +func (s *BaseRedshiftParserListener) ExitReindex_target_multitable(ctx *Reindex_target_multitableContext) { +} + +// EnterReindex_option_list is called when production reindex_option_list is entered. +func (s *BaseRedshiftParserListener) EnterReindex_option_list(ctx *Reindex_option_listContext) {} + +// ExitReindex_option_list is called when production reindex_option_list is exited. +func (s *BaseRedshiftParserListener) ExitReindex_option_list(ctx *Reindex_option_listContext) {} + +// EnterReindex_option_elem is called when production reindex_option_elem is entered. +func (s *BaseRedshiftParserListener) EnterReindex_option_elem(ctx *Reindex_option_elemContext) {} + +// ExitReindex_option_elem is called when production reindex_option_elem is exited. +func (s *BaseRedshiftParserListener) ExitReindex_option_elem(ctx *Reindex_option_elemContext) {} + +// EnterAltertblspcstmt is called when production altertblspcstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltertblspcstmt(ctx *AltertblspcstmtContext) {} + +// ExitAltertblspcstmt is called when production altertblspcstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltertblspcstmt(ctx *AltertblspcstmtContext) {} + +// EnterRenamestmt is called when production renamestmt is entered. +func (s *BaseRedshiftParserListener) EnterRenamestmt(ctx *RenamestmtContext) {} + +// ExitRenamestmt is called when production renamestmt is exited. +func (s *BaseRedshiftParserListener) ExitRenamestmt(ctx *RenamestmtContext) {} + +// EnterOpt_column is called when production opt_column is entered. +func (s *BaseRedshiftParserListener) EnterOpt_column(ctx *Opt_columnContext) {} + +// ExitOpt_column is called when production opt_column is exited. +func (s *BaseRedshiftParserListener) ExitOpt_column(ctx *Opt_columnContext) {} + +// EnterOpt_set_data is called when production opt_set_data is entered. +func (s *BaseRedshiftParserListener) EnterOpt_set_data(ctx *Opt_set_dataContext) {} + +// ExitOpt_set_data is called when production opt_set_data is exited. +func (s *BaseRedshiftParserListener) ExitOpt_set_data(ctx *Opt_set_dataContext) {} + +// EnterAlterobjectdependsstmt is called when production alterobjectdependsstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterobjectdependsstmt(ctx *AlterobjectdependsstmtContext) { +} + +// ExitAlterobjectdependsstmt is called when production alterobjectdependsstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterobjectdependsstmt(ctx *AlterobjectdependsstmtContext) {} + +// EnterOpt_no is called when production opt_no is entered. +func (s *BaseRedshiftParserListener) EnterOpt_no(ctx *Opt_noContext) {} + +// ExitOpt_no is called when production opt_no is exited. +func (s *BaseRedshiftParserListener) ExitOpt_no(ctx *Opt_noContext) {} + +// EnterAlterobjectschemastmt is called when production alterobjectschemastmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterobjectschemastmt(ctx *AlterobjectschemastmtContext) {} + +// ExitAlterobjectschemastmt is called when production alterobjectschemastmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterobjectschemastmt(ctx *AlterobjectschemastmtContext) {} + +// EnterAlteroperatorstmt is called when production alteroperatorstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlteroperatorstmt(ctx *AlteroperatorstmtContext) {} + +// ExitAlteroperatorstmt is called when production alteroperatorstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlteroperatorstmt(ctx *AlteroperatorstmtContext) {} + +// EnterOperator_def_list is called when production operator_def_list is entered. +func (s *BaseRedshiftParserListener) EnterOperator_def_list(ctx *Operator_def_listContext) {} + +// ExitOperator_def_list is called when production operator_def_list is exited. +func (s *BaseRedshiftParserListener) ExitOperator_def_list(ctx *Operator_def_listContext) {} + +// EnterOperator_def_elem is called when production operator_def_elem is entered. +func (s *BaseRedshiftParserListener) EnterOperator_def_elem(ctx *Operator_def_elemContext) {} + +// ExitOperator_def_elem is called when production operator_def_elem is exited. +func (s *BaseRedshiftParserListener) ExitOperator_def_elem(ctx *Operator_def_elemContext) {} + +// EnterOperator_def_arg is called when production operator_def_arg is entered. +func (s *BaseRedshiftParserListener) EnterOperator_def_arg(ctx *Operator_def_argContext) {} + +// ExitOperator_def_arg is called when production operator_def_arg is exited. +func (s *BaseRedshiftParserListener) ExitOperator_def_arg(ctx *Operator_def_argContext) {} + +// EnterAltertypestmt is called when production altertypestmt is entered. +func (s *BaseRedshiftParserListener) EnterAltertypestmt(ctx *AltertypestmtContext) {} + +// ExitAltertypestmt is called when production altertypestmt is exited. +func (s *BaseRedshiftParserListener) ExitAltertypestmt(ctx *AltertypestmtContext) {} + +// EnterAlterownerstmt is called when production alterownerstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterownerstmt(ctx *AlterownerstmtContext) {} + +// ExitAlterownerstmt is called when production alterownerstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterownerstmt(ctx *AlterownerstmtContext) {} + +// EnterCreatepublicationstmt is called when production createpublicationstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatepublicationstmt(ctx *CreatepublicationstmtContext) {} + +// ExitCreatepublicationstmt is called when production createpublicationstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatepublicationstmt(ctx *CreatepublicationstmtContext) {} + +// EnterPub_obj_list is called when production pub_obj_list is entered. +func (s *BaseRedshiftParserListener) EnterPub_obj_list(ctx *Pub_obj_listContext) {} + +// ExitPub_obj_list is called when production pub_obj_list is exited. +func (s *BaseRedshiftParserListener) ExitPub_obj_list(ctx *Pub_obj_listContext) {} + +// EnterPublication_obj_spec is called when production publication_obj_spec is entered. +func (s *BaseRedshiftParserListener) EnterPublication_obj_spec(ctx *Publication_obj_specContext) {} + +// ExitPublication_obj_spec is called when production publication_obj_spec is exited. +func (s *BaseRedshiftParserListener) ExitPublication_obj_spec(ctx *Publication_obj_specContext) {} + +// EnterOpt_where_clause is called when production opt_where_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_where_clause(ctx *Opt_where_clauseContext) {} + +// ExitOpt_where_clause is called when production opt_where_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_where_clause(ctx *Opt_where_clauseContext) {} + +// EnterAlterpublicationstmt is called when production alterpublicationstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterpublicationstmt(ctx *AlterpublicationstmtContext) {} + +// ExitAlterpublicationstmt is called when production alterpublicationstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterpublicationstmt(ctx *AlterpublicationstmtContext) {} + +// EnterCreatesubscriptionstmt is called when production createsubscriptionstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatesubscriptionstmt(ctx *CreatesubscriptionstmtContext) { +} + +// ExitCreatesubscriptionstmt is called when production createsubscriptionstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatesubscriptionstmt(ctx *CreatesubscriptionstmtContext) {} + +// EnterPublication_name_list is called when production publication_name_list is entered. +func (s *BaseRedshiftParserListener) EnterPublication_name_list(ctx *Publication_name_listContext) {} + +// ExitPublication_name_list is called when production publication_name_list is exited. +func (s *BaseRedshiftParserListener) ExitPublication_name_list(ctx *Publication_name_listContext) {} + +// EnterPublication_name_item is called when production publication_name_item is entered. +func (s *BaseRedshiftParserListener) EnterPublication_name_item(ctx *Publication_name_itemContext) {} + +// ExitPublication_name_item is called when production publication_name_item is exited. +func (s *BaseRedshiftParserListener) ExitPublication_name_item(ctx *Publication_name_itemContext) {} + +// EnterAltersubscriptionstmt is called when production altersubscriptionstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltersubscriptionstmt(ctx *AltersubscriptionstmtContext) {} + +// ExitAltersubscriptionstmt is called when production altersubscriptionstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltersubscriptionstmt(ctx *AltersubscriptionstmtContext) {} + +// EnterDropsubscriptionstmt is called when production dropsubscriptionstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropsubscriptionstmt(ctx *DropsubscriptionstmtContext) {} + +// ExitDropsubscriptionstmt is called when production dropsubscriptionstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropsubscriptionstmt(ctx *DropsubscriptionstmtContext) {} + +// EnterRulestmt is called when production rulestmt is entered. +func (s *BaseRedshiftParserListener) EnterRulestmt(ctx *RulestmtContext) {} + +// ExitRulestmt is called when production rulestmt is exited. +func (s *BaseRedshiftParserListener) ExitRulestmt(ctx *RulestmtContext) {} + +// EnterRuleactionlist is called when production ruleactionlist is entered. +func (s *BaseRedshiftParserListener) EnterRuleactionlist(ctx *RuleactionlistContext) {} + +// ExitRuleactionlist is called when production ruleactionlist is exited. +func (s *BaseRedshiftParserListener) ExitRuleactionlist(ctx *RuleactionlistContext) {} + +// EnterRuleactionmulti is called when production ruleactionmulti is entered. +func (s *BaseRedshiftParserListener) EnterRuleactionmulti(ctx *RuleactionmultiContext) {} + +// ExitRuleactionmulti is called when production ruleactionmulti is exited. +func (s *BaseRedshiftParserListener) ExitRuleactionmulti(ctx *RuleactionmultiContext) {} + +// EnterRuleactionstmt is called when production ruleactionstmt is entered. +func (s *BaseRedshiftParserListener) EnterRuleactionstmt(ctx *RuleactionstmtContext) {} + +// ExitRuleactionstmt is called when production ruleactionstmt is exited. +func (s *BaseRedshiftParserListener) ExitRuleactionstmt(ctx *RuleactionstmtContext) {} + +// EnterRuleactionstmtOrEmpty is called when production ruleactionstmtOrEmpty is entered. +func (s *BaseRedshiftParserListener) EnterRuleactionstmtOrEmpty(ctx *RuleactionstmtOrEmptyContext) {} + +// ExitRuleactionstmtOrEmpty is called when production ruleactionstmtOrEmpty is exited. +func (s *BaseRedshiftParserListener) ExitRuleactionstmtOrEmpty(ctx *RuleactionstmtOrEmptyContext) {} + +// EnterEvent is called when production event is entered. +func (s *BaseRedshiftParserListener) EnterEvent(ctx *EventContext) {} + +// ExitEvent is called when production event is exited. +func (s *BaseRedshiftParserListener) ExitEvent(ctx *EventContext) {} + +// EnterOpt_instead is called when production opt_instead is entered. +func (s *BaseRedshiftParserListener) EnterOpt_instead(ctx *Opt_insteadContext) {} + +// ExitOpt_instead is called when production opt_instead is exited. +func (s *BaseRedshiftParserListener) ExitOpt_instead(ctx *Opt_insteadContext) {} + +// EnterNotifystmt is called when production notifystmt is entered. +func (s *BaseRedshiftParserListener) EnterNotifystmt(ctx *NotifystmtContext) {} + +// ExitNotifystmt is called when production notifystmt is exited. +func (s *BaseRedshiftParserListener) ExitNotifystmt(ctx *NotifystmtContext) {} + +// EnterNotify_payload is called when production notify_payload is entered. +func (s *BaseRedshiftParserListener) EnterNotify_payload(ctx *Notify_payloadContext) {} + +// ExitNotify_payload is called when production notify_payload is exited. +func (s *BaseRedshiftParserListener) ExitNotify_payload(ctx *Notify_payloadContext) {} + +// EnterListenstmt is called when production listenstmt is entered. +func (s *BaseRedshiftParserListener) EnterListenstmt(ctx *ListenstmtContext) {} + +// ExitListenstmt is called when production listenstmt is exited. +func (s *BaseRedshiftParserListener) ExitListenstmt(ctx *ListenstmtContext) {} + +// EnterUnlistenstmt is called when production unlistenstmt is entered. +func (s *BaseRedshiftParserListener) EnterUnlistenstmt(ctx *UnlistenstmtContext) {} + +// ExitUnlistenstmt is called when production unlistenstmt is exited. +func (s *BaseRedshiftParserListener) ExitUnlistenstmt(ctx *UnlistenstmtContext) {} + +// EnterTransactionstmt is called when production transactionstmt is entered. +func (s *BaseRedshiftParserListener) EnterTransactionstmt(ctx *TransactionstmtContext) {} + +// ExitTransactionstmt is called when production transactionstmt is exited. +func (s *BaseRedshiftParserListener) ExitTransactionstmt(ctx *TransactionstmtContext) {} + +// EnterOpt_transaction is called when production opt_transaction is entered. +func (s *BaseRedshiftParserListener) EnterOpt_transaction(ctx *Opt_transactionContext) {} + +// ExitOpt_transaction is called when production opt_transaction is exited. +func (s *BaseRedshiftParserListener) ExitOpt_transaction(ctx *Opt_transactionContext) {} + +// EnterTransaction_mode_item is called when production transaction_mode_item is entered. +func (s *BaseRedshiftParserListener) EnterTransaction_mode_item(ctx *Transaction_mode_itemContext) {} + +// ExitTransaction_mode_item is called when production transaction_mode_item is exited. +func (s *BaseRedshiftParserListener) ExitTransaction_mode_item(ctx *Transaction_mode_itemContext) {} + +// EnterTransaction_mode_list is called when production transaction_mode_list is entered. +func (s *BaseRedshiftParserListener) EnterTransaction_mode_list(ctx *Transaction_mode_listContext) {} + +// ExitTransaction_mode_list is called when production transaction_mode_list is exited. +func (s *BaseRedshiftParserListener) ExitTransaction_mode_list(ctx *Transaction_mode_listContext) {} + +// EnterTransaction_mode_list_or_empty is called when production transaction_mode_list_or_empty is entered. +func (s *BaseRedshiftParserListener) EnterTransaction_mode_list_or_empty(ctx *Transaction_mode_list_or_emptyContext) { +} + +// ExitTransaction_mode_list_or_empty is called when production transaction_mode_list_or_empty is exited. +func (s *BaseRedshiftParserListener) ExitTransaction_mode_list_or_empty(ctx *Transaction_mode_list_or_emptyContext) { +} + +// EnterOpt_transaction_chain is called when production opt_transaction_chain is entered. +func (s *BaseRedshiftParserListener) EnterOpt_transaction_chain(ctx *Opt_transaction_chainContext) {} + +// ExitOpt_transaction_chain is called when production opt_transaction_chain is exited. +func (s *BaseRedshiftParserListener) ExitOpt_transaction_chain(ctx *Opt_transaction_chainContext) {} + +// EnterViewstmt is called when production viewstmt is entered. +func (s *BaseRedshiftParserListener) EnterViewstmt(ctx *ViewstmtContext) {} + +// ExitViewstmt is called when production viewstmt is exited. +func (s *BaseRedshiftParserListener) ExitViewstmt(ctx *ViewstmtContext) {} + +// EnterWith_no_schema_binding is called when production with_no_schema_binding is entered. +func (s *BaseRedshiftParserListener) EnterWith_no_schema_binding(ctx *With_no_schema_bindingContext) { +} + +// ExitWith_no_schema_binding is called when production with_no_schema_binding is exited. +func (s *BaseRedshiftParserListener) ExitWith_no_schema_binding(ctx *With_no_schema_bindingContext) {} + +// EnterOpt_check_option is called when production opt_check_option is entered. +func (s *BaseRedshiftParserListener) EnterOpt_check_option(ctx *Opt_check_optionContext) {} + +// ExitOpt_check_option is called when production opt_check_option is exited. +func (s *BaseRedshiftParserListener) ExitOpt_check_option(ctx *Opt_check_optionContext) {} + +// EnterLoadstmt is called when production loadstmt is entered. +func (s *BaseRedshiftParserListener) EnterLoadstmt(ctx *LoadstmtContext) {} + +// ExitLoadstmt is called when production loadstmt is exited. +func (s *BaseRedshiftParserListener) ExitLoadstmt(ctx *LoadstmtContext) {} + +// EnterAlterdatasharestmt is called when production alterdatasharestmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterdatasharestmt(ctx *AlterdatasharestmtContext) {} + +// ExitAlterdatasharestmt is called when production alterdatasharestmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterdatasharestmt(ctx *AlterdatasharestmtContext) {} + +// EnterAlterdatashare_action is called when production alterdatashare_action is entered. +func (s *BaseRedshiftParserListener) EnterAlterdatashare_action(ctx *Alterdatashare_actionContext) {} + +// ExitAlterdatashare_action is called when production alterdatashare_action is exited. +func (s *BaseRedshiftParserListener) ExitAlterdatashare_action(ctx *Alterdatashare_actionContext) {} + +// EnterAlterdatashare_add_drop is called when production alterdatashare_add_drop is entered. +func (s *BaseRedshiftParserListener) EnterAlterdatashare_add_drop(ctx *Alterdatashare_add_dropContext) { +} + +// ExitAlterdatashare_add_drop is called when production alterdatashare_add_drop is exited. +func (s *BaseRedshiftParserListener) ExitAlterdatashare_add_drop(ctx *Alterdatashare_add_dropContext) { +} + +// EnterAlterdatashare_objects is called when production alterdatashare_objects is entered. +func (s *BaseRedshiftParserListener) EnterAlterdatashare_objects(ctx *Alterdatashare_objectsContext) { +} + +// ExitAlterdatashare_objects is called when production alterdatashare_objects is exited. +func (s *BaseRedshiftParserListener) ExitAlterdatashare_objects(ctx *Alterdatashare_objectsContext) {} + +// EnterDatashare_table_list is called when production datashare_table_list is entered. +func (s *BaseRedshiftParserListener) EnterDatashare_table_list(ctx *Datashare_table_listContext) {} + +// ExitDatashare_table_list is called when production datashare_table_list is exited. +func (s *BaseRedshiftParserListener) ExitDatashare_table_list(ctx *Datashare_table_listContext) {} + +// EnterDatashare_table_name is called when production datashare_table_name is entered. +func (s *BaseRedshiftParserListener) EnterDatashare_table_name(ctx *Datashare_table_nameContext) {} + +// ExitDatashare_table_name is called when production datashare_table_name is exited. +func (s *BaseRedshiftParserListener) ExitDatashare_table_name(ctx *Datashare_table_nameContext) {} + +// EnterTable_name is called when production table_name is entered. +func (s *BaseRedshiftParserListener) EnterTable_name(ctx *Table_nameContext) {} + +// ExitTable_name is called when production table_name is exited. +func (s *BaseRedshiftParserListener) ExitTable_name(ctx *Table_nameContext) {} + +// EnterTemporary_table_name is called when production temporary_table_name is entered. +func (s *BaseRedshiftParserListener) EnterTemporary_table_name(ctx *Temporary_table_nameContext) {} + +// ExitTemporary_table_name is called when production temporary_table_name is exited. +func (s *BaseRedshiftParserListener) ExitTemporary_table_name(ctx *Temporary_table_nameContext) {} + +// EnterDatashare_function_list is called when production datashare_function_list is entered. +func (s *BaseRedshiftParserListener) EnterDatashare_function_list(ctx *Datashare_function_listContext) { +} + +// ExitDatashare_function_list is called when production datashare_function_list is exited. +func (s *BaseRedshiftParserListener) ExitDatashare_function_list(ctx *Datashare_function_listContext) { +} + +// EnterDatashare_function is called when production datashare_function is entered. +func (s *BaseRedshiftParserListener) EnterDatashare_function(ctx *Datashare_functionContext) {} + +// ExitDatashare_function is called when production datashare_function is exited. +func (s *BaseRedshiftParserListener) ExitDatashare_function(ctx *Datashare_functionContext) {} + +// EnterDatashare_function_name is called when production datashare_function_name is entered. +func (s *BaseRedshiftParserListener) EnterDatashare_function_name(ctx *Datashare_function_nameContext) { +} + +// ExitDatashare_function_name is called when production datashare_function_name is exited. +func (s *BaseRedshiftParserListener) ExitDatashare_function_name(ctx *Datashare_function_nameContext) { +} + +// EnterCreatedatasharestmt is called when production createdatasharestmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatedatasharestmt(ctx *CreatedatasharestmtContext) {} + +// ExitCreatedatasharestmt is called when production createdatasharestmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatedatasharestmt(ctx *CreatedatasharestmtContext) {} + +// EnterCreatedatashareoptions is called when production createdatashareoptions is entered. +func (s *BaseRedshiftParserListener) EnterCreatedatashareoptions(ctx *CreatedatashareoptionsContext) { +} + +// ExitCreatedatashareoptions is called when production createdatashareoptions is exited. +func (s *BaseRedshiftParserListener) ExitCreatedatashareoptions(ctx *CreatedatashareoptionsContext) {} + +// EnterCreatedatashareoption is called when production createdatashareoption is entered. +func (s *BaseRedshiftParserListener) EnterCreatedatashareoption(ctx *CreatedatashareoptionContext) {} + +// ExitCreatedatashareoption is called when production createdatashareoption is exited. +func (s *BaseRedshiftParserListener) ExitCreatedatashareoption(ctx *CreatedatashareoptionContext) {} + +// EnterSetpublicaccessibleoption is called when production setpublicaccessibleoption is entered. +func (s *BaseRedshiftParserListener) EnterSetpublicaccessibleoption(ctx *SetpublicaccessibleoptionContext) { +} + +// ExitSetpublicaccessibleoption is called when production setpublicaccessibleoption is exited. +func (s *BaseRedshiftParserListener) ExitSetpublicaccessibleoption(ctx *SetpublicaccessibleoptionContext) { +} + +// EnterManagedbyoption is called when production managedbyoption is entered. +func (s *BaseRedshiftParserListener) EnterManagedbyoption(ctx *ManagedbyoptionContext) {} + +// ExitManagedbyoption is called when production managedbyoption is exited. +func (s *BaseRedshiftParserListener) ExitManagedbyoption(ctx *ManagedbyoptionContext) {} + +// EnterDescdatasharestmt is called when production descdatasharestmt is entered. +func (s *BaseRedshiftParserListener) EnterDescdatasharestmt(ctx *DescdatasharestmtContext) {} + +// ExitDescdatasharestmt is called when production descdatasharestmt is exited. +func (s *BaseRedshiftParserListener) ExitDescdatasharestmt(ctx *DescdatasharestmtContext) {} + +// EnterDropdatasharestmt is called when production dropdatasharestmt is entered. +func (s *BaseRedshiftParserListener) EnterDropdatasharestmt(ctx *DropdatasharestmtContext) {} + +// ExitDropdatasharestmt is called when production dropdatasharestmt is exited. +func (s *BaseRedshiftParserListener) ExitDropdatasharestmt(ctx *DropdatasharestmtContext) {} + +// EnterAlterexternalschemastmt is called when production alterexternalschemastmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterexternalschemastmt(ctx *AlterexternalschemastmtContext) { +} + +// ExitAlterexternalschemastmt is called when production alterexternalschemastmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterexternalschemastmt(ctx *AlterexternalschemastmtContext) { +} + +// EnterAltexternalschemaopts is called when production altexternalschemaopts is entered. +func (s *BaseRedshiftParserListener) EnterAltexternalschemaopts(ctx *AltexternalschemaoptsContext) {} + +// ExitAltexternalschemaopts is called when production altexternalschemaopts is exited. +func (s *BaseRedshiftParserListener) ExitAltexternalschemaopts(ctx *AltexternalschemaoptsContext) {} + +// EnterAlterexternalviewstmt is called when production alterexternalviewstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterexternalviewstmt(ctx *AlterexternalviewstmtContext) {} + +// ExitAlterexternalviewstmt is called when production alterexternalviewstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterexternalviewstmt(ctx *AlterexternalviewstmtContext) {} + +// EnterCreateexternalschemastmt is called when production createexternalschemastmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateexternalschemastmt(ctx *CreateexternalschemastmtContext) { +} + +// ExitCreateexternalschemastmt is called when production createexternalschemastmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateexternalschemastmt(ctx *CreateexternalschemastmtContext) { +} + +// EnterFromdatacatalogclause is called when production fromdatacatalogclause is entered. +func (s *BaseRedshiftParserListener) EnterFromdatacatalogclause(ctx *FromdatacatalogclauseContext) {} + +// ExitFromdatacatalogclause is called when production fromdatacatalogclause is exited. +func (s *BaseRedshiftParserListener) ExitFromdatacatalogclause(ctx *FromdatacatalogclauseContext) {} + +// EnterDropschemastmt is called when production dropschemastmt is entered. +func (s *BaseRedshiftParserListener) EnterDropschemastmt(ctx *DropschemastmtContext) {} + +// ExitDropschemastmt is called when production dropschemastmt is exited. +func (s *BaseRedshiftParserListener) ExitDropschemastmt(ctx *DropschemastmtContext) {} + +// EnterImplicitdatacatalogclause is called when production implicitdatacatalogclause is entered. +func (s *BaseRedshiftParserListener) EnterImplicitdatacatalogclause(ctx *ImplicitdatacatalogclauseContext) { +} + +// ExitImplicitdatacatalogclause is called when production implicitdatacatalogclause is exited. +func (s *BaseRedshiftParserListener) ExitImplicitdatacatalogclause(ctx *ImplicitdatacatalogclauseContext) { +} + +// EnterFromhivemetastoreclause is called when production fromhivemetastoreclause is entered. +func (s *BaseRedshiftParserListener) EnterFromhivemetastoreclause(ctx *FromhivemetastoreclauseContext) { +} + +// ExitFromhivemetastoreclause is called when production fromhivemetastoreclause is exited. +func (s *BaseRedshiftParserListener) ExitFromhivemetastoreclause(ctx *FromhivemetastoreclauseContext) { +} + +// EnterFrompostgresclause is called when production frompostgresclause is entered. +func (s *BaseRedshiftParserListener) EnterFrompostgresclause(ctx *FrompostgresclauseContext) {} + +// ExitFrompostgresclause is called when production frompostgresclause is exited. +func (s *BaseRedshiftParserListener) ExitFrompostgresclause(ctx *FrompostgresclauseContext) {} + +// EnterFrommysqlclause is called when production frommysqlclause is entered. +func (s *BaseRedshiftParserListener) EnterFrommysqlclause(ctx *FrommysqlclauseContext) {} + +// ExitFrommysqlclause is called when production frommysqlclause is exited. +func (s *BaseRedshiftParserListener) ExitFrommysqlclause(ctx *FrommysqlclauseContext) {} + +// EnterFromkinesisclause is called when production fromkinesisclause is entered. +func (s *BaseRedshiftParserListener) EnterFromkinesisclause(ctx *FromkinesisclauseContext) {} + +// ExitFromkinesisclause is called when production fromkinesisclause is exited. +func (s *BaseRedshiftParserListener) ExitFromkinesisclause(ctx *FromkinesisclauseContext) {} + +// EnterFromkafkaclause is called when production fromkafkaclause is entered. +func (s *BaseRedshiftParserListener) EnterFromkafkaclause(ctx *FromkafkaclauseContext) {} + +// ExitFromkafkaclause is called when production fromkafkaclause is exited. +func (s *BaseRedshiftParserListener) ExitFromkafkaclause(ctx *FromkafkaclauseContext) {} + +// EnterFrommskclause is called when production frommskclause is entered. +func (s *BaseRedshiftParserListener) EnterFrommskclause(ctx *FrommskclauseContext) {} + +// ExitFrommskclause is called when production frommskclause is exited. +func (s *BaseRedshiftParserListener) ExitFrommskclause(ctx *FrommskclauseContext) {} + +// EnterFromredshiftclause is called when production fromredshiftclause is entered. +func (s *BaseRedshiftParserListener) EnterFromredshiftclause(ctx *FromredshiftclauseContext) {} + +// ExitFromredshiftclause is called when production fromredshiftclause is exited. +func (s *BaseRedshiftParserListener) ExitFromredshiftclause(ctx *FromredshiftclauseContext) {} + +// EnterIamrolevalue is called when production iamrolevalue is entered. +func (s *BaseRedshiftParserListener) EnterIamrolevalue(ctx *IamrolevalueContext) {} + +// ExitIamrolevalue is called when production iamrolevalue is exited. +func (s *BaseRedshiftParserListener) ExitIamrolevalue(ctx *IamrolevalueContext) {} + +// EnterCatalogrolevalue is called when production catalogrolevalue is entered. +func (s *BaseRedshiftParserListener) EnterCatalogrolevalue(ctx *CatalogrolevalueContext) {} + +// ExitCatalogrolevalue is called when production catalogrolevalue is exited. +func (s *BaseRedshiftParserListener) ExitCatalogrolevalue(ctx *CatalogrolevalueContext) {} + +// EnterAuthenticationvalue is called when production authenticationvalue is entered. +func (s *BaseRedshiftParserListener) EnterAuthenticationvalue(ctx *AuthenticationvalueContext) {} + +// ExitAuthenticationvalue is called when production authenticationvalue is exited. +func (s *BaseRedshiftParserListener) ExitAuthenticationvalue(ctx *AuthenticationvalueContext) {} + +// EnterCreateexternalfunctionstmt is called when production createexternalfunctionstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateexternalfunctionstmt(ctx *CreateexternalfunctionstmtContext) { +} + +// ExitCreateexternalfunctionstmt is called when production createexternalfunctionstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateexternalfunctionstmt(ctx *CreateexternalfunctionstmtContext) { +} + +// EnterExternal_func_params is called when production external_func_params is entered. +func (s *BaseRedshiftParserListener) EnterExternal_func_params(ctx *External_func_paramsContext) {} + +// ExitExternal_func_params is called when production external_func_params is exited. +func (s *BaseRedshiftParserListener) ExitExternal_func_params(ctx *External_func_paramsContext) {} + +// EnterParamlist is called when production paramlist is entered. +func (s *BaseRedshiftParserListener) EnterParamlist(ctx *ParamlistContext) {} + +// ExitParamlist is called when production paramlist is exited. +func (s *BaseRedshiftParserListener) ExitParamlist(ctx *ParamlistContext) {} + +// EnterParam_spec is called when production param_spec is entered. +func (s *BaseRedshiftParserListener) EnterParam_spec(ctx *Param_specContext) {} + +// ExitParam_spec is called when production param_spec is exited. +func (s *BaseRedshiftParserListener) ExitParam_spec(ctx *Param_specContext) {} + +// EnterCreateexternalmodelstmt is called when production createexternalmodelstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateexternalmodelstmt(ctx *CreateexternalmodelstmtContext) { +} + +// ExitCreateexternalmodelstmt is called when production createexternalmodelstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateexternalmodelstmt(ctx *CreateexternalmodelstmtContext) { +} + +// EnterCreateexternaltablestmt is called when production createexternaltablestmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateexternaltablestmt(ctx *CreateexternaltablestmtContext) { +} + +// ExitCreateexternaltablestmt is called when production createexternaltablestmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateexternaltablestmt(ctx *CreateexternaltablestmtContext) { +} + +// EnterExtern_column_list is called when production extern_column_list is entered. +func (s *BaseRedshiftParserListener) EnterExtern_column_list(ctx *Extern_column_listContext) {} + +// ExitExtern_column_list is called when production extern_column_list is exited. +func (s *BaseRedshiftParserListener) ExitExtern_column_list(ctx *Extern_column_listContext) {} + +// EnterExtern_column_def is called when production extern_column_def is entered. +func (s *BaseRedshiftParserListener) EnterExtern_column_def(ctx *Extern_column_defContext) {} + +// ExitExtern_column_def is called when production extern_column_def is exited. +func (s *BaseRedshiftParserListener) ExitExtern_column_def(ctx *Extern_column_defContext) {} + +// EnterExtern_typename is called when production extern_typename is entered. +func (s *BaseRedshiftParserListener) EnterExtern_typename(ctx *Extern_typenameContext) {} + +// ExitExtern_typename is called when production extern_typename is exited. +func (s *BaseRedshiftParserListener) ExitExtern_typename(ctx *Extern_typenameContext) {} + +// EnterExtern_table_format is called when production extern_table_format is entered. +func (s *BaseRedshiftParserListener) EnterExtern_table_format(ctx *Extern_table_formatContext) {} + +// ExitExtern_table_format is called when production extern_table_format is exited. +func (s *BaseRedshiftParserListener) ExitExtern_table_format(ctx *Extern_table_formatContext) {} + +// EnterRow_format_spec is called when production row_format_spec is entered. +func (s *BaseRedshiftParserListener) EnterRow_format_spec(ctx *Row_format_specContext) {} + +// ExitRow_format_spec is called when production row_format_spec is exited. +func (s *BaseRedshiftParserListener) ExitRow_format_spec(ctx *Row_format_specContext) {} + +// EnterSerde_properties_list is called when production serde_properties_list is entered. +func (s *BaseRedshiftParserListener) EnterSerde_properties_list(ctx *Serde_properties_listContext) {} + +// ExitSerde_properties_list is called when production serde_properties_list is exited. +func (s *BaseRedshiftParserListener) ExitSerde_properties_list(ctx *Serde_properties_listContext) {} + +// EnterSerde_property is called when production serde_property is entered. +func (s *BaseRedshiftParserListener) EnterSerde_property(ctx *Serde_propertyContext) {} + +// ExitSerde_property is called when production serde_property is exited. +func (s *BaseRedshiftParserListener) ExitSerde_property(ctx *Serde_propertyContext) {} + +// EnterExternal_format_spec is called when production external_format_spec is entered. +func (s *BaseRedshiftParserListener) EnterExternal_format_spec(ctx *External_format_specContext) {} + +// ExitExternal_format_spec is called when production external_format_spec is exited. +func (s *BaseRedshiftParserListener) ExitExternal_format_spec(ctx *External_format_specContext) {} + +// EnterTable_properties_list is called when production table_properties_list is entered. +func (s *BaseRedshiftParserListener) EnterTable_properties_list(ctx *Table_properties_listContext) {} + +// ExitTable_properties_list is called when production table_properties_list is exited. +func (s *BaseRedshiftParserListener) ExitTable_properties_list(ctx *Table_properties_listContext) {} + +// EnterTable_property is called when production table_property is entered. +func (s *BaseRedshiftParserListener) EnterTable_property(ctx *Table_propertyContext) {} + +// ExitTable_property is called when production table_property is exited. +func (s *BaseRedshiftParserListener) ExitTable_property(ctx *Table_propertyContext) {} + +// EnterCreateexternalviewstmt is called when production createexternalviewstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateexternalviewstmt(ctx *CreateexternalviewstmtContext) { +} + +// ExitCreateexternalviewstmt is called when production createexternalviewstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateexternalviewstmt(ctx *CreateexternalviewstmtContext) {} + +// EnterDropexternalviewstmt is called when production dropexternalviewstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropexternalviewstmt(ctx *DropexternalviewstmtContext) {} + +// ExitDropexternalviewstmt is called when production dropexternalviewstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropexternalviewstmt(ctx *DropexternalviewstmtContext) {} + +// EnterAlteridentityproviderstmt is called when production alteridentityproviderstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlteridentityproviderstmt(ctx *AlteridentityproviderstmtContext) { +} + +// ExitAlteridentityproviderstmt is called when production alteridentityproviderstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlteridentityproviderstmt(ctx *AlteridentityproviderstmtContext) { +} + +// EnterAlteridprovideropts is called when production alteridprovideropts is entered. +func (s *BaseRedshiftParserListener) EnterAlteridprovideropts(ctx *AlteridprovideroptsContext) {} + +// ExitAlteridprovideropts is called when production alteridprovideropts is exited. +func (s *BaseRedshiftParserListener) ExitAlteridprovideropts(ctx *AlteridprovideroptsContext) {} + +// EnterAltermaskingpolicystmt is called when production altermaskingpolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterAltermaskingpolicystmt(ctx *AltermaskingpolicystmtContext) { +} + +// ExitAltermaskingpolicystmt is called when production altermaskingpolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitAltermaskingpolicystmt(ctx *AltermaskingpolicystmtContext) {} + +// EnterAltermaterializedviewstmt is called when production altermaterializedviewstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltermaterializedviewstmt(ctx *AltermaterializedviewstmtContext) { +} + +// ExitAltermaterializedviewstmt is called when production altermaterializedviewstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltermaterializedviewstmt(ctx *AltermaterializedviewstmtContext) { +} + +// EnterAltmaskingpolicyopts is called when production altmaskingpolicyopts is entered. +func (s *BaseRedshiftParserListener) EnterAltmaskingpolicyopts(ctx *AltmaskingpolicyoptsContext) {} + +// ExitAltmaskingpolicyopts is called when production altmaskingpolicyopts is exited. +func (s *BaseRedshiftParserListener) ExitAltmaskingpolicyopts(ctx *AltmaskingpolicyoptsContext) {} + +// EnterAltmaskingpolicyargs is called when production altmaskingpolicyargs is entered. +func (s *BaseRedshiftParserListener) EnterAltmaskingpolicyargs(ctx *AltmaskingpolicyargsContext) {} + +// ExitAltmaskingpolicyargs is called when production altmaskingpolicyargs is exited. +func (s *BaseRedshiftParserListener) ExitAltmaskingpolicyargs(ctx *AltmaskingpolicyargsContext) {} + +// EnterAltmaskingpolicyarg is called when production altmaskingpolicyarg is entered. +func (s *BaseRedshiftParserListener) EnterAltmaskingpolicyarg(ctx *AltmaskingpolicyargContext) {} + +// ExitAltmaskingpolicyarg is called when production altmaskingpolicyarg is exited. +func (s *BaseRedshiftParserListener) ExitAltmaskingpolicyarg(ctx *AltmaskingpolicyargContext) {} + +// EnterAlterrlspolicystmt is called when production alterrlspolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterrlspolicystmt(ctx *AlterrlspolicystmtContext) {} + +// ExitAlterrlspolicystmt is called when production alterrlspolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterrlspolicystmt(ctx *AlterrlspolicystmtContext) {} + +// EnterAttachmaskingpolicystmt is called when production attachmaskingpolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterAttachmaskingpolicystmt(ctx *AttachmaskingpolicystmtContext) { +} + +// ExitAttachmaskingpolicystmt is called when production attachmaskingpolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitAttachmaskingpolicystmt(ctx *AttachmaskingpolicystmtContext) { +} + +// EnterAttachpolicycollist is called when production attachpolicycollist is entered. +func (s *BaseRedshiftParserListener) EnterAttachpolicycollist(ctx *AttachpolicycollistContext) {} + +// ExitAttachpolicycollist is called when production attachpolicycollist is exited. +func (s *BaseRedshiftParserListener) ExitAttachpolicycollist(ctx *AttachpolicycollistContext) {} + +// EnterAttachpolicycolumn is called when production attachpolicycolumn is entered. +func (s *BaseRedshiftParserListener) EnterAttachpolicycolumn(ctx *AttachpolicycolumnContext) {} + +// ExitAttachpolicycolumn is called when production attachpolicycolumn is exited. +func (s *BaseRedshiftParserListener) ExitAttachpolicycolumn(ctx *AttachpolicycolumnContext) {} + +// EnterAttachpolicytargets is called when production attachpolicytargets is entered. +func (s *BaseRedshiftParserListener) EnterAttachpolicytargets(ctx *AttachpolicytargetsContext) {} + +// ExitAttachpolicytargets is called when production attachpolicytargets is exited. +func (s *BaseRedshiftParserListener) ExitAttachpolicytargets(ctx *AttachpolicytargetsContext) {} + +// EnterAttachpolicytarget is called when production attachpolicytarget is entered. +func (s *BaseRedshiftParserListener) EnterAttachpolicytarget(ctx *AttachpolicytargetContext) {} + +// ExitAttachpolicytarget is called when production attachpolicytarget is exited. +func (s *BaseRedshiftParserListener) ExitAttachpolicytarget(ctx *AttachpolicytargetContext) {} + +// EnterAttachrlspolicystmt is called when production attachrlspolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterAttachrlspolicystmt(ctx *AttachrlspolicystmtContext) {} + +// ExitAttachrlspolicystmt is called when production attachrlspolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitAttachrlspolicystmt(ctx *AttachrlspolicystmtContext) {} + +// EnterTable_name_list is called when production table_name_list is entered. +func (s *BaseRedshiftParserListener) EnterTable_name_list(ctx *Table_name_listContext) {} + +// ExitTable_name_list is called when production table_name_list is exited. +func (s *BaseRedshiftParserListener) ExitTable_name_list(ctx *Table_name_listContext) {} + +// EnterCreateidentityproviderstmt is called when production createidentityproviderstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateidentityproviderstmt(ctx *CreateidentityproviderstmtContext) { +} + +// ExitCreateidentityproviderstmt is called when production createidentityproviderstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateidentityproviderstmt(ctx *CreateidentityproviderstmtContext) { +} + +// EnterCreateidprovideropts is called when production createidprovideropts is entered. +func (s *BaseRedshiftParserListener) EnterCreateidprovideropts(ctx *CreateidprovideroptsContext) {} + +// ExitCreateidprovideropts is called when production createidprovideropts is exited. +func (s *BaseRedshiftParserListener) ExitCreateidprovideropts(ctx *CreateidprovideroptsContext) {} + +// EnterGroupfilter is called when production groupfilter is entered. +func (s *BaseRedshiftParserListener) EnterGroupfilter(ctx *GroupfilterContext) {} + +// ExitGroupfilter is called when production groupfilter is exited. +func (s *BaseRedshiftParserListener) ExitGroupfilter(ctx *GroupfilterContext) {} + +// EnterCreatelibrarystmt is called when production createlibrarystmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatelibrarystmt(ctx *CreatelibrarystmtContext) {} + +// ExitCreatelibrarystmt is called when production createlibrarystmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatelibrarystmt(ctx *CreatelibrarystmtContext) {} + +// EnterCreatelibraryopts is called when production createlibraryopts is entered. +func (s *BaseRedshiftParserListener) EnterCreatelibraryopts(ctx *CreatelibraryoptsContext) {} + +// ExitCreatelibraryopts is called when production createlibraryopts is exited. +func (s *BaseRedshiftParserListener) ExitCreatelibraryopts(ctx *CreatelibraryoptsContext) {} + +// EnterCreatemaskingpolicystmt is called when production createmaskingpolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatemaskingpolicystmt(ctx *CreatemaskingpolicystmtContext) { +} + +// ExitCreatemaskingpolicystmt is called when production createmaskingpolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatemaskingpolicystmt(ctx *CreatemaskingpolicystmtContext) { +} + +// EnterInputcolumnlist is called when production inputcolumnlist is entered. +func (s *BaseRedshiftParserListener) EnterInputcolumnlist(ctx *InputcolumnlistContext) {} + +// ExitInputcolumnlist is called when production inputcolumnlist is exited. +func (s *BaseRedshiftParserListener) ExitInputcolumnlist(ctx *InputcolumnlistContext) {} + +// EnterInputcolumn is called when production inputcolumn is entered. +func (s *BaseRedshiftParserListener) EnterInputcolumn(ctx *InputcolumnContext) {} + +// ExitInputcolumn is called when production inputcolumn is exited. +func (s *BaseRedshiftParserListener) ExitInputcolumn(ctx *InputcolumnContext) {} + +// EnterMaskingexpression is called when production maskingexpression is entered. +func (s *BaseRedshiftParserListener) EnterMaskingexpression(ctx *MaskingexpressionContext) {} + +// ExitMaskingexpression is called when production maskingexpression is exited. +func (s *BaseRedshiftParserListener) ExitMaskingexpression(ctx *MaskingexpressionContext) {} + +// EnterCreatemodelstmt is called when production createmodelstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatemodelstmt(ctx *CreatemodelstmtContext) {} + +// ExitCreatemodelstmt is called when production createmodelstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatemodelstmt(ctx *CreatemodelstmtContext) {} + +// EnterCreatemodelfromclause is called when production createmodelfromclause is entered. +func (s *BaseRedshiftParserListener) EnterCreatemodelfromclause(ctx *CreatemodelfromclauseContext) {} + +// ExitCreatemodelfromclause is called when production createmodelfromclause is exited. +func (s *BaseRedshiftParserListener) ExitCreatemodelfromclause(ctx *CreatemodelfromclauseContext) {} + +// EnterIamrolespec is called when production iamrolespec is entered. +func (s *BaseRedshiftParserListener) EnterIamrolespec(ctx *IamrolespecContext) {} + +// ExitIamrolespec is called when production iamrolespec is exited. +func (s *BaseRedshiftParserListener) ExitIamrolespec(ctx *IamrolespecContext) {} + +// EnterSagemakerspec is called when production sagemakerspec is entered. +func (s *BaseRedshiftParserListener) EnterSagemakerspec(ctx *SagemakerspecContext) {} + +// ExitSagemakerspec is called when production sagemakerspec is exited. +func (s *BaseRedshiftParserListener) ExitSagemakerspec(ctx *SagemakerspecContext) {} + +// EnterModeltypespec is called when production modeltypespec is entered. +func (s *BaseRedshiftParserListener) EnterModeltypespec(ctx *ModeltypespecContext) {} + +// ExitModeltypespec is called when production modeltypespec is exited. +func (s *BaseRedshiftParserListener) ExitModeltypespec(ctx *ModeltypespecContext) {} + +// EnterProblemtypespec is called when production problemtypespec is entered. +func (s *BaseRedshiftParserListener) EnterProblemtypespec(ctx *ProblemtypespecContext) {} + +// ExitProblemtypespec is called when production problemtypespec is exited. +func (s *BaseRedshiftParserListener) ExitProblemtypespec(ctx *ProblemtypespecContext) {} + +// EnterProblemtype is called when production problemtype is entered. +func (s *BaseRedshiftParserListener) EnterProblemtype(ctx *ProblemtypeContext) {} + +// ExitProblemtype is called when production problemtype is exited. +func (s *BaseRedshiftParserListener) ExitProblemtype(ctx *ProblemtypeContext) {} + +// EnterObjectivespec is called when production objectivespec is entered. +func (s *BaseRedshiftParserListener) EnterObjectivespec(ctx *ObjectivespecContext) {} + +// ExitObjectivespec is called when production objectivespec is exited. +func (s *BaseRedshiftParserListener) ExitObjectivespec(ctx *ObjectivespecContext) {} + +// EnterHyperparametersspec is called when production hyperparametersspec is entered. +func (s *BaseRedshiftParserListener) EnterHyperparametersspec(ctx *HyperparametersspecContext) {} + +// ExitHyperparametersspec is called when production hyperparametersspec is exited. +func (s *BaseRedshiftParserListener) ExitHyperparametersspec(ctx *HyperparametersspecContext) {} + +// EnterHyperparameterslist is called when production hyperparameterslist is entered. +func (s *BaseRedshiftParserListener) EnterHyperparameterslist(ctx *HyperparameterslistContext) {} + +// ExitHyperparameterslist is called when production hyperparameterslist is exited. +func (s *BaseRedshiftParserListener) ExitHyperparameterslist(ctx *HyperparameterslistContext) {} + +// EnterHyperparameteritem is called when production hyperparameteritem is entered. +func (s *BaseRedshiftParserListener) EnterHyperparameteritem(ctx *HyperparameteritemContext) {} + +// ExitHyperparameteritem is called when production hyperparameteritem is exited. +func (s *BaseRedshiftParserListener) ExitHyperparameteritem(ctx *HyperparameteritemContext) {} + +// EnterSettingsclause is called when production settingsclause is entered. +func (s *BaseRedshiftParserListener) EnterSettingsclause(ctx *SettingsclauseContext) {} + +// ExitSettingsclause is called when production settingsclause is exited. +func (s *BaseRedshiftParserListener) ExitSettingsclause(ctx *SettingsclauseContext) {} + +// EnterSettingsitem is called when production settingsitem is entered. +func (s *BaseRedshiftParserListener) EnterSettingsitem(ctx *SettingsitemContext) {} + +// ExitSettingsitem is called when production settingsitem is exited. +func (s *BaseRedshiftParserListener) ExitSettingsitem(ctx *SettingsitemContext) {} + +// EnterDatatypelist is called when production datatypelist is entered. +func (s *BaseRedshiftParserListener) EnterDatatypelist(ctx *DatatypelistContext) {} + +// ExitDatatypelist is called when production datatypelist is exited. +func (s *BaseRedshiftParserListener) ExitDatatypelist(ctx *DatatypelistContext) {} + +// EnterDatatype is called when production datatype is entered. +func (s *BaseRedshiftParserListener) EnterDatatype(ctx *DatatypeContext) {} + +// ExitDatatype is called when production datatype is exited. +func (s *BaseRedshiftParserListener) ExitDatatype(ctx *DatatypeContext) {} + +// EnterCreaterlspolicystmt is called when production createrlspolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterCreaterlspolicystmt(ctx *CreaterlspolicystmtContext) {} + +// ExitCreaterlspolicystmt is called when production createrlspolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitCreaterlspolicystmt(ctx *CreaterlspolicystmtContext) {} + +// EnterDescidentityproviderstmt is called when production descidentityproviderstmt is entered. +func (s *BaseRedshiftParserListener) EnterDescidentityproviderstmt(ctx *DescidentityproviderstmtContext) { +} + +// ExitDescidentityproviderstmt is called when production descidentityproviderstmt is exited. +func (s *BaseRedshiftParserListener) ExitDescidentityproviderstmt(ctx *DescidentityproviderstmtContext) { +} + +// EnterDetachmaskingpolicystmt is called when production detachmaskingpolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterDetachmaskingpolicystmt(ctx *DetachmaskingpolicystmtContext) { +} + +// ExitDetachmaskingpolicystmt is called when production detachmaskingpolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitDetachmaskingpolicystmt(ctx *DetachmaskingpolicystmtContext) { +} + +// EnterDetachrlspolicystmt is called when production detachrlspolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterDetachrlspolicystmt(ctx *DetachrlspolicystmtContext) {} + +// ExitDetachrlspolicystmt is called when production detachrlspolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitDetachrlspolicystmt(ctx *DetachrlspolicystmtContext) {} + +// EnterRole_or_user_or_public_list is called when production role_or_user_or_public_list is entered. +func (s *BaseRedshiftParserListener) EnterRole_or_user_or_public_list(ctx *Role_or_user_or_public_listContext) { +} + +// ExitRole_or_user_or_public_list is called when production role_or_user_or_public_list is exited. +func (s *BaseRedshiftParserListener) ExitRole_or_user_or_public_list(ctx *Role_or_user_or_public_listContext) { +} + +// EnterRole_or_user_or_public is called when production role_or_user_or_public is entered. +func (s *BaseRedshiftParserListener) EnterRole_or_user_or_public(ctx *Role_or_user_or_publicContext) { +} + +// ExitRole_or_user_or_public is called when production role_or_user_or_public is exited. +func (s *BaseRedshiftParserListener) ExitRole_or_user_or_public(ctx *Role_or_user_or_publicContext) {} + +// EnterRlspolicyname is called when production rlspolicyname is entered. +func (s *BaseRedshiftParserListener) EnterRlspolicyname(ctx *RlspolicynameContext) {} + +// ExitRlspolicyname is called when production rlspolicyname is exited. +func (s *BaseRedshiftParserListener) ExitRlspolicyname(ctx *RlspolicynameContext) {} + +// EnterDropidentityproviderstmt is called when production dropidentityproviderstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropidentityproviderstmt(ctx *DropidentityproviderstmtContext) { +} + +// ExitDropidentityproviderstmt is called when production dropidentityproviderstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropidentityproviderstmt(ctx *DropidentityproviderstmtContext) { +} + +// EnterDroplibrarystmt is called when production droplibrarystmt is entered. +func (s *BaseRedshiftParserListener) EnterDroplibrarystmt(ctx *DroplibrarystmtContext) {} + +// ExitDroplibrarystmt is called when production droplibrarystmt is exited. +func (s *BaseRedshiftParserListener) ExitDroplibrarystmt(ctx *DroplibrarystmtContext) {} + +// EnterDropmaskingpolicystmt is called when production dropmaskingpolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterDropmaskingpolicystmt(ctx *DropmaskingpolicystmtContext) {} + +// ExitDropmaskingpolicystmt is called when production dropmaskingpolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitDropmaskingpolicystmt(ctx *DropmaskingpolicystmtContext) {} + +// EnterDropmodelstmt is called when production dropmodelstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropmodelstmt(ctx *DropmodelstmtContext) {} + +// ExitDropmodelstmt is called when production dropmodelstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropmodelstmt(ctx *DropmodelstmtContext) {} + +// EnterDroprlspolicystmt is called when production droprlspolicystmt is entered. +func (s *BaseRedshiftParserListener) EnterDroprlspolicystmt(ctx *DroprlspolicystmtContext) {} + +// ExitDroprlspolicystmt is called when production droprlspolicystmt is exited. +func (s *BaseRedshiftParserListener) ExitDroprlspolicystmt(ctx *DroprlspolicystmtContext) {} + +// EnterAltertableappendstmt is called when production altertableappendstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltertableappendstmt(ctx *AltertableappendstmtContext) {} + +// ExitAltertableappendstmt is called when production altertableappendstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltertableappendstmt(ctx *AltertableappendstmtContext) {} + +// EnterAppendoptions is called when production appendoptions is entered. +func (s *BaseRedshiftParserListener) EnterAppendoptions(ctx *AppendoptionsContext) {} + +// ExitAppendoptions is called when production appendoptions is exited. +func (s *BaseRedshiftParserListener) ExitAppendoptions(ctx *AppendoptionsContext) {} + +// EnterAlteruserstmt is called when production alteruserstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlteruserstmt(ctx *AlteruserstmtContext) {} + +// ExitAlteruserstmt is called when production alteruserstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlteruserstmt(ctx *AlteruserstmtContext) {} + +// EnterAlteruseropts is called when production alteruseropts is entered. +func (s *BaseRedshiftParserListener) EnterAlteruseropts(ctx *AlteruseroptsContext) {} + +// ExitAlteruseropts is called when production alteruseropts is exited. +func (s *BaseRedshiftParserListener) ExitAlteruseropts(ctx *AlteruseroptsContext) {} + +// EnterAnalyzecompressionstmt is called when production analyzecompressionstmt is entered. +func (s *BaseRedshiftParserListener) EnterAnalyzecompressionstmt(ctx *AnalyzecompressionstmtContext) { +} + +// ExitAnalyzecompressionstmt is called when production analyzecompressionstmt is exited. +func (s *BaseRedshiftParserListener) ExitAnalyzecompressionstmt(ctx *AnalyzecompressionstmtContext) {} + +// EnterCancelstmt is called when production cancelstmt is entered. +func (s *BaseRedshiftParserListener) EnterCancelstmt(ctx *CancelstmtContext) {} + +// ExitCancelstmt is called when production cancelstmt is exited. +func (s *BaseRedshiftParserListener) ExitCancelstmt(ctx *CancelstmtContext) {} + +// EnterClosestmt is called when production closestmt is entered. +func (s *BaseRedshiftParserListener) EnterClosestmt(ctx *ClosestmtContext) {} + +// ExitClosestmt is called when production closestmt is exited. +func (s *BaseRedshiftParserListener) ExitClosestmt(ctx *ClosestmtContext) {} + +// EnterInsertexternaltablestmt is called when production insertexternaltablestmt is entered. +func (s *BaseRedshiftParserListener) EnterInsertexternaltablestmt(ctx *InsertexternaltablestmtContext) { +} + +// ExitInsertexternaltablestmt is called when production insertexternaltablestmt is exited. +func (s *BaseRedshiftParserListener) ExitInsertexternaltablestmt(ctx *InsertexternaltablestmtContext) { +} + +// EnterSelect_or_values is called when production select_or_values is entered. +func (s *BaseRedshiftParserListener) EnterSelect_or_values(ctx *Select_or_valuesContext) {} + +// ExitSelect_or_values is called when production select_or_values is exited. +func (s *BaseRedshiftParserListener) ExitSelect_or_values(ctx *Select_or_valuesContext) {} + +// EnterSelectintostmt is called when production selectintostmt is entered. +func (s *BaseRedshiftParserListener) EnterSelectintostmt(ctx *SelectintostmtContext) {} + +// ExitSelectintostmt is called when production selectintostmt is exited. +func (s *BaseRedshiftParserListener) ExitSelectintostmt(ctx *SelectintostmtContext) {} + +// EnterSetsessionauthorizationstmt is called when production setsessionauthorizationstmt is entered. +func (s *BaseRedshiftParserListener) EnterSetsessionauthorizationstmt(ctx *SetsessionauthorizationstmtContext) { +} + +// ExitSetsessionauthorizationstmt is called when production setsessionauthorizationstmt is exited. +func (s *BaseRedshiftParserListener) ExitSetsessionauthorizationstmt(ctx *SetsessionauthorizationstmtContext) { +} + +// EnterSetsessioncharacteristicsstmt is called when production setsessioncharacteristicsstmt is entered. +func (s *BaseRedshiftParserListener) EnterSetsessioncharacteristicsstmt(ctx *SetsessioncharacteristicsstmtContext) { +} + +// ExitSetsessioncharacteristicsstmt is called when production setsessioncharacteristicsstmt is exited. +func (s *BaseRedshiftParserListener) ExitSetsessioncharacteristicsstmt(ctx *SetsessioncharacteristicsstmtContext) { +} + +// EnterShowcolumnsstmt is called when production showcolumnsstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowcolumnsstmt(ctx *ShowcolumnsstmtContext) {} + +// ExitShowcolumnsstmt is called when production showcolumnsstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowcolumnsstmt(ctx *ShowcolumnsstmtContext) {} + +// EnterShowdatabasesstmt is called when production showdatabasesstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowdatabasesstmt(ctx *ShowdatabasesstmtContext) {} + +// ExitShowdatabasesstmt is called when production showdatabasesstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowdatabasesstmt(ctx *ShowdatabasesstmtContext) {} + +// EnterShowdbsopts is called when production showdbsopts is entered. +func (s *BaseRedshiftParserListener) EnterShowdbsopts(ctx *ShowdbsoptsContext) {} + +// ExitShowdbsopts is called when production showdbsopts is exited. +func (s *BaseRedshiftParserListener) ExitShowdbsopts(ctx *ShowdbsoptsContext) {} + +// EnterShowdatasharesstmt is called when production showdatasharesstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowdatasharesstmt(ctx *ShowdatasharesstmtContext) {} + +// ExitShowdatasharesstmt is called when production showdatasharesstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowdatasharesstmt(ctx *ShowdatasharesstmtContext) {} + +// EnterShowexternaltablestmt is called when production showexternaltablestmt is entered. +func (s *BaseRedshiftParserListener) EnterShowexternaltablestmt(ctx *ShowexternaltablestmtContext) {} + +// ExitShowexternaltablestmt is called when production showexternaltablestmt is exited. +func (s *BaseRedshiftParserListener) ExitShowexternaltablestmt(ctx *ShowexternaltablestmtContext) {} + +// EnterShowgrantsstmt is called when production showgrantsstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowgrantsstmt(ctx *ShowgrantsstmtContext) {} + +// ExitShowgrantsstmt is called when production showgrantsstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowgrantsstmt(ctx *ShowgrantsstmtContext) {} + +// EnterGrantobject is called when production grantobject is entered. +func (s *BaseRedshiftParserListener) EnterGrantobject(ctx *GrantobjectContext) {} + +// ExitGrantobject is called when production grantobject is exited. +func (s *BaseRedshiftParserListener) ExitGrantobject(ctx *GrantobjectContext) {} + +// EnterGrantprincipal is called when production grantprincipal is entered. +func (s *BaseRedshiftParserListener) EnterGrantprincipal(ctx *GrantprincipalContext) {} + +// ExitGrantprincipal is called when production grantprincipal is exited. +func (s *BaseRedshiftParserListener) ExitGrantprincipal(ctx *GrantprincipalContext) {} + +// EnterShowmodelstmt is called when production showmodelstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowmodelstmt(ctx *ShowmodelstmtContext) {} + +// ExitShowmodelstmt is called when production showmodelstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowmodelstmt(ctx *ShowmodelstmtContext) {} + +// EnterShowprocedurestmt is called when production showprocedurestmt is entered. +func (s *BaseRedshiftParserListener) EnterShowprocedurestmt(ctx *ShowprocedurestmtContext) {} + +// ExitShowprocedurestmt is called when production showprocedurestmt is exited. +func (s *BaseRedshiftParserListener) ExitShowprocedurestmt(ctx *ShowprocedurestmtContext) {} + +// EnterShowschemasstmt is called when production showschemasstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowschemasstmt(ctx *ShowschemasstmtContext) {} + +// ExitShowschemasstmt is called when production showschemasstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowschemasstmt(ctx *ShowschemasstmtContext) {} + +// EnterShowtablestmt is called when production showtablestmt is entered. +func (s *BaseRedshiftParserListener) EnterShowtablestmt(ctx *ShowtablestmtContext) {} + +// ExitShowtablestmt is called when production showtablestmt is exited. +func (s *BaseRedshiftParserListener) ExitShowtablestmt(ctx *ShowtablestmtContext) {} + +// EnterShowtablesstmt is called when production showtablesstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowtablesstmt(ctx *ShowtablesstmtContext) {} + +// ExitShowtablesstmt is called when production showtablesstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowtablesstmt(ctx *ShowtablesstmtContext) {} + +// EnterShowviewstmt is called when production showviewstmt is entered. +func (s *BaseRedshiftParserListener) EnterShowviewstmt(ctx *ShowviewstmtContext) {} + +// ExitShowviewstmt is called when production showviewstmt is exited. +func (s *BaseRedshiftParserListener) ExitShowviewstmt(ctx *ShowviewstmtContext) {} + +// EnterUnloadstmt is called when production unloadstmt is entered. +func (s *BaseRedshiftParserListener) EnterUnloadstmt(ctx *UnloadstmtContext) {} + +// ExitUnloadstmt is called when production unloadstmt is exited. +func (s *BaseRedshiftParserListener) ExitUnloadstmt(ctx *UnloadstmtContext) {} + +// EnterIamroleclause is called when production iamroleclause is entered. +func (s *BaseRedshiftParserListener) EnterIamroleclause(ctx *IamroleclauseContext) {} + +// ExitIamroleclause is called when production iamroleclause is exited. +func (s *BaseRedshiftParserListener) ExitIamroleclause(ctx *IamroleclauseContext) {} + +// EnterUnloadoptions is called when production unloadoptions is entered. +func (s *BaseRedshiftParserListener) EnterUnloadoptions(ctx *UnloadoptionsContext) {} + +// ExitUnloadoptions is called when production unloadoptions is exited. +func (s *BaseRedshiftParserListener) ExitUnloadoptions(ctx *UnloadoptionsContext) {} + +// EnterFormatoption is called when production formatoption is entered. +func (s *BaseRedshiftParserListener) EnterFormatoption(ctx *FormatoptionContext) {} + +// ExitFormatoption is called when production formatoption is exited. +func (s *BaseRedshiftParserListener) ExitFormatoption(ctx *FormatoptionContext) {} + +// EnterPartitionbyoption is called when production partitionbyoption is entered. +func (s *BaseRedshiftParserListener) EnterPartitionbyoption(ctx *PartitionbyoptionContext) {} + +// ExitPartitionbyoption is called when production partitionbyoption is exited. +func (s *BaseRedshiftParserListener) ExitPartitionbyoption(ctx *PartitionbyoptionContext) {} + +// EnterManifestoption is called when production manifestoption is entered. +func (s *BaseRedshiftParserListener) EnterManifestoption(ctx *ManifestoptionContext) {} + +// ExitManifestoption is called when production manifestoption is exited. +func (s *BaseRedshiftParserListener) ExitManifestoption(ctx *ManifestoptionContext) {} + +// EnterHeaderoption is called when production headeroption is entered. +func (s *BaseRedshiftParserListener) EnterHeaderoption(ctx *HeaderoptionContext) {} + +// ExitHeaderoption is called when production headeroption is exited. +func (s *BaseRedshiftParserListener) ExitHeaderoption(ctx *HeaderoptionContext) {} + +// EnterDelimiteroption is called when production delimiteroption is entered. +func (s *BaseRedshiftParserListener) EnterDelimiteroption(ctx *DelimiteroptionContext) {} + +// ExitDelimiteroption is called when production delimiteroption is exited. +func (s *BaseRedshiftParserListener) ExitDelimiteroption(ctx *DelimiteroptionContext) {} + +// EnterFixedwidthoption is called when production fixedwidthoption is entered. +func (s *BaseRedshiftParserListener) EnterFixedwidthoption(ctx *FixedwidthoptionContext) {} + +// ExitFixedwidthoption is called when production fixedwidthoption is exited. +func (s *BaseRedshiftParserListener) ExitFixedwidthoption(ctx *FixedwidthoptionContext) {} + +// EnterEncryptedoption is called when production encryptedoption is entered. +func (s *BaseRedshiftParserListener) EnterEncryptedoption(ctx *EncryptedoptionContext) {} + +// ExitEncryptedoption is called when production encryptedoption is exited. +func (s *BaseRedshiftParserListener) ExitEncryptedoption(ctx *EncryptedoptionContext) {} + +// EnterKmskeyoption is called when production kmskeyoption is entered. +func (s *BaseRedshiftParserListener) EnterKmskeyoption(ctx *KmskeyoptionContext) {} + +// ExitKmskeyoption is called when production kmskeyoption is exited. +func (s *BaseRedshiftParserListener) ExitKmskeyoption(ctx *KmskeyoptionContext) {} + +// EnterCompressionoption is called when production compressionoption is entered. +func (s *BaseRedshiftParserListener) EnterCompressionoption(ctx *CompressionoptionContext) {} + +// ExitCompressionoption is called when production compressionoption is exited. +func (s *BaseRedshiftParserListener) ExitCompressionoption(ctx *CompressionoptionContext) {} + +// EnterAddquotesoption is called when production addquotesoption is entered. +func (s *BaseRedshiftParserListener) EnterAddquotesoption(ctx *AddquotesoptionContext) {} + +// ExitAddquotesoption is called when production addquotesoption is exited. +func (s *BaseRedshiftParserListener) ExitAddquotesoption(ctx *AddquotesoptionContext) {} + +// EnterNullasoption is called when production nullasoption is entered. +func (s *BaseRedshiftParserListener) EnterNullasoption(ctx *NullasoptionContext) {} + +// ExitNullasoption is called when production nullasoption is exited. +func (s *BaseRedshiftParserListener) ExitNullasoption(ctx *NullasoptionContext) {} + +// EnterEscapeoption is called when production escapeoption is entered. +func (s *BaseRedshiftParserListener) EnterEscapeoption(ctx *EscapeoptionContext) {} + +// ExitEscapeoption is called when production escapeoption is exited. +func (s *BaseRedshiftParserListener) ExitEscapeoption(ctx *EscapeoptionContext) {} + +// EnterAllowoverwriteoption is called when production allowoverwriteoption is entered. +func (s *BaseRedshiftParserListener) EnterAllowoverwriteoption(ctx *AllowoverwriteoptionContext) {} + +// ExitAllowoverwriteoption is called when production allowoverwriteoption is exited. +func (s *BaseRedshiftParserListener) ExitAllowoverwriteoption(ctx *AllowoverwriteoptionContext) {} + +// EnterCleanpathoption is called when production cleanpathoption is entered. +func (s *BaseRedshiftParserListener) EnterCleanpathoption(ctx *CleanpathoptionContext) {} + +// ExitCleanpathoption is called when production cleanpathoption is exited. +func (s *BaseRedshiftParserListener) ExitCleanpathoption(ctx *CleanpathoptionContext) {} + +// EnterParalleloption is called when production paralleloption is entered. +func (s *BaseRedshiftParserListener) EnterParalleloption(ctx *ParalleloptionContext) {} + +// ExitParalleloption is called when production paralleloption is exited. +func (s *BaseRedshiftParserListener) ExitParalleloption(ctx *ParalleloptionContext) {} + +// EnterMaxfilesizeoption is called when production maxfilesizeoption is entered. +func (s *BaseRedshiftParserListener) EnterMaxfilesizeoption(ctx *MaxfilesizeoptionContext) {} + +// ExitMaxfilesizeoption is called when production maxfilesizeoption is exited. +func (s *BaseRedshiftParserListener) ExitMaxfilesizeoption(ctx *MaxfilesizeoptionContext) {} + +// EnterRowgroupsizeoption is called when production rowgroupsizeoption is entered. +func (s *BaseRedshiftParserListener) EnterRowgroupsizeoption(ctx *RowgroupsizeoptionContext) {} + +// ExitRowgroupsizeoption is called when production rowgroupsizeoption is exited. +func (s *BaseRedshiftParserListener) ExitRowgroupsizeoption(ctx *RowgroupsizeoptionContext) {} + +// EnterSizeunit is called when production sizeunit is entered. +func (s *BaseRedshiftParserListener) EnterSizeunit(ctx *SizeunitContext) {} + +// ExitSizeunit is called when production sizeunit is exited. +func (s *BaseRedshiftParserListener) ExitSizeunit(ctx *SizeunitContext) {} + +// EnterRegionoption is called when production regionoption is entered. +func (s *BaseRedshiftParserListener) EnterRegionoption(ctx *RegionoptionContext) {} + +// ExitRegionoption is called when production regionoption is exited. +func (s *BaseRedshiftParserListener) ExitRegionoption(ctx *RegionoptionContext) {} + +// EnterExtensionoption is called when production extensionoption is entered. +func (s *BaseRedshiftParserListener) EnterExtensionoption(ctx *ExtensionoptionContext) {} + +// ExitExtensionoption is called when production extensionoption is exited. +func (s *BaseRedshiftParserListener) ExitExtensionoption(ctx *ExtensionoptionContext) {} + +// EnterUsestmt is called when production usestmt is entered. +func (s *BaseRedshiftParserListener) EnterUsestmt(ctx *UsestmtContext) {} + +// ExitUsestmt is called when production usestmt is exited. +func (s *BaseRedshiftParserListener) ExitUsestmt(ctx *UsestmtContext) {} + +// EnterCreatedbstmt is called when production createdbstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatedbstmt(ctx *CreatedbstmtContext) {} + +// ExitCreatedbstmt is called when production createdbstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatedbstmt(ctx *CreatedbstmtContext) {} + +// EnterCreatedb_opt_list is called when production createdb_opt_list is entered. +func (s *BaseRedshiftParserListener) EnterCreatedb_opt_list(ctx *Createdb_opt_listContext) {} + +// ExitCreatedb_opt_list is called when production createdb_opt_list is exited. +func (s *BaseRedshiftParserListener) ExitCreatedb_opt_list(ctx *Createdb_opt_listContext) {} + +// EnterCreatedb_opt_items is called when production createdb_opt_items is entered. +func (s *BaseRedshiftParserListener) EnterCreatedb_opt_items(ctx *Createdb_opt_itemsContext) {} + +// ExitCreatedb_opt_items is called when production createdb_opt_items is exited. +func (s *BaseRedshiftParserListener) ExitCreatedb_opt_items(ctx *Createdb_opt_itemsContext) {} + +// EnterCreatedb_opt_item is called when production createdb_opt_item is entered. +func (s *BaseRedshiftParserListener) EnterCreatedb_opt_item(ctx *Createdb_opt_itemContext) {} + +// ExitCreatedb_opt_item is called when production createdb_opt_item is exited. +func (s *BaseRedshiftParserListener) ExitCreatedb_opt_item(ctx *Createdb_opt_itemContext) {} + +// EnterCreatedb_opt_name is called when production createdb_opt_name is entered. +func (s *BaseRedshiftParserListener) EnterCreatedb_opt_name(ctx *Createdb_opt_nameContext) {} + +// ExitCreatedb_opt_name is called when production createdb_opt_name is exited. +func (s *BaseRedshiftParserListener) ExitCreatedb_opt_name(ctx *Createdb_opt_nameContext) {} + +// EnterOpt_equal is called when production opt_equal is entered. +func (s *BaseRedshiftParserListener) EnterOpt_equal(ctx *Opt_equalContext) {} + +// ExitOpt_equal is called when production opt_equal is exited. +func (s *BaseRedshiftParserListener) ExitOpt_equal(ctx *Opt_equalContext) {} + +// EnterAlterdatabasestmt is called when production alterdatabasestmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterdatabasestmt(ctx *AlterdatabasestmtContext) {} + +// ExitAlterdatabasestmt is called when production alterdatabasestmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterdatabasestmt(ctx *AlterdatabasestmtContext) {} + +// EnterAlterdatabasesetstmt is called when production alterdatabasesetstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterdatabasesetstmt(ctx *AlterdatabasesetstmtContext) {} + +// ExitAlterdatabasesetstmt is called when production alterdatabasesetstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterdatabasesetstmt(ctx *AlterdatabasesetstmtContext) {} + +// EnterDropdbstmt is called when production dropdbstmt is entered. +func (s *BaseRedshiftParserListener) EnterDropdbstmt(ctx *DropdbstmtContext) {} + +// ExitDropdbstmt is called when production dropdbstmt is exited. +func (s *BaseRedshiftParserListener) ExitDropdbstmt(ctx *DropdbstmtContext) {} + +// EnterDrop_option_list is called when production drop_option_list is entered. +func (s *BaseRedshiftParserListener) EnterDrop_option_list(ctx *Drop_option_listContext) {} + +// ExitDrop_option_list is called when production drop_option_list is exited. +func (s *BaseRedshiftParserListener) ExitDrop_option_list(ctx *Drop_option_listContext) {} + +// EnterDrop_option is called when production drop_option is entered. +func (s *BaseRedshiftParserListener) EnterDrop_option(ctx *Drop_optionContext) {} + +// ExitDrop_option is called when production drop_option is exited. +func (s *BaseRedshiftParserListener) ExitDrop_option(ctx *Drop_optionContext) {} + +// EnterAltercollationstmt is called when production altercollationstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltercollationstmt(ctx *AltercollationstmtContext) {} + +// ExitAltercollationstmt is called when production altercollationstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltercollationstmt(ctx *AltercollationstmtContext) {} + +// EnterAltersystemstmt is called when production altersystemstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltersystemstmt(ctx *AltersystemstmtContext) {} + +// ExitAltersystemstmt is called when production altersystemstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltersystemstmt(ctx *AltersystemstmtContext) {} + +// EnterCreatedomainstmt is called when production createdomainstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreatedomainstmt(ctx *CreatedomainstmtContext) {} + +// ExitCreatedomainstmt is called when production createdomainstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreatedomainstmt(ctx *CreatedomainstmtContext) {} + +// EnterAlterdomainstmt is called when production alterdomainstmt is entered. +func (s *BaseRedshiftParserListener) EnterAlterdomainstmt(ctx *AlterdomainstmtContext) {} + +// ExitAlterdomainstmt is called when production alterdomainstmt is exited. +func (s *BaseRedshiftParserListener) ExitAlterdomainstmt(ctx *AlterdomainstmtContext) {} + +// EnterOpt_as is called when production opt_as is entered. +func (s *BaseRedshiftParserListener) EnterOpt_as(ctx *Opt_asContext) {} + +// ExitOpt_as is called when production opt_as is exited. +func (s *BaseRedshiftParserListener) ExitOpt_as(ctx *Opt_asContext) {} + +// EnterAltertsdictionarystmt is called when production altertsdictionarystmt is entered. +func (s *BaseRedshiftParserListener) EnterAltertsdictionarystmt(ctx *AltertsdictionarystmtContext) {} + +// ExitAltertsdictionarystmt is called when production altertsdictionarystmt is exited. +func (s *BaseRedshiftParserListener) ExitAltertsdictionarystmt(ctx *AltertsdictionarystmtContext) {} + +// EnterAltertsconfigurationstmt is called when production altertsconfigurationstmt is entered. +func (s *BaseRedshiftParserListener) EnterAltertsconfigurationstmt(ctx *AltertsconfigurationstmtContext) { +} + +// ExitAltertsconfigurationstmt is called when production altertsconfigurationstmt is exited. +func (s *BaseRedshiftParserListener) ExitAltertsconfigurationstmt(ctx *AltertsconfigurationstmtContext) { +} + +// EnterAny_with is called when production any_with is entered. +func (s *BaseRedshiftParserListener) EnterAny_with(ctx *Any_withContext) {} + +// ExitAny_with is called when production any_with is exited. +func (s *BaseRedshiftParserListener) ExitAny_with(ctx *Any_withContext) {} + +// EnterCreateconversionstmt is called when production createconversionstmt is entered. +func (s *BaseRedshiftParserListener) EnterCreateconversionstmt(ctx *CreateconversionstmtContext) {} + +// ExitCreateconversionstmt is called when production createconversionstmt is exited. +func (s *BaseRedshiftParserListener) ExitCreateconversionstmt(ctx *CreateconversionstmtContext) {} + +// EnterClusterstmt is called when production clusterstmt is entered. +func (s *BaseRedshiftParserListener) EnterClusterstmt(ctx *ClusterstmtContext) {} + +// ExitClusterstmt is called when production clusterstmt is exited. +func (s *BaseRedshiftParserListener) ExitClusterstmt(ctx *ClusterstmtContext) {} + +// EnterCluster_index_specification is called when production cluster_index_specification is entered. +func (s *BaseRedshiftParserListener) EnterCluster_index_specification(ctx *Cluster_index_specificationContext) { +} + +// ExitCluster_index_specification is called when production cluster_index_specification is exited. +func (s *BaseRedshiftParserListener) ExitCluster_index_specification(ctx *Cluster_index_specificationContext) { +} + +// EnterVacuumstmt is called when production vacuumstmt is entered. +func (s *BaseRedshiftParserListener) EnterVacuumstmt(ctx *VacuumstmtContext) {} + +// ExitVacuumstmt is called when production vacuumstmt is exited. +func (s *BaseRedshiftParserListener) ExitVacuumstmt(ctx *VacuumstmtContext) {} + +// EnterVacuum_option is called when production vacuum_option is entered. +func (s *BaseRedshiftParserListener) EnterVacuum_option(ctx *Vacuum_optionContext) {} + +// ExitVacuum_option is called when production vacuum_option is exited. +func (s *BaseRedshiftParserListener) ExitVacuum_option(ctx *Vacuum_optionContext) {} + +// EnterAnalyzestmt is called when production analyzestmt is entered. +func (s *BaseRedshiftParserListener) EnterAnalyzestmt(ctx *AnalyzestmtContext) {} + +// ExitAnalyzestmt is called when production analyzestmt is exited. +func (s *BaseRedshiftParserListener) ExitAnalyzestmt(ctx *AnalyzestmtContext) {} + +// EnterVac_analyze_option_list is called when production vac_analyze_option_list is entered. +func (s *BaseRedshiftParserListener) EnterVac_analyze_option_list(ctx *Vac_analyze_option_listContext) { +} + +// ExitVac_analyze_option_list is called when production vac_analyze_option_list is exited. +func (s *BaseRedshiftParserListener) ExitVac_analyze_option_list(ctx *Vac_analyze_option_listContext) { +} + +// EnterAnalyze_keyword is called when production analyze_keyword is entered. +func (s *BaseRedshiftParserListener) EnterAnalyze_keyword(ctx *Analyze_keywordContext) {} + +// ExitAnalyze_keyword is called when production analyze_keyword is exited. +func (s *BaseRedshiftParserListener) ExitAnalyze_keyword(ctx *Analyze_keywordContext) {} + +// EnterVac_analyze_option_elem is called when production vac_analyze_option_elem is entered. +func (s *BaseRedshiftParserListener) EnterVac_analyze_option_elem(ctx *Vac_analyze_option_elemContext) { +} + +// ExitVac_analyze_option_elem is called when production vac_analyze_option_elem is exited. +func (s *BaseRedshiftParserListener) ExitVac_analyze_option_elem(ctx *Vac_analyze_option_elemContext) { +} + +// EnterVac_analyze_option_name is called when production vac_analyze_option_name is entered. +func (s *BaseRedshiftParserListener) EnterVac_analyze_option_name(ctx *Vac_analyze_option_nameContext) { +} + +// ExitVac_analyze_option_name is called when production vac_analyze_option_name is exited. +func (s *BaseRedshiftParserListener) ExitVac_analyze_option_name(ctx *Vac_analyze_option_nameContext) { +} + +// EnterVac_analyze_option_arg is called when production vac_analyze_option_arg is entered. +func (s *BaseRedshiftParserListener) EnterVac_analyze_option_arg(ctx *Vac_analyze_option_argContext) { +} + +// ExitVac_analyze_option_arg is called when production vac_analyze_option_arg is exited. +func (s *BaseRedshiftParserListener) ExitVac_analyze_option_arg(ctx *Vac_analyze_option_argContext) {} + +// EnterOpt_analyze is called when production opt_analyze is entered. +func (s *BaseRedshiftParserListener) EnterOpt_analyze(ctx *Opt_analyzeContext) {} + +// ExitOpt_analyze is called when production opt_analyze is exited. +func (s *BaseRedshiftParserListener) ExitOpt_analyze(ctx *Opt_analyzeContext) {} + +// EnterOpt_verbose is called when production opt_verbose is entered. +func (s *BaseRedshiftParserListener) EnterOpt_verbose(ctx *Opt_verboseContext) {} + +// ExitOpt_verbose is called when production opt_verbose is exited. +func (s *BaseRedshiftParserListener) ExitOpt_verbose(ctx *Opt_verboseContext) {} + +// EnterOpt_full is called when production opt_full is entered. +func (s *BaseRedshiftParserListener) EnterOpt_full(ctx *Opt_fullContext) {} + +// ExitOpt_full is called when production opt_full is exited. +func (s *BaseRedshiftParserListener) ExitOpt_full(ctx *Opt_fullContext) {} + +// EnterOpt_freeze is called when production opt_freeze is entered. +func (s *BaseRedshiftParserListener) EnterOpt_freeze(ctx *Opt_freezeContext) {} + +// ExitOpt_freeze is called when production opt_freeze is exited. +func (s *BaseRedshiftParserListener) ExitOpt_freeze(ctx *Opt_freezeContext) {} + +// EnterOpt_name_list is called when production opt_name_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_name_list(ctx *Opt_name_listContext) {} + +// ExitOpt_name_list is called when production opt_name_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_name_list(ctx *Opt_name_listContext) {} + +// EnterVacuum_relation is called when production vacuum_relation is entered. +func (s *BaseRedshiftParserListener) EnterVacuum_relation(ctx *Vacuum_relationContext) {} + +// ExitVacuum_relation is called when production vacuum_relation is exited. +func (s *BaseRedshiftParserListener) ExitVacuum_relation(ctx *Vacuum_relationContext) {} + +// EnterVacuum_relation_list is called when production vacuum_relation_list is entered. +func (s *BaseRedshiftParserListener) EnterVacuum_relation_list(ctx *Vacuum_relation_listContext) {} + +// ExitVacuum_relation_list is called when production vacuum_relation_list is exited. +func (s *BaseRedshiftParserListener) ExitVacuum_relation_list(ctx *Vacuum_relation_listContext) {} + +// EnterOpt_vacuum_relation_list is called when production opt_vacuum_relation_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_vacuum_relation_list(ctx *Opt_vacuum_relation_listContext) { +} + +// ExitOpt_vacuum_relation_list is called when production opt_vacuum_relation_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_vacuum_relation_list(ctx *Opt_vacuum_relation_listContext) { +} + +// EnterExplainstmt is called when production explainstmt is entered. +func (s *BaseRedshiftParserListener) EnterExplainstmt(ctx *ExplainstmtContext) {} + +// ExitExplainstmt is called when production explainstmt is exited. +func (s *BaseRedshiftParserListener) ExitExplainstmt(ctx *ExplainstmtContext) {} + +// EnterExplainablestmt is called when production explainablestmt is entered. +func (s *BaseRedshiftParserListener) EnterExplainablestmt(ctx *ExplainablestmtContext) {} + +// ExitExplainablestmt is called when production explainablestmt is exited. +func (s *BaseRedshiftParserListener) ExitExplainablestmt(ctx *ExplainablestmtContext) {} + +// EnterExplain_option_list is called when production explain_option_list is entered. +func (s *BaseRedshiftParserListener) EnterExplain_option_list(ctx *Explain_option_listContext) {} + +// ExitExplain_option_list is called when production explain_option_list is exited. +func (s *BaseRedshiftParserListener) ExitExplain_option_list(ctx *Explain_option_listContext) {} + +// EnterExplain_option_elem is called when production explain_option_elem is entered. +func (s *BaseRedshiftParserListener) EnterExplain_option_elem(ctx *Explain_option_elemContext) {} + +// ExitExplain_option_elem is called when production explain_option_elem is exited. +func (s *BaseRedshiftParserListener) ExitExplain_option_elem(ctx *Explain_option_elemContext) {} + +// EnterExplain_option_name is called when production explain_option_name is entered. +func (s *BaseRedshiftParserListener) EnterExplain_option_name(ctx *Explain_option_nameContext) {} + +// ExitExplain_option_name is called when production explain_option_name is exited. +func (s *BaseRedshiftParserListener) ExitExplain_option_name(ctx *Explain_option_nameContext) {} + +// EnterExplain_option_arg is called when production explain_option_arg is entered. +func (s *BaseRedshiftParserListener) EnterExplain_option_arg(ctx *Explain_option_argContext) {} + +// ExitExplain_option_arg is called when production explain_option_arg is exited. +func (s *BaseRedshiftParserListener) ExitExplain_option_arg(ctx *Explain_option_argContext) {} + +// EnterPreparestmt is called when production preparestmt is entered. +func (s *BaseRedshiftParserListener) EnterPreparestmt(ctx *PreparestmtContext) {} + +// ExitPreparestmt is called when production preparestmt is exited. +func (s *BaseRedshiftParserListener) ExitPreparestmt(ctx *PreparestmtContext) {} + +// EnterPrep_type_clause is called when production prep_type_clause is entered. +func (s *BaseRedshiftParserListener) EnterPrep_type_clause(ctx *Prep_type_clauseContext) {} + +// ExitPrep_type_clause is called when production prep_type_clause is exited. +func (s *BaseRedshiftParserListener) ExitPrep_type_clause(ctx *Prep_type_clauseContext) {} + +// EnterPreparablestmt is called when production preparablestmt is entered. +func (s *BaseRedshiftParserListener) EnterPreparablestmt(ctx *PreparablestmtContext) {} + +// ExitPreparablestmt is called when production preparablestmt is exited. +func (s *BaseRedshiftParserListener) ExitPreparablestmt(ctx *PreparablestmtContext) {} + +// EnterExecutestmt is called when production executestmt is entered. +func (s *BaseRedshiftParserListener) EnterExecutestmt(ctx *ExecutestmtContext) {} + +// ExitExecutestmt is called when production executestmt is exited. +func (s *BaseRedshiftParserListener) ExitExecutestmt(ctx *ExecutestmtContext) {} + +// EnterExecute_param_clause is called when production execute_param_clause is entered. +func (s *BaseRedshiftParserListener) EnterExecute_param_clause(ctx *Execute_param_clauseContext) {} + +// ExitExecute_param_clause is called when production execute_param_clause is exited. +func (s *BaseRedshiftParserListener) ExitExecute_param_clause(ctx *Execute_param_clauseContext) {} + +// EnterDeallocatestmt is called when production deallocatestmt is entered. +func (s *BaseRedshiftParserListener) EnterDeallocatestmt(ctx *DeallocatestmtContext) {} + +// ExitDeallocatestmt is called when production deallocatestmt is exited. +func (s *BaseRedshiftParserListener) ExitDeallocatestmt(ctx *DeallocatestmtContext) {} + +// EnterInsertstmt is called when production insertstmt is entered. +func (s *BaseRedshiftParserListener) EnterInsertstmt(ctx *InsertstmtContext) {} + +// ExitInsertstmt is called when production insertstmt is exited. +func (s *BaseRedshiftParserListener) ExitInsertstmt(ctx *InsertstmtContext) {} + +// EnterInsert_target is called when production insert_target is entered. +func (s *BaseRedshiftParserListener) EnterInsert_target(ctx *Insert_targetContext) {} + +// ExitInsert_target is called when production insert_target is exited. +func (s *BaseRedshiftParserListener) ExitInsert_target(ctx *Insert_targetContext) {} + +// EnterInsert_rest is called when production insert_rest is entered. +func (s *BaseRedshiftParserListener) EnterInsert_rest(ctx *Insert_restContext) {} + +// ExitInsert_rest is called when production insert_rest is exited. +func (s *BaseRedshiftParserListener) ExitInsert_rest(ctx *Insert_restContext) {} + +// EnterOverride_kind is called when production override_kind is entered. +func (s *BaseRedshiftParserListener) EnterOverride_kind(ctx *Override_kindContext) {} + +// ExitOverride_kind is called when production override_kind is exited. +func (s *BaseRedshiftParserListener) ExitOverride_kind(ctx *Override_kindContext) {} + +// EnterInsert_column_list is called when production insert_column_list is entered. +func (s *BaseRedshiftParserListener) EnterInsert_column_list(ctx *Insert_column_listContext) {} + +// ExitInsert_column_list is called when production insert_column_list is exited. +func (s *BaseRedshiftParserListener) ExitInsert_column_list(ctx *Insert_column_listContext) {} + +// EnterInsert_column_item is called when production insert_column_item is entered. +func (s *BaseRedshiftParserListener) EnterInsert_column_item(ctx *Insert_column_itemContext) {} + +// ExitInsert_column_item is called when production insert_column_item is exited. +func (s *BaseRedshiftParserListener) ExitInsert_column_item(ctx *Insert_column_itemContext) {} + +// EnterOpt_on_conflict is called when production opt_on_conflict is entered. +func (s *BaseRedshiftParserListener) EnterOpt_on_conflict(ctx *Opt_on_conflictContext) {} + +// ExitOpt_on_conflict is called when production opt_on_conflict is exited. +func (s *BaseRedshiftParserListener) ExitOpt_on_conflict(ctx *Opt_on_conflictContext) {} + +// EnterOpt_conf_expr is called when production opt_conf_expr is entered. +func (s *BaseRedshiftParserListener) EnterOpt_conf_expr(ctx *Opt_conf_exprContext) {} + +// ExitOpt_conf_expr is called when production opt_conf_expr is exited. +func (s *BaseRedshiftParserListener) ExitOpt_conf_expr(ctx *Opt_conf_exprContext) {} + +// EnterReturning_clause is called when production returning_clause is entered. +func (s *BaseRedshiftParserListener) EnterReturning_clause(ctx *Returning_clauseContext) {} + +// ExitReturning_clause is called when production returning_clause is exited. +func (s *BaseRedshiftParserListener) ExitReturning_clause(ctx *Returning_clauseContext) {} + +// EnterMergestmt is called when production mergestmt is entered. +func (s *BaseRedshiftParserListener) EnterMergestmt(ctx *MergestmtContext) {} + +// ExitMergestmt is called when production mergestmt is exited. +func (s *BaseRedshiftParserListener) ExitMergestmt(ctx *MergestmtContext) {} + +// EnterMerge_when_clause is called when production merge_when_clause is entered. +func (s *BaseRedshiftParserListener) EnterMerge_when_clause(ctx *Merge_when_clauseContext) {} + +// ExitMerge_when_clause is called when production merge_when_clause is exited. +func (s *BaseRedshiftParserListener) ExitMerge_when_clause(ctx *Merge_when_clauseContext) {} + +// EnterMerge_insert_clause is called when production merge_insert_clause is entered. +func (s *BaseRedshiftParserListener) EnterMerge_insert_clause(ctx *Merge_insert_clauseContext) {} + +// ExitMerge_insert_clause is called when production merge_insert_clause is exited. +func (s *BaseRedshiftParserListener) ExitMerge_insert_clause(ctx *Merge_insert_clauseContext) {} + +// EnterMerge_update_clause is called when production merge_update_clause is entered. +func (s *BaseRedshiftParserListener) EnterMerge_update_clause(ctx *Merge_update_clauseContext) {} + +// ExitMerge_update_clause is called when production merge_update_clause is exited. +func (s *BaseRedshiftParserListener) ExitMerge_update_clause(ctx *Merge_update_clauseContext) {} + +// EnterMerge_delete_clause is called when production merge_delete_clause is entered. +func (s *BaseRedshiftParserListener) EnterMerge_delete_clause(ctx *Merge_delete_clauseContext) {} + +// ExitMerge_delete_clause is called when production merge_delete_clause is exited. +func (s *BaseRedshiftParserListener) ExitMerge_delete_clause(ctx *Merge_delete_clauseContext) {} + +// EnterDeletestmt is called when production deletestmt is entered. +func (s *BaseRedshiftParserListener) EnterDeletestmt(ctx *DeletestmtContext) {} + +// ExitDeletestmt is called when production deletestmt is exited. +func (s *BaseRedshiftParserListener) ExitDeletestmt(ctx *DeletestmtContext) {} + +// EnterUsing_clause is called when production using_clause is entered. +func (s *BaseRedshiftParserListener) EnterUsing_clause(ctx *Using_clauseContext) {} + +// ExitUsing_clause is called when production using_clause is exited. +func (s *BaseRedshiftParserListener) ExitUsing_clause(ctx *Using_clauseContext) {} + +// EnterLockstmt is called when production lockstmt is entered. +func (s *BaseRedshiftParserListener) EnterLockstmt(ctx *LockstmtContext) {} + +// ExitLockstmt is called when production lockstmt is exited. +func (s *BaseRedshiftParserListener) ExitLockstmt(ctx *LockstmtContext) {} + +// EnterOpt_lock is called when production opt_lock is entered. +func (s *BaseRedshiftParserListener) EnterOpt_lock(ctx *Opt_lockContext) {} + +// ExitOpt_lock is called when production opt_lock is exited. +func (s *BaseRedshiftParserListener) ExitOpt_lock(ctx *Opt_lockContext) {} + +// EnterLock_type is called when production lock_type is entered. +func (s *BaseRedshiftParserListener) EnterLock_type(ctx *Lock_typeContext) {} + +// ExitLock_type is called when production lock_type is exited. +func (s *BaseRedshiftParserListener) ExitLock_type(ctx *Lock_typeContext) {} + +// EnterOpt_nowait is called when production opt_nowait is entered. +func (s *BaseRedshiftParserListener) EnterOpt_nowait(ctx *Opt_nowaitContext) {} + +// ExitOpt_nowait is called when production opt_nowait is exited. +func (s *BaseRedshiftParserListener) ExitOpt_nowait(ctx *Opt_nowaitContext) {} + +// EnterOpt_nowait_or_skip is called when production opt_nowait_or_skip is entered. +func (s *BaseRedshiftParserListener) EnterOpt_nowait_or_skip(ctx *Opt_nowait_or_skipContext) {} + +// ExitOpt_nowait_or_skip is called when production opt_nowait_or_skip is exited. +func (s *BaseRedshiftParserListener) ExitOpt_nowait_or_skip(ctx *Opt_nowait_or_skipContext) {} + +// EnterUpdatestmt is called when production updatestmt is entered. +func (s *BaseRedshiftParserListener) EnterUpdatestmt(ctx *UpdatestmtContext) {} + +// ExitUpdatestmt is called when production updatestmt is exited. +func (s *BaseRedshiftParserListener) ExitUpdatestmt(ctx *UpdatestmtContext) {} + +// EnterSet_clause_list is called when production set_clause_list is entered. +func (s *BaseRedshiftParserListener) EnterSet_clause_list(ctx *Set_clause_listContext) {} + +// ExitSet_clause_list is called when production set_clause_list is exited. +func (s *BaseRedshiftParserListener) ExitSet_clause_list(ctx *Set_clause_listContext) {} + +// EnterSet_clause is called when production set_clause is entered. +func (s *BaseRedshiftParserListener) EnterSet_clause(ctx *Set_clauseContext) {} + +// ExitSet_clause is called when production set_clause is exited. +func (s *BaseRedshiftParserListener) ExitSet_clause(ctx *Set_clauseContext) {} + +// EnterSet_target is called when production set_target is entered. +func (s *BaseRedshiftParserListener) EnterSet_target(ctx *Set_targetContext) {} + +// ExitSet_target is called when production set_target is exited. +func (s *BaseRedshiftParserListener) ExitSet_target(ctx *Set_targetContext) {} + +// EnterSet_target_list is called when production set_target_list is entered. +func (s *BaseRedshiftParserListener) EnterSet_target_list(ctx *Set_target_listContext) {} + +// ExitSet_target_list is called when production set_target_list is exited. +func (s *BaseRedshiftParserListener) ExitSet_target_list(ctx *Set_target_listContext) {} + +// EnterDeclarecursorstmt is called when production declarecursorstmt is entered. +func (s *BaseRedshiftParserListener) EnterDeclarecursorstmt(ctx *DeclarecursorstmtContext) {} + +// ExitDeclarecursorstmt is called when production declarecursorstmt is exited. +func (s *BaseRedshiftParserListener) ExitDeclarecursorstmt(ctx *DeclarecursorstmtContext) {} + +// EnterCursor_name is called when production cursor_name is entered. +func (s *BaseRedshiftParserListener) EnterCursor_name(ctx *Cursor_nameContext) {} + +// ExitCursor_name is called when production cursor_name is exited. +func (s *BaseRedshiftParserListener) ExitCursor_name(ctx *Cursor_nameContext) {} + +// EnterCursor_options is called when production cursor_options is entered. +func (s *BaseRedshiftParserListener) EnterCursor_options(ctx *Cursor_optionsContext) {} + +// ExitCursor_options is called when production cursor_options is exited. +func (s *BaseRedshiftParserListener) ExitCursor_options(ctx *Cursor_optionsContext) {} + +// EnterOpt_hold is called when production opt_hold is entered. +func (s *BaseRedshiftParserListener) EnterOpt_hold(ctx *Opt_holdContext) {} + +// ExitOpt_hold is called when production opt_hold is exited. +func (s *BaseRedshiftParserListener) ExitOpt_hold(ctx *Opt_holdContext) {} + +// EnterSelectstmt is called when production selectstmt is entered. +func (s *BaseRedshiftParserListener) EnterSelectstmt(ctx *SelectstmtContext) {} + +// ExitSelectstmt is called when production selectstmt is exited. +func (s *BaseRedshiftParserListener) ExitSelectstmt(ctx *SelectstmtContext) {} + +// EnterSelect_with_parens is called when production select_with_parens is entered. +func (s *BaseRedshiftParserListener) EnterSelect_with_parens(ctx *Select_with_parensContext) {} + +// ExitSelect_with_parens is called when production select_with_parens is exited. +func (s *BaseRedshiftParserListener) ExitSelect_with_parens(ctx *Select_with_parensContext) {} + +// EnterSelect_no_parens is called when production select_no_parens is entered. +func (s *BaseRedshiftParserListener) EnterSelect_no_parens(ctx *Select_no_parensContext) {} + +// ExitSelect_no_parens is called when production select_no_parens is exited. +func (s *BaseRedshiftParserListener) ExitSelect_no_parens(ctx *Select_no_parensContext) {} + +// EnterSelect_clause is called when production select_clause is entered. +func (s *BaseRedshiftParserListener) EnterSelect_clause(ctx *Select_clauseContext) {} + +// ExitSelect_clause is called when production select_clause is exited. +func (s *BaseRedshiftParserListener) ExitSelect_clause(ctx *Select_clauseContext) {} + +// EnterSimple_select_intersect is called when production simple_select_intersect is entered. +func (s *BaseRedshiftParserListener) EnterSimple_select_intersect(ctx *Simple_select_intersectContext) { +} + +// ExitSimple_select_intersect is called when production simple_select_intersect is exited. +func (s *BaseRedshiftParserListener) ExitSimple_select_intersect(ctx *Simple_select_intersectContext) { +} + +// EnterSimple_select_pramary is called when production simple_select_pramary is entered. +func (s *BaseRedshiftParserListener) EnterSimple_select_pramary(ctx *Simple_select_pramaryContext) {} + +// ExitSimple_select_pramary is called when production simple_select_pramary is exited. +func (s *BaseRedshiftParserListener) ExitSimple_select_pramary(ctx *Simple_select_pramaryContext) {} + +// EnterExclude_clause is called when production exclude_clause is entered. +func (s *BaseRedshiftParserListener) EnterExclude_clause(ctx *Exclude_clauseContext) {} + +// ExitExclude_clause is called when production exclude_clause is exited. +func (s *BaseRedshiftParserListener) ExitExclude_clause(ctx *Exclude_clauseContext) {} + +// EnterQualify_clause is called when production qualify_clause is entered. +func (s *BaseRedshiftParserListener) EnterQualify_clause(ctx *Qualify_clauseContext) {} + +// ExitQualify_clause is called when production qualify_clause is exited. +func (s *BaseRedshiftParserListener) ExitQualify_clause(ctx *Qualify_clauseContext) {} + +// EnterStart_with_clause is called when production start_with_clause is entered. +func (s *BaseRedshiftParserListener) EnterStart_with_clause(ctx *Start_with_clauseContext) {} + +// ExitStart_with_clause is called when production start_with_clause is exited. +func (s *BaseRedshiftParserListener) ExitStart_with_clause(ctx *Start_with_clauseContext) {} + +// EnterWith_clause is called when production with_clause is entered. +func (s *BaseRedshiftParserListener) EnterWith_clause(ctx *With_clauseContext) {} + +// ExitWith_clause is called when production with_clause is exited. +func (s *BaseRedshiftParserListener) ExitWith_clause(ctx *With_clauseContext) {} + +// EnterCte_list is called when production cte_list is entered. +func (s *BaseRedshiftParserListener) EnterCte_list(ctx *Cte_listContext) {} + +// ExitCte_list is called when production cte_list is exited. +func (s *BaseRedshiftParserListener) ExitCte_list(ctx *Cte_listContext) {} + +// EnterCommon_table_expr is called when production common_table_expr is entered. +func (s *BaseRedshiftParserListener) EnterCommon_table_expr(ctx *Common_table_exprContext) {} + +// ExitCommon_table_expr is called when production common_table_expr is exited. +func (s *BaseRedshiftParserListener) ExitCommon_table_expr(ctx *Common_table_exprContext) {} + +// EnterOpt_materialized is called when production opt_materialized is entered. +func (s *BaseRedshiftParserListener) EnterOpt_materialized(ctx *Opt_materializedContext) {} + +// ExitOpt_materialized is called when production opt_materialized is exited. +func (s *BaseRedshiftParserListener) ExitOpt_materialized(ctx *Opt_materializedContext) {} + +// EnterOpt_with_clause is called when production opt_with_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_with_clause(ctx *Opt_with_clauseContext) {} + +// ExitOpt_with_clause is called when production opt_with_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_with_clause(ctx *Opt_with_clauseContext) {} + +// EnterInto_clause is called when production into_clause is entered. +func (s *BaseRedshiftParserListener) EnterInto_clause(ctx *Into_clauseContext) {} + +// ExitInto_clause is called when production into_clause is exited. +func (s *BaseRedshiftParserListener) ExitInto_clause(ctx *Into_clauseContext) {} + +// EnterOpt_top_clause is called when production opt_top_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_top_clause(ctx *Opt_top_clauseContext) {} + +// ExitOpt_top_clause is called when production opt_top_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_top_clause(ctx *Opt_top_clauseContext) {} + +// EnterOpt_strict is called when production opt_strict is entered. +func (s *BaseRedshiftParserListener) EnterOpt_strict(ctx *Opt_strictContext) {} + +// ExitOpt_strict is called when production opt_strict is exited. +func (s *BaseRedshiftParserListener) ExitOpt_strict(ctx *Opt_strictContext) {} + +// EnterOpttempTableName is called when production opttempTableName is entered. +func (s *BaseRedshiftParserListener) EnterOpttempTableName(ctx *OpttempTableNameContext) {} + +// ExitOpttempTableName is called when production opttempTableName is exited. +func (s *BaseRedshiftParserListener) ExitOpttempTableName(ctx *OpttempTableNameContext) {} + +// EnterOpt_table is called when production opt_table is entered. +func (s *BaseRedshiftParserListener) EnterOpt_table(ctx *Opt_tableContext) {} + +// ExitOpt_table is called when production opt_table is exited. +func (s *BaseRedshiftParserListener) ExitOpt_table(ctx *Opt_tableContext) {} + +// EnterAll_or_distinct is called when production all_or_distinct is entered. +func (s *BaseRedshiftParserListener) EnterAll_or_distinct(ctx *All_or_distinctContext) {} + +// ExitAll_or_distinct is called when production all_or_distinct is exited. +func (s *BaseRedshiftParserListener) ExitAll_or_distinct(ctx *All_or_distinctContext) {} + +// EnterDistinct_clause is called when production distinct_clause is entered. +func (s *BaseRedshiftParserListener) EnterDistinct_clause(ctx *Distinct_clauseContext) {} + +// ExitDistinct_clause is called when production distinct_clause is exited. +func (s *BaseRedshiftParserListener) ExitDistinct_clause(ctx *Distinct_clauseContext) {} + +// EnterOpt_all_clause is called when production opt_all_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_all_clause(ctx *Opt_all_clauseContext) {} + +// ExitOpt_all_clause is called when production opt_all_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_all_clause(ctx *Opt_all_clauseContext) {} + +// EnterOpt_sort_clause is called when production opt_sort_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_sort_clause(ctx *Opt_sort_clauseContext) {} + +// ExitOpt_sort_clause is called when production opt_sort_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_sort_clause(ctx *Opt_sort_clauseContext) {} + +// EnterSort_clause is called when production sort_clause is entered. +func (s *BaseRedshiftParserListener) EnterSort_clause(ctx *Sort_clauseContext) {} + +// ExitSort_clause is called when production sort_clause is exited. +func (s *BaseRedshiftParserListener) ExitSort_clause(ctx *Sort_clauseContext) {} + +// EnterSortby_list is called when production sortby_list is entered. +func (s *BaseRedshiftParserListener) EnterSortby_list(ctx *Sortby_listContext) {} + +// ExitSortby_list is called when production sortby_list is exited. +func (s *BaseRedshiftParserListener) ExitSortby_list(ctx *Sortby_listContext) {} + +// EnterSortby is called when production sortby is entered. +func (s *BaseRedshiftParserListener) EnterSortby(ctx *SortbyContext) {} + +// ExitSortby is called when production sortby is exited. +func (s *BaseRedshiftParserListener) ExitSortby(ctx *SortbyContext) {} + +// EnterSelect_limit is called when production select_limit is entered. +func (s *BaseRedshiftParserListener) EnterSelect_limit(ctx *Select_limitContext) {} + +// ExitSelect_limit is called when production select_limit is exited. +func (s *BaseRedshiftParserListener) ExitSelect_limit(ctx *Select_limitContext) {} + +// EnterOpt_select_limit is called when production opt_select_limit is entered. +func (s *BaseRedshiftParserListener) EnterOpt_select_limit(ctx *Opt_select_limitContext) {} + +// ExitOpt_select_limit is called when production opt_select_limit is exited. +func (s *BaseRedshiftParserListener) ExitOpt_select_limit(ctx *Opt_select_limitContext) {} + +// EnterLimit_clause is called when production limit_clause is entered. +func (s *BaseRedshiftParserListener) EnterLimit_clause(ctx *Limit_clauseContext) {} + +// ExitLimit_clause is called when production limit_clause is exited. +func (s *BaseRedshiftParserListener) ExitLimit_clause(ctx *Limit_clauseContext) {} + +// EnterOffset_clause is called when production offset_clause is entered. +func (s *BaseRedshiftParserListener) EnterOffset_clause(ctx *Offset_clauseContext) {} + +// ExitOffset_clause is called when production offset_clause is exited. +func (s *BaseRedshiftParserListener) ExitOffset_clause(ctx *Offset_clauseContext) {} + +// EnterSelect_limit_value is called when production select_limit_value is entered. +func (s *BaseRedshiftParserListener) EnterSelect_limit_value(ctx *Select_limit_valueContext) {} + +// ExitSelect_limit_value is called when production select_limit_value is exited. +func (s *BaseRedshiftParserListener) ExitSelect_limit_value(ctx *Select_limit_valueContext) {} + +// EnterSelect_offset_value is called when production select_offset_value is entered. +func (s *BaseRedshiftParserListener) EnterSelect_offset_value(ctx *Select_offset_valueContext) {} + +// ExitSelect_offset_value is called when production select_offset_value is exited. +func (s *BaseRedshiftParserListener) ExitSelect_offset_value(ctx *Select_offset_valueContext) {} + +// EnterSelect_fetch_first_value is called when production select_fetch_first_value is entered. +func (s *BaseRedshiftParserListener) EnterSelect_fetch_first_value(ctx *Select_fetch_first_valueContext) { +} + +// ExitSelect_fetch_first_value is called when production select_fetch_first_value is exited. +func (s *BaseRedshiftParserListener) ExitSelect_fetch_first_value(ctx *Select_fetch_first_valueContext) { +} + +// EnterI_or_f_const is called when production i_or_f_const is entered. +func (s *BaseRedshiftParserListener) EnterI_or_f_const(ctx *I_or_f_constContext) {} + +// ExitI_or_f_const is called when production i_or_f_const is exited. +func (s *BaseRedshiftParserListener) ExitI_or_f_const(ctx *I_or_f_constContext) {} + +// EnterRow_or_rows is called when production row_or_rows is entered. +func (s *BaseRedshiftParserListener) EnterRow_or_rows(ctx *Row_or_rowsContext) {} + +// ExitRow_or_rows is called when production row_or_rows is exited. +func (s *BaseRedshiftParserListener) ExitRow_or_rows(ctx *Row_or_rowsContext) {} + +// EnterFirst_or_next is called when production first_or_next is entered. +func (s *BaseRedshiftParserListener) EnterFirst_or_next(ctx *First_or_nextContext) {} + +// ExitFirst_or_next is called when production first_or_next is exited. +func (s *BaseRedshiftParserListener) ExitFirst_or_next(ctx *First_or_nextContext) {} + +// EnterGroup_clause is called when production group_clause is entered. +func (s *BaseRedshiftParserListener) EnterGroup_clause(ctx *Group_clauseContext) {} + +// ExitGroup_clause is called when production group_clause is exited. +func (s *BaseRedshiftParserListener) ExitGroup_clause(ctx *Group_clauseContext) {} + +// EnterGroup_by_list is called when production group_by_list is entered. +func (s *BaseRedshiftParserListener) EnterGroup_by_list(ctx *Group_by_listContext) {} + +// ExitGroup_by_list is called when production group_by_list is exited. +func (s *BaseRedshiftParserListener) ExitGroup_by_list(ctx *Group_by_listContext) {} + +// EnterGroup_by_item is called when production group_by_item is entered. +func (s *BaseRedshiftParserListener) EnterGroup_by_item(ctx *Group_by_itemContext) {} + +// ExitGroup_by_item is called when production group_by_item is exited. +func (s *BaseRedshiftParserListener) ExitGroup_by_item(ctx *Group_by_itemContext) {} + +// EnterEmpty_grouping_set is called when production empty_grouping_set is entered. +func (s *BaseRedshiftParserListener) EnterEmpty_grouping_set(ctx *Empty_grouping_setContext) {} + +// ExitEmpty_grouping_set is called when production empty_grouping_set is exited. +func (s *BaseRedshiftParserListener) ExitEmpty_grouping_set(ctx *Empty_grouping_setContext) {} + +// EnterRollup_clause is called when production rollup_clause is entered. +func (s *BaseRedshiftParserListener) EnterRollup_clause(ctx *Rollup_clauseContext) {} + +// ExitRollup_clause is called when production rollup_clause is exited. +func (s *BaseRedshiftParserListener) ExitRollup_clause(ctx *Rollup_clauseContext) {} + +// EnterCube_clause is called when production cube_clause is entered. +func (s *BaseRedshiftParserListener) EnterCube_clause(ctx *Cube_clauseContext) {} + +// ExitCube_clause is called when production cube_clause is exited. +func (s *BaseRedshiftParserListener) ExitCube_clause(ctx *Cube_clauseContext) {} + +// EnterGrouping_sets_clause is called when production grouping_sets_clause is entered. +func (s *BaseRedshiftParserListener) EnterGrouping_sets_clause(ctx *Grouping_sets_clauseContext) {} + +// ExitGrouping_sets_clause is called when production grouping_sets_clause is exited. +func (s *BaseRedshiftParserListener) ExitGrouping_sets_clause(ctx *Grouping_sets_clauseContext) {} + +// EnterHaving_clause is called when production having_clause is entered. +func (s *BaseRedshiftParserListener) EnterHaving_clause(ctx *Having_clauseContext) {} + +// ExitHaving_clause is called when production having_clause is exited. +func (s *BaseRedshiftParserListener) ExitHaving_clause(ctx *Having_clauseContext) {} + +// EnterFor_locking_clause is called when production for_locking_clause is entered. +func (s *BaseRedshiftParserListener) EnterFor_locking_clause(ctx *For_locking_clauseContext) {} + +// ExitFor_locking_clause is called when production for_locking_clause is exited. +func (s *BaseRedshiftParserListener) ExitFor_locking_clause(ctx *For_locking_clauseContext) {} + +// EnterOpt_for_locking_clause is called when production opt_for_locking_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_for_locking_clause(ctx *Opt_for_locking_clauseContext) { +} + +// ExitOpt_for_locking_clause is called when production opt_for_locking_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_for_locking_clause(ctx *Opt_for_locking_clauseContext) {} + +// EnterFor_locking_items is called when production for_locking_items is entered. +func (s *BaseRedshiftParserListener) EnterFor_locking_items(ctx *For_locking_itemsContext) {} + +// ExitFor_locking_items is called when production for_locking_items is exited. +func (s *BaseRedshiftParserListener) ExitFor_locking_items(ctx *For_locking_itemsContext) {} + +// EnterFor_locking_item is called when production for_locking_item is entered. +func (s *BaseRedshiftParserListener) EnterFor_locking_item(ctx *For_locking_itemContext) {} + +// ExitFor_locking_item is called when production for_locking_item is exited. +func (s *BaseRedshiftParserListener) ExitFor_locking_item(ctx *For_locking_itemContext) {} + +// EnterFor_locking_strength is called when production for_locking_strength is entered. +func (s *BaseRedshiftParserListener) EnterFor_locking_strength(ctx *For_locking_strengthContext) {} + +// ExitFor_locking_strength is called when production for_locking_strength is exited. +func (s *BaseRedshiftParserListener) ExitFor_locking_strength(ctx *For_locking_strengthContext) {} + +// EnterLocked_rels_list is called when production locked_rels_list is entered. +func (s *BaseRedshiftParserListener) EnterLocked_rels_list(ctx *Locked_rels_listContext) {} + +// ExitLocked_rels_list is called when production locked_rels_list is exited. +func (s *BaseRedshiftParserListener) ExitLocked_rels_list(ctx *Locked_rels_listContext) {} + +// EnterValues_clause is called when production values_clause is entered. +func (s *BaseRedshiftParserListener) EnterValues_clause(ctx *Values_clauseContext) {} + +// ExitValues_clause is called when production values_clause is exited. +func (s *BaseRedshiftParserListener) ExitValues_clause(ctx *Values_clauseContext) {} + +// EnterFrom_clause is called when production from_clause is entered. +func (s *BaseRedshiftParserListener) EnterFrom_clause(ctx *From_clauseContext) {} + +// ExitFrom_clause is called when production from_clause is exited. +func (s *BaseRedshiftParserListener) ExitFrom_clause(ctx *From_clauseContext) {} + +// EnterFrom_list is called when production from_list is entered. +func (s *BaseRedshiftParserListener) EnterFrom_list(ctx *From_listContext) {} + +// ExitFrom_list is called when production from_list is exited. +func (s *BaseRedshiftParserListener) ExitFrom_list(ctx *From_listContext) {} + +// EnterTable_ref is called when production table_ref is entered. +func (s *BaseRedshiftParserListener) EnterTable_ref(ctx *Table_refContext) {} + +// ExitTable_ref is called when production table_ref is exited. +func (s *BaseRedshiftParserListener) ExitTable_ref(ctx *Table_refContext) {} + +// EnterJoined_table is called when production joined_table is entered. +func (s *BaseRedshiftParserListener) EnterJoined_table(ctx *Joined_tableContext) {} + +// ExitJoined_table is called when production joined_table is exited. +func (s *BaseRedshiftParserListener) ExitJoined_table(ctx *Joined_tableContext) {} + +// EnterAlias_clause is called when production alias_clause is entered. +func (s *BaseRedshiftParserListener) EnterAlias_clause(ctx *Alias_clauseContext) {} + +// ExitAlias_clause is called when production alias_clause is exited. +func (s *BaseRedshiftParserListener) ExitAlias_clause(ctx *Alias_clauseContext) {} + +// EnterOpt_alias_clause is called when production opt_alias_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_alias_clause(ctx *Opt_alias_clauseContext) {} + +// ExitOpt_alias_clause is called when production opt_alias_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_alias_clause(ctx *Opt_alias_clauseContext) {} + +// EnterTable_alias_clause is called when production table_alias_clause is entered. +func (s *BaseRedshiftParserListener) EnterTable_alias_clause(ctx *Table_alias_clauseContext) {} + +// ExitTable_alias_clause is called when production table_alias_clause is exited. +func (s *BaseRedshiftParserListener) ExitTable_alias_clause(ctx *Table_alias_clauseContext) {} + +// EnterFunc_alias_clause is called when production func_alias_clause is entered. +func (s *BaseRedshiftParserListener) EnterFunc_alias_clause(ctx *Func_alias_clauseContext) {} + +// ExitFunc_alias_clause is called when production func_alias_clause is exited. +func (s *BaseRedshiftParserListener) ExitFunc_alias_clause(ctx *Func_alias_clauseContext) {} + +// EnterJoin_type is called when production join_type is entered. +func (s *BaseRedshiftParserListener) EnterJoin_type(ctx *Join_typeContext) {} + +// ExitJoin_type is called when production join_type is exited. +func (s *BaseRedshiftParserListener) ExitJoin_type(ctx *Join_typeContext) {} + +// EnterJoin_qual is called when production join_qual is entered. +func (s *BaseRedshiftParserListener) EnterJoin_qual(ctx *Join_qualContext) {} + +// ExitJoin_qual is called when production join_qual is exited. +func (s *BaseRedshiftParserListener) ExitJoin_qual(ctx *Join_qualContext) {} + +// EnterRelation_expr is called when production relation_expr is entered. +func (s *BaseRedshiftParserListener) EnterRelation_expr(ctx *Relation_exprContext) {} + +// ExitRelation_expr is called when production relation_expr is exited. +func (s *BaseRedshiftParserListener) ExitRelation_expr(ctx *Relation_exprContext) {} + +// EnterRelation_expr_list is called when production relation_expr_list is entered. +func (s *BaseRedshiftParserListener) EnterRelation_expr_list(ctx *Relation_expr_listContext) {} + +// ExitRelation_expr_list is called when production relation_expr_list is exited. +func (s *BaseRedshiftParserListener) ExitRelation_expr_list(ctx *Relation_expr_listContext) {} + +// EnterRelation_expr_opt_alias is called when production relation_expr_opt_alias is entered. +func (s *BaseRedshiftParserListener) EnterRelation_expr_opt_alias(ctx *Relation_expr_opt_aliasContext) { +} + +// ExitRelation_expr_opt_alias is called when production relation_expr_opt_alias is exited. +func (s *BaseRedshiftParserListener) ExitRelation_expr_opt_alias(ctx *Relation_expr_opt_aliasContext) { +} + +// EnterTablesample_clause is called when production tablesample_clause is entered. +func (s *BaseRedshiftParserListener) EnterTablesample_clause(ctx *Tablesample_clauseContext) {} + +// ExitTablesample_clause is called when production tablesample_clause is exited. +func (s *BaseRedshiftParserListener) ExitTablesample_clause(ctx *Tablesample_clauseContext) {} + +// EnterOpt_repeatable_clause is called when production opt_repeatable_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_repeatable_clause(ctx *Opt_repeatable_clauseContext) {} + +// ExitOpt_repeatable_clause is called when production opt_repeatable_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_repeatable_clause(ctx *Opt_repeatable_clauseContext) {} + +// EnterFunc_table is called when production func_table is entered. +func (s *BaseRedshiftParserListener) EnterFunc_table(ctx *Func_tableContext) {} + +// ExitFunc_table is called when production func_table is exited. +func (s *BaseRedshiftParserListener) ExitFunc_table(ctx *Func_tableContext) {} + +// EnterRowsfrom_item is called when production rowsfrom_item is entered. +func (s *BaseRedshiftParserListener) EnterRowsfrom_item(ctx *Rowsfrom_itemContext) {} + +// ExitRowsfrom_item is called when production rowsfrom_item is exited. +func (s *BaseRedshiftParserListener) ExitRowsfrom_item(ctx *Rowsfrom_itemContext) {} + +// EnterRowsfrom_list is called when production rowsfrom_list is entered. +func (s *BaseRedshiftParserListener) EnterRowsfrom_list(ctx *Rowsfrom_listContext) {} + +// ExitRowsfrom_list is called when production rowsfrom_list is exited. +func (s *BaseRedshiftParserListener) ExitRowsfrom_list(ctx *Rowsfrom_listContext) {} + +// EnterOpt_col_def_list is called when production opt_col_def_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_col_def_list(ctx *Opt_col_def_listContext) {} + +// ExitOpt_col_def_list is called when production opt_col_def_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_col_def_list(ctx *Opt_col_def_listContext) {} + +// EnterOpt_ordinality is called when production opt_ordinality is entered. +func (s *BaseRedshiftParserListener) EnterOpt_ordinality(ctx *Opt_ordinalityContext) {} + +// ExitOpt_ordinality is called when production opt_ordinality is exited. +func (s *BaseRedshiftParserListener) ExitOpt_ordinality(ctx *Opt_ordinalityContext) {} + +// EnterWhere_clause is called when production where_clause is entered. +func (s *BaseRedshiftParserListener) EnterWhere_clause(ctx *Where_clauseContext) {} + +// ExitWhere_clause is called when production where_clause is exited. +func (s *BaseRedshiftParserListener) ExitWhere_clause(ctx *Where_clauseContext) {} + +// EnterWhere_or_current_clause is called when production where_or_current_clause is entered. +func (s *BaseRedshiftParserListener) EnterWhere_or_current_clause(ctx *Where_or_current_clauseContext) { +} + +// ExitWhere_or_current_clause is called when production where_or_current_clause is exited. +func (s *BaseRedshiftParserListener) ExitWhere_or_current_clause(ctx *Where_or_current_clauseContext) { +} + +// EnterOpttablefuncelementlist is called when production opttablefuncelementlist is entered. +func (s *BaseRedshiftParserListener) EnterOpttablefuncelementlist(ctx *OpttablefuncelementlistContext) { +} + +// ExitOpttablefuncelementlist is called when production opttablefuncelementlist is exited. +func (s *BaseRedshiftParserListener) ExitOpttablefuncelementlist(ctx *OpttablefuncelementlistContext) { +} + +// EnterTablefuncelementlist is called when production tablefuncelementlist is entered. +func (s *BaseRedshiftParserListener) EnterTablefuncelementlist(ctx *TablefuncelementlistContext) {} + +// ExitTablefuncelementlist is called when production tablefuncelementlist is exited. +func (s *BaseRedshiftParserListener) ExitTablefuncelementlist(ctx *TablefuncelementlistContext) {} + +// EnterTablefuncelement is called when production tablefuncelement is entered. +func (s *BaseRedshiftParserListener) EnterTablefuncelement(ctx *TablefuncelementContext) {} + +// ExitTablefuncelement is called when production tablefuncelement is exited. +func (s *BaseRedshiftParserListener) ExitTablefuncelement(ctx *TablefuncelementContext) {} + +// EnterXmltable is called when production xmltable is entered. +func (s *BaseRedshiftParserListener) EnterXmltable(ctx *XmltableContext) {} + +// ExitXmltable is called when production xmltable is exited. +func (s *BaseRedshiftParserListener) ExitXmltable(ctx *XmltableContext) {} + +// EnterXmltable_column_list is called when production xmltable_column_list is entered. +func (s *BaseRedshiftParserListener) EnterXmltable_column_list(ctx *Xmltable_column_listContext) {} + +// ExitXmltable_column_list is called when production xmltable_column_list is exited. +func (s *BaseRedshiftParserListener) ExitXmltable_column_list(ctx *Xmltable_column_listContext) {} + +// EnterXmltable_column_el is called when production xmltable_column_el is entered. +func (s *BaseRedshiftParserListener) EnterXmltable_column_el(ctx *Xmltable_column_elContext) {} + +// ExitXmltable_column_el is called when production xmltable_column_el is exited. +func (s *BaseRedshiftParserListener) ExitXmltable_column_el(ctx *Xmltable_column_elContext) {} + +// EnterXmltable_column_option_list is called when production xmltable_column_option_list is entered. +func (s *BaseRedshiftParserListener) EnterXmltable_column_option_list(ctx *Xmltable_column_option_listContext) { +} + +// ExitXmltable_column_option_list is called when production xmltable_column_option_list is exited. +func (s *BaseRedshiftParserListener) ExitXmltable_column_option_list(ctx *Xmltable_column_option_listContext) { +} + +// EnterXmltable_column_option_el is called when production xmltable_column_option_el is entered. +func (s *BaseRedshiftParserListener) EnterXmltable_column_option_el(ctx *Xmltable_column_option_elContext) { +} + +// ExitXmltable_column_option_el is called when production xmltable_column_option_el is exited. +func (s *BaseRedshiftParserListener) ExitXmltable_column_option_el(ctx *Xmltable_column_option_elContext) { +} + +// EnterXml_namespace_list is called when production xml_namespace_list is entered. +func (s *BaseRedshiftParserListener) EnterXml_namespace_list(ctx *Xml_namespace_listContext) {} + +// ExitXml_namespace_list is called when production xml_namespace_list is exited. +func (s *BaseRedshiftParserListener) ExitXml_namespace_list(ctx *Xml_namespace_listContext) {} + +// EnterXml_namespace_el is called when production xml_namespace_el is entered. +func (s *BaseRedshiftParserListener) EnterXml_namespace_el(ctx *Xml_namespace_elContext) {} + +// ExitXml_namespace_el is called when production xml_namespace_el is exited. +func (s *BaseRedshiftParserListener) ExitXml_namespace_el(ctx *Xml_namespace_elContext) {} + +// EnterTypename is called when production typename is entered. +func (s *BaseRedshiftParserListener) EnterTypename(ctx *TypenameContext) {} + +// ExitTypename is called when production typename is exited. +func (s *BaseRedshiftParserListener) ExitTypename(ctx *TypenameContext) {} + +// EnterOpt_array_bounds is called when production opt_array_bounds is entered. +func (s *BaseRedshiftParserListener) EnterOpt_array_bounds(ctx *Opt_array_boundsContext) {} + +// ExitOpt_array_bounds is called when production opt_array_bounds is exited. +func (s *BaseRedshiftParserListener) ExitOpt_array_bounds(ctx *Opt_array_boundsContext) {} + +// EnterSimpletypename is called when production simpletypename is entered. +func (s *BaseRedshiftParserListener) EnterSimpletypename(ctx *SimpletypenameContext) {} + +// ExitSimpletypename is called when production simpletypename is exited. +func (s *BaseRedshiftParserListener) ExitSimpletypename(ctx *SimpletypenameContext) {} + +// EnterVarbyte is called when production varbyte is entered. +func (s *BaseRedshiftParserListener) EnterVarbyte(ctx *VarbyteContext) {} + +// ExitVarbyte is called when production varbyte is exited. +func (s *BaseRedshiftParserListener) ExitVarbyte(ctx *VarbyteContext) {} + +// EnterJson_type is called when production json_type is entered. +func (s *BaseRedshiftParserListener) EnterJson_type(ctx *Json_typeContext) {} + +// ExitJson_type is called when production json_type is exited. +func (s *BaseRedshiftParserListener) ExitJson_type(ctx *Json_typeContext) {} + +// EnterConsttypename is called when production consttypename is entered. +func (s *BaseRedshiftParserListener) EnterConsttypename(ctx *ConsttypenameContext) {} + +// ExitConsttypename is called when production consttypename is exited. +func (s *BaseRedshiftParserListener) ExitConsttypename(ctx *ConsttypenameContext) {} + +// EnterGenerictype is called when production generictype is entered. +func (s *BaseRedshiftParserListener) EnterGenerictype(ctx *GenerictypeContext) {} + +// ExitGenerictype is called when production generictype is exited. +func (s *BaseRedshiftParserListener) ExitGenerictype(ctx *GenerictypeContext) {} + +// EnterOpt_type_modifiers is called when production opt_type_modifiers is entered. +func (s *BaseRedshiftParserListener) EnterOpt_type_modifiers(ctx *Opt_type_modifiersContext) {} + +// ExitOpt_type_modifiers is called when production opt_type_modifiers is exited. +func (s *BaseRedshiftParserListener) ExitOpt_type_modifiers(ctx *Opt_type_modifiersContext) {} + +// EnterNumeric is called when production numeric is entered. +func (s *BaseRedshiftParserListener) EnterNumeric(ctx *NumericContext) {} + +// ExitNumeric is called when production numeric is exited. +func (s *BaseRedshiftParserListener) ExitNumeric(ctx *NumericContext) {} + +// EnterOpt_float is called when production opt_float is entered. +func (s *BaseRedshiftParserListener) EnterOpt_float(ctx *Opt_floatContext) {} + +// ExitOpt_float is called when production opt_float is exited. +func (s *BaseRedshiftParserListener) ExitOpt_float(ctx *Opt_floatContext) {} + +// EnterBit is called when production bit is entered. +func (s *BaseRedshiftParserListener) EnterBit(ctx *BitContext) {} + +// ExitBit is called when production bit is exited. +func (s *BaseRedshiftParserListener) ExitBit(ctx *BitContext) {} + +// EnterConstbit is called when production constbit is entered. +func (s *BaseRedshiftParserListener) EnterConstbit(ctx *ConstbitContext) {} + +// ExitConstbit is called when production constbit is exited. +func (s *BaseRedshiftParserListener) ExitConstbit(ctx *ConstbitContext) {} + +// EnterBitwithlength is called when production bitwithlength is entered. +func (s *BaseRedshiftParserListener) EnterBitwithlength(ctx *BitwithlengthContext) {} + +// ExitBitwithlength is called when production bitwithlength is exited. +func (s *BaseRedshiftParserListener) ExitBitwithlength(ctx *BitwithlengthContext) {} + +// EnterBitwithoutlength is called when production bitwithoutlength is entered. +func (s *BaseRedshiftParserListener) EnterBitwithoutlength(ctx *BitwithoutlengthContext) {} + +// ExitBitwithoutlength is called when production bitwithoutlength is exited. +func (s *BaseRedshiftParserListener) ExitBitwithoutlength(ctx *BitwithoutlengthContext) {} + +// EnterCharacter is called when production character is entered. +func (s *BaseRedshiftParserListener) EnterCharacter(ctx *CharacterContext) {} + +// ExitCharacter is called when production character is exited. +func (s *BaseRedshiftParserListener) ExitCharacter(ctx *CharacterContext) {} + +// EnterConstcharacter is called when production constcharacter is entered. +func (s *BaseRedshiftParserListener) EnterConstcharacter(ctx *ConstcharacterContext) {} + +// ExitConstcharacter is called when production constcharacter is exited. +func (s *BaseRedshiftParserListener) ExitConstcharacter(ctx *ConstcharacterContext) {} + +// EnterCharacter_c is called when production character_c is entered. +func (s *BaseRedshiftParserListener) EnterCharacter_c(ctx *Character_cContext) {} + +// ExitCharacter_c is called when production character_c is exited. +func (s *BaseRedshiftParserListener) ExitCharacter_c(ctx *Character_cContext) {} + +// EnterOpt_varying is called when production opt_varying is entered. +func (s *BaseRedshiftParserListener) EnterOpt_varying(ctx *Opt_varyingContext) {} + +// ExitOpt_varying is called when production opt_varying is exited. +func (s *BaseRedshiftParserListener) ExitOpt_varying(ctx *Opt_varyingContext) {} + +// EnterConstdatetime is called when production constdatetime is entered. +func (s *BaseRedshiftParserListener) EnterConstdatetime(ctx *ConstdatetimeContext) {} + +// ExitConstdatetime is called when production constdatetime is exited. +func (s *BaseRedshiftParserListener) ExitConstdatetime(ctx *ConstdatetimeContext) {} + +// EnterConstinterval is called when production constinterval is entered. +func (s *BaseRedshiftParserListener) EnterConstinterval(ctx *ConstintervalContext) {} + +// ExitConstinterval is called when production constinterval is exited. +func (s *BaseRedshiftParserListener) ExitConstinterval(ctx *ConstintervalContext) {} + +// EnterOpt_timezone is called when production opt_timezone is entered. +func (s *BaseRedshiftParserListener) EnterOpt_timezone(ctx *Opt_timezoneContext) {} + +// ExitOpt_timezone is called when production opt_timezone is exited. +func (s *BaseRedshiftParserListener) ExitOpt_timezone(ctx *Opt_timezoneContext) {} + +// EnterOpt_interval is called when production opt_interval is entered. +func (s *BaseRedshiftParserListener) EnterOpt_interval(ctx *Opt_intervalContext) {} + +// ExitOpt_interval is called when production opt_interval is exited. +func (s *BaseRedshiftParserListener) ExitOpt_interval(ctx *Opt_intervalContext) {} + +// EnterInterval_second is called when production interval_second is entered. +func (s *BaseRedshiftParserListener) EnterInterval_second(ctx *Interval_secondContext) {} + +// ExitInterval_second is called when production interval_second is exited. +func (s *BaseRedshiftParserListener) ExitInterval_second(ctx *Interval_secondContext) {} + +// EnterOpt_escape is called when production opt_escape is entered. +func (s *BaseRedshiftParserListener) EnterOpt_escape(ctx *Opt_escapeContext) {} + +// ExitOpt_escape is called when production opt_escape is exited. +func (s *BaseRedshiftParserListener) ExitOpt_escape(ctx *Opt_escapeContext) {} + +// EnterA_expr is called when production a_expr is entered. +func (s *BaseRedshiftParserListener) EnterA_expr(ctx *A_exprContext) {} + +// ExitA_expr is called when production a_expr is exited. +func (s *BaseRedshiftParserListener) ExitA_expr(ctx *A_exprContext) {} + +// EnterA_expr_qual is called when production a_expr_qual is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_qual(ctx *A_expr_qualContext) {} + +// ExitA_expr_qual is called when production a_expr_qual is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_qual(ctx *A_expr_qualContext) {} + +// EnterA_expr_lessless is called when production a_expr_lessless is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_lessless(ctx *A_expr_lesslessContext) {} + +// ExitA_expr_lessless is called when production a_expr_lessless is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_lessless(ctx *A_expr_lesslessContext) {} + +// EnterA_expr_or is called when production a_expr_or is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_or(ctx *A_expr_orContext) {} + +// ExitA_expr_or is called when production a_expr_or is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_or(ctx *A_expr_orContext) {} + +// EnterA_expr_and is called when production a_expr_and is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_and(ctx *A_expr_andContext) {} + +// ExitA_expr_and is called when production a_expr_and is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_and(ctx *A_expr_andContext) {} + +// EnterA_expr_between is called when production a_expr_between is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_between(ctx *A_expr_betweenContext) {} + +// ExitA_expr_between is called when production a_expr_between is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_between(ctx *A_expr_betweenContext) {} + +// EnterA_expr_in is called when production a_expr_in is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_in(ctx *A_expr_inContext) {} + +// ExitA_expr_in is called when production a_expr_in is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_in(ctx *A_expr_inContext) {} + +// EnterA_expr_unary_not is called when production a_expr_unary_not is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_unary_not(ctx *A_expr_unary_notContext) {} + +// ExitA_expr_unary_not is called when production a_expr_unary_not is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_unary_not(ctx *A_expr_unary_notContext) {} + +// EnterA_expr_isnull is called when production a_expr_isnull is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_isnull(ctx *A_expr_isnullContext) {} + +// ExitA_expr_isnull is called when production a_expr_isnull is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_isnull(ctx *A_expr_isnullContext) {} + +// EnterA_expr_is_not is called when production a_expr_is_not is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_is_not(ctx *A_expr_is_notContext) {} + +// ExitA_expr_is_not is called when production a_expr_is_not is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_is_not(ctx *A_expr_is_notContext) {} + +// EnterA_expr_compare is called when production a_expr_compare is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_compare(ctx *A_expr_compareContext) {} + +// ExitA_expr_compare is called when production a_expr_compare is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_compare(ctx *A_expr_compareContext) {} + +// EnterA_expr_prior_or_level is called when production a_expr_prior_or_level is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_prior_or_level(ctx *A_expr_prior_or_levelContext) {} + +// ExitA_expr_prior_or_level is called when production a_expr_prior_or_level is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_prior_or_level(ctx *A_expr_prior_or_levelContext) {} + +// EnterA_expr_like is called when production a_expr_like is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_like(ctx *A_expr_likeContext) {} + +// ExitA_expr_like is called when production a_expr_like is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_like(ctx *A_expr_likeContext) {} + +// EnterA_expr_qual_op is called when production a_expr_qual_op is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_qual_op(ctx *A_expr_qual_opContext) {} + +// ExitA_expr_qual_op is called when production a_expr_qual_op is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_qual_op(ctx *A_expr_qual_opContext) {} + +// EnterA_expr_unary_qualop is called when production a_expr_unary_qualop is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_unary_qualop(ctx *A_expr_unary_qualopContext) {} + +// ExitA_expr_unary_qualop is called when production a_expr_unary_qualop is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_unary_qualop(ctx *A_expr_unary_qualopContext) {} + +// EnterA_expr_add is called when production a_expr_add is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_add(ctx *A_expr_addContext) {} + +// ExitA_expr_add is called when production a_expr_add is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_add(ctx *A_expr_addContext) {} + +// EnterA_expr_mul is called when production a_expr_mul is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_mul(ctx *A_expr_mulContext) {} + +// ExitA_expr_mul is called when production a_expr_mul is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_mul(ctx *A_expr_mulContext) {} + +// EnterA_expr_caret is called when production a_expr_caret is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_caret(ctx *A_expr_caretContext) {} + +// ExitA_expr_caret is called when production a_expr_caret is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_caret(ctx *A_expr_caretContext) {} + +// EnterA_expr_unary_sign is called when production a_expr_unary_sign is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_unary_sign(ctx *A_expr_unary_signContext) {} + +// ExitA_expr_unary_sign is called when production a_expr_unary_sign is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_unary_sign(ctx *A_expr_unary_signContext) {} + +// EnterA_expr_at_time_zone is called when production a_expr_at_time_zone is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_at_time_zone(ctx *A_expr_at_time_zoneContext) {} + +// ExitA_expr_at_time_zone is called when production a_expr_at_time_zone is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_at_time_zone(ctx *A_expr_at_time_zoneContext) {} + +// EnterA_expr_collate is called when production a_expr_collate is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_collate(ctx *A_expr_collateContext) {} + +// ExitA_expr_collate is called when production a_expr_collate is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_collate(ctx *A_expr_collateContext) {} + +// EnterA_expr_typecast is called when production a_expr_typecast is entered. +func (s *BaseRedshiftParserListener) EnterA_expr_typecast(ctx *A_expr_typecastContext) {} + +// ExitA_expr_typecast is called when production a_expr_typecast is exited. +func (s *BaseRedshiftParserListener) ExitA_expr_typecast(ctx *A_expr_typecastContext) {} + +// EnterB_expr is called when production b_expr is entered. +func (s *BaseRedshiftParserListener) EnterB_expr(ctx *B_exprContext) {} + +// ExitB_expr is called when production b_expr is exited. +func (s *BaseRedshiftParserListener) ExitB_expr(ctx *B_exprContext) {} + +// EnterC_expr_exists is called when production c_expr_exists is entered. +func (s *BaseRedshiftParserListener) EnterC_expr_exists(ctx *C_expr_existsContext) {} + +// ExitC_expr_exists is called when production c_expr_exists is exited. +func (s *BaseRedshiftParserListener) ExitC_expr_exists(ctx *C_expr_existsContext) {} + +// EnterC_expr_expr is called when production c_expr_expr is entered. +func (s *BaseRedshiftParserListener) EnterC_expr_expr(ctx *C_expr_exprContext) {} + +// ExitC_expr_expr is called when production c_expr_expr is exited. +func (s *BaseRedshiftParserListener) ExitC_expr_expr(ctx *C_expr_exprContext) {} + +// EnterC_expr_case is called when production c_expr_case is entered. +func (s *BaseRedshiftParserListener) EnterC_expr_case(ctx *C_expr_caseContext) {} + +// ExitC_expr_case is called when production c_expr_case is exited. +func (s *BaseRedshiftParserListener) ExitC_expr_case(ctx *C_expr_caseContext) {} + +// EnterPlsqlvariablename is called when production plsqlvariablename is entered. +func (s *BaseRedshiftParserListener) EnterPlsqlvariablename(ctx *PlsqlvariablenameContext) {} + +// ExitPlsqlvariablename is called when production plsqlvariablename is exited. +func (s *BaseRedshiftParserListener) ExitPlsqlvariablename(ctx *PlsqlvariablenameContext) {} + +// EnterFunc_application is called when production func_application is entered. +func (s *BaseRedshiftParserListener) EnterFunc_application(ctx *Func_applicationContext) {} + +// ExitFunc_application is called when production func_application is exited. +func (s *BaseRedshiftParserListener) ExitFunc_application(ctx *Func_applicationContext) {} + +// EnterFunc_expr is called when production func_expr is entered. +func (s *BaseRedshiftParserListener) EnterFunc_expr(ctx *Func_exprContext) {} + +// ExitFunc_expr is called when production func_expr is exited. +func (s *BaseRedshiftParserListener) ExitFunc_expr(ctx *Func_exprContext) {} + +// EnterFunc_expr_windowless is called when production func_expr_windowless is entered. +func (s *BaseRedshiftParserListener) EnterFunc_expr_windowless(ctx *Func_expr_windowlessContext) {} + +// ExitFunc_expr_windowless is called when production func_expr_windowless is exited. +func (s *BaseRedshiftParserListener) ExitFunc_expr_windowless(ctx *Func_expr_windowlessContext) {} + +// EnterFunc_expr_common_subexpr is called when production func_expr_common_subexpr is entered. +func (s *BaseRedshiftParserListener) EnterFunc_expr_common_subexpr(ctx *Func_expr_common_subexprContext) { +} + +// ExitFunc_expr_common_subexpr is called when production func_expr_common_subexpr is exited. +func (s *BaseRedshiftParserListener) ExitFunc_expr_common_subexpr(ctx *Func_expr_common_subexprContext) { +} + +// EnterXml_root_version is called when production xml_root_version is entered. +func (s *BaseRedshiftParserListener) EnterXml_root_version(ctx *Xml_root_versionContext) {} + +// ExitXml_root_version is called when production xml_root_version is exited. +func (s *BaseRedshiftParserListener) ExitXml_root_version(ctx *Xml_root_versionContext) {} + +// EnterOpt_xml_root_standalone is called when production opt_xml_root_standalone is entered. +func (s *BaseRedshiftParserListener) EnterOpt_xml_root_standalone(ctx *Opt_xml_root_standaloneContext) { +} + +// ExitOpt_xml_root_standalone is called when production opt_xml_root_standalone is exited. +func (s *BaseRedshiftParserListener) ExitOpt_xml_root_standalone(ctx *Opt_xml_root_standaloneContext) { +} + +// EnterXml_attributes is called when production xml_attributes is entered. +func (s *BaseRedshiftParserListener) EnterXml_attributes(ctx *Xml_attributesContext) {} + +// ExitXml_attributes is called when production xml_attributes is exited. +func (s *BaseRedshiftParserListener) ExitXml_attributes(ctx *Xml_attributesContext) {} + +// EnterXml_attribute_list is called when production xml_attribute_list is entered. +func (s *BaseRedshiftParserListener) EnterXml_attribute_list(ctx *Xml_attribute_listContext) {} + +// ExitXml_attribute_list is called when production xml_attribute_list is exited. +func (s *BaseRedshiftParserListener) ExitXml_attribute_list(ctx *Xml_attribute_listContext) {} + +// EnterXml_attribute_el is called when production xml_attribute_el is entered. +func (s *BaseRedshiftParserListener) EnterXml_attribute_el(ctx *Xml_attribute_elContext) {} + +// ExitXml_attribute_el is called when production xml_attribute_el is exited. +func (s *BaseRedshiftParserListener) ExitXml_attribute_el(ctx *Xml_attribute_elContext) {} + +// EnterDocument_or_content is called when production document_or_content is entered. +func (s *BaseRedshiftParserListener) EnterDocument_or_content(ctx *Document_or_contentContext) {} + +// ExitDocument_or_content is called when production document_or_content is exited. +func (s *BaseRedshiftParserListener) ExitDocument_or_content(ctx *Document_or_contentContext) {} + +// EnterXml_whitespace_option is called when production xml_whitespace_option is entered. +func (s *BaseRedshiftParserListener) EnterXml_whitespace_option(ctx *Xml_whitespace_optionContext) {} + +// ExitXml_whitespace_option is called when production xml_whitespace_option is exited. +func (s *BaseRedshiftParserListener) ExitXml_whitespace_option(ctx *Xml_whitespace_optionContext) {} + +// EnterXmlexists_argument is called when production xmlexists_argument is entered. +func (s *BaseRedshiftParserListener) EnterXmlexists_argument(ctx *Xmlexists_argumentContext) {} + +// ExitXmlexists_argument is called when production xmlexists_argument is exited. +func (s *BaseRedshiftParserListener) ExitXmlexists_argument(ctx *Xmlexists_argumentContext) {} + +// EnterXml_passing_mech is called when production xml_passing_mech is entered. +func (s *BaseRedshiftParserListener) EnterXml_passing_mech(ctx *Xml_passing_mechContext) {} + +// ExitXml_passing_mech is called when production xml_passing_mech is exited. +func (s *BaseRedshiftParserListener) ExitXml_passing_mech(ctx *Xml_passing_mechContext) {} + +// EnterWithin_group_clause is called when production within_group_clause is entered. +func (s *BaseRedshiftParserListener) EnterWithin_group_clause(ctx *Within_group_clauseContext) {} + +// ExitWithin_group_clause is called when production within_group_clause is exited. +func (s *BaseRedshiftParserListener) ExitWithin_group_clause(ctx *Within_group_clauseContext) {} + +// EnterFilter_clause is called when production filter_clause is entered. +func (s *BaseRedshiftParserListener) EnterFilter_clause(ctx *Filter_clauseContext) {} + +// ExitFilter_clause is called when production filter_clause is exited. +func (s *BaseRedshiftParserListener) ExitFilter_clause(ctx *Filter_clauseContext) {} + +// EnterWindow_clause is called when production window_clause is entered. +func (s *BaseRedshiftParserListener) EnterWindow_clause(ctx *Window_clauseContext) {} + +// ExitWindow_clause is called when production window_clause is exited. +func (s *BaseRedshiftParserListener) ExitWindow_clause(ctx *Window_clauseContext) {} + +// EnterWindow_definition_list is called when production window_definition_list is entered. +func (s *BaseRedshiftParserListener) EnterWindow_definition_list(ctx *Window_definition_listContext) { +} + +// ExitWindow_definition_list is called when production window_definition_list is exited. +func (s *BaseRedshiftParserListener) ExitWindow_definition_list(ctx *Window_definition_listContext) {} + +// EnterWindow_definition is called when production window_definition is entered. +func (s *BaseRedshiftParserListener) EnterWindow_definition(ctx *Window_definitionContext) {} + +// ExitWindow_definition is called when production window_definition is exited. +func (s *BaseRedshiftParserListener) ExitWindow_definition(ctx *Window_definitionContext) {} + +// EnterOver_clause is called when production over_clause is entered. +func (s *BaseRedshiftParserListener) EnterOver_clause(ctx *Over_clauseContext) {} + +// ExitOver_clause is called when production over_clause is exited. +func (s *BaseRedshiftParserListener) ExitOver_clause(ctx *Over_clauseContext) {} + +// EnterWindow_specification is called when production window_specification is entered. +func (s *BaseRedshiftParserListener) EnterWindow_specification(ctx *Window_specificationContext) {} + +// ExitWindow_specification is called when production window_specification is exited. +func (s *BaseRedshiftParserListener) ExitWindow_specification(ctx *Window_specificationContext) {} + +// EnterOpt_existing_window_name is called when production opt_existing_window_name is entered. +func (s *BaseRedshiftParserListener) EnterOpt_existing_window_name(ctx *Opt_existing_window_nameContext) { +} + +// ExitOpt_existing_window_name is called when production opt_existing_window_name is exited. +func (s *BaseRedshiftParserListener) ExitOpt_existing_window_name(ctx *Opt_existing_window_nameContext) { +} + +// EnterOpt_partition_clause is called when production opt_partition_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_partition_clause(ctx *Opt_partition_clauseContext) {} + +// ExitOpt_partition_clause is called when production opt_partition_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_partition_clause(ctx *Opt_partition_clauseContext) {} + +// EnterOpt_frame_clause is called when production opt_frame_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_frame_clause(ctx *Opt_frame_clauseContext) {} + +// ExitOpt_frame_clause is called when production opt_frame_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_frame_clause(ctx *Opt_frame_clauseContext) {} + +// EnterFrame_extent is called when production frame_extent is entered. +func (s *BaseRedshiftParserListener) EnterFrame_extent(ctx *Frame_extentContext) {} + +// ExitFrame_extent is called when production frame_extent is exited. +func (s *BaseRedshiftParserListener) ExitFrame_extent(ctx *Frame_extentContext) {} + +// EnterFrame_bound is called when production frame_bound is entered. +func (s *BaseRedshiftParserListener) EnterFrame_bound(ctx *Frame_boundContext) {} + +// ExitFrame_bound is called when production frame_bound is exited. +func (s *BaseRedshiftParserListener) ExitFrame_bound(ctx *Frame_boundContext) {} + +// EnterOpt_window_exclusion_clause is called when production opt_window_exclusion_clause is entered. +func (s *BaseRedshiftParserListener) EnterOpt_window_exclusion_clause(ctx *Opt_window_exclusion_clauseContext) { +} + +// ExitOpt_window_exclusion_clause is called when production opt_window_exclusion_clause is exited. +func (s *BaseRedshiftParserListener) ExitOpt_window_exclusion_clause(ctx *Opt_window_exclusion_clauseContext) { +} + +// EnterRow is called when production row is entered. +func (s *BaseRedshiftParserListener) EnterRow(ctx *RowContext) {} + +// ExitRow is called when production row is exited. +func (s *BaseRedshiftParserListener) ExitRow(ctx *RowContext) {} + +// EnterExplicit_row is called when production explicit_row is entered. +func (s *BaseRedshiftParserListener) EnterExplicit_row(ctx *Explicit_rowContext) {} + +// ExitExplicit_row is called when production explicit_row is exited. +func (s *BaseRedshiftParserListener) ExitExplicit_row(ctx *Explicit_rowContext) {} + +// EnterImplicit_row is called when production implicit_row is entered. +func (s *BaseRedshiftParserListener) EnterImplicit_row(ctx *Implicit_rowContext) {} + +// ExitImplicit_row is called when production implicit_row is exited. +func (s *BaseRedshiftParserListener) ExitImplicit_row(ctx *Implicit_rowContext) {} + +// EnterSub_type is called when production sub_type is entered. +func (s *BaseRedshiftParserListener) EnterSub_type(ctx *Sub_typeContext) {} + +// ExitSub_type is called when production sub_type is exited. +func (s *BaseRedshiftParserListener) ExitSub_type(ctx *Sub_typeContext) {} + +// EnterAll_op is called when production all_op is entered. +func (s *BaseRedshiftParserListener) EnterAll_op(ctx *All_opContext) {} + +// ExitAll_op is called when production all_op is exited. +func (s *BaseRedshiftParserListener) ExitAll_op(ctx *All_opContext) {} + +// EnterMathop is called when production mathop is entered. +func (s *BaseRedshiftParserListener) EnterMathop(ctx *MathopContext) {} + +// ExitMathop is called when production mathop is exited. +func (s *BaseRedshiftParserListener) ExitMathop(ctx *MathopContext) {} + +// EnterQual_op is called when production qual_op is entered. +func (s *BaseRedshiftParserListener) EnterQual_op(ctx *Qual_opContext) {} + +// ExitQual_op is called when production qual_op is exited. +func (s *BaseRedshiftParserListener) ExitQual_op(ctx *Qual_opContext) {} + +// EnterQual_all_op is called when production qual_all_op is entered. +func (s *BaseRedshiftParserListener) EnterQual_all_op(ctx *Qual_all_opContext) {} + +// ExitQual_all_op is called when production qual_all_op is exited. +func (s *BaseRedshiftParserListener) ExitQual_all_op(ctx *Qual_all_opContext) {} + +// EnterSubquery_Op is called when production subquery_Op is entered. +func (s *BaseRedshiftParserListener) EnterSubquery_Op(ctx *Subquery_OpContext) {} + +// ExitSubquery_Op is called when production subquery_Op is exited. +func (s *BaseRedshiftParserListener) ExitSubquery_Op(ctx *Subquery_OpContext) {} + +// EnterExpr_list is called when production expr_list is entered. +func (s *BaseRedshiftParserListener) EnterExpr_list(ctx *Expr_listContext) {} + +// ExitExpr_list is called when production expr_list is exited. +func (s *BaseRedshiftParserListener) ExitExpr_list(ctx *Expr_listContext) {} + +// EnterFunc_arg_list is called when production func_arg_list is entered. +func (s *BaseRedshiftParserListener) EnterFunc_arg_list(ctx *Func_arg_listContext) {} + +// ExitFunc_arg_list is called when production func_arg_list is exited. +func (s *BaseRedshiftParserListener) ExitFunc_arg_list(ctx *Func_arg_listContext) {} + +// EnterFunc_arg_expr is called when production func_arg_expr is entered. +func (s *BaseRedshiftParserListener) EnterFunc_arg_expr(ctx *Func_arg_exprContext) {} + +// ExitFunc_arg_expr is called when production func_arg_expr is exited. +func (s *BaseRedshiftParserListener) ExitFunc_arg_expr(ctx *Func_arg_exprContext) {} + +// EnterType_list is called when production type_list is entered. +func (s *BaseRedshiftParserListener) EnterType_list(ctx *Type_listContext) {} + +// ExitType_list is called when production type_list is exited. +func (s *BaseRedshiftParserListener) ExitType_list(ctx *Type_listContext) {} + +// EnterArray_expr is called when production array_expr is entered. +func (s *BaseRedshiftParserListener) EnterArray_expr(ctx *Array_exprContext) {} + +// ExitArray_expr is called when production array_expr is exited. +func (s *BaseRedshiftParserListener) ExitArray_expr(ctx *Array_exprContext) {} + +// EnterArray_expr_list is called when production array_expr_list is entered. +func (s *BaseRedshiftParserListener) EnterArray_expr_list(ctx *Array_expr_listContext) {} + +// ExitArray_expr_list is called when production array_expr_list is exited. +func (s *BaseRedshiftParserListener) ExitArray_expr_list(ctx *Array_expr_listContext) {} + +// EnterExtract_list is called when production extract_list is entered. +func (s *BaseRedshiftParserListener) EnterExtract_list(ctx *Extract_listContext) {} + +// ExitExtract_list is called when production extract_list is exited. +func (s *BaseRedshiftParserListener) ExitExtract_list(ctx *Extract_listContext) {} + +// EnterExtract_arg is called when production extract_arg is entered. +func (s *BaseRedshiftParserListener) EnterExtract_arg(ctx *Extract_argContext) {} + +// ExitExtract_arg is called when production extract_arg is exited. +func (s *BaseRedshiftParserListener) ExitExtract_arg(ctx *Extract_argContext) {} + +// EnterUnicode_normal_form is called when production unicode_normal_form is entered. +func (s *BaseRedshiftParserListener) EnterUnicode_normal_form(ctx *Unicode_normal_formContext) {} + +// ExitUnicode_normal_form is called when production unicode_normal_form is exited. +func (s *BaseRedshiftParserListener) ExitUnicode_normal_form(ctx *Unicode_normal_formContext) {} + +// EnterOverlay_list is called when production overlay_list is entered. +func (s *BaseRedshiftParserListener) EnterOverlay_list(ctx *Overlay_listContext) {} + +// ExitOverlay_list is called when production overlay_list is exited. +func (s *BaseRedshiftParserListener) ExitOverlay_list(ctx *Overlay_listContext) {} + +// EnterPosition_list is called when production position_list is entered. +func (s *BaseRedshiftParserListener) EnterPosition_list(ctx *Position_listContext) {} + +// ExitPosition_list is called when production position_list is exited. +func (s *BaseRedshiftParserListener) ExitPosition_list(ctx *Position_listContext) {} + +// EnterSubstr_list is called when production substr_list is entered. +func (s *BaseRedshiftParserListener) EnterSubstr_list(ctx *Substr_listContext) {} + +// ExitSubstr_list is called when production substr_list is exited. +func (s *BaseRedshiftParserListener) ExitSubstr_list(ctx *Substr_listContext) {} + +// EnterTrim_list is called when production trim_list is entered. +func (s *BaseRedshiftParserListener) EnterTrim_list(ctx *Trim_listContext) {} + +// ExitTrim_list is called when production trim_list is exited. +func (s *BaseRedshiftParserListener) ExitTrim_list(ctx *Trim_listContext) {} + +// EnterIn_expr_select is called when production in_expr_select is entered. +func (s *BaseRedshiftParserListener) EnterIn_expr_select(ctx *In_expr_selectContext) {} + +// ExitIn_expr_select is called when production in_expr_select is exited. +func (s *BaseRedshiftParserListener) ExitIn_expr_select(ctx *In_expr_selectContext) {} + +// EnterIn_expr_list is called when production in_expr_list is entered. +func (s *BaseRedshiftParserListener) EnterIn_expr_list(ctx *In_expr_listContext) {} + +// ExitIn_expr_list is called when production in_expr_list is exited. +func (s *BaseRedshiftParserListener) ExitIn_expr_list(ctx *In_expr_listContext) {} + +// EnterCase_expr is called when production case_expr is entered. +func (s *BaseRedshiftParserListener) EnterCase_expr(ctx *Case_exprContext) {} + +// ExitCase_expr is called when production case_expr is exited. +func (s *BaseRedshiftParserListener) ExitCase_expr(ctx *Case_exprContext) {} + +// EnterWhen_clause_list is called when production when_clause_list is entered. +func (s *BaseRedshiftParserListener) EnterWhen_clause_list(ctx *When_clause_listContext) {} + +// ExitWhen_clause_list is called when production when_clause_list is exited. +func (s *BaseRedshiftParserListener) ExitWhen_clause_list(ctx *When_clause_listContext) {} + +// EnterWhen_clause is called when production when_clause is entered. +func (s *BaseRedshiftParserListener) EnterWhen_clause(ctx *When_clauseContext) {} + +// ExitWhen_clause is called when production when_clause is exited. +func (s *BaseRedshiftParserListener) ExitWhen_clause(ctx *When_clauseContext) {} + +// EnterCase_default is called when production case_default is entered. +func (s *BaseRedshiftParserListener) EnterCase_default(ctx *Case_defaultContext) {} + +// ExitCase_default is called when production case_default is exited. +func (s *BaseRedshiftParserListener) ExitCase_default(ctx *Case_defaultContext) {} + +// EnterCase_arg is called when production case_arg is entered. +func (s *BaseRedshiftParserListener) EnterCase_arg(ctx *Case_argContext) {} + +// ExitCase_arg is called when production case_arg is exited. +func (s *BaseRedshiftParserListener) ExitCase_arg(ctx *Case_argContext) {} + +// EnterColumnref is called when production columnref is entered. +func (s *BaseRedshiftParserListener) EnterColumnref(ctx *ColumnrefContext) {} + +// ExitColumnref is called when production columnref is exited. +func (s *BaseRedshiftParserListener) ExitColumnref(ctx *ColumnrefContext) {} + +// EnterIndirection_el is called when production indirection_el is entered. +func (s *BaseRedshiftParserListener) EnterIndirection_el(ctx *Indirection_elContext) {} + +// ExitIndirection_el is called when production indirection_el is exited. +func (s *BaseRedshiftParserListener) ExitIndirection_el(ctx *Indirection_elContext) {} + +// EnterOpt_slice_bound is called when production opt_slice_bound is entered. +func (s *BaseRedshiftParserListener) EnterOpt_slice_bound(ctx *Opt_slice_boundContext) {} + +// ExitOpt_slice_bound is called when production opt_slice_bound is exited. +func (s *BaseRedshiftParserListener) ExitOpt_slice_bound(ctx *Opt_slice_boundContext) {} + +// EnterIndirection is called when production indirection is entered. +func (s *BaseRedshiftParserListener) EnterIndirection(ctx *IndirectionContext) {} + +// ExitIndirection is called when production indirection is exited. +func (s *BaseRedshiftParserListener) ExitIndirection(ctx *IndirectionContext) {} + +// EnterOpt_indirection is called when production opt_indirection is entered. +func (s *BaseRedshiftParserListener) EnterOpt_indirection(ctx *Opt_indirectionContext) {} + +// ExitOpt_indirection is called when production opt_indirection is exited. +func (s *BaseRedshiftParserListener) ExitOpt_indirection(ctx *Opt_indirectionContext) {} + +// EnterOpt_target_list is called when production opt_target_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_target_list(ctx *Opt_target_listContext) {} + +// ExitOpt_target_list is called when production opt_target_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_target_list(ctx *Opt_target_listContext) {} + +// EnterTarget_list is called when production target_list is entered. +func (s *BaseRedshiftParserListener) EnterTarget_list(ctx *Target_listContext) {} + +// ExitTarget_list is called when production target_list is exited. +func (s *BaseRedshiftParserListener) ExitTarget_list(ctx *Target_listContext) {} + +// EnterTarget_label is called when production target_label is entered. +func (s *BaseRedshiftParserListener) EnterTarget_label(ctx *Target_labelContext) {} + +// ExitTarget_label is called when production target_label is exited. +func (s *BaseRedshiftParserListener) ExitTarget_label(ctx *Target_labelContext) {} + +// EnterTarget_star is called when production target_star is entered. +func (s *BaseRedshiftParserListener) EnterTarget_star(ctx *Target_starContext) {} + +// ExitTarget_star is called when production target_star is exited. +func (s *BaseRedshiftParserListener) ExitTarget_star(ctx *Target_starContext) {} + +// EnterTarget_alias is called when production target_alias is entered. +func (s *BaseRedshiftParserListener) EnterTarget_alias(ctx *Target_aliasContext) {} + +// ExitTarget_alias is called when production target_alias is exited. +func (s *BaseRedshiftParserListener) ExitTarget_alias(ctx *Target_aliasContext) {} + +// EnterQualified_name_list is called when production qualified_name_list is entered. +func (s *BaseRedshiftParserListener) EnterQualified_name_list(ctx *Qualified_name_listContext) {} + +// ExitQualified_name_list is called when production qualified_name_list is exited. +func (s *BaseRedshiftParserListener) ExitQualified_name_list(ctx *Qualified_name_listContext) {} + +// EnterQualified_name is called when production qualified_name is entered. +func (s *BaseRedshiftParserListener) EnterQualified_name(ctx *Qualified_nameContext) {} + +// ExitQualified_name is called when production qualified_name is exited. +func (s *BaseRedshiftParserListener) ExitQualified_name(ctx *Qualified_nameContext) {} + +// EnterName_list is called when production name_list is entered. +func (s *BaseRedshiftParserListener) EnterName_list(ctx *Name_listContext) {} + +// ExitName_list is called when production name_list is exited. +func (s *BaseRedshiftParserListener) ExitName_list(ctx *Name_listContext) {} + +// EnterName is called when production name is entered. +func (s *BaseRedshiftParserListener) EnterName(ctx *NameContext) {} + +// ExitName is called when production name is exited. +func (s *BaseRedshiftParserListener) ExitName(ctx *NameContext) {} + +// EnterAttr_name is called when production attr_name is entered. +func (s *BaseRedshiftParserListener) EnterAttr_name(ctx *Attr_nameContext) {} + +// ExitAttr_name is called when production attr_name is exited. +func (s *BaseRedshiftParserListener) ExitAttr_name(ctx *Attr_nameContext) {} + +// EnterFile_name is called when production file_name is entered. +func (s *BaseRedshiftParserListener) EnterFile_name(ctx *File_nameContext) {} + +// ExitFile_name is called when production file_name is exited. +func (s *BaseRedshiftParserListener) ExitFile_name(ctx *File_nameContext) {} + +// EnterFunc_name is called when production func_name is entered. +func (s *BaseRedshiftParserListener) EnterFunc_name(ctx *Func_nameContext) {} + +// ExitFunc_name is called when production func_name is exited. +func (s *BaseRedshiftParserListener) ExitFunc_name(ctx *Func_nameContext) {} + +// EnterAexprconst is called when production aexprconst is entered. +func (s *BaseRedshiftParserListener) EnterAexprconst(ctx *AexprconstContext) {} + +// ExitAexprconst is called when production aexprconst is exited. +func (s *BaseRedshiftParserListener) ExitAexprconst(ctx *AexprconstContext) {} + +// EnterXconst is called when production xconst is entered. +func (s *BaseRedshiftParserListener) EnterXconst(ctx *XconstContext) {} + +// ExitXconst is called when production xconst is exited. +func (s *BaseRedshiftParserListener) ExitXconst(ctx *XconstContext) {} + +// EnterBconst is called when production bconst is entered. +func (s *BaseRedshiftParserListener) EnterBconst(ctx *BconstContext) {} + +// ExitBconst is called when production bconst is exited. +func (s *BaseRedshiftParserListener) ExitBconst(ctx *BconstContext) {} + +// EnterFconst is called when production fconst is entered. +func (s *BaseRedshiftParserListener) EnterFconst(ctx *FconstContext) {} + +// ExitFconst is called when production fconst is exited. +func (s *BaseRedshiftParserListener) ExitFconst(ctx *FconstContext) {} + +// EnterIconst is called when production iconst is entered. +func (s *BaseRedshiftParserListener) EnterIconst(ctx *IconstContext) {} + +// ExitIconst is called when production iconst is exited. +func (s *BaseRedshiftParserListener) ExitIconst(ctx *IconstContext) {} + +// EnterSconst is called when production sconst is entered. +func (s *BaseRedshiftParserListener) EnterSconst(ctx *SconstContext) {} + +// ExitSconst is called when production sconst is exited. +func (s *BaseRedshiftParserListener) ExitSconst(ctx *SconstContext) {} + +// EnterAnysconst is called when production anysconst is entered. +func (s *BaseRedshiftParserListener) EnterAnysconst(ctx *AnysconstContext) {} + +// ExitAnysconst is called when production anysconst is exited. +func (s *BaseRedshiftParserListener) ExitAnysconst(ctx *AnysconstContext) {} + +// EnterOpt_uescape is called when production opt_uescape is entered. +func (s *BaseRedshiftParserListener) EnterOpt_uescape(ctx *Opt_uescapeContext) {} + +// ExitOpt_uescape is called when production opt_uescape is exited. +func (s *BaseRedshiftParserListener) ExitOpt_uescape(ctx *Opt_uescapeContext) {} + +// EnterSignediconst is called when production signediconst is entered. +func (s *BaseRedshiftParserListener) EnterSignediconst(ctx *SignediconstContext) {} + +// ExitSignediconst is called when production signediconst is exited. +func (s *BaseRedshiftParserListener) ExitSignediconst(ctx *SignediconstContext) {} + +// EnterRoleid is called when production roleid is entered. +func (s *BaseRedshiftParserListener) EnterRoleid(ctx *RoleidContext) {} + +// ExitRoleid is called when production roleid is exited. +func (s *BaseRedshiftParserListener) ExitRoleid(ctx *RoleidContext) {} + +// EnterRolespec is called when production rolespec is entered. +func (s *BaseRedshiftParserListener) EnterRolespec(ctx *RolespecContext) {} + +// ExitRolespec is called when production rolespec is exited. +func (s *BaseRedshiftParserListener) ExitRolespec(ctx *RolespecContext) {} + +// EnterRole_list is called when production role_list is entered. +func (s *BaseRedshiftParserListener) EnterRole_list(ctx *Role_listContext) {} + +// ExitRole_list is called when production role_list is exited. +func (s *BaseRedshiftParserListener) ExitRole_list(ctx *Role_listContext) {} + +// EnterColid is called when production colid is entered. +func (s *BaseRedshiftParserListener) EnterColid(ctx *ColidContext) {} + +// ExitColid is called when production colid is exited. +func (s *BaseRedshiftParserListener) ExitColid(ctx *ColidContext) {} + +// EnterTable_alias is called when production table_alias is entered. +func (s *BaseRedshiftParserListener) EnterTable_alias(ctx *Table_aliasContext) {} + +// ExitTable_alias is called when production table_alias is exited. +func (s *BaseRedshiftParserListener) ExitTable_alias(ctx *Table_aliasContext) {} + +// EnterType_function_name is called when production type_function_name is entered. +func (s *BaseRedshiftParserListener) EnterType_function_name(ctx *Type_function_nameContext) {} + +// ExitType_function_name is called when production type_function_name is exited. +func (s *BaseRedshiftParserListener) ExitType_function_name(ctx *Type_function_nameContext) {} + +// EnterNonreservedword is called when production nonreservedword is entered. +func (s *BaseRedshiftParserListener) EnterNonreservedword(ctx *NonreservedwordContext) {} + +// ExitNonreservedword is called when production nonreservedword is exited. +func (s *BaseRedshiftParserListener) ExitNonreservedword(ctx *NonreservedwordContext) {} + +// EnterCollabel is called when production collabel is entered. +func (s *BaseRedshiftParserListener) EnterCollabel(ctx *CollabelContext) {} + +// ExitCollabel is called when production collabel is exited. +func (s *BaseRedshiftParserListener) ExitCollabel(ctx *CollabelContext) {} + +// EnterIdentifier is called when production identifier is entered. +func (s *BaseRedshiftParserListener) EnterIdentifier(ctx *IdentifierContext) {} + +// ExitIdentifier is called when production identifier is exited. +func (s *BaseRedshiftParserListener) ExitIdentifier(ctx *IdentifierContext) {} + +// EnterPlsqlidentifier is called when production plsqlidentifier is entered. +func (s *BaseRedshiftParserListener) EnterPlsqlidentifier(ctx *PlsqlidentifierContext) {} + +// ExitPlsqlidentifier is called when production plsqlidentifier is exited. +func (s *BaseRedshiftParserListener) ExitPlsqlidentifier(ctx *PlsqlidentifierContext) {} + +// EnterUnreserved_keyword is called when production unreserved_keyword is entered. +func (s *BaseRedshiftParserListener) EnterUnreserved_keyword(ctx *Unreserved_keywordContext) {} + +// ExitUnreserved_keyword is called when production unreserved_keyword is exited. +func (s *BaseRedshiftParserListener) ExitUnreserved_keyword(ctx *Unreserved_keywordContext) {} + +// EnterCol_name_keyword is called when production col_name_keyword is entered. +func (s *BaseRedshiftParserListener) EnterCol_name_keyword(ctx *Col_name_keywordContext) {} + +// ExitCol_name_keyword is called when production col_name_keyword is exited. +func (s *BaseRedshiftParserListener) ExitCol_name_keyword(ctx *Col_name_keywordContext) {} + +// EnterType_func_name_keyword is called when production type_func_name_keyword is entered. +func (s *BaseRedshiftParserListener) EnterType_func_name_keyword(ctx *Type_func_name_keywordContext) { +} + +// ExitType_func_name_keyword is called when production type_func_name_keyword is exited. +func (s *BaseRedshiftParserListener) ExitType_func_name_keyword(ctx *Type_func_name_keywordContext) {} + +// EnterReserved_keyword is called when production reserved_keyword is entered. +func (s *BaseRedshiftParserListener) EnterReserved_keyword(ctx *Reserved_keywordContext) {} + +// ExitReserved_keyword is called when production reserved_keyword is exited. +func (s *BaseRedshiftParserListener) ExitReserved_keyword(ctx *Reserved_keywordContext) {} + +// EnterBuiltin_function_name is called when production builtin_function_name is entered. +func (s *BaseRedshiftParserListener) EnterBuiltin_function_name(ctx *Builtin_function_nameContext) {} + +// ExitBuiltin_function_name is called when production builtin_function_name is exited. +func (s *BaseRedshiftParserListener) ExitBuiltin_function_name(ctx *Builtin_function_nameContext) {} + +// EnterPl_function is called when production pl_function is entered. +func (s *BaseRedshiftParserListener) EnterPl_function(ctx *Pl_functionContext) {} + +// ExitPl_function is called when production pl_function is exited. +func (s *BaseRedshiftParserListener) ExitPl_function(ctx *Pl_functionContext) {} + +// EnterComp_options is called when production comp_options is entered. +func (s *BaseRedshiftParserListener) EnterComp_options(ctx *Comp_optionsContext) {} + +// ExitComp_options is called when production comp_options is exited. +func (s *BaseRedshiftParserListener) ExitComp_options(ctx *Comp_optionsContext) {} + +// EnterComp_option is called when production comp_option is entered. +func (s *BaseRedshiftParserListener) EnterComp_option(ctx *Comp_optionContext) {} + +// ExitComp_option is called when production comp_option is exited. +func (s *BaseRedshiftParserListener) ExitComp_option(ctx *Comp_optionContext) {} + +// EnterSharp is called when production sharp is entered. +func (s *BaseRedshiftParserListener) EnterSharp(ctx *SharpContext) {} + +// ExitSharp is called when production sharp is exited. +func (s *BaseRedshiftParserListener) ExitSharp(ctx *SharpContext) {} + +// EnterOption_value is called when production option_value is entered. +func (s *BaseRedshiftParserListener) EnterOption_value(ctx *Option_valueContext) {} + +// ExitOption_value is called when production option_value is exited. +func (s *BaseRedshiftParserListener) ExitOption_value(ctx *Option_valueContext) {} + +// EnterOpt_semi is called when production opt_semi is entered. +func (s *BaseRedshiftParserListener) EnterOpt_semi(ctx *Opt_semiContext) {} + +// ExitOpt_semi is called when production opt_semi is exited. +func (s *BaseRedshiftParserListener) ExitOpt_semi(ctx *Opt_semiContext) {} + +// EnterPl_block is called when production pl_block is entered. +func (s *BaseRedshiftParserListener) EnterPl_block(ctx *Pl_blockContext) {} + +// ExitPl_block is called when production pl_block is exited. +func (s *BaseRedshiftParserListener) ExitPl_block(ctx *Pl_blockContext) {} + +// EnterDecl_sect is called when production decl_sect is entered. +func (s *BaseRedshiftParserListener) EnterDecl_sect(ctx *Decl_sectContext) {} + +// ExitDecl_sect is called when production decl_sect is exited. +func (s *BaseRedshiftParserListener) ExitDecl_sect(ctx *Decl_sectContext) {} + +// EnterDecl_start is called when production decl_start is entered. +func (s *BaseRedshiftParserListener) EnterDecl_start(ctx *Decl_startContext) {} + +// ExitDecl_start is called when production decl_start is exited. +func (s *BaseRedshiftParserListener) ExitDecl_start(ctx *Decl_startContext) {} + +// EnterDecl_stmts is called when production decl_stmts is entered. +func (s *BaseRedshiftParserListener) EnterDecl_stmts(ctx *Decl_stmtsContext) {} + +// ExitDecl_stmts is called when production decl_stmts is exited. +func (s *BaseRedshiftParserListener) ExitDecl_stmts(ctx *Decl_stmtsContext) {} + +// EnterLabel_decl is called when production label_decl is entered. +func (s *BaseRedshiftParserListener) EnterLabel_decl(ctx *Label_declContext) {} + +// ExitLabel_decl is called when production label_decl is exited. +func (s *BaseRedshiftParserListener) ExitLabel_decl(ctx *Label_declContext) {} + +// EnterDecl_stmt is called when production decl_stmt is entered. +func (s *BaseRedshiftParserListener) EnterDecl_stmt(ctx *Decl_stmtContext) {} + +// ExitDecl_stmt is called when production decl_stmt is exited. +func (s *BaseRedshiftParserListener) ExitDecl_stmt(ctx *Decl_stmtContext) {} + +// EnterDecl_statement is called when production decl_statement is entered. +func (s *BaseRedshiftParserListener) EnterDecl_statement(ctx *Decl_statementContext) {} + +// ExitDecl_statement is called when production decl_statement is exited. +func (s *BaseRedshiftParserListener) ExitDecl_statement(ctx *Decl_statementContext) {} + +// EnterOpt_scrollable is called when production opt_scrollable is entered. +func (s *BaseRedshiftParserListener) EnterOpt_scrollable(ctx *Opt_scrollableContext) {} + +// ExitOpt_scrollable is called when production opt_scrollable is exited. +func (s *BaseRedshiftParserListener) ExitOpt_scrollable(ctx *Opt_scrollableContext) {} + +// EnterDecl_cursor_query is called when production decl_cursor_query is entered. +func (s *BaseRedshiftParserListener) EnterDecl_cursor_query(ctx *Decl_cursor_queryContext) {} + +// ExitDecl_cursor_query is called when production decl_cursor_query is exited. +func (s *BaseRedshiftParserListener) ExitDecl_cursor_query(ctx *Decl_cursor_queryContext) {} + +// EnterDecl_cursor_args is called when production decl_cursor_args is entered. +func (s *BaseRedshiftParserListener) EnterDecl_cursor_args(ctx *Decl_cursor_argsContext) {} + +// ExitDecl_cursor_args is called when production decl_cursor_args is exited. +func (s *BaseRedshiftParserListener) ExitDecl_cursor_args(ctx *Decl_cursor_argsContext) {} + +// EnterDecl_cursor_arglist is called when production decl_cursor_arglist is entered. +func (s *BaseRedshiftParserListener) EnterDecl_cursor_arglist(ctx *Decl_cursor_arglistContext) {} + +// ExitDecl_cursor_arglist is called when production decl_cursor_arglist is exited. +func (s *BaseRedshiftParserListener) ExitDecl_cursor_arglist(ctx *Decl_cursor_arglistContext) {} + +// EnterDecl_cursor_arg is called when production decl_cursor_arg is entered. +func (s *BaseRedshiftParserListener) EnterDecl_cursor_arg(ctx *Decl_cursor_argContext) {} + +// ExitDecl_cursor_arg is called when production decl_cursor_arg is exited. +func (s *BaseRedshiftParserListener) ExitDecl_cursor_arg(ctx *Decl_cursor_argContext) {} + +// EnterDecl_is_for is called when production decl_is_for is entered. +func (s *BaseRedshiftParserListener) EnterDecl_is_for(ctx *Decl_is_forContext) {} + +// ExitDecl_is_for is called when production decl_is_for is exited. +func (s *BaseRedshiftParserListener) ExitDecl_is_for(ctx *Decl_is_forContext) {} + +// EnterDecl_aliasitem is called when production decl_aliasitem is entered. +func (s *BaseRedshiftParserListener) EnterDecl_aliasitem(ctx *Decl_aliasitemContext) {} + +// ExitDecl_aliasitem is called when production decl_aliasitem is exited. +func (s *BaseRedshiftParserListener) ExitDecl_aliasitem(ctx *Decl_aliasitemContext) {} + +// EnterDecl_varname is called when production decl_varname is entered. +func (s *BaseRedshiftParserListener) EnterDecl_varname(ctx *Decl_varnameContext) {} + +// ExitDecl_varname is called when production decl_varname is exited. +func (s *BaseRedshiftParserListener) ExitDecl_varname(ctx *Decl_varnameContext) {} + +// EnterDecl_const is called when production decl_const is entered. +func (s *BaseRedshiftParserListener) EnterDecl_const(ctx *Decl_constContext) {} + +// ExitDecl_const is called when production decl_const is exited. +func (s *BaseRedshiftParserListener) ExitDecl_const(ctx *Decl_constContext) {} + +// EnterDecl_datatype is called when production decl_datatype is entered. +func (s *BaseRedshiftParserListener) EnterDecl_datatype(ctx *Decl_datatypeContext) {} + +// ExitDecl_datatype is called when production decl_datatype is exited. +func (s *BaseRedshiftParserListener) ExitDecl_datatype(ctx *Decl_datatypeContext) {} + +// EnterDecl_collate is called when production decl_collate is entered. +func (s *BaseRedshiftParserListener) EnterDecl_collate(ctx *Decl_collateContext) {} + +// ExitDecl_collate is called when production decl_collate is exited. +func (s *BaseRedshiftParserListener) ExitDecl_collate(ctx *Decl_collateContext) {} + +// EnterDecl_notnull is called when production decl_notnull is entered. +func (s *BaseRedshiftParserListener) EnterDecl_notnull(ctx *Decl_notnullContext) {} + +// ExitDecl_notnull is called when production decl_notnull is exited. +func (s *BaseRedshiftParserListener) ExitDecl_notnull(ctx *Decl_notnullContext) {} + +// EnterDecl_defval is called when production decl_defval is entered. +func (s *BaseRedshiftParserListener) EnterDecl_defval(ctx *Decl_defvalContext) {} + +// ExitDecl_defval is called when production decl_defval is exited. +func (s *BaseRedshiftParserListener) ExitDecl_defval(ctx *Decl_defvalContext) {} + +// EnterDecl_defkey is called when production decl_defkey is entered. +func (s *BaseRedshiftParserListener) EnterDecl_defkey(ctx *Decl_defkeyContext) {} + +// ExitDecl_defkey is called when production decl_defkey is exited. +func (s *BaseRedshiftParserListener) ExitDecl_defkey(ctx *Decl_defkeyContext) {} + +// EnterAssign_operator is called when production assign_operator is entered. +func (s *BaseRedshiftParserListener) EnterAssign_operator(ctx *Assign_operatorContext) {} + +// ExitAssign_operator is called when production assign_operator is exited. +func (s *BaseRedshiftParserListener) ExitAssign_operator(ctx *Assign_operatorContext) {} + +// EnterProc_sect is called when production proc_sect is entered. +func (s *BaseRedshiftParserListener) EnterProc_sect(ctx *Proc_sectContext) {} + +// ExitProc_sect is called when production proc_sect is exited. +func (s *BaseRedshiftParserListener) ExitProc_sect(ctx *Proc_sectContext) {} + +// EnterProc_stmt is called when production proc_stmt is entered. +func (s *BaseRedshiftParserListener) EnterProc_stmt(ctx *Proc_stmtContext) {} + +// ExitProc_stmt is called when production proc_stmt is exited. +func (s *BaseRedshiftParserListener) ExitProc_stmt(ctx *Proc_stmtContext) {} + +// EnterStmt_perform is called when production stmt_perform is entered. +func (s *BaseRedshiftParserListener) EnterStmt_perform(ctx *Stmt_performContext) {} + +// ExitStmt_perform is called when production stmt_perform is exited. +func (s *BaseRedshiftParserListener) ExitStmt_perform(ctx *Stmt_performContext) {} + +// EnterStmt_call is called when production stmt_call is entered. +func (s *BaseRedshiftParserListener) EnterStmt_call(ctx *Stmt_callContext) {} + +// ExitStmt_call is called when production stmt_call is exited. +func (s *BaseRedshiftParserListener) ExitStmt_call(ctx *Stmt_callContext) {} + +// EnterOpt_expr_list is called when production opt_expr_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_expr_list(ctx *Opt_expr_listContext) {} + +// ExitOpt_expr_list is called when production opt_expr_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_expr_list(ctx *Opt_expr_listContext) {} + +// EnterStmt_assign is called when production stmt_assign is entered. +func (s *BaseRedshiftParserListener) EnterStmt_assign(ctx *Stmt_assignContext) {} + +// ExitStmt_assign is called when production stmt_assign is exited. +func (s *BaseRedshiftParserListener) ExitStmt_assign(ctx *Stmt_assignContext) {} + +// EnterStmt_getdiag is called when production stmt_getdiag is entered. +func (s *BaseRedshiftParserListener) EnterStmt_getdiag(ctx *Stmt_getdiagContext) {} + +// ExitStmt_getdiag is called when production stmt_getdiag is exited. +func (s *BaseRedshiftParserListener) ExitStmt_getdiag(ctx *Stmt_getdiagContext) {} + +// EnterGetdiag_area_opt is called when production getdiag_area_opt is entered. +func (s *BaseRedshiftParserListener) EnterGetdiag_area_opt(ctx *Getdiag_area_optContext) {} + +// ExitGetdiag_area_opt is called when production getdiag_area_opt is exited. +func (s *BaseRedshiftParserListener) ExitGetdiag_area_opt(ctx *Getdiag_area_optContext) {} + +// EnterGetdiag_list is called when production getdiag_list is entered. +func (s *BaseRedshiftParserListener) EnterGetdiag_list(ctx *Getdiag_listContext) {} + +// ExitGetdiag_list is called when production getdiag_list is exited. +func (s *BaseRedshiftParserListener) ExitGetdiag_list(ctx *Getdiag_listContext) {} + +// EnterGetdiag_list_item is called when production getdiag_list_item is entered. +func (s *BaseRedshiftParserListener) EnterGetdiag_list_item(ctx *Getdiag_list_itemContext) {} + +// ExitGetdiag_list_item is called when production getdiag_list_item is exited. +func (s *BaseRedshiftParserListener) ExitGetdiag_list_item(ctx *Getdiag_list_itemContext) {} + +// EnterGetdiag_item is called when production getdiag_item is entered. +func (s *BaseRedshiftParserListener) EnterGetdiag_item(ctx *Getdiag_itemContext) {} + +// ExitGetdiag_item is called when production getdiag_item is exited. +func (s *BaseRedshiftParserListener) ExitGetdiag_item(ctx *Getdiag_itemContext) {} + +// EnterGetdiag_target is called when production getdiag_target is entered. +func (s *BaseRedshiftParserListener) EnterGetdiag_target(ctx *Getdiag_targetContext) {} + +// ExitGetdiag_target is called when production getdiag_target is exited. +func (s *BaseRedshiftParserListener) ExitGetdiag_target(ctx *Getdiag_targetContext) {} + +// EnterAssign_var is called when production assign_var is entered. +func (s *BaseRedshiftParserListener) EnterAssign_var(ctx *Assign_varContext) {} + +// ExitAssign_var is called when production assign_var is exited. +func (s *BaseRedshiftParserListener) ExitAssign_var(ctx *Assign_varContext) {} + +// EnterStmt_if is called when production stmt_if is entered. +func (s *BaseRedshiftParserListener) EnterStmt_if(ctx *Stmt_ifContext) {} + +// ExitStmt_if is called when production stmt_if is exited. +func (s *BaseRedshiftParserListener) ExitStmt_if(ctx *Stmt_ifContext) {} + +// EnterStmt_elsifs is called when production stmt_elsifs is entered. +func (s *BaseRedshiftParserListener) EnterStmt_elsifs(ctx *Stmt_elsifsContext) {} + +// ExitStmt_elsifs is called when production stmt_elsifs is exited. +func (s *BaseRedshiftParserListener) ExitStmt_elsifs(ctx *Stmt_elsifsContext) {} + +// EnterStmt_else is called when production stmt_else is entered. +func (s *BaseRedshiftParserListener) EnterStmt_else(ctx *Stmt_elseContext) {} + +// ExitStmt_else is called when production stmt_else is exited. +func (s *BaseRedshiftParserListener) ExitStmt_else(ctx *Stmt_elseContext) {} + +// EnterStmt_case is called when production stmt_case is entered. +func (s *BaseRedshiftParserListener) EnterStmt_case(ctx *Stmt_caseContext) {} + +// ExitStmt_case is called when production stmt_case is exited. +func (s *BaseRedshiftParserListener) ExitStmt_case(ctx *Stmt_caseContext) {} + +// EnterOpt_expr_until_when is called when production opt_expr_until_when is entered. +func (s *BaseRedshiftParserListener) EnterOpt_expr_until_when(ctx *Opt_expr_until_whenContext) {} + +// ExitOpt_expr_until_when is called when production opt_expr_until_when is exited. +func (s *BaseRedshiftParserListener) ExitOpt_expr_until_when(ctx *Opt_expr_until_whenContext) {} + +// EnterCase_when_list is called when production case_when_list is entered. +func (s *BaseRedshiftParserListener) EnterCase_when_list(ctx *Case_when_listContext) {} + +// ExitCase_when_list is called when production case_when_list is exited. +func (s *BaseRedshiftParserListener) ExitCase_when_list(ctx *Case_when_listContext) {} + +// EnterCase_when is called when production case_when is entered. +func (s *BaseRedshiftParserListener) EnterCase_when(ctx *Case_whenContext) {} + +// ExitCase_when is called when production case_when is exited. +func (s *BaseRedshiftParserListener) ExitCase_when(ctx *Case_whenContext) {} + +// EnterOpt_case_else is called when production opt_case_else is entered. +func (s *BaseRedshiftParserListener) EnterOpt_case_else(ctx *Opt_case_elseContext) {} + +// ExitOpt_case_else is called when production opt_case_else is exited. +func (s *BaseRedshiftParserListener) ExitOpt_case_else(ctx *Opt_case_elseContext) {} + +// EnterStmt_loop is called when production stmt_loop is entered. +func (s *BaseRedshiftParserListener) EnterStmt_loop(ctx *Stmt_loopContext) {} + +// ExitStmt_loop is called when production stmt_loop is exited. +func (s *BaseRedshiftParserListener) ExitStmt_loop(ctx *Stmt_loopContext) {} + +// EnterStmt_while is called when production stmt_while is entered. +func (s *BaseRedshiftParserListener) EnterStmt_while(ctx *Stmt_whileContext) {} + +// ExitStmt_while is called when production stmt_while is exited. +func (s *BaseRedshiftParserListener) ExitStmt_while(ctx *Stmt_whileContext) {} + +// EnterStmt_for is called when production stmt_for is entered. +func (s *BaseRedshiftParserListener) EnterStmt_for(ctx *Stmt_forContext) {} + +// ExitStmt_for is called when production stmt_for is exited. +func (s *BaseRedshiftParserListener) ExitStmt_for(ctx *Stmt_forContext) {} + +// EnterFor_control is called when production for_control is entered. +func (s *BaseRedshiftParserListener) EnterFor_control(ctx *For_controlContext) {} + +// ExitFor_control is called when production for_control is exited. +func (s *BaseRedshiftParserListener) ExitFor_control(ctx *For_controlContext) {} + +// EnterOpt_for_using_expression is called when production opt_for_using_expression is entered. +func (s *BaseRedshiftParserListener) EnterOpt_for_using_expression(ctx *Opt_for_using_expressionContext) { +} + +// ExitOpt_for_using_expression is called when production opt_for_using_expression is exited. +func (s *BaseRedshiftParserListener) ExitOpt_for_using_expression(ctx *Opt_for_using_expressionContext) { +} + +// EnterOpt_cursor_parameters is called when production opt_cursor_parameters is entered. +func (s *BaseRedshiftParserListener) EnterOpt_cursor_parameters(ctx *Opt_cursor_parametersContext) {} + +// ExitOpt_cursor_parameters is called when production opt_cursor_parameters is exited. +func (s *BaseRedshiftParserListener) ExitOpt_cursor_parameters(ctx *Opt_cursor_parametersContext) {} + +// EnterOpt_reverse is called when production opt_reverse is entered. +func (s *BaseRedshiftParserListener) EnterOpt_reverse(ctx *Opt_reverseContext) {} + +// ExitOpt_reverse is called when production opt_reverse is exited. +func (s *BaseRedshiftParserListener) ExitOpt_reverse(ctx *Opt_reverseContext) {} + +// EnterOpt_by_expression is called when production opt_by_expression is entered. +func (s *BaseRedshiftParserListener) EnterOpt_by_expression(ctx *Opt_by_expressionContext) {} + +// ExitOpt_by_expression is called when production opt_by_expression is exited. +func (s *BaseRedshiftParserListener) ExitOpt_by_expression(ctx *Opt_by_expressionContext) {} + +// EnterFor_variable is called when production for_variable is entered. +func (s *BaseRedshiftParserListener) EnterFor_variable(ctx *For_variableContext) {} + +// ExitFor_variable is called when production for_variable is exited. +func (s *BaseRedshiftParserListener) ExitFor_variable(ctx *For_variableContext) {} + +// EnterStmt_foreach_a is called when production stmt_foreach_a is entered. +func (s *BaseRedshiftParserListener) EnterStmt_foreach_a(ctx *Stmt_foreach_aContext) {} + +// ExitStmt_foreach_a is called when production stmt_foreach_a is exited. +func (s *BaseRedshiftParserListener) ExitStmt_foreach_a(ctx *Stmt_foreach_aContext) {} + +// EnterForeach_slice is called when production foreach_slice is entered. +func (s *BaseRedshiftParserListener) EnterForeach_slice(ctx *Foreach_sliceContext) {} + +// ExitForeach_slice is called when production foreach_slice is exited. +func (s *BaseRedshiftParserListener) ExitForeach_slice(ctx *Foreach_sliceContext) {} + +// EnterStmt_exit is called when production stmt_exit is entered. +func (s *BaseRedshiftParserListener) EnterStmt_exit(ctx *Stmt_exitContext) {} + +// ExitStmt_exit is called when production stmt_exit is exited. +func (s *BaseRedshiftParserListener) ExitStmt_exit(ctx *Stmt_exitContext) {} + +// EnterExit_type is called when production exit_type is entered. +func (s *BaseRedshiftParserListener) EnterExit_type(ctx *Exit_typeContext) {} + +// ExitExit_type is called when production exit_type is exited. +func (s *BaseRedshiftParserListener) ExitExit_type(ctx *Exit_typeContext) {} + +// EnterStmt_return is called when production stmt_return is entered. +func (s *BaseRedshiftParserListener) EnterStmt_return(ctx *Stmt_returnContext) {} + +// ExitStmt_return is called when production stmt_return is exited. +func (s *BaseRedshiftParserListener) ExitStmt_return(ctx *Stmt_returnContext) {} + +// EnterOpt_return_result is called when production opt_return_result is entered. +func (s *BaseRedshiftParserListener) EnterOpt_return_result(ctx *Opt_return_resultContext) {} + +// ExitOpt_return_result is called when production opt_return_result is exited. +func (s *BaseRedshiftParserListener) ExitOpt_return_result(ctx *Opt_return_resultContext) {} + +// EnterStmt_raise is called when production stmt_raise is entered. +func (s *BaseRedshiftParserListener) EnterStmt_raise(ctx *Stmt_raiseContext) {} + +// ExitStmt_raise is called when production stmt_raise is exited. +func (s *BaseRedshiftParserListener) ExitStmt_raise(ctx *Stmt_raiseContext) {} + +// EnterOpt_stmt_raise_level is called when production opt_stmt_raise_level is entered. +func (s *BaseRedshiftParserListener) EnterOpt_stmt_raise_level(ctx *Opt_stmt_raise_levelContext) {} + +// ExitOpt_stmt_raise_level is called when production opt_stmt_raise_level is exited. +func (s *BaseRedshiftParserListener) ExitOpt_stmt_raise_level(ctx *Opt_stmt_raise_levelContext) {} + +// EnterOpt_raise_list is called when production opt_raise_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_raise_list(ctx *Opt_raise_listContext) {} + +// ExitOpt_raise_list is called when production opt_raise_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_raise_list(ctx *Opt_raise_listContext) {} + +// EnterOpt_raise_using is called when production opt_raise_using is entered. +func (s *BaseRedshiftParserListener) EnterOpt_raise_using(ctx *Opt_raise_usingContext) {} + +// ExitOpt_raise_using is called when production opt_raise_using is exited. +func (s *BaseRedshiftParserListener) ExitOpt_raise_using(ctx *Opt_raise_usingContext) {} + +// EnterOpt_raise_using_elem is called when production opt_raise_using_elem is entered. +func (s *BaseRedshiftParserListener) EnterOpt_raise_using_elem(ctx *Opt_raise_using_elemContext) {} + +// ExitOpt_raise_using_elem is called when production opt_raise_using_elem is exited. +func (s *BaseRedshiftParserListener) ExitOpt_raise_using_elem(ctx *Opt_raise_using_elemContext) {} + +// EnterOpt_raise_using_elem_list is called when production opt_raise_using_elem_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_raise_using_elem_list(ctx *Opt_raise_using_elem_listContext) { +} + +// ExitOpt_raise_using_elem_list is called when production opt_raise_using_elem_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_raise_using_elem_list(ctx *Opt_raise_using_elem_listContext) { +} + +// EnterStmt_assert is called when production stmt_assert is entered. +func (s *BaseRedshiftParserListener) EnterStmt_assert(ctx *Stmt_assertContext) {} + +// ExitStmt_assert is called when production stmt_assert is exited. +func (s *BaseRedshiftParserListener) ExitStmt_assert(ctx *Stmt_assertContext) {} + +// EnterOpt_stmt_assert_message is called when production opt_stmt_assert_message is entered. +func (s *BaseRedshiftParserListener) EnterOpt_stmt_assert_message(ctx *Opt_stmt_assert_messageContext) { +} + +// ExitOpt_stmt_assert_message is called when production opt_stmt_assert_message is exited. +func (s *BaseRedshiftParserListener) ExitOpt_stmt_assert_message(ctx *Opt_stmt_assert_messageContext) { +} + +// EnterLoop_body is called when production loop_body is entered. +func (s *BaseRedshiftParserListener) EnterLoop_body(ctx *Loop_bodyContext) {} + +// ExitLoop_body is called when production loop_body is exited. +func (s *BaseRedshiftParserListener) ExitLoop_body(ctx *Loop_bodyContext) {} + +// EnterStmt_execsql is called when production stmt_execsql is entered. +func (s *BaseRedshiftParserListener) EnterStmt_execsql(ctx *Stmt_execsqlContext) {} + +// ExitStmt_execsql is called when production stmt_execsql is exited. +func (s *BaseRedshiftParserListener) ExitStmt_execsql(ctx *Stmt_execsqlContext) {} + +// EnterStmt_dynexecute is called when production stmt_dynexecute is entered. +func (s *BaseRedshiftParserListener) EnterStmt_dynexecute(ctx *Stmt_dynexecuteContext) {} + +// ExitStmt_dynexecute is called when production stmt_dynexecute is exited. +func (s *BaseRedshiftParserListener) ExitStmt_dynexecute(ctx *Stmt_dynexecuteContext) {} + +// EnterOpt_execute_using is called when production opt_execute_using is entered. +func (s *BaseRedshiftParserListener) EnterOpt_execute_using(ctx *Opt_execute_usingContext) {} + +// ExitOpt_execute_using is called when production opt_execute_using is exited. +func (s *BaseRedshiftParserListener) ExitOpt_execute_using(ctx *Opt_execute_usingContext) {} + +// EnterOpt_execute_using_list is called when production opt_execute_using_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_execute_using_list(ctx *Opt_execute_using_listContext) { +} + +// ExitOpt_execute_using_list is called when production opt_execute_using_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_execute_using_list(ctx *Opt_execute_using_listContext) {} + +// EnterOpt_execute_into is called when production opt_execute_into is entered. +func (s *BaseRedshiftParserListener) EnterOpt_execute_into(ctx *Opt_execute_intoContext) {} + +// ExitOpt_execute_into is called when production opt_execute_into is exited. +func (s *BaseRedshiftParserListener) ExitOpt_execute_into(ctx *Opt_execute_intoContext) {} + +// EnterStmt_open is called when production stmt_open is entered. +func (s *BaseRedshiftParserListener) EnterStmt_open(ctx *Stmt_openContext) {} + +// ExitStmt_open is called when production stmt_open is exited. +func (s *BaseRedshiftParserListener) ExitStmt_open(ctx *Stmt_openContext) {} + +// EnterOpt_open_bound_list_item is called when production opt_open_bound_list_item is entered. +func (s *BaseRedshiftParserListener) EnterOpt_open_bound_list_item(ctx *Opt_open_bound_list_itemContext) { +} + +// ExitOpt_open_bound_list_item is called when production opt_open_bound_list_item is exited. +func (s *BaseRedshiftParserListener) ExitOpt_open_bound_list_item(ctx *Opt_open_bound_list_itemContext) { +} + +// EnterOpt_open_bound_list is called when production opt_open_bound_list is entered. +func (s *BaseRedshiftParserListener) EnterOpt_open_bound_list(ctx *Opt_open_bound_listContext) {} + +// ExitOpt_open_bound_list is called when production opt_open_bound_list is exited. +func (s *BaseRedshiftParserListener) ExitOpt_open_bound_list(ctx *Opt_open_bound_listContext) {} + +// EnterOpt_open_using is called when production opt_open_using is entered. +func (s *BaseRedshiftParserListener) EnterOpt_open_using(ctx *Opt_open_usingContext) {} + +// ExitOpt_open_using is called when production opt_open_using is exited. +func (s *BaseRedshiftParserListener) ExitOpt_open_using(ctx *Opt_open_usingContext) {} + +// EnterOpt_scroll_option is called when production opt_scroll_option is entered. +func (s *BaseRedshiftParserListener) EnterOpt_scroll_option(ctx *Opt_scroll_optionContext) {} + +// ExitOpt_scroll_option is called when production opt_scroll_option is exited. +func (s *BaseRedshiftParserListener) ExitOpt_scroll_option(ctx *Opt_scroll_optionContext) {} + +// EnterOpt_scroll_option_no is called when production opt_scroll_option_no is entered. +func (s *BaseRedshiftParserListener) EnterOpt_scroll_option_no(ctx *Opt_scroll_option_noContext) {} + +// ExitOpt_scroll_option_no is called when production opt_scroll_option_no is exited. +func (s *BaseRedshiftParserListener) ExitOpt_scroll_option_no(ctx *Opt_scroll_option_noContext) {} + +// EnterStmt_fetch is called when production stmt_fetch is entered. +func (s *BaseRedshiftParserListener) EnterStmt_fetch(ctx *Stmt_fetchContext) {} + +// ExitStmt_fetch is called when production stmt_fetch is exited. +func (s *BaseRedshiftParserListener) ExitStmt_fetch(ctx *Stmt_fetchContext) {} + +// EnterInto_target is called when production into_target is entered. +func (s *BaseRedshiftParserListener) EnterInto_target(ctx *Into_targetContext) {} + +// ExitInto_target is called when production into_target is exited. +func (s *BaseRedshiftParserListener) ExitInto_target(ctx *Into_targetContext) {} + +// EnterOpt_cursor_from is called when production opt_cursor_from is entered. +func (s *BaseRedshiftParserListener) EnterOpt_cursor_from(ctx *Opt_cursor_fromContext) {} + +// ExitOpt_cursor_from is called when production opt_cursor_from is exited. +func (s *BaseRedshiftParserListener) ExitOpt_cursor_from(ctx *Opt_cursor_fromContext) {} + +// EnterOpt_fetch_direction is called when production opt_fetch_direction is entered. +func (s *BaseRedshiftParserListener) EnterOpt_fetch_direction(ctx *Opt_fetch_directionContext) {} + +// ExitOpt_fetch_direction is called when production opt_fetch_direction is exited. +func (s *BaseRedshiftParserListener) ExitOpt_fetch_direction(ctx *Opt_fetch_directionContext) {} + +// EnterStmt_move is called when production stmt_move is entered. +func (s *BaseRedshiftParserListener) EnterStmt_move(ctx *Stmt_moveContext) {} + +// ExitStmt_move is called when production stmt_move is exited. +func (s *BaseRedshiftParserListener) ExitStmt_move(ctx *Stmt_moveContext) {} + +// EnterStmt_close is called when production stmt_close is entered. +func (s *BaseRedshiftParserListener) EnterStmt_close(ctx *Stmt_closeContext) {} + +// ExitStmt_close is called when production stmt_close is exited. +func (s *BaseRedshiftParserListener) ExitStmt_close(ctx *Stmt_closeContext) {} + +// EnterStmt_null is called when production stmt_null is entered. +func (s *BaseRedshiftParserListener) EnterStmt_null(ctx *Stmt_nullContext) {} + +// ExitStmt_null is called when production stmt_null is exited. +func (s *BaseRedshiftParserListener) ExitStmt_null(ctx *Stmt_nullContext) {} + +// EnterStmt_commit is called when production stmt_commit is entered. +func (s *BaseRedshiftParserListener) EnterStmt_commit(ctx *Stmt_commitContext) {} + +// ExitStmt_commit is called when production stmt_commit is exited. +func (s *BaseRedshiftParserListener) ExitStmt_commit(ctx *Stmt_commitContext) {} + +// EnterStmt_rollback is called when production stmt_rollback is entered. +func (s *BaseRedshiftParserListener) EnterStmt_rollback(ctx *Stmt_rollbackContext) {} + +// ExitStmt_rollback is called when production stmt_rollback is exited. +func (s *BaseRedshiftParserListener) ExitStmt_rollback(ctx *Stmt_rollbackContext) {} + +// EnterPlsql_opt_transaction_chain is called when production plsql_opt_transaction_chain is entered. +func (s *BaseRedshiftParserListener) EnterPlsql_opt_transaction_chain(ctx *Plsql_opt_transaction_chainContext) { +} + +// ExitPlsql_opt_transaction_chain is called when production plsql_opt_transaction_chain is exited. +func (s *BaseRedshiftParserListener) ExitPlsql_opt_transaction_chain(ctx *Plsql_opt_transaction_chainContext) { +} + +// EnterStmt_set is called when production stmt_set is entered. +func (s *BaseRedshiftParserListener) EnterStmt_set(ctx *Stmt_setContext) {} + +// ExitStmt_set is called when production stmt_set is exited. +func (s *BaseRedshiftParserListener) ExitStmt_set(ctx *Stmt_setContext) {} + +// EnterCursor_variable is called when production cursor_variable is entered. +func (s *BaseRedshiftParserListener) EnterCursor_variable(ctx *Cursor_variableContext) {} + +// ExitCursor_variable is called when production cursor_variable is exited. +func (s *BaseRedshiftParserListener) ExitCursor_variable(ctx *Cursor_variableContext) {} + +// EnterException_sect is called when production exception_sect is entered. +func (s *BaseRedshiftParserListener) EnterException_sect(ctx *Exception_sectContext) {} + +// ExitException_sect is called when production exception_sect is exited. +func (s *BaseRedshiftParserListener) ExitException_sect(ctx *Exception_sectContext) {} + +// EnterProc_exceptions is called when production proc_exceptions is entered. +func (s *BaseRedshiftParserListener) EnterProc_exceptions(ctx *Proc_exceptionsContext) {} + +// ExitProc_exceptions is called when production proc_exceptions is exited. +func (s *BaseRedshiftParserListener) ExitProc_exceptions(ctx *Proc_exceptionsContext) {} + +// EnterProc_exception is called when production proc_exception is entered. +func (s *BaseRedshiftParserListener) EnterProc_exception(ctx *Proc_exceptionContext) {} + +// ExitProc_exception is called when production proc_exception is exited. +func (s *BaseRedshiftParserListener) ExitProc_exception(ctx *Proc_exceptionContext) {} + +// EnterProc_conditions is called when production proc_conditions is entered. +func (s *BaseRedshiftParserListener) EnterProc_conditions(ctx *Proc_conditionsContext) {} + +// ExitProc_conditions is called when production proc_conditions is exited. +func (s *BaseRedshiftParserListener) ExitProc_conditions(ctx *Proc_conditionsContext) {} + +// EnterProc_condition is called when production proc_condition is entered. +func (s *BaseRedshiftParserListener) EnterProc_condition(ctx *Proc_conditionContext) {} + +// ExitProc_condition is called when production proc_condition is exited. +func (s *BaseRedshiftParserListener) ExitProc_condition(ctx *Proc_conditionContext) {} + +// EnterOpt_block_label is called when production opt_block_label is entered. +func (s *BaseRedshiftParserListener) EnterOpt_block_label(ctx *Opt_block_labelContext) {} + +// ExitOpt_block_label is called when production opt_block_label is exited. +func (s *BaseRedshiftParserListener) ExitOpt_block_label(ctx *Opt_block_labelContext) {} + +// EnterOpt_loop_label is called when production opt_loop_label is entered. +func (s *BaseRedshiftParserListener) EnterOpt_loop_label(ctx *Opt_loop_labelContext) {} + +// ExitOpt_loop_label is called when production opt_loop_label is exited. +func (s *BaseRedshiftParserListener) ExitOpt_loop_label(ctx *Opt_loop_labelContext) {} + +// EnterOpt_label is called when production opt_label is entered. +func (s *BaseRedshiftParserListener) EnterOpt_label(ctx *Opt_labelContext) {} + +// ExitOpt_label is called when production opt_label is exited. +func (s *BaseRedshiftParserListener) ExitOpt_label(ctx *Opt_labelContext) {} + +// EnterOpt_exitcond is called when production opt_exitcond is entered. +func (s *BaseRedshiftParserListener) EnterOpt_exitcond(ctx *Opt_exitcondContext) {} + +// ExitOpt_exitcond is called when production opt_exitcond is exited. +func (s *BaseRedshiftParserListener) ExitOpt_exitcond(ctx *Opt_exitcondContext) {} + +// EnterAny_identifier is called when production any_identifier is entered. +func (s *BaseRedshiftParserListener) EnterAny_identifier(ctx *Any_identifierContext) {} + +// ExitAny_identifier is called when production any_identifier is exited. +func (s *BaseRedshiftParserListener) ExitAny_identifier(ctx *Any_identifierContext) {} + +// EnterPlsql_unreserved_keyword is called when production plsql_unreserved_keyword is entered. +func (s *BaseRedshiftParserListener) EnterPlsql_unreserved_keyword(ctx *Plsql_unreserved_keywordContext) { +} + +// ExitPlsql_unreserved_keyword is called when production plsql_unreserved_keyword is exited. +func (s *BaseRedshiftParserListener) ExitPlsql_unreserved_keyword(ctx *Plsql_unreserved_keywordContext) { +} + +// EnterSql_expression is called when production sql_expression is entered. +func (s *BaseRedshiftParserListener) EnterSql_expression(ctx *Sql_expressionContext) {} + +// ExitSql_expression is called when production sql_expression is exited. +func (s *BaseRedshiftParserListener) ExitSql_expression(ctx *Sql_expressionContext) {} + +// EnterExpr_until_then is called when production expr_until_then is entered. +func (s *BaseRedshiftParserListener) EnterExpr_until_then(ctx *Expr_until_thenContext) {} + +// ExitExpr_until_then is called when production expr_until_then is exited. +func (s *BaseRedshiftParserListener) ExitExpr_until_then(ctx *Expr_until_thenContext) {} + +// EnterExpr_until_semi is called when production expr_until_semi is entered. +func (s *BaseRedshiftParserListener) EnterExpr_until_semi(ctx *Expr_until_semiContext) {} + +// ExitExpr_until_semi is called when production expr_until_semi is exited. +func (s *BaseRedshiftParserListener) ExitExpr_until_semi(ctx *Expr_until_semiContext) {} + +// EnterExpr_until_rightbracket is called when production expr_until_rightbracket is entered. +func (s *BaseRedshiftParserListener) EnterExpr_until_rightbracket(ctx *Expr_until_rightbracketContext) { +} + +// ExitExpr_until_rightbracket is called when production expr_until_rightbracket is exited. +func (s *BaseRedshiftParserListener) ExitExpr_until_rightbracket(ctx *Expr_until_rightbracketContext) { +} + +// EnterExpr_until_loop is called when production expr_until_loop is entered. +func (s *BaseRedshiftParserListener) EnterExpr_until_loop(ctx *Expr_until_loopContext) {} + +// ExitExpr_until_loop is called when production expr_until_loop is exited. +func (s *BaseRedshiftParserListener) ExitExpr_until_loop(ctx *Expr_until_loopContext) {} + +// EnterMake_execsql_stmt is called when production make_execsql_stmt is entered. +func (s *BaseRedshiftParserListener) EnterMake_execsql_stmt(ctx *Make_execsql_stmtContext) {} + +// ExitMake_execsql_stmt is called when production make_execsql_stmt is exited. +func (s *BaseRedshiftParserListener) ExitMake_execsql_stmt(ctx *Make_execsql_stmtContext) {} + +// EnterOpt_returning_clause_into is called when production opt_returning_clause_into is entered. +func (s *BaseRedshiftParserListener) EnterOpt_returning_clause_into(ctx *Opt_returning_clause_intoContext) { +} + +// ExitOpt_returning_clause_into is called when production opt_returning_clause_into is exited. +func (s *BaseRedshiftParserListener) ExitOpt_returning_clause_into(ctx *Opt_returning_clause_intoContext) { +} diff --git a/redshift/redshiftparser_base_visitor.go b/redshift/redshiftparser_base_visitor.go new file mode 100644 index 0000000..68eb9a7 --- /dev/null +++ b/redshift/redshiftparser_base_visitor.go @@ -0,0 +1,4376 @@ +// Code generated from RedshiftParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package redshift // RedshiftParser +import "github.com/antlr4-go/antlr/v4" + +type BaseRedshiftParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseRedshiftParserVisitor) VisitRoot(ctx *RootContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPlsqlroot(ctx *PlsqlrootContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmtblock(ctx *StmtblockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmtmulti(ctx *StmtmultiContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt(ctx *StmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPlsqlconsolecommand(ctx *PlsqlconsolecommandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCallstmt(ctx *CallstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreaterolestmt(ctx *CreaterolestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_with(ctx *Opt_withContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptrolelist(ctx *OptrolelistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteroptrolelist(ctx *AlteroptrolelistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteroptroleelem(ctx *AlteroptroleelemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateoptroleelem(ctx *CreateoptroleelemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateuserstmt(ctx *CreateuserstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterrolestmt(ctx *AlterrolestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterroleaction(ctx *AlterroleactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_in_database(ctx *Opt_in_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterrolesetstmt(ctx *AlterrolesetstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterschemastmt(ctx *AlterschemastmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDroprolestmt(ctx *DroprolestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropuserstmt(ctx *DropuserstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropgroupstmt(ctx *DropgroupstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreategroupstmt(ctx *CreategroupstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltergroupstmt(ctx *AltergroupstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAdd_drop(ctx *Add_dropContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateschemastmt(ctx *CreateschemastmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_auth_clause(ctx *Opt_auth_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_quota(ctx *Opt_quotaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptschemaeltlist(ctx *OptschemaeltlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSchema_stmt(ctx *Schema_stmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVariablesetstmt(ctx *VariablesetstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSet_rest(ctx *Set_restContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGeneric_set(ctx *Generic_setContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSet_rest_more(ctx *Set_rest_moreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVar_name(ctx *Var_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVar_list(ctx *Var_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVar_value(ctx *Var_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIso_level(ctx *Iso_levelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_boolean_or_string(ctx *Opt_boolean_or_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitZone_value(ctx *Zone_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_encoding(ctx *Opt_encodingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNonreservedword_or_sconst(ctx *Nonreservedword_or_sconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVariableresetstmt(ctx *VariableresetstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReset_rest(ctx *Reset_restContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGeneric_reset(ctx *Generic_resetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSetresetclause(ctx *SetresetclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunctionsetresetclause(ctx *FunctionsetresetclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVariableshowstmt(ctx *VariableshowstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstraintssetstmt(ctx *ConstraintssetstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstraints_set_list(ctx *Constraints_set_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstraints_set_mode(ctx *Constraints_set_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCheckpointstmt(ctx *CheckpointstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDiscardstmt(ctx *DiscardstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltertablestmt(ctx *AltertablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_table_cmds(ctx *Alter_table_cmdsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_constraint(ctx *Table_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPartition_cmd(ctx *Partition_cmdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndex_partition_cmd(ctx *Index_partition_cmdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_table_cmd(ctx *Alter_table_cmdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_column_default(ctx *Alter_column_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_drop_behavior(ctx *Opt_drop_behaviorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_collate_clause(ctx *Opt_collate_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_using(ctx *Alter_usingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReplica_identity(ctx *Replica_identityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReloptions(ctx *ReloptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_reloptions(ctx *Opt_reloptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReloption_list(ctx *Reloption_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReloption_elem(ctx *Reloption_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_identity_column_option_list(ctx *Alter_identity_column_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_identity_column_option(ctx *Alter_identity_column_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPartitionboundspec(ctx *PartitionboundspecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHash_partbound_elem(ctx *Hash_partbound_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHash_partbound(ctx *Hash_partboundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltercompositetypestmt(ctx *AltercompositetypestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_type_cmds(ctx *Alter_type_cmdsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_type_cmd(ctx *Alter_type_cmdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCloseportalstmt(ctx *CloseportalstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopystmt(ctx *CopystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRedshift_copy_authorization(ctx *Redshift_copy_authorizationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRedshift_copy_format(ctx *Redshift_copy_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRedshift_copy_parameter(ctx *Redshift_copy_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_param_name(ctx *Copy_param_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_param_value(ctx *Copy_param_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_from(ctx *Copy_fromContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_program(ctx *Opt_programContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_file_name(ctx *Copy_file_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_options(ctx *Copy_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_opt_list(ctx *Copy_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_opt_item(ctx *Copy_opt_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_binary(ctx *Opt_binaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_delimiter(ctx *Copy_delimiterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_using(ctx *Opt_usingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_generic_opt_list(ctx *Copy_generic_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_generic_opt_elem(ctx *Copy_generic_opt_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_generic_opt_arg(ctx *Copy_generic_opt_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_generic_opt_arg_list(ctx *Copy_generic_opt_arg_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_generic_opt_arg_list_item(ctx *Copy_generic_opt_arg_list_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatestmt(ctx *CreatestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_table_attributes(ctx *Opt_table_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpttemp(ctx *OpttempContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpttableelementlist(ctx *OpttableelementlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpttypedtableelementlist(ctx *OpttypedtableelementlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTableelementlist(ctx *TableelementlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTypedtableelementlist(ctx *TypedtableelementlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTableelement(ctx *TableelementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTypedtableelement(ctx *TypedtableelementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumnDef(ctx *ColumnDefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRs_colattributes(ctx *Rs_colattributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRs_colattribute(ctx *Rs_colattributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumnOptions(ctx *ColumnOptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColquallist(ctx *ColquallistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColconstraint(ctx *ColconstraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColconstraintelem(ctx *ColconstraintelemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_unique_null_treatment(ctx *Opt_unique_null_treatmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGenerated_when(ctx *Generated_whenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstraintattr(ctx *ConstraintattrContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTablelikeclause(ctx *TablelikeclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTablelikeoptionlist(ctx *TablelikeoptionlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTablelikeoption(ctx *TablelikeoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTableconstraint(ctx *TableconstraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstraintelem(ctx *ConstraintelemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_no_inherit(ctx *Opt_no_inheritContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_column_list(ctx *Opt_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumnlist(ctx *ColumnlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumnElem(ctx *ColumnElemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_c_include(ctx *Opt_c_includeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitKey_match(ctx *Key_matchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExclusionconstraintlist(ctx *ExclusionconstraintlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExclusionconstraintelem(ctx *ExclusionconstraintelemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExclusionwhereclause(ctx *ExclusionwhereclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitKey_actions(ctx *Key_actionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitKey_update(ctx *Key_updateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitKey_delete(ctx *Key_deleteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitKey_action(ctx *Key_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptinherit(ctx *OptinheritContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptpartitionspec(ctx *OptpartitionspecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPartitionspec(ctx *PartitionspecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPart_params(ctx *Part_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPart_elem(ctx *Part_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_access_method_clause(ctx *Table_access_method_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptwith(ctx *OptwithContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOncommitoption(ctx *OncommitoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpttablespace(ctx *OpttablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptredshifttableoptions(ctx *OptredshifttableoptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRedshifttableoption(ctx *RedshifttableoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSortkeyclause(ctx *SortkeyclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSortkeyclausetype(ctx *SortkeyclausetypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptconstablespace(ctx *OptconstablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExistingindex(ctx *ExistingindexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatestatsstmt(ctx *CreatestatsstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterstatsstmt(ctx *AlterstatsstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateasstmt(ctx *CreateasstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreate_as_target(ctx *Create_as_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_backup_clause_table_attributes(ctx *Opt_backup_clause_table_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_attributes(ctx *Table_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_backup_clause(ctx *Opt_backup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_with_data(ctx *Opt_with_dataContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatematviewstmt(ctx *CreatematviewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_auto_refresh(ctx *Opt_auto_refreshContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRefreshmatviewstmt(ctx *RefreshmatviewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateseqstmt(ctx *CreateseqstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterseqstmt(ctx *AlterseqstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptseqoptlist(ctx *OptseqoptlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptparenthesizedseqoptlist(ctx *OptparenthesizedseqoptlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSeqoptlist(ctx *SeqoptlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSeqoptelem(ctx *SeqoptelemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_by(ctx *Opt_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNumericonly(ctx *NumericonlyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNumericonly_list(ctx *Numericonly_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateplangstmt(ctx *CreateplangstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_trusted(ctx *Opt_trustedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHandler_name(ctx *Handler_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_inline_handler(ctx *Opt_inline_handlerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitValidator_clause(ctx *Validator_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_validator(ctx *Opt_validatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_procedural(ctx *Opt_proceduralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatetablespacestmt(ctx *CreatetablespacestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpttablespaceowner(ctx *OpttablespaceownerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDroptablespacestmt(ctx *DroptablespacestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateextensionstmt(ctx *CreateextensionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreate_extension_opt_list(ctx *Create_extension_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreate_extension_opt_item(ctx *Create_extension_opt_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterextensionstmt(ctx *AlterextensionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_extension_opt_list(ctx *Alter_extension_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_extension_opt_item(ctx *Alter_extension_opt_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterextensioncontentsstmt(ctx *AlterextensioncontentsstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatefdwstmt(ctx *CreatefdwstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFdw_option(ctx *Fdw_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFdw_options(ctx *Fdw_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_fdw_options(ctx *Opt_fdw_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterfdwstmt(ctx *AlterfdwstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreate_generic_options(ctx *Create_generic_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGeneric_option_list(ctx *Generic_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_generic_options(ctx *Alter_generic_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_generic_option_list(ctx *Alter_generic_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlter_generic_option_elem(ctx *Alter_generic_option_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGeneric_option_elem(ctx *Generic_option_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGeneric_option_name(ctx *Generic_option_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGeneric_option_arg(ctx *Generic_option_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateforeignserverstmt(ctx *CreateforeignserverstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_type(ctx *Opt_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitForeign_server_version(ctx *Foreign_server_versionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_foreign_server_version(ctx *Opt_foreign_server_versionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterforeignserverstmt(ctx *AlterforeignserverstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateforeigntablestmt(ctx *CreateforeigntablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitImportforeignschemastmt(ctx *ImportforeignschemastmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitImport_qualification_type(ctx *Import_qualification_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitImport_qualification(ctx *Import_qualificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateusermappingstmt(ctx *CreateusermappingstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAuth_ident(ctx *Auth_identContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropusermappingstmt(ctx *DropusermappingstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterusermappingstmt(ctx *AlterusermappingstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatepolicystmt(ctx *CreatepolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterpolicystmt(ctx *AlterpolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsecurityoptionalexpr(ctx *RowsecurityoptionalexprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsecurityoptionalwithcheck(ctx *RowsecurityoptionalwithcheckContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsecuritydefaulttorole(ctx *RowsecuritydefaulttoroleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsecurityoptionaltorole(ctx *RowsecurityoptionaltoroleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsecuritydefaultpermissive(ctx *RowsecuritydefaultpermissiveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsecuritydefaultforcmd(ctx *RowsecuritydefaultforcmdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRow_security_cmd(ctx *Row_security_cmdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateamstmt(ctx *CreateamstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAm_type(ctx *Am_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatetrigstmt(ctx *CreatetrigstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggeractiontime(ctx *TriggeractiontimeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerevents(ctx *TriggereventsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggeroneevent(ctx *TriggeroneeventContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerreferencing(ctx *TriggerreferencingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggertransitions(ctx *TriggertransitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggertransition(ctx *TriggertransitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransitionoldornew(ctx *TransitionoldornewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransitionrowortable(ctx *TransitionrowortableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransitionrelname(ctx *TransitionrelnameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerforspec(ctx *TriggerforspecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerforopteach(ctx *TriggerforopteachContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerfortype(ctx *TriggerfortypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerwhen(ctx *TriggerwhenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunction_or_procedure(ctx *Function_or_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerfuncargs(ctx *TriggerfuncargsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTriggerfuncarg(ctx *TriggerfuncargContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOptconstrfromtable(ctx *OptconstrfromtableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstraintattributespec(ctx *ConstraintattributespecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstraintattributeElem(ctx *ConstraintattributeElemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateeventtrigstmt(ctx *CreateeventtrigstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEvent_trigger_when_list(ctx *Event_trigger_when_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEvent_trigger_when_item(ctx *Event_trigger_when_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEvent_trigger_value_list(ctx *Event_trigger_value_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltereventtrigstmt(ctx *AltereventtrigstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEnable_trigger(ctx *Enable_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateassertionstmt(ctx *CreateassertionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDefinestmt(ctx *DefinestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDefinition(ctx *DefinitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDef_list(ctx *Def_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDef_elem(ctx *Def_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDef_arg(ctx *Def_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOld_aggr_definition(ctx *Old_aggr_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOld_aggr_list(ctx *Old_aggr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOld_aggr_elem(ctx *Old_aggr_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_enum_val_list(ctx *Opt_enum_val_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEnum_val_list(ctx *Enum_val_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterenumstmt(ctx *AlterenumstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_if_not_exists(ctx *Opt_if_not_existsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateopclassstmt(ctx *CreateopclassstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpclass_item_list(ctx *Opclass_item_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpclass_item(ctx *Opclass_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_default(ctx *Opt_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_opfamily(ctx *Opt_opfamilyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpclass_purpose(ctx *Opclass_purposeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_recheck(ctx *Opt_recheckContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateopfamilystmt(ctx *CreateopfamilystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteropfamilystmt(ctx *AlteropfamilystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpclass_drop_list(ctx *Opclass_drop_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpclass_drop(ctx *Opclass_dropContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropopclassstmt(ctx *DropopclassstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropopfamilystmt(ctx *DropopfamilystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropownedstmt(ctx *DropownedstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReassignownedstmt(ctx *ReassignownedstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropstmt(ctx *DropstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitObject_type_any_name(ctx *Object_type_any_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitObject_type_name(ctx *Object_type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDrop_type_name(ctx *Drop_type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitObject_type_name_on_any_name(ctx *Object_type_name_on_any_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAny_name_list(ctx *Any_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAny_name(ctx *Any_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttrs(ctx *AttrsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitType_name_list(ctx *Type_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTruncatestmt(ctx *TruncatestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_restart_seqs(ctx *Opt_restart_seqsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCommentstmt(ctx *CommentstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitComment_text(ctx *Comment_textContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSeclabelstmt(ctx *SeclabelstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_provider(ctx *Opt_providerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSecurity_label(ctx *Security_labelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFetchstmt(ctx *FetchstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFetch_args(ctx *Fetch_argsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantstmt(ctx *GrantstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_permissions_for_rls_lookup_tables(ctx *Grant_permissions_for_rls_lookup_tablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_explain_permissions_for_row_level_security_policy_filters(ctx *Grant_explain_permissions_for_row_level_security_policy_filtersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_machine_learning_permissions(ctx *Grant_machine_learning_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_role_permissions(ctx *Grant_role_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_role_permission_target_list(ctx *Grant_role_permission_target_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_role_permission_target_list_item(ctx *Grant_role_permission_target_list_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSystem_permissions(ctx *System_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSystem_permissions_item(ctx *System_permissions_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_with_admin_option(ctx *Opt_with_admin_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_scoped_permissions(ctx *Grant_scoped_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_scoped_schemas_permissions(ctx *Grant_scoped_schemas_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_scoped_tables_permissions(ctx *Grant_scoped_tables_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_scoped_functions_permissions(ctx *Grant_scoped_functions_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_scoped_procedures_permissions(ctx *Grant_scoped_procedures_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_scoped_languages_permissions(ctx *Grant_scoped_languages_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_scoped_copy_jobs_permissions(ctx *Grant_scoped_copy_jobs_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantee_list_without_public(ctx *Grantee_list_without_publicContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantee_without_public(ctx *Grantee_without_publicContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_datashare_permissions(ctx *Grant_datashare_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_spectrum_integration_permissions(ctx *Grant_spectrum_integration_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_spectrum_integration_external_schema_permissions(ctx *Grant_spectrum_integration_external_schema_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSpectrum_integration_external_schema_permission_list(ctx *Spectrum_integration_external_schema_permission_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSpectrum_integration_external_schema_permission(ctx *Spectrum_integration_external_schema_permissionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_spectrum_integration_external_table_permissions(ctx *Grant_spectrum_integration_external_table_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSpectrum_integration_external_table_permission(ctx *Spectrum_integration_external_table_permissionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSpectrum_integration_external_table_permission_list(ctx *Spectrum_integration_external_table_permission_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_spectrum_integration_extenral_column_permissions(ctx *Grant_spectrum_integration_extenral_column_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIamrolelist_or_public(ctx *Iamrolelist_or_publicContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIamrolelist(ctx *IamrolelistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_assume_role_permissions(ctx *Grant_assume_role_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_assume_role_for_list(ctx *Grant_assume_role_for_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_assume_role_for_item(ctx *Grant_assume_role_for_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_assume_role_target(ctx *Grant_assume_role_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_column_level_permissions(ctx *Grant_column_level_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumn_privilege_target(ctx *Column_privilege_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumn_privilege_list(ctx *Column_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumn_all_privilege(ctx *Column_all_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumn_select_update_privilege(ctx *Column_select_update_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCommon_grant(ctx *Common_grantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_job_privilege_list(ctx *Copy_job_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_job_privilege(ctx *Copy_job_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_job_target(ctx *Copy_job_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCopy_job_name(ctx *Copy_job_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLanguage_privilege_list(ctx *Language_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_language_target(ctx *Grant_language_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_procedure_target(ctx *Grant_procedure_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProcedure_privilege_list(ctx *Procedure_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProcedure_privilege(ctx *Procedure_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunction_privilege_list(ctx *Function_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunction_privilege(ctx *Function_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_function_target(ctx *Grant_function_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_schema_target(ctx *Grant_schema_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_schema_target(ctx *Revoke_schema_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSchema_privilege_list(ctx *Schema_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSchema_privilege(ctx *Schema_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatabase_privilege_list(ctx *Database_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatabase_privilege(ctx *Database_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_database_target(ctx *Grant_database_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrant_table_target(ctx *Grant_table_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_table_target(ctx *Revoke_table_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAll_tables_in_schema_list(ctx *All_tables_in_schema_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAll_privileges(ctx *All_privilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantee_list(ctx *Grantee_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantee(ctx *GranteeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_with_grant_option(ctx *Opt_with_grant_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_privilege(ctx *Table_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_privilege_list(ctx *Table_privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevokestmt(ctx *RevokestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_permissions_for_rls_lookup_tables(ctx *Revoke_permissions_for_rls_lookup_tablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_explain_permissions_for_row_level_security_policy_filters(ctx *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_machine_learning_permissions(ctx *Revoke_machine_learning_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_role_permissions(ctx *Revoke_role_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_scoped_permissions(ctx *Revoke_scoped_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_scoped_schemas_permissions(ctx *Revoke_scoped_schemas_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_scoped_tables_permissions(ctx *Revoke_scoped_tables_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_scoped_functions_permissions(ctx *Revoke_scoped_functions_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_scoped_procedures_permissions(ctx *Revoke_scoped_procedures_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_scoped_languages_permissions(ctx *Revoke_scoped_languages_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_scoped_copy_jobs_permissions(ctx *Revoke_scoped_copy_jobs_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_datashare_permissions(ctx *Revoke_datashare_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_spectrum_integration_permissions(ctx *Revoke_spectrum_integration_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_spectrum_integration_external_schema_permissions(ctx *Revoke_spectrum_integration_external_schema_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_spectrum_integration_external_table_permissions(ctx *Revoke_spectrum_integration_external_table_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_spectrum_integration_extenral_column_permissions(ctx *Revoke_spectrum_integration_extenral_column_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_assume_role_permissions(ctx *Revoke_assume_role_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevoke_column_level_permissions(ctx *Revoke_column_level_permissionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCommon_revoke(ctx *Common_revokeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPrivileges(ctx *PrivilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPrivilege_list(ctx *Privilege_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPrivilege(ctx *PrivilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPrivilege_target(ctx *Privilege_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitParameter_name_list(ctx *Parameter_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitParameter_name(ctx *Parameter_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_grant_grant_option(ctx *Opt_grant_grant_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantrolestmt(ctx *GrantrolestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRevokerolestmt(ctx *RevokerolestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_grant_admin_option(ctx *Opt_grant_admin_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_granted_by(ctx *Opt_granted_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdefaultprivilegesstmt(ctx *AlterdefaultprivilegesstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDefacloptionlist(ctx *DefacloptionlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDefacloption(ctx *DefacloptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDefaclaction(ctx *DefaclactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDefacl_privilege_target(ctx *Defacl_privilege_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndexstmt(ctx *IndexstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_unique(ctx *Opt_uniqueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_concurrently(ctx *Opt_concurrentlyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_index_name(ctx *Opt_index_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAccess_method_clause(ctx *Access_method_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndex_params(ctx *Index_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndex_elem_options(ctx *Index_elem_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndex_elem(ctx *Index_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_include(ctx *Opt_includeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndex_including_params(ctx *Index_including_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_collate(ctx *Opt_collateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_class(ctx *Opt_classContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_asc_desc(ctx *Opt_asc_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_nulls_order(ctx *Opt_nulls_orderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatefunctionstmt(ctx *CreatefunctionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateprocedurestmt(ctx *CreateprocedurestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_nonatomic(ctx *Opt_nonatomicContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_or_replace(ctx *Opt_or_replaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_py_args_or_sql_args(ctx *Func_py_args_or_sql_argsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_py_args_or_sql_args_list(ctx *Func_py_args_or_sql_args_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_args(ctx *Func_argsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_args_list(ctx *Func_args_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunction_with_argtypes_list(ctx *Function_with_argtypes_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunction_with_argtypes(ctx *Function_with_argtypesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_args_with_defaults(ctx *Func_args_with_defaultsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_args_with_defaults_list(ctx *Func_args_with_defaults_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_arg(ctx *Func_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitArg_class(ctx *Arg_classContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitParam_name(ctx *Param_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_return(ctx *Func_returnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_type(ctx *Func_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_arg_with_default(ctx *Func_arg_with_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAggr_arg(ctx *Aggr_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAggr_args(ctx *Aggr_argsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAggr_args_list(ctx *Aggr_args_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAggregate_with_argtypes(ctx *Aggregate_with_argtypesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAggregate_with_argtypes_list(ctx *Aggregate_with_argtypes_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatefunc_opt_list(ctx *Createfunc_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCommon_func_opt_item(ctx *Common_func_opt_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatefunc_opt_item(ctx *Createfunc_opt_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_as(ctx *Func_asContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransform_type_list(ctx *Transform_type_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_definition(ctx *Opt_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_func_column(ctx *Table_func_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_func_column_list(ctx *Table_func_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterfunctionstmt(ctx *AlterfunctionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterprocedurestmt(ctx *AlterprocedurestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterfunc_opt_list(ctx *Alterfunc_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_restrict(ctx *Opt_restrictContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRemovefuncstmt(ctx *RemovefuncstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRemoveaggrstmt(ctx *RemoveaggrstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRemoveoperstmt(ctx *RemoveoperstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOper_argtypes(ctx *Oper_argtypesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAny_operator(ctx *Any_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOperator_with_argtypes_list(ctx *Operator_with_argtypes_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOperator_with_argtypes(ctx *Operator_with_argtypesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDostmt(ctx *DostmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDostmt_opt_list(ctx *Dostmt_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDostmt_opt_item(ctx *Dostmt_opt_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatecaststmt(ctx *CreatecaststmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCast_context(ctx *Cast_contextContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropcaststmt(ctx *DropcaststmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_if_exists(ctx *Opt_if_existsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatetransformstmt(ctx *CreatetransformstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransform_element_list(ctx *Transform_element_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDroptransformstmt(ctx *DroptransformstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReindexstmt(ctx *ReindexstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReindex_target_type(ctx *Reindex_target_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReindex_target_multitable(ctx *Reindex_target_multitableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReindex_option_list(ctx *Reindex_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReindex_option_elem(ctx *Reindex_option_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltertblspcstmt(ctx *AltertblspcstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRenamestmt(ctx *RenamestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_column(ctx *Opt_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_set_data(ctx *Opt_set_dataContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterobjectdependsstmt(ctx *AlterobjectdependsstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_no(ctx *Opt_noContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterobjectschemastmt(ctx *AlterobjectschemastmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteroperatorstmt(ctx *AlteroperatorstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOperator_def_list(ctx *Operator_def_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOperator_def_elem(ctx *Operator_def_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOperator_def_arg(ctx *Operator_def_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltertypestmt(ctx *AltertypestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterownerstmt(ctx *AlterownerstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatepublicationstmt(ctx *CreatepublicationstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPub_obj_list(ctx *Pub_obj_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPublication_obj_spec(ctx *Publication_obj_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_where_clause(ctx *Opt_where_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterpublicationstmt(ctx *AlterpublicationstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatesubscriptionstmt(ctx *CreatesubscriptionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPublication_name_list(ctx *Publication_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPublication_name_item(ctx *Publication_name_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltersubscriptionstmt(ctx *AltersubscriptionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropsubscriptionstmt(ctx *DropsubscriptionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRulestmt(ctx *RulestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRuleactionlist(ctx *RuleactionlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRuleactionmulti(ctx *RuleactionmultiContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRuleactionstmt(ctx *RuleactionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRuleactionstmtOrEmpty(ctx *RuleactionstmtOrEmptyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEvent(ctx *EventContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_instead(ctx *Opt_insteadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNotifystmt(ctx *NotifystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNotify_payload(ctx *Notify_payloadContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitListenstmt(ctx *ListenstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUnlistenstmt(ctx *UnlistenstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransactionstmt(ctx *TransactionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_transaction(ctx *Opt_transactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransaction_mode_item(ctx *Transaction_mode_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransaction_mode_list(ctx *Transaction_mode_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTransaction_mode_list_or_empty(ctx *Transaction_mode_list_or_emptyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_transaction_chain(ctx *Opt_transaction_chainContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitViewstmt(ctx *ViewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWith_no_schema_binding(ctx *With_no_schema_bindingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_check_option(ctx *Opt_check_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLoadstmt(ctx *LoadstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdatasharestmt(ctx *AlterdatasharestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdatashare_action(ctx *Alterdatashare_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdatashare_add_drop(ctx *Alterdatashare_add_dropContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdatashare_objects(ctx *Alterdatashare_objectsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatashare_table_list(ctx *Datashare_table_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatashare_table_name(ctx *Datashare_table_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_name(ctx *Table_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTemporary_table_name(ctx *Temporary_table_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatashare_function_list(ctx *Datashare_function_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatashare_function(ctx *Datashare_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatashare_function_name(ctx *Datashare_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedatasharestmt(ctx *CreatedatasharestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedatashareoptions(ctx *CreatedatashareoptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedatashareoption(ctx *CreatedatashareoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSetpublicaccessibleoption(ctx *SetpublicaccessibleoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitManagedbyoption(ctx *ManagedbyoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDescdatasharestmt(ctx *DescdatasharestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropdatasharestmt(ctx *DropdatasharestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterexternalschemastmt(ctx *AlterexternalschemastmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltexternalschemaopts(ctx *AltexternalschemaoptsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterexternalviewstmt(ctx *AlterexternalviewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateexternalschemastmt(ctx *CreateexternalschemastmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFromdatacatalogclause(ctx *FromdatacatalogclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropschemastmt(ctx *DropschemastmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitImplicitdatacatalogclause(ctx *ImplicitdatacatalogclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFromhivemetastoreclause(ctx *FromhivemetastoreclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFrompostgresclause(ctx *FrompostgresclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFrommysqlclause(ctx *FrommysqlclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFromkinesisclause(ctx *FromkinesisclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFromkafkaclause(ctx *FromkafkaclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFrommskclause(ctx *FrommskclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFromredshiftclause(ctx *FromredshiftclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIamrolevalue(ctx *IamrolevalueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCatalogrolevalue(ctx *CatalogrolevalueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAuthenticationvalue(ctx *AuthenticationvalueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateexternalfunctionstmt(ctx *CreateexternalfunctionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExternal_func_params(ctx *External_func_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitParamlist(ctx *ParamlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitParam_spec(ctx *Param_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateexternalmodelstmt(ctx *CreateexternalmodelstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateexternaltablestmt(ctx *CreateexternaltablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExtern_column_list(ctx *Extern_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExtern_column_def(ctx *Extern_column_defContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExtern_typename(ctx *Extern_typenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExtern_table_format(ctx *Extern_table_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRow_format_spec(ctx *Row_format_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSerde_properties_list(ctx *Serde_properties_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSerde_property(ctx *Serde_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExternal_format_spec(ctx *External_format_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_properties_list(ctx *Table_properties_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_property(ctx *Table_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateexternalviewstmt(ctx *CreateexternalviewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropexternalviewstmt(ctx *DropexternalviewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteridentityproviderstmt(ctx *AlteridentityproviderstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteridprovideropts(ctx *AlteridprovideroptsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltermaskingpolicystmt(ctx *AltermaskingpolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltermaterializedviewstmt(ctx *AltermaterializedviewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltmaskingpolicyopts(ctx *AltmaskingpolicyoptsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltmaskingpolicyargs(ctx *AltmaskingpolicyargsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltmaskingpolicyarg(ctx *AltmaskingpolicyargContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterrlspolicystmt(ctx *AlterrlspolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttachmaskingpolicystmt(ctx *AttachmaskingpolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttachpolicycollist(ctx *AttachpolicycollistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttachpolicycolumn(ctx *AttachpolicycolumnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttachpolicytargets(ctx *AttachpolicytargetsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttachpolicytarget(ctx *AttachpolicytargetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttachrlspolicystmt(ctx *AttachrlspolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_name_list(ctx *Table_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateidentityproviderstmt(ctx *CreateidentityproviderstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateidprovideropts(ctx *CreateidprovideroptsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGroupfilter(ctx *GroupfilterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatelibrarystmt(ctx *CreatelibrarystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatelibraryopts(ctx *CreatelibraryoptsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatemaskingpolicystmt(ctx *CreatemaskingpolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInputcolumnlist(ctx *InputcolumnlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInputcolumn(ctx *InputcolumnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMaskingexpression(ctx *MaskingexpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatemodelstmt(ctx *CreatemodelstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatemodelfromclause(ctx *CreatemodelfromclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIamrolespec(ctx *IamrolespecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSagemakerspec(ctx *SagemakerspecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitModeltypespec(ctx *ModeltypespecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProblemtypespec(ctx *ProblemtypespecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProblemtype(ctx *ProblemtypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitObjectivespec(ctx *ObjectivespecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHyperparametersspec(ctx *HyperparametersspecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHyperparameterslist(ctx *HyperparameterslistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHyperparameteritem(ctx *HyperparameteritemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSettingsclause(ctx *SettingsclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSettingsitem(ctx *SettingsitemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatatypelist(ctx *DatatypelistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDatatype(ctx *DatatypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreaterlspolicystmt(ctx *CreaterlspolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDescidentityproviderstmt(ctx *DescidentityproviderstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDetachmaskingpolicystmt(ctx *DetachmaskingpolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDetachrlspolicystmt(ctx *DetachrlspolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRole_or_user_or_public_list(ctx *Role_or_user_or_public_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRole_or_user_or_public(ctx *Role_or_user_or_publicContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRlspolicyname(ctx *RlspolicynameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropidentityproviderstmt(ctx *DropidentityproviderstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDroplibrarystmt(ctx *DroplibrarystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropmaskingpolicystmt(ctx *DropmaskingpolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropmodelstmt(ctx *DropmodelstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDroprlspolicystmt(ctx *DroprlspolicystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltertableappendstmt(ctx *AltertableappendstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAppendoptions(ctx *AppendoptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteruserstmt(ctx *AlteruserstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlteruseropts(ctx *AlteruseroptsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAnalyzecompressionstmt(ctx *AnalyzecompressionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCancelstmt(ctx *CancelstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitClosestmt(ctx *ClosestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInsertexternaltablestmt(ctx *InsertexternaltablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_or_values(ctx *Select_or_valuesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelectintostmt(ctx *SelectintostmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSetsessionauthorizationstmt(ctx *SetsessionauthorizationstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSetsessioncharacteristicsstmt(ctx *SetsessioncharacteristicsstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowcolumnsstmt(ctx *ShowcolumnsstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowdatabasesstmt(ctx *ShowdatabasesstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowdbsopts(ctx *ShowdbsoptsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowdatasharesstmt(ctx *ShowdatasharesstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowexternaltablestmt(ctx *ShowexternaltablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowgrantsstmt(ctx *ShowgrantsstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantobject(ctx *GrantobjectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrantprincipal(ctx *GrantprincipalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowmodelstmt(ctx *ShowmodelstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowprocedurestmt(ctx *ShowprocedurestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowschemasstmt(ctx *ShowschemasstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowtablestmt(ctx *ShowtablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowtablesstmt(ctx *ShowtablesstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitShowviewstmt(ctx *ShowviewstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUnloadstmt(ctx *UnloadstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIamroleclause(ctx *IamroleclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUnloadoptions(ctx *UnloadoptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFormatoption(ctx *FormatoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPartitionbyoption(ctx *PartitionbyoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitManifestoption(ctx *ManifestoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHeaderoption(ctx *HeaderoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDelimiteroption(ctx *DelimiteroptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFixedwidthoption(ctx *FixedwidthoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEncryptedoption(ctx *EncryptedoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitKmskeyoption(ctx *KmskeyoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCompressionoption(ctx *CompressionoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAddquotesoption(ctx *AddquotesoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNullasoption(ctx *NullasoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEscapeoption(ctx *EscapeoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAllowoverwriteoption(ctx *AllowoverwriteoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCleanpathoption(ctx *CleanpathoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitParalleloption(ctx *ParalleloptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMaxfilesizeoption(ctx *MaxfilesizeoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowgroupsizeoption(ctx *RowgroupsizeoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSizeunit(ctx *SizeunitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRegionoption(ctx *RegionoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExtensionoption(ctx *ExtensionoptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUsestmt(ctx *UsestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedbstmt(ctx *CreatedbstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedb_opt_list(ctx *Createdb_opt_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedb_opt_items(ctx *Createdb_opt_itemsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedb_opt_item(ctx *Createdb_opt_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedb_opt_name(ctx *Createdb_opt_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_equal(ctx *Opt_equalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdatabasestmt(ctx *AlterdatabasestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdatabasesetstmt(ctx *AlterdatabasesetstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDropdbstmt(ctx *DropdbstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDrop_option_list(ctx *Drop_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDrop_option(ctx *Drop_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltercollationstmt(ctx *AltercollationstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltersystemstmt(ctx *AltersystemstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreatedomainstmt(ctx *CreatedomainstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlterdomainstmt(ctx *AlterdomainstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_as(ctx *Opt_asContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltertsdictionarystmt(ctx *AltertsdictionarystmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAltertsconfigurationstmt(ctx *AltertsconfigurationstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAny_with(ctx *Any_withContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCreateconversionstmt(ctx *CreateconversionstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitClusterstmt(ctx *ClusterstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCluster_index_specification(ctx *Cluster_index_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVacuumstmt(ctx *VacuumstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVacuum_option(ctx *Vacuum_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAnalyzestmt(ctx *AnalyzestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVac_analyze_option_list(ctx *Vac_analyze_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAnalyze_keyword(ctx *Analyze_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVac_analyze_option_elem(ctx *Vac_analyze_option_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVac_analyze_option_name(ctx *Vac_analyze_option_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVac_analyze_option_arg(ctx *Vac_analyze_option_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_analyze(ctx *Opt_analyzeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_verbose(ctx *Opt_verboseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_full(ctx *Opt_fullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_freeze(ctx *Opt_freezeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_name_list(ctx *Opt_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVacuum_relation(ctx *Vacuum_relationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVacuum_relation_list(ctx *Vacuum_relation_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_vacuum_relation_list(ctx *Opt_vacuum_relation_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExplainstmt(ctx *ExplainstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExplainablestmt(ctx *ExplainablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExplain_option_list(ctx *Explain_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExplain_option_elem(ctx *Explain_option_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExplain_option_name(ctx *Explain_option_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExplain_option_arg(ctx *Explain_option_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPreparestmt(ctx *PreparestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPrep_type_clause(ctx *Prep_type_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPreparablestmt(ctx *PreparablestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExecutestmt(ctx *ExecutestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExecute_param_clause(ctx *Execute_param_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDeallocatestmt(ctx *DeallocatestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInsertstmt(ctx *InsertstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInsert_target(ctx *Insert_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInsert_rest(ctx *Insert_restContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOverride_kind(ctx *Override_kindContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInsert_column_list(ctx *Insert_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInsert_column_item(ctx *Insert_column_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_on_conflict(ctx *Opt_on_conflictContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_conf_expr(ctx *Opt_conf_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReturning_clause(ctx *Returning_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMergestmt(ctx *MergestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMerge_when_clause(ctx *Merge_when_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMerge_insert_clause(ctx *Merge_insert_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMerge_update_clause(ctx *Merge_update_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMerge_delete_clause(ctx *Merge_delete_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDeletestmt(ctx *DeletestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUsing_clause(ctx *Using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLockstmt(ctx *LockstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_lock(ctx *Opt_lockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLock_type(ctx *Lock_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_nowait(ctx *Opt_nowaitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_nowait_or_skip(ctx *Opt_nowait_or_skipContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUpdatestmt(ctx *UpdatestmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSet_clause_list(ctx *Set_clause_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSet_clause(ctx *Set_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSet_target(ctx *Set_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSet_target_list(ctx *Set_target_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDeclarecursorstmt(ctx *DeclarecursorstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCursor_name(ctx *Cursor_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCursor_options(ctx *Cursor_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_hold(ctx *Opt_holdContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelectstmt(ctx *SelectstmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_with_parens(ctx *Select_with_parensContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_no_parens(ctx *Select_no_parensContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_clause(ctx *Select_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSimple_select_intersect(ctx *Simple_select_intersectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSimple_select_pramary(ctx *Simple_select_pramaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExclude_clause(ctx *Exclude_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitQualify_clause(ctx *Qualify_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStart_with_clause(ctx *Start_with_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWith_clause(ctx *With_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCte_list(ctx *Cte_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCommon_table_expr(ctx *Common_table_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_materialized(ctx *Opt_materializedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_with_clause(ctx *Opt_with_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInto_clause(ctx *Into_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_top_clause(ctx *Opt_top_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_strict(ctx *Opt_strictContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpttempTableName(ctx *OpttempTableNameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_table(ctx *Opt_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAll_or_distinct(ctx *All_or_distinctContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDistinct_clause(ctx *Distinct_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_all_clause(ctx *Opt_all_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_sort_clause(ctx *Opt_sort_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSort_clause(ctx *Sort_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSortby_list(ctx *Sortby_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSortby(ctx *SortbyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_limit(ctx *Select_limitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_select_limit(ctx *Opt_select_limitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLimit_clause(ctx *Limit_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOffset_clause(ctx *Offset_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_limit_value(ctx *Select_limit_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_offset_value(ctx *Select_offset_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSelect_fetch_first_value(ctx *Select_fetch_first_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitI_or_f_const(ctx *I_or_f_constContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRow_or_rows(ctx *Row_or_rowsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFirst_or_next(ctx *First_or_nextContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGroup_clause(ctx *Group_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGroup_by_list(ctx *Group_by_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGroup_by_item(ctx *Group_by_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitEmpty_grouping_set(ctx *Empty_grouping_setContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRollup_clause(ctx *Rollup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCube_clause(ctx *Cube_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGrouping_sets_clause(ctx *Grouping_sets_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitHaving_clause(ctx *Having_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFor_locking_clause(ctx *For_locking_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_for_locking_clause(ctx *Opt_for_locking_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFor_locking_items(ctx *For_locking_itemsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFor_locking_item(ctx *For_locking_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFor_locking_strength(ctx *For_locking_strengthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLocked_rels_list(ctx *Locked_rels_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitValues_clause(ctx *Values_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFrom_clause(ctx *From_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFrom_list(ctx *From_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_ref(ctx *Table_refContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitJoined_table(ctx *Joined_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAlias_clause(ctx *Alias_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_alias_clause(ctx *Opt_alias_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_alias_clause(ctx *Table_alias_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_alias_clause(ctx *Func_alias_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitJoin_type(ctx *Join_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitJoin_qual(ctx *Join_qualContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRelation_expr(ctx *Relation_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRelation_expr_list(ctx *Relation_expr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRelation_expr_opt_alias(ctx *Relation_expr_opt_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTablesample_clause(ctx *Tablesample_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_repeatable_clause(ctx *Opt_repeatable_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_table(ctx *Func_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsfrom_item(ctx *Rowsfrom_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRowsfrom_list(ctx *Rowsfrom_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_col_def_list(ctx *Opt_col_def_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_ordinality(ctx *Opt_ordinalityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWhere_clause(ctx *Where_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWhere_or_current_clause(ctx *Where_or_current_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpttablefuncelementlist(ctx *OpttablefuncelementlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTablefuncelementlist(ctx *TablefuncelementlistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTablefuncelement(ctx *TablefuncelementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXmltable(ctx *XmltableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXmltable_column_list(ctx *Xmltable_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXmltable_column_el(ctx *Xmltable_column_elContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXmltable_column_option_list(ctx *Xmltable_column_option_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXmltable_column_option_el(ctx *Xmltable_column_option_elContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_namespace_list(ctx *Xml_namespace_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_namespace_el(ctx *Xml_namespace_elContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTypename(ctx *TypenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_array_bounds(ctx *Opt_array_boundsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSimpletypename(ctx *SimpletypenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitVarbyte(ctx *VarbyteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitJson_type(ctx *Json_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConsttypename(ctx *ConsttypenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGenerictype(ctx *GenerictypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_type_modifiers(ctx *Opt_type_modifiersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNumeric(ctx *NumericContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_float(ctx *Opt_floatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitBit(ctx *BitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstbit(ctx *ConstbitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitBitwithlength(ctx *BitwithlengthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitBitwithoutlength(ctx *BitwithoutlengthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCharacter(ctx *CharacterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstcharacter(ctx *ConstcharacterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCharacter_c(ctx *Character_cContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_varying(ctx *Opt_varyingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstdatetime(ctx *ConstdatetimeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitConstinterval(ctx *ConstintervalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_timezone(ctx *Opt_timezoneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_interval(ctx *Opt_intervalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInterval_second(ctx *Interval_secondContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_escape(ctx *Opt_escapeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr(ctx *A_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_qual(ctx *A_expr_qualContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_lessless(ctx *A_expr_lesslessContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_or(ctx *A_expr_orContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_and(ctx *A_expr_andContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_between(ctx *A_expr_betweenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_in(ctx *A_expr_inContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_unary_not(ctx *A_expr_unary_notContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_isnull(ctx *A_expr_isnullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_is_not(ctx *A_expr_is_notContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_compare(ctx *A_expr_compareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_prior_or_level(ctx *A_expr_prior_or_levelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_like(ctx *A_expr_likeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_qual_op(ctx *A_expr_qual_opContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_unary_qualop(ctx *A_expr_unary_qualopContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_add(ctx *A_expr_addContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_mul(ctx *A_expr_mulContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_caret(ctx *A_expr_caretContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_unary_sign(ctx *A_expr_unary_signContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_at_time_zone(ctx *A_expr_at_time_zoneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_collate(ctx *A_expr_collateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitA_expr_typecast(ctx *A_expr_typecastContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitB_expr(ctx *B_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitC_expr_exists(ctx *C_expr_existsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitC_expr_expr(ctx *C_expr_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitC_expr_case(ctx *C_expr_caseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPlsqlvariablename(ctx *PlsqlvariablenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_application(ctx *Func_applicationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_expr(ctx *Func_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_expr_windowless(ctx *Func_expr_windowlessContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_expr_common_subexpr(ctx *Func_expr_common_subexprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_root_version(ctx *Xml_root_versionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_xml_root_standalone(ctx *Opt_xml_root_standaloneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_attributes(ctx *Xml_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_attribute_list(ctx *Xml_attribute_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_attribute_el(ctx *Xml_attribute_elContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDocument_or_content(ctx *Document_or_contentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_whitespace_option(ctx *Xml_whitespace_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXmlexists_argument(ctx *Xmlexists_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXml_passing_mech(ctx *Xml_passing_mechContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWithin_group_clause(ctx *Within_group_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFilter_clause(ctx *Filter_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWindow_clause(ctx *Window_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWindow_definition_list(ctx *Window_definition_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWindow_definition(ctx *Window_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOver_clause(ctx *Over_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWindow_specification(ctx *Window_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_existing_window_name(ctx *Opt_existing_window_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_partition_clause(ctx *Opt_partition_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_frame_clause(ctx *Opt_frame_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFrame_extent(ctx *Frame_extentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFrame_bound(ctx *Frame_boundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_window_exclusion_clause(ctx *Opt_window_exclusion_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRow(ctx *RowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExplicit_row(ctx *Explicit_rowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitImplicit_row(ctx *Implicit_rowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSub_type(ctx *Sub_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAll_op(ctx *All_opContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMathop(ctx *MathopContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitQual_op(ctx *Qual_opContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitQual_all_op(ctx *Qual_all_opContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSubquery_Op(ctx *Subquery_OpContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExpr_list(ctx *Expr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_arg_list(ctx *Func_arg_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_arg_expr(ctx *Func_arg_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitType_list(ctx *Type_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitArray_expr(ctx *Array_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitArray_expr_list(ctx *Array_expr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExtract_list(ctx *Extract_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExtract_arg(ctx *Extract_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUnicode_normal_form(ctx *Unicode_normal_formContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOverlay_list(ctx *Overlay_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPosition_list(ctx *Position_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSubstr_list(ctx *Substr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTrim_list(ctx *Trim_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIn_expr_select(ctx *In_expr_selectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIn_expr_list(ctx *In_expr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCase_expr(ctx *Case_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWhen_clause_list(ctx *When_clause_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitWhen_clause(ctx *When_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCase_default(ctx *Case_defaultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCase_arg(ctx *Case_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColumnref(ctx *ColumnrefContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndirection_el(ctx *Indirection_elContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_slice_bound(ctx *Opt_slice_boundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIndirection(ctx *IndirectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_indirection(ctx *Opt_indirectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_target_list(ctx *Opt_target_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTarget_list(ctx *Target_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTarget_label(ctx *Target_labelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTarget_star(ctx *Target_starContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTarget_alias(ctx *Target_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitQualified_name_list(ctx *Qualified_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitQualified_name(ctx *Qualified_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitName_list(ctx *Name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitName(ctx *NameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAttr_name(ctx *Attr_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFile_name(ctx *File_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFunc_name(ctx *Func_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAexprconst(ctx *AexprconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitXconst(ctx *XconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitBconst(ctx *BconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFconst(ctx *FconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIconst(ctx *IconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSconst(ctx *SconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAnysconst(ctx *AnysconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_uescape(ctx *Opt_uescapeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSignediconst(ctx *SignediconstContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRoleid(ctx *RoleidContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRolespec(ctx *RolespecContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitRole_list(ctx *Role_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitColid(ctx *ColidContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitTable_alias(ctx *Table_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitType_function_name(ctx *Type_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitNonreservedword(ctx *NonreservedwordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCollabel(ctx *CollabelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitIdentifier(ctx *IdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPlsqlidentifier(ctx *PlsqlidentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitUnreserved_keyword(ctx *Unreserved_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCol_name_keyword(ctx *Col_name_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitType_func_name_keyword(ctx *Type_func_name_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitReserved_keyword(ctx *Reserved_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitBuiltin_function_name(ctx *Builtin_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPl_function(ctx *Pl_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitComp_options(ctx *Comp_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitComp_option(ctx *Comp_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSharp(ctx *SharpContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOption_value(ctx *Option_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_semi(ctx *Opt_semiContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPl_block(ctx *Pl_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_sect(ctx *Decl_sectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_start(ctx *Decl_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_stmts(ctx *Decl_stmtsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLabel_decl(ctx *Label_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_stmt(ctx *Decl_stmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_statement(ctx *Decl_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_scrollable(ctx *Opt_scrollableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_cursor_query(ctx *Decl_cursor_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_cursor_args(ctx *Decl_cursor_argsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_cursor_arglist(ctx *Decl_cursor_arglistContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_cursor_arg(ctx *Decl_cursor_argContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_is_for(ctx *Decl_is_forContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_aliasitem(ctx *Decl_aliasitemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_varname(ctx *Decl_varnameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_const(ctx *Decl_constContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_datatype(ctx *Decl_datatypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_collate(ctx *Decl_collateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_notnull(ctx *Decl_notnullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_defval(ctx *Decl_defvalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitDecl_defkey(ctx *Decl_defkeyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAssign_operator(ctx *Assign_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProc_sect(ctx *Proc_sectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProc_stmt(ctx *Proc_stmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_perform(ctx *Stmt_performContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_call(ctx *Stmt_callContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_expr_list(ctx *Opt_expr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_assign(ctx *Stmt_assignContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_getdiag(ctx *Stmt_getdiagContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGetdiag_area_opt(ctx *Getdiag_area_optContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGetdiag_list(ctx *Getdiag_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGetdiag_list_item(ctx *Getdiag_list_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGetdiag_item(ctx *Getdiag_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitGetdiag_target(ctx *Getdiag_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAssign_var(ctx *Assign_varContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_if(ctx *Stmt_ifContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_elsifs(ctx *Stmt_elsifsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_else(ctx *Stmt_elseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_case(ctx *Stmt_caseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_expr_until_when(ctx *Opt_expr_until_whenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCase_when_list(ctx *Case_when_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCase_when(ctx *Case_whenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_case_else(ctx *Opt_case_elseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_loop(ctx *Stmt_loopContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_while(ctx *Stmt_whileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_for(ctx *Stmt_forContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFor_control(ctx *For_controlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_for_using_expression(ctx *Opt_for_using_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_cursor_parameters(ctx *Opt_cursor_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_reverse(ctx *Opt_reverseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_by_expression(ctx *Opt_by_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitFor_variable(ctx *For_variableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_foreach_a(ctx *Stmt_foreach_aContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitForeach_slice(ctx *Foreach_sliceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_exit(ctx *Stmt_exitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExit_type(ctx *Exit_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_return(ctx *Stmt_returnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_return_result(ctx *Opt_return_resultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_raise(ctx *Stmt_raiseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_stmt_raise_level(ctx *Opt_stmt_raise_levelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_raise_list(ctx *Opt_raise_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_raise_using(ctx *Opt_raise_usingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_raise_using_elem(ctx *Opt_raise_using_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_raise_using_elem_list(ctx *Opt_raise_using_elem_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_assert(ctx *Stmt_assertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_stmt_assert_message(ctx *Opt_stmt_assert_messageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitLoop_body(ctx *Loop_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_execsql(ctx *Stmt_execsqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_dynexecute(ctx *Stmt_dynexecuteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_execute_using(ctx *Opt_execute_usingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_execute_using_list(ctx *Opt_execute_using_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_execute_into(ctx *Opt_execute_intoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_open(ctx *Stmt_openContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_open_bound_list_item(ctx *Opt_open_bound_list_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_open_bound_list(ctx *Opt_open_bound_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_open_using(ctx *Opt_open_usingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_scroll_option(ctx *Opt_scroll_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_scroll_option_no(ctx *Opt_scroll_option_noContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_fetch(ctx *Stmt_fetchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitInto_target(ctx *Into_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_cursor_from(ctx *Opt_cursor_fromContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_fetch_direction(ctx *Opt_fetch_directionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_move(ctx *Stmt_moveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_close(ctx *Stmt_closeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_null(ctx *Stmt_nullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_commit(ctx *Stmt_commitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_rollback(ctx *Stmt_rollbackContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPlsql_opt_transaction_chain(ctx *Plsql_opt_transaction_chainContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitStmt_set(ctx *Stmt_setContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitCursor_variable(ctx *Cursor_variableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitException_sect(ctx *Exception_sectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProc_exceptions(ctx *Proc_exceptionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProc_exception(ctx *Proc_exceptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProc_conditions(ctx *Proc_conditionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitProc_condition(ctx *Proc_conditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_block_label(ctx *Opt_block_labelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_loop_label(ctx *Opt_loop_labelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_label(ctx *Opt_labelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_exitcond(ctx *Opt_exitcondContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitAny_identifier(ctx *Any_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitPlsql_unreserved_keyword(ctx *Plsql_unreserved_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitSql_expression(ctx *Sql_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExpr_until_then(ctx *Expr_until_thenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExpr_until_semi(ctx *Expr_until_semiContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExpr_until_rightbracket(ctx *Expr_until_rightbracketContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitExpr_until_loop(ctx *Expr_until_loopContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitMake_execsql_stmt(ctx *Make_execsql_stmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseRedshiftParserVisitor) VisitOpt_returning_clause_into(ctx *Opt_returning_clause_intoContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/redshift/redshiftparser_listener.go b/redshift/redshiftparser_listener.go new file mode 100644 index 0000000..3152392 --- /dev/null +++ b/redshift/redshiftparser_listener.go @@ -0,0 +1,6561 @@ +// Code generated from RedshiftParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package redshift // RedshiftParser +import "github.com/antlr4-go/antlr/v4" + +// RedshiftParserListener is a complete listener for a parse tree produced by RedshiftParser. +type RedshiftParserListener interface { + antlr.ParseTreeListener + + // EnterRoot is called when entering the root production. + EnterRoot(c *RootContext) + + // EnterPlsqlroot is called when entering the plsqlroot production. + EnterPlsqlroot(c *PlsqlrootContext) + + // EnterStmtblock is called when entering the stmtblock production. + EnterStmtblock(c *StmtblockContext) + + // EnterStmtmulti is called when entering the stmtmulti production. + EnterStmtmulti(c *StmtmultiContext) + + // EnterStmt is called when entering the stmt production. + EnterStmt(c *StmtContext) + + // EnterPlsqlconsolecommand is called when entering the plsqlconsolecommand production. + EnterPlsqlconsolecommand(c *PlsqlconsolecommandContext) + + // EnterCallstmt is called when entering the callstmt production. + EnterCallstmt(c *CallstmtContext) + + // EnterCreaterolestmt is called when entering the createrolestmt production. + EnterCreaterolestmt(c *CreaterolestmtContext) + + // EnterOpt_with is called when entering the opt_with production. + EnterOpt_with(c *Opt_withContext) + + // EnterOptrolelist is called when entering the optrolelist production. + EnterOptrolelist(c *OptrolelistContext) + + // EnterAlteroptrolelist is called when entering the alteroptrolelist production. + EnterAlteroptrolelist(c *AlteroptrolelistContext) + + // EnterAlteroptroleelem is called when entering the alteroptroleelem production. + EnterAlteroptroleelem(c *AlteroptroleelemContext) + + // EnterCreateoptroleelem is called when entering the createoptroleelem production. + EnterCreateoptroleelem(c *CreateoptroleelemContext) + + // EnterCreateuserstmt is called when entering the createuserstmt production. + EnterCreateuserstmt(c *CreateuserstmtContext) + + // EnterAlterrolestmt is called when entering the alterrolestmt production. + EnterAlterrolestmt(c *AlterrolestmtContext) + + // EnterAlterroleaction is called when entering the alterroleaction production. + EnterAlterroleaction(c *AlterroleactionContext) + + // EnterOpt_in_database is called when entering the opt_in_database production. + EnterOpt_in_database(c *Opt_in_databaseContext) + + // EnterAlterrolesetstmt is called when entering the alterrolesetstmt production. + EnterAlterrolesetstmt(c *AlterrolesetstmtContext) + + // EnterAlterschemastmt is called when entering the alterschemastmt production. + EnterAlterschemastmt(c *AlterschemastmtContext) + + // EnterDroprolestmt is called when entering the droprolestmt production. + EnterDroprolestmt(c *DroprolestmtContext) + + // EnterDropuserstmt is called when entering the dropuserstmt production. + EnterDropuserstmt(c *DropuserstmtContext) + + // EnterDropgroupstmt is called when entering the dropgroupstmt production. + EnterDropgroupstmt(c *DropgroupstmtContext) + + // EnterCreategroupstmt is called when entering the creategroupstmt production. + EnterCreategroupstmt(c *CreategroupstmtContext) + + // EnterAltergroupstmt is called when entering the altergroupstmt production. + EnterAltergroupstmt(c *AltergroupstmtContext) + + // EnterAdd_drop is called when entering the add_drop production. + EnterAdd_drop(c *Add_dropContext) + + // EnterCreateschemastmt is called when entering the createschemastmt production. + EnterCreateschemastmt(c *CreateschemastmtContext) + + // EnterOpt_auth_clause is called when entering the opt_auth_clause production. + EnterOpt_auth_clause(c *Opt_auth_clauseContext) + + // EnterOpt_quota is called when entering the opt_quota production. + EnterOpt_quota(c *Opt_quotaContext) + + // EnterOptschemaeltlist is called when entering the optschemaeltlist production. + EnterOptschemaeltlist(c *OptschemaeltlistContext) + + // EnterSchema_stmt is called when entering the schema_stmt production. + EnterSchema_stmt(c *Schema_stmtContext) + + // EnterVariablesetstmt is called when entering the variablesetstmt production. + EnterVariablesetstmt(c *VariablesetstmtContext) + + // EnterSet_rest is called when entering the set_rest production. + EnterSet_rest(c *Set_restContext) + + // EnterGeneric_set is called when entering the generic_set production. + EnterGeneric_set(c *Generic_setContext) + + // EnterSet_rest_more is called when entering the set_rest_more production. + EnterSet_rest_more(c *Set_rest_moreContext) + + // EnterVar_name is called when entering the var_name production. + EnterVar_name(c *Var_nameContext) + + // EnterVar_list is called when entering the var_list production. + EnterVar_list(c *Var_listContext) + + // EnterVar_value is called when entering the var_value production. + EnterVar_value(c *Var_valueContext) + + // EnterIso_level is called when entering the iso_level production. + EnterIso_level(c *Iso_levelContext) + + // EnterOpt_boolean_or_string is called when entering the opt_boolean_or_string production. + EnterOpt_boolean_or_string(c *Opt_boolean_or_stringContext) + + // EnterZone_value is called when entering the zone_value production. + EnterZone_value(c *Zone_valueContext) + + // EnterOpt_encoding is called when entering the opt_encoding production. + EnterOpt_encoding(c *Opt_encodingContext) + + // EnterNonreservedword_or_sconst is called when entering the nonreservedword_or_sconst production. + EnterNonreservedword_or_sconst(c *Nonreservedword_or_sconstContext) + + // EnterVariableresetstmt is called when entering the variableresetstmt production. + EnterVariableresetstmt(c *VariableresetstmtContext) + + // EnterReset_rest is called when entering the reset_rest production. + EnterReset_rest(c *Reset_restContext) + + // EnterGeneric_reset is called when entering the generic_reset production. + EnterGeneric_reset(c *Generic_resetContext) + + // EnterSetresetclause is called when entering the setresetclause production. + EnterSetresetclause(c *SetresetclauseContext) + + // EnterFunctionsetresetclause is called when entering the functionsetresetclause production. + EnterFunctionsetresetclause(c *FunctionsetresetclauseContext) + + // EnterVariableshowstmt is called when entering the variableshowstmt production. + EnterVariableshowstmt(c *VariableshowstmtContext) + + // EnterConstraintssetstmt is called when entering the constraintssetstmt production. + EnterConstraintssetstmt(c *ConstraintssetstmtContext) + + // EnterConstraints_set_list is called when entering the constraints_set_list production. + EnterConstraints_set_list(c *Constraints_set_listContext) + + // EnterConstraints_set_mode is called when entering the constraints_set_mode production. + EnterConstraints_set_mode(c *Constraints_set_modeContext) + + // EnterCheckpointstmt is called when entering the checkpointstmt production. + EnterCheckpointstmt(c *CheckpointstmtContext) + + // EnterDiscardstmt is called when entering the discardstmt production. + EnterDiscardstmt(c *DiscardstmtContext) + + // EnterAltertablestmt is called when entering the altertablestmt production. + EnterAltertablestmt(c *AltertablestmtContext) + + // EnterAlter_table_cmds is called when entering the alter_table_cmds production. + EnterAlter_table_cmds(c *Alter_table_cmdsContext) + + // EnterTable_constraint is called when entering the table_constraint production. + EnterTable_constraint(c *Table_constraintContext) + + // EnterPartition_cmd is called when entering the partition_cmd production. + EnterPartition_cmd(c *Partition_cmdContext) + + // EnterIndex_partition_cmd is called when entering the index_partition_cmd production. + EnterIndex_partition_cmd(c *Index_partition_cmdContext) + + // EnterAlter_table_cmd is called when entering the alter_table_cmd production. + EnterAlter_table_cmd(c *Alter_table_cmdContext) + + // EnterAlter_column_default is called when entering the alter_column_default production. + EnterAlter_column_default(c *Alter_column_defaultContext) + + // EnterOpt_drop_behavior is called when entering the opt_drop_behavior production. + EnterOpt_drop_behavior(c *Opt_drop_behaviorContext) + + // EnterOpt_collate_clause is called when entering the opt_collate_clause production. + EnterOpt_collate_clause(c *Opt_collate_clauseContext) + + // EnterAlter_using is called when entering the alter_using production. + EnterAlter_using(c *Alter_usingContext) + + // EnterReplica_identity is called when entering the replica_identity production. + EnterReplica_identity(c *Replica_identityContext) + + // EnterReloptions is called when entering the reloptions production. + EnterReloptions(c *ReloptionsContext) + + // EnterOpt_reloptions is called when entering the opt_reloptions production. + EnterOpt_reloptions(c *Opt_reloptionsContext) + + // EnterReloption_list is called when entering the reloption_list production. + EnterReloption_list(c *Reloption_listContext) + + // EnterReloption_elem is called when entering the reloption_elem production. + EnterReloption_elem(c *Reloption_elemContext) + + // EnterAlter_identity_column_option_list is called when entering the alter_identity_column_option_list production. + EnterAlter_identity_column_option_list(c *Alter_identity_column_option_listContext) + + // EnterAlter_identity_column_option is called when entering the alter_identity_column_option production. + EnterAlter_identity_column_option(c *Alter_identity_column_optionContext) + + // EnterPartitionboundspec is called when entering the partitionboundspec production. + EnterPartitionboundspec(c *PartitionboundspecContext) + + // EnterHash_partbound_elem is called when entering the hash_partbound_elem production. + EnterHash_partbound_elem(c *Hash_partbound_elemContext) + + // EnterHash_partbound is called when entering the hash_partbound production. + EnterHash_partbound(c *Hash_partboundContext) + + // EnterAltercompositetypestmt is called when entering the altercompositetypestmt production. + EnterAltercompositetypestmt(c *AltercompositetypestmtContext) + + // EnterAlter_type_cmds is called when entering the alter_type_cmds production. + EnterAlter_type_cmds(c *Alter_type_cmdsContext) + + // EnterAlter_type_cmd is called when entering the alter_type_cmd production. + EnterAlter_type_cmd(c *Alter_type_cmdContext) + + // EnterCloseportalstmt is called when entering the closeportalstmt production. + EnterCloseportalstmt(c *CloseportalstmtContext) + + // EnterCopystmt is called when entering the copystmt production. + EnterCopystmt(c *CopystmtContext) + + // EnterRedshift_copy_authorization is called when entering the redshift_copy_authorization production. + EnterRedshift_copy_authorization(c *Redshift_copy_authorizationContext) + + // EnterRedshift_copy_format is called when entering the redshift_copy_format production. + EnterRedshift_copy_format(c *Redshift_copy_formatContext) + + // EnterRedshift_copy_parameter is called when entering the redshift_copy_parameter production. + EnterRedshift_copy_parameter(c *Redshift_copy_parameterContext) + + // EnterCopy_param_name is called when entering the copy_param_name production. + EnterCopy_param_name(c *Copy_param_nameContext) + + // EnterCopy_param_value is called when entering the copy_param_value production. + EnterCopy_param_value(c *Copy_param_valueContext) + + // EnterCopy_from is called when entering the copy_from production. + EnterCopy_from(c *Copy_fromContext) + + // EnterOpt_program is called when entering the opt_program production. + EnterOpt_program(c *Opt_programContext) + + // EnterCopy_file_name is called when entering the copy_file_name production. + EnterCopy_file_name(c *Copy_file_nameContext) + + // EnterCopy_options is called when entering the copy_options production. + EnterCopy_options(c *Copy_optionsContext) + + // EnterCopy_opt_list is called when entering the copy_opt_list production. + EnterCopy_opt_list(c *Copy_opt_listContext) + + // EnterCopy_opt_item is called when entering the copy_opt_item production. + EnterCopy_opt_item(c *Copy_opt_itemContext) + + // EnterOpt_binary is called when entering the opt_binary production. + EnterOpt_binary(c *Opt_binaryContext) + + // EnterCopy_delimiter is called when entering the copy_delimiter production. + EnterCopy_delimiter(c *Copy_delimiterContext) + + // EnterOpt_using is called when entering the opt_using production. + EnterOpt_using(c *Opt_usingContext) + + // EnterCopy_generic_opt_list is called when entering the copy_generic_opt_list production. + EnterCopy_generic_opt_list(c *Copy_generic_opt_listContext) + + // EnterCopy_generic_opt_elem is called when entering the copy_generic_opt_elem production. + EnterCopy_generic_opt_elem(c *Copy_generic_opt_elemContext) + + // EnterCopy_generic_opt_arg is called when entering the copy_generic_opt_arg production. + EnterCopy_generic_opt_arg(c *Copy_generic_opt_argContext) + + // EnterCopy_generic_opt_arg_list is called when entering the copy_generic_opt_arg_list production. + EnterCopy_generic_opt_arg_list(c *Copy_generic_opt_arg_listContext) + + // EnterCopy_generic_opt_arg_list_item is called when entering the copy_generic_opt_arg_list_item production. + EnterCopy_generic_opt_arg_list_item(c *Copy_generic_opt_arg_list_itemContext) + + // EnterCreatestmt is called when entering the createstmt production. + EnterCreatestmt(c *CreatestmtContext) + + // EnterOpt_table_attributes is called when entering the opt_table_attributes production. + EnterOpt_table_attributes(c *Opt_table_attributesContext) + + // EnterOpttemp is called when entering the opttemp production. + EnterOpttemp(c *OpttempContext) + + // EnterOpttableelementlist is called when entering the opttableelementlist production. + EnterOpttableelementlist(c *OpttableelementlistContext) + + // EnterOpttypedtableelementlist is called when entering the opttypedtableelementlist production. + EnterOpttypedtableelementlist(c *OpttypedtableelementlistContext) + + // EnterTableelementlist is called when entering the tableelementlist production. + EnterTableelementlist(c *TableelementlistContext) + + // EnterTypedtableelementlist is called when entering the typedtableelementlist production. + EnterTypedtableelementlist(c *TypedtableelementlistContext) + + // EnterTableelement is called when entering the tableelement production. + EnterTableelement(c *TableelementContext) + + // EnterTypedtableelement is called when entering the typedtableelement production. + EnterTypedtableelement(c *TypedtableelementContext) + + // EnterColumnDef is called when entering the columnDef production. + EnterColumnDef(c *ColumnDefContext) + + // EnterRs_colattributes is called when entering the rs_colattributes production. + EnterRs_colattributes(c *Rs_colattributesContext) + + // EnterRs_colattribute is called when entering the rs_colattribute production. + EnterRs_colattribute(c *Rs_colattributeContext) + + // EnterColumnOptions is called when entering the columnOptions production. + EnterColumnOptions(c *ColumnOptionsContext) + + // EnterColquallist is called when entering the colquallist production. + EnterColquallist(c *ColquallistContext) + + // EnterColconstraint is called when entering the colconstraint production. + EnterColconstraint(c *ColconstraintContext) + + // EnterColconstraintelem is called when entering the colconstraintelem production. + EnterColconstraintelem(c *ColconstraintelemContext) + + // EnterOpt_unique_null_treatment is called when entering the opt_unique_null_treatment production. + EnterOpt_unique_null_treatment(c *Opt_unique_null_treatmentContext) + + // EnterGenerated_when is called when entering the generated_when production. + EnterGenerated_when(c *Generated_whenContext) + + // EnterConstraintattr is called when entering the constraintattr production. + EnterConstraintattr(c *ConstraintattrContext) + + // EnterTablelikeclause is called when entering the tablelikeclause production. + EnterTablelikeclause(c *TablelikeclauseContext) + + // EnterTablelikeoptionlist is called when entering the tablelikeoptionlist production. + EnterTablelikeoptionlist(c *TablelikeoptionlistContext) + + // EnterTablelikeoption is called when entering the tablelikeoption production. + EnterTablelikeoption(c *TablelikeoptionContext) + + // EnterTableconstraint is called when entering the tableconstraint production. + EnterTableconstraint(c *TableconstraintContext) + + // EnterConstraintelem is called when entering the constraintelem production. + EnterConstraintelem(c *ConstraintelemContext) + + // EnterOpt_no_inherit is called when entering the opt_no_inherit production. + EnterOpt_no_inherit(c *Opt_no_inheritContext) + + // EnterOpt_column_list is called when entering the opt_column_list production. + EnterOpt_column_list(c *Opt_column_listContext) + + // EnterColumnlist is called when entering the columnlist production. + EnterColumnlist(c *ColumnlistContext) + + // EnterColumnElem is called when entering the columnElem production. + EnterColumnElem(c *ColumnElemContext) + + // EnterOpt_c_include is called when entering the opt_c_include production. + EnterOpt_c_include(c *Opt_c_includeContext) + + // EnterKey_match is called when entering the key_match production. + EnterKey_match(c *Key_matchContext) + + // EnterExclusionconstraintlist is called when entering the exclusionconstraintlist production. + EnterExclusionconstraintlist(c *ExclusionconstraintlistContext) + + // EnterExclusionconstraintelem is called when entering the exclusionconstraintelem production. + EnterExclusionconstraintelem(c *ExclusionconstraintelemContext) + + // EnterExclusionwhereclause is called when entering the exclusionwhereclause production. + EnterExclusionwhereclause(c *ExclusionwhereclauseContext) + + // EnterKey_actions is called when entering the key_actions production. + EnterKey_actions(c *Key_actionsContext) + + // EnterKey_update is called when entering the key_update production. + EnterKey_update(c *Key_updateContext) + + // EnterKey_delete is called when entering the key_delete production. + EnterKey_delete(c *Key_deleteContext) + + // EnterKey_action is called when entering the key_action production. + EnterKey_action(c *Key_actionContext) + + // EnterOptinherit is called when entering the optinherit production. + EnterOptinherit(c *OptinheritContext) + + // EnterOptpartitionspec is called when entering the optpartitionspec production. + EnterOptpartitionspec(c *OptpartitionspecContext) + + // EnterPartitionspec is called when entering the partitionspec production. + EnterPartitionspec(c *PartitionspecContext) + + // EnterPart_params is called when entering the part_params production. + EnterPart_params(c *Part_paramsContext) + + // EnterPart_elem is called when entering the part_elem production. + EnterPart_elem(c *Part_elemContext) + + // EnterTable_access_method_clause is called when entering the table_access_method_clause production. + EnterTable_access_method_clause(c *Table_access_method_clauseContext) + + // EnterOptwith is called when entering the optwith production. + EnterOptwith(c *OptwithContext) + + // EnterOncommitoption is called when entering the oncommitoption production. + EnterOncommitoption(c *OncommitoptionContext) + + // EnterOpttablespace is called when entering the opttablespace production. + EnterOpttablespace(c *OpttablespaceContext) + + // EnterOptredshifttableoptions is called when entering the optredshifttableoptions production. + EnterOptredshifttableoptions(c *OptredshifttableoptionsContext) + + // EnterRedshifttableoption is called when entering the redshifttableoption production. + EnterRedshifttableoption(c *RedshifttableoptionContext) + + // EnterSortkeyclause is called when entering the sortkeyclause production. + EnterSortkeyclause(c *SortkeyclauseContext) + + // EnterSortkeyclausetype is called when entering the sortkeyclausetype production. + EnterSortkeyclausetype(c *SortkeyclausetypeContext) + + // EnterOptconstablespace is called when entering the optconstablespace production. + EnterOptconstablespace(c *OptconstablespaceContext) + + // EnterExistingindex is called when entering the existingindex production. + EnterExistingindex(c *ExistingindexContext) + + // EnterCreatestatsstmt is called when entering the createstatsstmt production. + EnterCreatestatsstmt(c *CreatestatsstmtContext) + + // EnterAlterstatsstmt is called when entering the alterstatsstmt production. + EnterAlterstatsstmt(c *AlterstatsstmtContext) + + // EnterCreateasstmt is called when entering the createasstmt production. + EnterCreateasstmt(c *CreateasstmtContext) + + // EnterCreate_as_target is called when entering the create_as_target production. + EnterCreate_as_target(c *Create_as_targetContext) + + // EnterOpt_backup_clause_table_attributes is called when entering the opt_backup_clause_table_attributes production. + EnterOpt_backup_clause_table_attributes(c *Opt_backup_clause_table_attributesContext) + + // EnterTable_attributes is called when entering the table_attributes production. + EnterTable_attributes(c *Table_attributesContext) + + // EnterOpt_backup_clause is called when entering the opt_backup_clause production. + EnterOpt_backup_clause(c *Opt_backup_clauseContext) + + // EnterOpt_with_data is called when entering the opt_with_data production. + EnterOpt_with_data(c *Opt_with_dataContext) + + // EnterCreatematviewstmt is called when entering the creatematviewstmt production. + EnterCreatematviewstmt(c *CreatematviewstmtContext) + + // EnterOpt_auto_refresh is called when entering the opt_auto_refresh production. + EnterOpt_auto_refresh(c *Opt_auto_refreshContext) + + // EnterRefreshmatviewstmt is called when entering the refreshmatviewstmt production. + EnterRefreshmatviewstmt(c *RefreshmatviewstmtContext) + + // EnterCreateseqstmt is called when entering the createseqstmt production. + EnterCreateseqstmt(c *CreateseqstmtContext) + + // EnterAlterseqstmt is called when entering the alterseqstmt production. + EnterAlterseqstmt(c *AlterseqstmtContext) + + // EnterOptseqoptlist is called when entering the optseqoptlist production. + EnterOptseqoptlist(c *OptseqoptlistContext) + + // EnterOptparenthesizedseqoptlist is called when entering the optparenthesizedseqoptlist production. + EnterOptparenthesizedseqoptlist(c *OptparenthesizedseqoptlistContext) + + // EnterSeqoptlist is called when entering the seqoptlist production. + EnterSeqoptlist(c *SeqoptlistContext) + + // EnterSeqoptelem is called when entering the seqoptelem production. + EnterSeqoptelem(c *SeqoptelemContext) + + // EnterOpt_by is called when entering the opt_by production. + EnterOpt_by(c *Opt_byContext) + + // EnterNumericonly is called when entering the numericonly production. + EnterNumericonly(c *NumericonlyContext) + + // EnterNumericonly_list is called when entering the numericonly_list production. + EnterNumericonly_list(c *Numericonly_listContext) + + // EnterCreateplangstmt is called when entering the createplangstmt production. + EnterCreateplangstmt(c *CreateplangstmtContext) + + // EnterOpt_trusted is called when entering the opt_trusted production. + EnterOpt_trusted(c *Opt_trustedContext) + + // EnterHandler_name is called when entering the handler_name production. + EnterHandler_name(c *Handler_nameContext) + + // EnterOpt_inline_handler is called when entering the opt_inline_handler production. + EnterOpt_inline_handler(c *Opt_inline_handlerContext) + + // EnterValidator_clause is called when entering the validator_clause production. + EnterValidator_clause(c *Validator_clauseContext) + + // EnterOpt_validator is called when entering the opt_validator production. + EnterOpt_validator(c *Opt_validatorContext) + + // EnterOpt_procedural is called when entering the opt_procedural production. + EnterOpt_procedural(c *Opt_proceduralContext) + + // EnterCreatetablespacestmt is called when entering the createtablespacestmt production. + EnterCreatetablespacestmt(c *CreatetablespacestmtContext) + + // EnterOpttablespaceowner is called when entering the opttablespaceowner production. + EnterOpttablespaceowner(c *OpttablespaceownerContext) + + // EnterDroptablespacestmt is called when entering the droptablespacestmt production. + EnterDroptablespacestmt(c *DroptablespacestmtContext) + + // EnterCreateextensionstmt is called when entering the createextensionstmt production. + EnterCreateextensionstmt(c *CreateextensionstmtContext) + + // EnterCreate_extension_opt_list is called when entering the create_extension_opt_list production. + EnterCreate_extension_opt_list(c *Create_extension_opt_listContext) + + // EnterCreate_extension_opt_item is called when entering the create_extension_opt_item production. + EnterCreate_extension_opt_item(c *Create_extension_opt_itemContext) + + // EnterAlterextensionstmt is called when entering the alterextensionstmt production. + EnterAlterextensionstmt(c *AlterextensionstmtContext) + + // EnterAlter_extension_opt_list is called when entering the alter_extension_opt_list production. + EnterAlter_extension_opt_list(c *Alter_extension_opt_listContext) + + // EnterAlter_extension_opt_item is called when entering the alter_extension_opt_item production. + EnterAlter_extension_opt_item(c *Alter_extension_opt_itemContext) + + // EnterAlterextensioncontentsstmt is called when entering the alterextensioncontentsstmt production. + EnterAlterextensioncontentsstmt(c *AlterextensioncontentsstmtContext) + + // EnterCreatefdwstmt is called when entering the createfdwstmt production. + EnterCreatefdwstmt(c *CreatefdwstmtContext) + + // EnterFdw_option is called when entering the fdw_option production. + EnterFdw_option(c *Fdw_optionContext) + + // EnterFdw_options is called when entering the fdw_options production. + EnterFdw_options(c *Fdw_optionsContext) + + // EnterOpt_fdw_options is called when entering the opt_fdw_options production. + EnterOpt_fdw_options(c *Opt_fdw_optionsContext) + + // EnterAlterfdwstmt is called when entering the alterfdwstmt production. + EnterAlterfdwstmt(c *AlterfdwstmtContext) + + // EnterCreate_generic_options is called when entering the create_generic_options production. + EnterCreate_generic_options(c *Create_generic_optionsContext) + + // EnterGeneric_option_list is called when entering the generic_option_list production. + EnterGeneric_option_list(c *Generic_option_listContext) + + // EnterAlter_generic_options is called when entering the alter_generic_options production. + EnterAlter_generic_options(c *Alter_generic_optionsContext) + + // EnterAlter_generic_option_list is called when entering the alter_generic_option_list production. + EnterAlter_generic_option_list(c *Alter_generic_option_listContext) + + // EnterAlter_generic_option_elem is called when entering the alter_generic_option_elem production. + EnterAlter_generic_option_elem(c *Alter_generic_option_elemContext) + + // EnterGeneric_option_elem is called when entering the generic_option_elem production. + EnterGeneric_option_elem(c *Generic_option_elemContext) + + // EnterGeneric_option_name is called when entering the generic_option_name production. + EnterGeneric_option_name(c *Generic_option_nameContext) + + // EnterGeneric_option_arg is called when entering the generic_option_arg production. + EnterGeneric_option_arg(c *Generic_option_argContext) + + // EnterCreateforeignserverstmt is called when entering the createforeignserverstmt production. + EnterCreateforeignserverstmt(c *CreateforeignserverstmtContext) + + // EnterOpt_type is called when entering the opt_type production. + EnterOpt_type(c *Opt_typeContext) + + // EnterForeign_server_version is called when entering the foreign_server_version production. + EnterForeign_server_version(c *Foreign_server_versionContext) + + // EnterOpt_foreign_server_version is called when entering the opt_foreign_server_version production. + EnterOpt_foreign_server_version(c *Opt_foreign_server_versionContext) + + // EnterAlterforeignserverstmt is called when entering the alterforeignserverstmt production. + EnterAlterforeignserverstmt(c *AlterforeignserverstmtContext) + + // EnterCreateforeigntablestmt is called when entering the createforeigntablestmt production. + EnterCreateforeigntablestmt(c *CreateforeigntablestmtContext) + + // EnterImportforeignschemastmt is called when entering the importforeignschemastmt production. + EnterImportforeignschemastmt(c *ImportforeignschemastmtContext) + + // EnterImport_qualification_type is called when entering the import_qualification_type production. + EnterImport_qualification_type(c *Import_qualification_typeContext) + + // EnterImport_qualification is called when entering the import_qualification production. + EnterImport_qualification(c *Import_qualificationContext) + + // EnterCreateusermappingstmt is called when entering the createusermappingstmt production. + EnterCreateusermappingstmt(c *CreateusermappingstmtContext) + + // EnterAuth_ident is called when entering the auth_ident production. + EnterAuth_ident(c *Auth_identContext) + + // EnterDropusermappingstmt is called when entering the dropusermappingstmt production. + EnterDropusermappingstmt(c *DropusermappingstmtContext) + + // EnterAlterusermappingstmt is called when entering the alterusermappingstmt production. + EnterAlterusermappingstmt(c *AlterusermappingstmtContext) + + // EnterCreatepolicystmt is called when entering the createpolicystmt production. + EnterCreatepolicystmt(c *CreatepolicystmtContext) + + // EnterAlterpolicystmt is called when entering the alterpolicystmt production. + EnterAlterpolicystmt(c *AlterpolicystmtContext) + + // EnterRowsecurityoptionalexpr is called when entering the rowsecurityoptionalexpr production. + EnterRowsecurityoptionalexpr(c *RowsecurityoptionalexprContext) + + // EnterRowsecurityoptionalwithcheck is called when entering the rowsecurityoptionalwithcheck production. + EnterRowsecurityoptionalwithcheck(c *RowsecurityoptionalwithcheckContext) + + // EnterRowsecuritydefaulttorole is called when entering the rowsecuritydefaulttorole production. + EnterRowsecuritydefaulttorole(c *RowsecuritydefaulttoroleContext) + + // EnterRowsecurityoptionaltorole is called when entering the rowsecurityoptionaltorole production. + EnterRowsecurityoptionaltorole(c *RowsecurityoptionaltoroleContext) + + // EnterRowsecuritydefaultpermissive is called when entering the rowsecuritydefaultpermissive production. + EnterRowsecuritydefaultpermissive(c *RowsecuritydefaultpermissiveContext) + + // EnterRowsecuritydefaultforcmd is called when entering the rowsecuritydefaultforcmd production. + EnterRowsecuritydefaultforcmd(c *RowsecuritydefaultforcmdContext) + + // EnterRow_security_cmd is called when entering the row_security_cmd production. + EnterRow_security_cmd(c *Row_security_cmdContext) + + // EnterCreateamstmt is called when entering the createamstmt production. + EnterCreateamstmt(c *CreateamstmtContext) + + // EnterAm_type is called when entering the am_type production. + EnterAm_type(c *Am_typeContext) + + // EnterCreatetrigstmt is called when entering the createtrigstmt production. + EnterCreatetrigstmt(c *CreatetrigstmtContext) + + // EnterTriggeractiontime is called when entering the triggeractiontime production. + EnterTriggeractiontime(c *TriggeractiontimeContext) + + // EnterTriggerevents is called when entering the triggerevents production. + EnterTriggerevents(c *TriggereventsContext) + + // EnterTriggeroneevent is called when entering the triggeroneevent production. + EnterTriggeroneevent(c *TriggeroneeventContext) + + // EnterTriggerreferencing is called when entering the triggerreferencing production. + EnterTriggerreferencing(c *TriggerreferencingContext) + + // EnterTriggertransitions is called when entering the triggertransitions production. + EnterTriggertransitions(c *TriggertransitionsContext) + + // EnterTriggertransition is called when entering the triggertransition production. + EnterTriggertransition(c *TriggertransitionContext) + + // EnterTransitionoldornew is called when entering the transitionoldornew production. + EnterTransitionoldornew(c *TransitionoldornewContext) + + // EnterTransitionrowortable is called when entering the transitionrowortable production. + EnterTransitionrowortable(c *TransitionrowortableContext) + + // EnterTransitionrelname is called when entering the transitionrelname production. + EnterTransitionrelname(c *TransitionrelnameContext) + + // EnterTriggerforspec is called when entering the triggerforspec production. + EnterTriggerforspec(c *TriggerforspecContext) + + // EnterTriggerforopteach is called when entering the triggerforopteach production. + EnterTriggerforopteach(c *TriggerforopteachContext) + + // EnterTriggerfortype is called when entering the triggerfortype production. + EnterTriggerfortype(c *TriggerfortypeContext) + + // EnterTriggerwhen is called when entering the triggerwhen production. + EnterTriggerwhen(c *TriggerwhenContext) + + // EnterFunction_or_procedure is called when entering the function_or_procedure production. + EnterFunction_or_procedure(c *Function_or_procedureContext) + + // EnterTriggerfuncargs is called when entering the triggerfuncargs production. + EnterTriggerfuncargs(c *TriggerfuncargsContext) + + // EnterTriggerfuncarg is called when entering the triggerfuncarg production. + EnterTriggerfuncarg(c *TriggerfuncargContext) + + // EnterOptconstrfromtable is called when entering the optconstrfromtable production. + EnterOptconstrfromtable(c *OptconstrfromtableContext) + + // EnterConstraintattributespec is called when entering the constraintattributespec production. + EnterConstraintattributespec(c *ConstraintattributespecContext) + + // EnterConstraintattributeElem is called when entering the constraintattributeElem production. + EnterConstraintattributeElem(c *ConstraintattributeElemContext) + + // EnterCreateeventtrigstmt is called when entering the createeventtrigstmt production. + EnterCreateeventtrigstmt(c *CreateeventtrigstmtContext) + + // EnterEvent_trigger_when_list is called when entering the event_trigger_when_list production. + EnterEvent_trigger_when_list(c *Event_trigger_when_listContext) + + // EnterEvent_trigger_when_item is called when entering the event_trigger_when_item production. + EnterEvent_trigger_when_item(c *Event_trigger_when_itemContext) + + // EnterEvent_trigger_value_list is called when entering the event_trigger_value_list production. + EnterEvent_trigger_value_list(c *Event_trigger_value_listContext) + + // EnterAltereventtrigstmt is called when entering the altereventtrigstmt production. + EnterAltereventtrigstmt(c *AltereventtrigstmtContext) + + // EnterEnable_trigger is called when entering the enable_trigger production. + EnterEnable_trigger(c *Enable_triggerContext) + + // EnterCreateassertionstmt is called when entering the createassertionstmt production. + EnterCreateassertionstmt(c *CreateassertionstmtContext) + + // EnterDefinestmt is called when entering the definestmt production. + EnterDefinestmt(c *DefinestmtContext) + + // EnterDefinition is called when entering the definition production. + EnterDefinition(c *DefinitionContext) + + // EnterDef_list is called when entering the def_list production. + EnterDef_list(c *Def_listContext) + + // EnterDef_elem is called when entering the def_elem production. + EnterDef_elem(c *Def_elemContext) + + // EnterDef_arg is called when entering the def_arg production. + EnterDef_arg(c *Def_argContext) + + // EnterOld_aggr_definition is called when entering the old_aggr_definition production. + EnterOld_aggr_definition(c *Old_aggr_definitionContext) + + // EnterOld_aggr_list is called when entering the old_aggr_list production. + EnterOld_aggr_list(c *Old_aggr_listContext) + + // EnterOld_aggr_elem is called when entering the old_aggr_elem production. + EnterOld_aggr_elem(c *Old_aggr_elemContext) + + // EnterOpt_enum_val_list is called when entering the opt_enum_val_list production. + EnterOpt_enum_val_list(c *Opt_enum_val_listContext) + + // EnterEnum_val_list is called when entering the enum_val_list production. + EnterEnum_val_list(c *Enum_val_listContext) + + // EnterAlterenumstmt is called when entering the alterenumstmt production. + EnterAlterenumstmt(c *AlterenumstmtContext) + + // EnterOpt_if_not_exists is called when entering the opt_if_not_exists production. + EnterOpt_if_not_exists(c *Opt_if_not_existsContext) + + // EnterCreateopclassstmt is called when entering the createopclassstmt production. + EnterCreateopclassstmt(c *CreateopclassstmtContext) + + // EnterOpclass_item_list is called when entering the opclass_item_list production. + EnterOpclass_item_list(c *Opclass_item_listContext) + + // EnterOpclass_item is called when entering the opclass_item production. + EnterOpclass_item(c *Opclass_itemContext) + + // EnterOpt_default is called when entering the opt_default production. + EnterOpt_default(c *Opt_defaultContext) + + // EnterOpt_opfamily is called when entering the opt_opfamily production. + EnterOpt_opfamily(c *Opt_opfamilyContext) + + // EnterOpclass_purpose is called when entering the opclass_purpose production. + EnterOpclass_purpose(c *Opclass_purposeContext) + + // EnterOpt_recheck is called when entering the opt_recheck production. + EnterOpt_recheck(c *Opt_recheckContext) + + // EnterCreateopfamilystmt is called when entering the createopfamilystmt production. + EnterCreateopfamilystmt(c *CreateopfamilystmtContext) + + // EnterAlteropfamilystmt is called when entering the alteropfamilystmt production. + EnterAlteropfamilystmt(c *AlteropfamilystmtContext) + + // EnterOpclass_drop_list is called when entering the opclass_drop_list production. + EnterOpclass_drop_list(c *Opclass_drop_listContext) + + // EnterOpclass_drop is called when entering the opclass_drop production. + EnterOpclass_drop(c *Opclass_dropContext) + + // EnterDropopclassstmt is called when entering the dropopclassstmt production. + EnterDropopclassstmt(c *DropopclassstmtContext) + + // EnterDropopfamilystmt is called when entering the dropopfamilystmt production. + EnterDropopfamilystmt(c *DropopfamilystmtContext) + + // EnterDropownedstmt is called when entering the dropownedstmt production. + EnterDropownedstmt(c *DropownedstmtContext) + + // EnterReassignownedstmt is called when entering the reassignownedstmt production. + EnterReassignownedstmt(c *ReassignownedstmtContext) + + // EnterDropstmt is called when entering the dropstmt production. + EnterDropstmt(c *DropstmtContext) + + // EnterObject_type_any_name is called when entering the object_type_any_name production. + EnterObject_type_any_name(c *Object_type_any_nameContext) + + // EnterObject_type_name is called when entering the object_type_name production. + EnterObject_type_name(c *Object_type_nameContext) + + // EnterDrop_type_name is called when entering the drop_type_name production. + EnterDrop_type_name(c *Drop_type_nameContext) + + // EnterObject_type_name_on_any_name is called when entering the object_type_name_on_any_name production. + EnterObject_type_name_on_any_name(c *Object_type_name_on_any_nameContext) + + // EnterAny_name_list is called when entering the any_name_list production. + EnterAny_name_list(c *Any_name_listContext) + + // EnterAny_name is called when entering the any_name production. + EnterAny_name(c *Any_nameContext) + + // EnterAttrs is called when entering the attrs production. + EnterAttrs(c *AttrsContext) + + // EnterType_name_list is called when entering the type_name_list production. + EnterType_name_list(c *Type_name_listContext) + + // EnterTruncatestmt is called when entering the truncatestmt production. + EnterTruncatestmt(c *TruncatestmtContext) + + // EnterOpt_restart_seqs is called when entering the opt_restart_seqs production. + EnterOpt_restart_seqs(c *Opt_restart_seqsContext) + + // EnterCommentstmt is called when entering the commentstmt production. + EnterCommentstmt(c *CommentstmtContext) + + // EnterComment_text is called when entering the comment_text production. + EnterComment_text(c *Comment_textContext) + + // EnterSeclabelstmt is called when entering the seclabelstmt production. + EnterSeclabelstmt(c *SeclabelstmtContext) + + // EnterOpt_provider is called when entering the opt_provider production. + EnterOpt_provider(c *Opt_providerContext) + + // EnterSecurity_label is called when entering the security_label production. + EnterSecurity_label(c *Security_labelContext) + + // EnterFetchstmt is called when entering the fetchstmt production. + EnterFetchstmt(c *FetchstmtContext) + + // EnterFetch_args is called when entering the fetch_args production. + EnterFetch_args(c *Fetch_argsContext) + + // EnterGrantstmt is called when entering the grantstmt production. + EnterGrantstmt(c *GrantstmtContext) + + // EnterGrant_permissions_for_rls_lookup_tables is called when entering the grant_permissions_for_rls_lookup_tables production. + EnterGrant_permissions_for_rls_lookup_tables(c *Grant_permissions_for_rls_lookup_tablesContext) + + // EnterGrant_explain_permissions_for_row_level_security_policy_filters is called when entering the grant_explain_permissions_for_row_level_security_policy_filters production. + EnterGrant_explain_permissions_for_row_level_security_policy_filters(c *Grant_explain_permissions_for_row_level_security_policy_filtersContext) + + // EnterGrant_machine_learning_permissions is called when entering the grant_machine_learning_permissions production. + EnterGrant_machine_learning_permissions(c *Grant_machine_learning_permissionsContext) + + // EnterGrant_role_permissions is called when entering the grant_role_permissions production. + EnterGrant_role_permissions(c *Grant_role_permissionsContext) + + // EnterGrant_role_permission_target_list is called when entering the grant_role_permission_target_list production. + EnterGrant_role_permission_target_list(c *Grant_role_permission_target_listContext) + + // EnterGrant_role_permission_target_list_item is called when entering the grant_role_permission_target_list_item production. + EnterGrant_role_permission_target_list_item(c *Grant_role_permission_target_list_itemContext) + + // EnterSystem_permissions is called when entering the system_permissions production. + EnterSystem_permissions(c *System_permissionsContext) + + // EnterSystem_permissions_item is called when entering the system_permissions_item production. + EnterSystem_permissions_item(c *System_permissions_itemContext) + + // EnterOpt_with_admin_option is called when entering the opt_with_admin_option production. + EnterOpt_with_admin_option(c *Opt_with_admin_optionContext) + + // EnterGrant_scoped_permissions is called when entering the grant_scoped_permissions production. + EnterGrant_scoped_permissions(c *Grant_scoped_permissionsContext) + + // EnterGrant_scoped_schemas_permissions is called when entering the grant_scoped_schemas_permissions production. + EnterGrant_scoped_schemas_permissions(c *Grant_scoped_schemas_permissionsContext) + + // EnterGrant_scoped_tables_permissions is called when entering the grant_scoped_tables_permissions production. + EnterGrant_scoped_tables_permissions(c *Grant_scoped_tables_permissionsContext) + + // EnterGrant_scoped_functions_permissions is called when entering the grant_scoped_functions_permissions production. + EnterGrant_scoped_functions_permissions(c *Grant_scoped_functions_permissionsContext) + + // EnterGrant_scoped_procedures_permissions is called when entering the grant_scoped_procedures_permissions production. + EnterGrant_scoped_procedures_permissions(c *Grant_scoped_procedures_permissionsContext) + + // EnterGrant_scoped_languages_permissions is called when entering the grant_scoped_languages_permissions production. + EnterGrant_scoped_languages_permissions(c *Grant_scoped_languages_permissionsContext) + + // EnterGrant_scoped_copy_jobs_permissions is called when entering the grant_scoped_copy_jobs_permissions production. + EnterGrant_scoped_copy_jobs_permissions(c *Grant_scoped_copy_jobs_permissionsContext) + + // EnterGrantee_list_without_public is called when entering the grantee_list_without_public production. + EnterGrantee_list_without_public(c *Grantee_list_without_publicContext) + + // EnterGrantee_without_public is called when entering the grantee_without_public production. + EnterGrantee_without_public(c *Grantee_without_publicContext) + + // EnterGrant_datashare_permissions is called when entering the grant_datashare_permissions production. + EnterGrant_datashare_permissions(c *Grant_datashare_permissionsContext) + + // EnterGrant_spectrum_integration_permissions is called when entering the grant_spectrum_integration_permissions production. + EnterGrant_spectrum_integration_permissions(c *Grant_spectrum_integration_permissionsContext) + + // EnterGrant_spectrum_integration_external_schema_permissions is called when entering the grant_spectrum_integration_external_schema_permissions production. + EnterGrant_spectrum_integration_external_schema_permissions(c *Grant_spectrum_integration_external_schema_permissionsContext) + + // EnterSpectrum_integration_external_schema_permission_list is called when entering the spectrum_integration_external_schema_permission_list production. + EnterSpectrum_integration_external_schema_permission_list(c *Spectrum_integration_external_schema_permission_listContext) + + // EnterSpectrum_integration_external_schema_permission is called when entering the spectrum_integration_external_schema_permission production. + EnterSpectrum_integration_external_schema_permission(c *Spectrum_integration_external_schema_permissionContext) + + // EnterGrant_spectrum_integration_external_table_permissions is called when entering the grant_spectrum_integration_external_table_permissions production. + EnterGrant_spectrum_integration_external_table_permissions(c *Grant_spectrum_integration_external_table_permissionsContext) + + // EnterSpectrum_integration_external_table_permission is called when entering the spectrum_integration_external_table_permission production. + EnterSpectrum_integration_external_table_permission(c *Spectrum_integration_external_table_permissionContext) + + // EnterSpectrum_integration_external_table_permission_list is called when entering the spectrum_integration_external_table_permission_list production. + EnterSpectrum_integration_external_table_permission_list(c *Spectrum_integration_external_table_permission_listContext) + + // EnterGrant_spectrum_integration_extenral_column_permissions is called when entering the grant_spectrum_integration_extenral_column_permissions production. + EnterGrant_spectrum_integration_extenral_column_permissions(c *Grant_spectrum_integration_extenral_column_permissionsContext) + + // EnterIamrolelist_or_public is called when entering the iamrolelist_or_public production. + EnterIamrolelist_or_public(c *Iamrolelist_or_publicContext) + + // EnterIamrolelist is called when entering the iamrolelist production. + EnterIamrolelist(c *IamrolelistContext) + + // EnterGrant_assume_role_permissions is called when entering the grant_assume_role_permissions production. + EnterGrant_assume_role_permissions(c *Grant_assume_role_permissionsContext) + + // EnterGrant_assume_role_for_list is called when entering the grant_assume_role_for_list production. + EnterGrant_assume_role_for_list(c *Grant_assume_role_for_listContext) + + // EnterGrant_assume_role_for_item is called when entering the grant_assume_role_for_item production. + EnterGrant_assume_role_for_item(c *Grant_assume_role_for_itemContext) + + // EnterGrant_assume_role_target is called when entering the grant_assume_role_target production. + EnterGrant_assume_role_target(c *Grant_assume_role_targetContext) + + // EnterGrant_column_level_permissions is called when entering the grant_column_level_permissions production. + EnterGrant_column_level_permissions(c *Grant_column_level_permissionsContext) + + // EnterColumn_privilege_target is called when entering the column_privilege_target production. + EnterColumn_privilege_target(c *Column_privilege_targetContext) + + // EnterColumn_privilege_list is called when entering the column_privilege_list production. + EnterColumn_privilege_list(c *Column_privilege_listContext) + + // EnterColumn_all_privilege is called when entering the column_all_privilege production. + EnterColumn_all_privilege(c *Column_all_privilegeContext) + + // EnterColumn_select_update_privilege is called when entering the column_select_update_privilege production. + EnterColumn_select_update_privilege(c *Column_select_update_privilegeContext) + + // EnterCommon_grant is called when entering the common_grant production. + EnterCommon_grant(c *Common_grantContext) + + // EnterCopy_job_privilege_list is called when entering the copy_job_privilege_list production. + EnterCopy_job_privilege_list(c *Copy_job_privilege_listContext) + + // EnterCopy_job_privilege is called when entering the copy_job_privilege production. + EnterCopy_job_privilege(c *Copy_job_privilegeContext) + + // EnterCopy_job_target is called when entering the copy_job_target production. + EnterCopy_job_target(c *Copy_job_targetContext) + + // EnterCopy_job_name is called when entering the copy_job_name production. + EnterCopy_job_name(c *Copy_job_nameContext) + + // EnterLanguage_privilege_list is called when entering the language_privilege_list production. + EnterLanguage_privilege_list(c *Language_privilege_listContext) + + // EnterGrant_language_target is called when entering the grant_language_target production. + EnterGrant_language_target(c *Grant_language_targetContext) + + // EnterGrant_procedure_target is called when entering the grant_procedure_target production. + EnterGrant_procedure_target(c *Grant_procedure_targetContext) + + // EnterProcedure_privilege_list is called when entering the procedure_privilege_list production. + EnterProcedure_privilege_list(c *Procedure_privilege_listContext) + + // EnterProcedure_privilege is called when entering the procedure_privilege production. + EnterProcedure_privilege(c *Procedure_privilegeContext) + + // EnterFunction_privilege_list is called when entering the function_privilege_list production. + EnterFunction_privilege_list(c *Function_privilege_listContext) + + // EnterFunction_privilege is called when entering the function_privilege production. + EnterFunction_privilege(c *Function_privilegeContext) + + // EnterGrant_function_target is called when entering the grant_function_target production. + EnterGrant_function_target(c *Grant_function_targetContext) + + // EnterGrant_schema_target is called when entering the grant_schema_target production. + EnterGrant_schema_target(c *Grant_schema_targetContext) + + // EnterRevoke_schema_target is called when entering the revoke_schema_target production. + EnterRevoke_schema_target(c *Revoke_schema_targetContext) + + // EnterSchema_privilege_list is called when entering the schema_privilege_list production. + EnterSchema_privilege_list(c *Schema_privilege_listContext) + + // EnterSchema_privilege is called when entering the schema_privilege production. + EnterSchema_privilege(c *Schema_privilegeContext) + + // EnterDatabase_privilege_list is called when entering the database_privilege_list production. + EnterDatabase_privilege_list(c *Database_privilege_listContext) + + // EnterDatabase_privilege is called when entering the database_privilege production. + EnterDatabase_privilege(c *Database_privilegeContext) + + // EnterGrant_database_target is called when entering the grant_database_target production. + EnterGrant_database_target(c *Grant_database_targetContext) + + // EnterGrant_table_target is called when entering the grant_table_target production. + EnterGrant_table_target(c *Grant_table_targetContext) + + // EnterRevoke_table_target is called when entering the revoke_table_target production. + EnterRevoke_table_target(c *Revoke_table_targetContext) + + // EnterAll_tables_in_schema_list is called when entering the all_tables_in_schema_list production. + EnterAll_tables_in_schema_list(c *All_tables_in_schema_listContext) + + // EnterAll_privileges is called when entering the all_privileges production. + EnterAll_privileges(c *All_privilegesContext) + + // EnterGrantee_list is called when entering the grantee_list production. + EnterGrantee_list(c *Grantee_listContext) + + // EnterGrantee is called when entering the grantee production. + EnterGrantee(c *GranteeContext) + + // EnterOpt_with_grant_option is called when entering the opt_with_grant_option production. + EnterOpt_with_grant_option(c *Opt_with_grant_optionContext) + + // EnterTable_privilege is called when entering the table_privilege production. + EnterTable_privilege(c *Table_privilegeContext) + + // EnterTable_privilege_list is called when entering the table_privilege_list production. + EnterTable_privilege_list(c *Table_privilege_listContext) + + // EnterRevokestmt is called when entering the revokestmt production. + EnterRevokestmt(c *RevokestmtContext) + + // EnterRevoke_permissions_for_rls_lookup_tables is called when entering the revoke_permissions_for_rls_lookup_tables production. + EnterRevoke_permissions_for_rls_lookup_tables(c *Revoke_permissions_for_rls_lookup_tablesContext) + + // EnterRevoke_explain_permissions_for_row_level_security_policy_filters is called when entering the revoke_explain_permissions_for_row_level_security_policy_filters production. + EnterRevoke_explain_permissions_for_row_level_security_policy_filters(c *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) + + // EnterRevoke_machine_learning_permissions is called when entering the revoke_machine_learning_permissions production. + EnterRevoke_machine_learning_permissions(c *Revoke_machine_learning_permissionsContext) + + // EnterRevoke_role_permissions is called when entering the revoke_role_permissions production. + EnterRevoke_role_permissions(c *Revoke_role_permissionsContext) + + // EnterRevoke_scoped_permissions is called when entering the revoke_scoped_permissions production. + EnterRevoke_scoped_permissions(c *Revoke_scoped_permissionsContext) + + // EnterRevoke_scoped_schemas_permissions is called when entering the revoke_scoped_schemas_permissions production. + EnterRevoke_scoped_schemas_permissions(c *Revoke_scoped_schemas_permissionsContext) + + // EnterRevoke_scoped_tables_permissions is called when entering the revoke_scoped_tables_permissions production. + EnterRevoke_scoped_tables_permissions(c *Revoke_scoped_tables_permissionsContext) + + // EnterRevoke_scoped_functions_permissions is called when entering the revoke_scoped_functions_permissions production. + EnterRevoke_scoped_functions_permissions(c *Revoke_scoped_functions_permissionsContext) + + // EnterRevoke_scoped_procedures_permissions is called when entering the revoke_scoped_procedures_permissions production. + EnterRevoke_scoped_procedures_permissions(c *Revoke_scoped_procedures_permissionsContext) + + // EnterRevoke_scoped_languages_permissions is called when entering the revoke_scoped_languages_permissions production. + EnterRevoke_scoped_languages_permissions(c *Revoke_scoped_languages_permissionsContext) + + // EnterRevoke_scoped_copy_jobs_permissions is called when entering the revoke_scoped_copy_jobs_permissions production. + EnterRevoke_scoped_copy_jobs_permissions(c *Revoke_scoped_copy_jobs_permissionsContext) + + // EnterRevoke_datashare_permissions is called when entering the revoke_datashare_permissions production. + EnterRevoke_datashare_permissions(c *Revoke_datashare_permissionsContext) + + // EnterRevoke_spectrum_integration_permissions is called when entering the revoke_spectrum_integration_permissions production. + EnterRevoke_spectrum_integration_permissions(c *Revoke_spectrum_integration_permissionsContext) + + // EnterRevoke_spectrum_integration_external_schema_permissions is called when entering the revoke_spectrum_integration_external_schema_permissions production. + EnterRevoke_spectrum_integration_external_schema_permissions(c *Revoke_spectrum_integration_external_schema_permissionsContext) + + // EnterRevoke_spectrum_integration_external_table_permissions is called when entering the revoke_spectrum_integration_external_table_permissions production. + EnterRevoke_spectrum_integration_external_table_permissions(c *Revoke_spectrum_integration_external_table_permissionsContext) + + // EnterRevoke_spectrum_integration_extenral_column_permissions is called when entering the revoke_spectrum_integration_extenral_column_permissions production. + EnterRevoke_spectrum_integration_extenral_column_permissions(c *Revoke_spectrum_integration_extenral_column_permissionsContext) + + // EnterRevoke_assume_role_permissions is called when entering the revoke_assume_role_permissions production. + EnterRevoke_assume_role_permissions(c *Revoke_assume_role_permissionsContext) + + // EnterRevoke_column_level_permissions is called when entering the revoke_column_level_permissions production. + EnterRevoke_column_level_permissions(c *Revoke_column_level_permissionsContext) + + // EnterCommon_revoke is called when entering the common_revoke production. + EnterCommon_revoke(c *Common_revokeContext) + + // EnterPrivileges is called when entering the privileges production. + EnterPrivileges(c *PrivilegesContext) + + // EnterPrivilege_list is called when entering the privilege_list production. + EnterPrivilege_list(c *Privilege_listContext) + + // EnterPrivilege is called when entering the privilege production. + EnterPrivilege(c *PrivilegeContext) + + // EnterPrivilege_target is called when entering the privilege_target production. + EnterPrivilege_target(c *Privilege_targetContext) + + // EnterParameter_name_list is called when entering the parameter_name_list production. + EnterParameter_name_list(c *Parameter_name_listContext) + + // EnterParameter_name is called when entering the parameter_name production. + EnterParameter_name(c *Parameter_nameContext) + + // EnterOpt_grant_grant_option is called when entering the opt_grant_grant_option production. + EnterOpt_grant_grant_option(c *Opt_grant_grant_optionContext) + + // EnterGrantrolestmt is called when entering the grantrolestmt production. + EnterGrantrolestmt(c *GrantrolestmtContext) + + // EnterRevokerolestmt is called when entering the revokerolestmt production. + EnterRevokerolestmt(c *RevokerolestmtContext) + + // EnterOpt_grant_admin_option is called when entering the opt_grant_admin_option production. + EnterOpt_grant_admin_option(c *Opt_grant_admin_optionContext) + + // EnterOpt_granted_by is called when entering the opt_granted_by production. + EnterOpt_granted_by(c *Opt_granted_byContext) + + // EnterAlterdefaultprivilegesstmt is called when entering the alterdefaultprivilegesstmt production. + EnterAlterdefaultprivilegesstmt(c *AlterdefaultprivilegesstmtContext) + + // EnterDefacloptionlist is called when entering the defacloptionlist production. + EnterDefacloptionlist(c *DefacloptionlistContext) + + // EnterDefacloption is called when entering the defacloption production. + EnterDefacloption(c *DefacloptionContext) + + // EnterDefaclaction is called when entering the defaclaction production. + EnterDefaclaction(c *DefaclactionContext) + + // EnterDefacl_privilege_target is called when entering the defacl_privilege_target production. + EnterDefacl_privilege_target(c *Defacl_privilege_targetContext) + + // EnterIndexstmt is called when entering the indexstmt production. + EnterIndexstmt(c *IndexstmtContext) + + // EnterOpt_unique is called when entering the opt_unique production. + EnterOpt_unique(c *Opt_uniqueContext) + + // EnterOpt_concurrently is called when entering the opt_concurrently production. + EnterOpt_concurrently(c *Opt_concurrentlyContext) + + // EnterOpt_index_name is called when entering the opt_index_name production. + EnterOpt_index_name(c *Opt_index_nameContext) + + // EnterAccess_method_clause is called when entering the access_method_clause production. + EnterAccess_method_clause(c *Access_method_clauseContext) + + // EnterIndex_params is called when entering the index_params production. + EnterIndex_params(c *Index_paramsContext) + + // EnterIndex_elem_options is called when entering the index_elem_options production. + EnterIndex_elem_options(c *Index_elem_optionsContext) + + // EnterIndex_elem is called when entering the index_elem production. + EnterIndex_elem(c *Index_elemContext) + + // EnterOpt_include is called when entering the opt_include production. + EnterOpt_include(c *Opt_includeContext) + + // EnterIndex_including_params is called when entering the index_including_params production. + EnterIndex_including_params(c *Index_including_paramsContext) + + // EnterOpt_collate is called when entering the opt_collate production. + EnterOpt_collate(c *Opt_collateContext) + + // EnterOpt_class is called when entering the opt_class production. + EnterOpt_class(c *Opt_classContext) + + // EnterOpt_asc_desc is called when entering the opt_asc_desc production. + EnterOpt_asc_desc(c *Opt_asc_descContext) + + // EnterOpt_nulls_order is called when entering the opt_nulls_order production. + EnterOpt_nulls_order(c *Opt_nulls_orderContext) + + // EnterCreatefunctionstmt is called when entering the createfunctionstmt production. + EnterCreatefunctionstmt(c *CreatefunctionstmtContext) + + // EnterCreateprocedurestmt is called when entering the createprocedurestmt production. + EnterCreateprocedurestmt(c *CreateprocedurestmtContext) + + // EnterOpt_nonatomic is called when entering the opt_nonatomic production. + EnterOpt_nonatomic(c *Opt_nonatomicContext) + + // EnterOpt_or_replace is called when entering the opt_or_replace production. + EnterOpt_or_replace(c *Opt_or_replaceContext) + + // EnterFunc_py_args_or_sql_args is called when entering the func_py_args_or_sql_args production. + EnterFunc_py_args_or_sql_args(c *Func_py_args_or_sql_argsContext) + + // EnterFunc_py_args_or_sql_args_list is called when entering the func_py_args_or_sql_args_list production. + EnterFunc_py_args_or_sql_args_list(c *Func_py_args_or_sql_args_listContext) + + // EnterFunc_args is called when entering the func_args production. + EnterFunc_args(c *Func_argsContext) + + // EnterFunc_args_list is called when entering the func_args_list production. + EnterFunc_args_list(c *Func_args_listContext) + + // EnterFunction_with_argtypes_list is called when entering the function_with_argtypes_list production. + EnterFunction_with_argtypes_list(c *Function_with_argtypes_listContext) + + // EnterFunction_with_argtypes is called when entering the function_with_argtypes production. + EnterFunction_with_argtypes(c *Function_with_argtypesContext) + + // EnterFunc_args_with_defaults is called when entering the func_args_with_defaults production. + EnterFunc_args_with_defaults(c *Func_args_with_defaultsContext) + + // EnterFunc_args_with_defaults_list is called when entering the func_args_with_defaults_list production. + EnterFunc_args_with_defaults_list(c *Func_args_with_defaults_listContext) + + // EnterFunc_arg is called when entering the func_arg production. + EnterFunc_arg(c *Func_argContext) + + // EnterArg_class is called when entering the arg_class production. + EnterArg_class(c *Arg_classContext) + + // EnterParam_name is called when entering the param_name production. + EnterParam_name(c *Param_nameContext) + + // EnterFunc_return is called when entering the func_return production. + EnterFunc_return(c *Func_returnContext) + + // EnterFunc_type is called when entering the func_type production. + EnterFunc_type(c *Func_typeContext) + + // EnterFunc_arg_with_default is called when entering the func_arg_with_default production. + EnterFunc_arg_with_default(c *Func_arg_with_defaultContext) + + // EnterAggr_arg is called when entering the aggr_arg production. + EnterAggr_arg(c *Aggr_argContext) + + // EnterAggr_args is called when entering the aggr_args production. + EnterAggr_args(c *Aggr_argsContext) + + // EnterAggr_args_list is called when entering the aggr_args_list production. + EnterAggr_args_list(c *Aggr_args_listContext) + + // EnterAggregate_with_argtypes is called when entering the aggregate_with_argtypes production. + EnterAggregate_with_argtypes(c *Aggregate_with_argtypesContext) + + // EnterAggregate_with_argtypes_list is called when entering the aggregate_with_argtypes_list production. + EnterAggregate_with_argtypes_list(c *Aggregate_with_argtypes_listContext) + + // EnterCreatefunc_opt_list is called when entering the createfunc_opt_list production. + EnterCreatefunc_opt_list(c *Createfunc_opt_listContext) + + // EnterCommon_func_opt_item is called when entering the common_func_opt_item production. + EnterCommon_func_opt_item(c *Common_func_opt_itemContext) + + // EnterCreatefunc_opt_item is called when entering the createfunc_opt_item production. + EnterCreatefunc_opt_item(c *Createfunc_opt_itemContext) + + // EnterFunc_as is called when entering the func_as production. + EnterFunc_as(c *Func_asContext) + + // EnterTransform_type_list is called when entering the transform_type_list production. + EnterTransform_type_list(c *Transform_type_listContext) + + // EnterOpt_definition is called when entering the opt_definition production. + EnterOpt_definition(c *Opt_definitionContext) + + // EnterTable_func_column is called when entering the table_func_column production. + EnterTable_func_column(c *Table_func_columnContext) + + // EnterTable_func_column_list is called when entering the table_func_column_list production. + EnterTable_func_column_list(c *Table_func_column_listContext) + + // EnterAlterfunctionstmt is called when entering the alterfunctionstmt production. + EnterAlterfunctionstmt(c *AlterfunctionstmtContext) + + // EnterAlterprocedurestmt is called when entering the alterprocedurestmt production. + EnterAlterprocedurestmt(c *AlterprocedurestmtContext) + + // EnterAlterfunc_opt_list is called when entering the alterfunc_opt_list production. + EnterAlterfunc_opt_list(c *Alterfunc_opt_listContext) + + // EnterOpt_restrict is called when entering the opt_restrict production. + EnterOpt_restrict(c *Opt_restrictContext) + + // EnterRemovefuncstmt is called when entering the removefuncstmt production. + EnterRemovefuncstmt(c *RemovefuncstmtContext) + + // EnterRemoveaggrstmt is called when entering the removeaggrstmt production. + EnterRemoveaggrstmt(c *RemoveaggrstmtContext) + + // EnterRemoveoperstmt is called when entering the removeoperstmt production. + EnterRemoveoperstmt(c *RemoveoperstmtContext) + + // EnterOper_argtypes is called when entering the oper_argtypes production. + EnterOper_argtypes(c *Oper_argtypesContext) + + // EnterAny_operator is called when entering the any_operator production. + EnterAny_operator(c *Any_operatorContext) + + // EnterOperator_with_argtypes_list is called when entering the operator_with_argtypes_list production. + EnterOperator_with_argtypes_list(c *Operator_with_argtypes_listContext) + + // EnterOperator_with_argtypes is called when entering the operator_with_argtypes production. + EnterOperator_with_argtypes(c *Operator_with_argtypesContext) + + // EnterDostmt is called when entering the dostmt production. + EnterDostmt(c *DostmtContext) + + // EnterDostmt_opt_list is called when entering the dostmt_opt_list production. + EnterDostmt_opt_list(c *Dostmt_opt_listContext) + + // EnterDostmt_opt_item is called when entering the dostmt_opt_item production. + EnterDostmt_opt_item(c *Dostmt_opt_itemContext) + + // EnterCreatecaststmt is called when entering the createcaststmt production. + EnterCreatecaststmt(c *CreatecaststmtContext) + + // EnterCast_context is called when entering the cast_context production. + EnterCast_context(c *Cast_contextContext) + + // EnterDropcaststmt is called when entering the dropcaststmt production. + EnterDropcaststmt(c *DropcaststmtContext) + + // EnterOpt_if_exists is called when entering the opt_if_exists production. + EnterOpt_if_exists(c *Opt_if_existsContext) + + // EnterCreatetransformstmt is called when entering the createtransformstmt production. + EnterCreatetransformstmt(c *CreatetransformstmtContext) + + // EnterTransform_element_list is called when entering the transform_element_list production. + EnterTransform_element_list(c *Transform_element_listContext) + + // EnterDroptransformstmt is called when entering the droptransformstmt production. + EnterDroptransformstmt(c *DroptransformstmtContext) + + // EnterReindexstmt is called when entering the reindexstmt production. + EnterReindexstmt(c *ReindexstmtContext) + + // EnterReindex_target_type is called when entering the reindex_target_type production. + EnterReindex_target_type(c *Reindex_target_typeContext) + + // EnterReindex_target_multitable is called when entering the reindex_target_multitable production. + EnterReindex_target_multitable(c *Reindex_target_multitableContext) + + // EnterReindex_option_list is called when entering the reindex_option_list production. + EnterReindex_option_list(c *Reindex_option_listContext) + + // EnterReindex_option_elem is called when entering the reindex_option_elem production. + EnterReindex_option_elem(c *Reindex_option_elemContext) + + // EnterAltertblspcstmt is called when entering the altertblspcstmt production. + EnterAltertblspcstmt(c *AltertblspcstmtContext) + + // EnterRenamestmt is called when entering the renamestmt production. + EnterRenamestmt(c *RenamestmtContext) + + // EnterOpt_column is called when entering the opt_column production. + EnterOpt_column(c *Opt_columnContext) + + // EnterOpt_set_data is called when entering the opt_set_data production. + EnterOpt_set_data(c *Opt_set_dataContext) + + // EnterAlterobjectdependsstmt is called when entering the alterobjectdependsstmt production. + EnterAlterobjectdependsstmt(c *AlterobjectdependsstmtContext) + + // EnterOpt_no is called when entering the opt_no production. + EnterOpt_no(c *Opt_noContext) + + // EnterAlterobjectschemastmt is called when entering the alterobjectschemastmt production. + EnterAlterobjectschemastmt(c *AlterobjectschemastmtContext) + + // EnterAlteroperatorstmt is called when entering the alteroperatorstmt production. + EnterAlteroperatorstmt(c *AlteroperatorstmtContext) + + // EnterOperator_def_list is called when entering the operator_def_list production. + EnterOperator_def_list(c *Operator_def_listContext) + + // EnterOperator_def_elem is called when entering the operator_def_elem production. + EnterOperator_def_elem(c *Operator_def_elemContext) + + // EnterOperator_def_arg is called when entering the operator_def_arg production. + EnterOperator_def_arg(c *Operator_def_argContext) + + // EnterAltertypestmt is called when entering the altertypestmt production. + EnterAltertypestmt(c *AltertypestmtContext) + + // EnterAlterownerstmt is called when entering the alterownerstmt production. + EnterAlterownerstmt(c *AlterownerstmtContext) + + // EnterCreatepublicationstmt is called when entering the createpublicationstmt production. + EnterCreatepublicationstmt(c *CreatepublicationstmtContext) + + // EnterPub_obj_list is called when entering the pub_obj_list production. + EnterPub_obj_list(c *Pub_obj_listContext) + + // EnterPublication_obj_spec is called when entering the publication_obj_spec production. + EnterPublication_obj_spec(c *Publication_obj_specContext) + + // EnterOpt_where_clause is called when entering the opt_where_clause production. + EnterOpt_where_clause(c *Opt_where_clauseContext) + + // EnterAlterpublicationstmt is called when entering the alterpublicationstmt production. + EnterAlterpublicationstmt(c *AlterpublicationstmtContext) + + // EnterCreatesubscriptionstmt is called when entering the createsubscriptionstmt production. + EnterCreatesubscriptionstmt(c *CreatesubscriptionstmtContext) + + // EnterPublication_name_list is called when entering the publication_name_list production. + EnterPublication_name_list(c *Publication_name_listContext) + + // EnterPublication_name_item is called when entering the publication_name_item production. + EnterPublication_name_item(c *Publication_name_itemContext) + + // EnterAltersubscriptionstmt is called when entering the altersubscriptionstmt production. + EnterAltersubscriptionstmt(c *AltersubscriptionstmtContext) + + // EnterDropsubscriptionstmt is called when entering the dropsubscriptionstmt production. + EnterDropsubscriptionstmt(c *DropsubscriptionstmtContext) + + // EnterRulestmt is called when entering the rulestmt production. + EnterRulestmt(c *RulestmtContext) + + // EnterRuleactionlist is called when entering the ruleactionlist production. + EnterRuleactionlist(c *RuleactionlistContext) + + // EnterRuleactionmulti is called when entering the ruleactionmulti production. + EnterRuleactionmulti(c *RuleactionmultiContext) + + // EnterRuleactionstmt is called when entering the ruleactionstmt production. + EnterRuleactionstmt(c *RuleactionstmtContext) + + // EnterRuleactionstmtOrEmpty is called when entering the ruleactionstmtOrEmpty production. + EnterRuleactionstmtOrEmpty(c *RuleactionstmtOrEmptyContext) + + // EnterEvent is called when entering the event production. + EnterEvent(c *EventContext) + + // EnterOpt_instead is called when entering the opt_instead production. + EnterOpt_instead(c *Opt_insteadContext) + + // EnterNotifystmt is called when entering the notifystmt production. + EnterNotifystmt(c *NotifystmtContext) + + // EnterNotify_payload is called when entering the notify_payload production. + EnterNotify_payload(c *Notify_payloadContext) + + // EnterListenstmt is called when entering the listenstmt production. + EnterListenstmt(c *ListenstmtContext) + + // EnterUnlistenstmt is called when entering the unlistenstmt production. + EnterUnlistenstmt(c *UnlistenstmtContext) + + // EnterTransactionstmt is called when entering the transactionstmt production. + EnterTransactionstmt(c *TransactionstmtContext) + + // EnterOpt_transaction is called when entering the opt_transaction production. + EnterOpt_transaction(c *Opt_transactionContext) + + // EnterTransaction_mode_item is called when entering the transaction_mode_item production. + EnterTransaction_mode_item(c *Transaction_mode_itemContext) + + // EnterTransaction_mode_list is called when entering the transaction_mode_list production. + EnterTransaction_mode_list(c *Transaction_mode_listContext) + + // EnterTransaction_mode_list_or_empty is called when entering the transaction_mode_list_or_empty production. + EnterTransaction_mode_list_or_empty(c *Transaction_mode_list_or_emptyContext) + + // EnterOpt_transaction_chain is called when entering the opt_transaction_chain production. + EnterOpt_transaction_chain(c *Opt_transaction_chainContext) + + // EnterViewstmt is called when entering the viewstmt production. + EnterViewstmt(c *ViewstmtContext) + + // EnterWith_no_schema_binding is called when entering the with_no_schema_binding production. + EnterWith_no_schema_binding(c *With_no_schema_bindingContext) + + // EnterOpt_check_option is called when entering the opt_check_option production. + EnterOpt_check_option(c *Opt_check_optionContext) + + // EnterLoadstmt is called when entering the loadstmt production. + EnterLoadstmt(c *LoadstmtContext) + + // EnterAlterdatasharestmt is called when entering the alterdatasharestmt production. + EnterAlterdatasharestmt(c *AlterdatasharestmtContext) + + // EnterAlterdatashare_action is called when entering the alterdatashare_action production. + EnterAlterdatashare_action(c *Alterdatashare_actionContext) + + // EnterAlterdatashare_add_drop is called when entering the alterdatashare_add_drop production. + EnterAlterdatashare_add_drop(c *Alterdatashare_add_dropContext) + + // EnterAlterdatashare_objects is called when entering the alterdatashare_objects production. + EnterAlterdatashare_objects(c *Alterdatashare_objectsContext) + + // EnterDatashare_table_list is called when entering the datashare_table_list production. + EnterDatashare_table_list(c *Datashare_table_listContext) + + // EnterDatashare_table_name is called when entering the datashare_table_name production. + EnterDatashare_table_name(c *Datashare_table_nameContext) + + // EnterTable_name is called when entering the table_name production. + EnterTable_name(c *Table_nameContext) + + // EnterTemporary_table_name is called when entering the temporary_table_name production. + EnterTemporary_table_name(c *Temporary_table_nameContext) + + // EnterDatashare_function_list is called when entering the datashare_function_list production. + EnterDatashare_function_list(c *Datashare_function_listContext) + + // EnterDatashare_function is called when entering the datashare_function production. + EnterDatashare_function(c *Datashare_functionContext) + + // EnterDatashare_function_name is called when entering the datashare_function_name production. + EnterDatashare_function_name(c *Datashare_function_nameContext) + + // EnterCreatedatasharestmt is called when entering the createdatasharestmt production. + EnterCreatedatasharestmt(c *CreatedatasharestmtContext) + + // EnterCreatedatashareoptions is called when entering the createdatashareoptions production. + EnterCreatedatashareoptions(c *CreatedatashareoptionsContext) + + // EnterCreatedatashareoption is called when entering the createdatashareoption production. + EnterCreatedatashareoption(c *CreatedatashareoptionContext) + + // EnterSetpublicaccessibleoption is called when entering the setpublicaccessibleoption production. + EnterSetpublicaccessibleoption(c *SetpublicaccessibleoptionContext) + + // EnterManagedbyoption is called when entering the managedbyoption production. + EnterManagedbyoption(c *ManagedbyoptionContext) + + // EnterDescdatasharestmt is called when entering the descdatasharestmt production. + EnterDescdatasharestmt(c *DescdatasharestmtContext) + + // EnterDropdatasharestmt is called when entering the dropdatasharestmt production. + EnterDropdatasharestmt(c *DropdatasharestmtContext) + + // EnterAlterexternalschemastmt is called when entering the alterexternalschemastmt production. + EnterAlterexternalschemastmt(c *AlterexternalschemastmtContext) + + // EnterAltexternalschemaopts is called when entering the altexternalschemaopts production. + EnterAltexternalschemaopts(c *AltexternalschemaoptsContext) + + // EnterAlterexternalviewstmt is called when entering the alterexternalviewstmt production. + EnterAlterexternalviewstmt(c *AlterexternalviewstmtContext) + + // EnterCreateexternalschemastmt is called when entering the createexternalschemastmt production. + EnterCreateexternalschemastmt(c *CreateexternalschemastmtContext) + + // EnterFromdatacatalogclause is called when entering the fromdatacatalogclause production. + EnterFromdatacatalogclause(c *FromdatacatalogclauseContext) + + // EnterDropschemastmt is called when entering the dropschemastmt production. + EnterDropschemastmt(c *DropschemastmtContext) + + // EnterImplicitdatacatalogclause is called when entering the implicitdatacatalogclause production. + EnterImplicitdatacatalogclause(c *ImplicitdatacatalogclauseContext) + + // EnterFromhivemetastoreclause is called when entering the fromhivemetastoreclause production. + EnterFromhivemetastoreclause(c *FromhivemetastoreclauseContext) + + // EnterFrompostgresclause is called when entering the frompostgresclause production. + EnterFrompostgresclause(c *FrompostgresclauseContext) + + // EnterFrommysqlclause is called when entering the frommysqlclause production. + EnterFrommysqlclause(c *FrommysqlclauseContext) + + // EnterFromkinesisclause is called when entering the fromkinesisclause production. + EnterFromkinesisclause(c *FromkinesisclauseContext) + + // EnterFromkafkaclause is called when entering the fromkafkaclause production. + EnterFromkafkaclause(c *FromkafkaclauseContext) + + // EnterFrommskclause is called when entering the frommskclause production. + EnterFrommskclause(c *FrommskclauseContext) + + // EnterFromredshiftclause is called when entering the fromredshiftclause production. + EnterFromredshiftclause(c *FromredshiftclauseContext) + + // EnterIamrolevalue is called when entering the iamrolevalue production. + EnterIamrolevalue(c *IamrolevalueContext) + + // EnterCatalogrolevalue is called when entering the catalogrolevalue production. + EnterCatalogrolevalue(c *CatalogrolevalueContext) + + // EnterAuthenticationvalue is called when entering the authenticationvalue production. + EnterAuthenticationvalue(c *AuthenticationvalueContext) + + // EnterCreateexternalfunctionstmt is called when entering the createexternalfunctionstmt production. + EnterCreateexternalfunctionstmt(c *CreateexternalfunctionstmtContext) + + // EnterExternal_func_params is called when entering the external_func_params production. + EnterExternal_func_params(c *External_func_paramsContext) + + // EnterParamlist is called when entering the paramlist production. + EnterParamlist(c *ParamlistContext) + + // EnterParam_spec is called when entering the param_spec production. + EnterParam_spec(c *Param_specContext) + + // EnterCreateexternalmodelstmt is called when entering the createexternalmodelstmt production. + EnterCreateexternalmodelstmt(c *CreateexternalmodelstmtContext) + + // EnterCreateexternaltablestmt is called when entering the createexternaltablestmt production. + EnterCreateexternaltablestmt(c *CreateexternaltablestmtContext) + + // EnterExtern_column_list is called when entering the extern_column_list production. + EnterExtern_column_list(c *Extern_column_listContext) + + // EnterExtern_column_def is called when entering the extern_column_def production. + EnterExtern_column_def(c *Extern_column_defContext) + + // EnterExtern_typename is called when entering the extern_typename production. + EnterExtern_typename(c *Extern_typenameContext) + + // EnterExtern_table_format is called when entering the extern_table_format production. + EnterExtern_table_format(c *Extern_table_formatContext) + + // EnterRow_format_spec is called when entering the row_format_spec production. + EnterRow_format_spec(c *Row_format_specContext) + + // EnterSerde_properties_list is called when entering the serde_properties_list production. + EnterSerde_properties_list(c *Serde_properties_listContext) + + // EnterSerde_property is called when entering the serde_property production. + EnterSerde_property(c *Serde_propertyContext) + + // EnterExternal_format_spec is called when entering the external_format_spec production. + EnterExternal_format_spec(c *External_format_specContext) + + // EnterTable_properties_list is called when entering the table_properties_list production. + EnterTable_properties_list(c *Table_properties_listContext) + + // EnterTable_property is called when entering the table_property production. + EnterTable_property(c *Table_propertyContext) + + // EnterCreateexternalviewstmt is called when entering the createexternalviewstmt production. + EnterCreateexternalviewstmt(c *CreateexternalviewstmtContext) + + // EnterDropexternalviewstmt is called when entering the dropexternalviewstmt production. + EnterDropexternalviewstmt(c *DropexternalviewstmtContext) + + // EnterAlteridentityproviderstmt is called when entering the alteridentityproviderstmt production. + EnterAlteridentityproviderstmt(c *AlteridentityproviderstmtContext) + + // EnterAlteridprovideropts is called when entering the alteridprovideropts production. + EnterAlteridprovideropts(c *AlteridprovideroptsContext) + + // EnterAltermaskingpolicystmt is called when entering the altermaskingpolicystmt production. + EnterAltermaskingpolicystmt(c *AltermaskingpolicystmtContext) + + // EnterAltermaterializedviewstmt is called when entering the altermaterializedviewstmt production. + EnterAltermaterializedviewstmt(c *AltermaterializedviewstmtContext) + + // EnterAltmaskingpolicyopts is called when entering the altmaskingpolicyopts production. + EnterAltmaskingpolicyopts(c *AltmaskingpolicyoptsContext) + + // EnterAltmaskingpolicyargs is called when entering the altmaskingpolicyargs production. + EnterAltmaskingpolicyargs(c *AltmaskingpolicyargsContext) + + // EnterAltmaskingpolicyarg is called when entering the altmaskingpolicyarg production. + EnterAltmaskingpolicyarg(c *AltmaskingpolicyargContext) + + // EnterAlterrlspolicystmt is called when entering the alterrlspolicystmt production. + EnterAlterrlspolicystmt(c *AlterrlspolicystmtContext) + + // EnterAttachmaskingpolicystmt is called when entering the attachmaskingpolicystmt production. + EnterAttachmaskingpolicystmt(c *AttachmaskingpolicystmtContext) + + // EnterAttachpolicycollist is called when entering the attachpolicycollist production. + EnterAttachpolicycollist(c *AttachpolicycollistContext) + + // EnterAttachpolicycolumn is called when entering the attachpolicycolumn production. + EnterAttachpolicycolumn(c *AttachpolicycolumnContext) + + // EnterAttachpolicytargets is called when entering the attachpolicytargets production. + EnterAttachpolicytargets(c *AttachpolicytargetsContext) + + // EnterAttachpolicytarget is called when entering the attachpolicytarget production. + EnterAttachpolicytarget(c *AttachpolicytargetContext) + + // EnterAttachrlspolicystmt is called when entering the attachrlspolicystmt production. + EnterAttachrlspolicystmt(c *AttachrlspolicystmtContext) + + // EnterTable_name_list is called when entering the table_name_list production. + EnterTable_name_list(c *Table_name_listContext) + + // EnterCreateidentityproviderstmt is called when entering the createidentityproviderstmt production. + EnterCreateidentityproviderstmt(c *CreateidentityproviderstmtContext) + + // EnterCreateidprovideropts is called when entering the createidprovideropts production. + EnterCreateidprovideropts(c *CreateidprovideroptsContext) + + // EnterGroupfilter is called when entering the groupfilter production. + EnterGroupfilter(c *GroupfilterContext) + + // EnterCreatelibrarystmt is called when entering the createlibrarystmt production. + EnterCreatelibrarystmt(c *CreatelibrarystmtContext) + + // EnterCreatelibraryopts is called when entering the createlibraryopts production. + EnterCreatelibraryopts(c *CreatelibraryoptsContext) + + // EnterCreatemaskingpolicystmt is called when entering the createmaskingpolicystmt production. + EnterCreatemaskingpolicystmt(c *CreatemaskingpolicystmtContext) + + // EnterInputcolumnlist is called when entering the inputcolumnlist production. + EnterInputcolumnlist(c *InputcolumnlistContext) + + // EnterInputcolumn is called when entering the inputcolumn production. + EnterInputcolumn(c *InputcolumnContext) + + // EnterMaskingexpression is called when entering the maskingexpression production. + EnterMaskingexpression(c *MaskingexpressionContext) + + // EnterCreatemodelstmt is called when entering the createmodelstmt production. + EnterCreatemodelstmt(c *CreatemodelstmtContext) + + // EnterCreatemodelfromclause is called when entering the createmodelfromclause production. + EnterCreatemodelfromclause(c *CreatemodelfromclauseContext) + + // EnterIamrolespec is called when entering the iamrolespec production. + EnterIamrolespec(c *IamrolespecContext) + + // EnterSagemakerspec is called when entering the sagemakerspec production. + EnterSagemakerspec(c *SagemakerspecContext) + + // EnterModeltypespec is called when entering the modeltypespec production. + EnterModeltypespec(c *ModeltypespecContext) + + // EnterProblemtypespec is called when entering the problemtypespec production. + EnterProblemtypespec(c *ProblemtypespecContext) + + // EnterProblemtype is called when entering the problemtype production. + EnterProblemtype(c *ProblemtypeContext) + + // EnterObjectivespec is called when entering the objectivespec production. + EnterObjectivespec(c *ObjectivespecContext) + + // EnterHyperparametersspec is called when entering the hyperparametersspec production. + EnterHyperparametersspec(c *HyperparametersspecContext) + + // EnterHyperparameterslist is called when entering the hyperparameterslist production. + EnterHyperparameterslist(c *HyperparameterslistContext) + + // EnterHyperparameteritem is called when entering the hyperparameteritem production. + EnterHyperparameteritem(c *HyperparameteritemContext) + + // EnterSettingsclause is called when entering the settingsclause production. + EnterSettingsclause(c *SettingsclauseContext) + + // EnterSettingsitem is called when entering the settingsitem production. + EnterSettingsitem(c *SettingsitemContext) + + // EnterDatatypelist is called when entering the datatypelist production. + EnterDatatypelist(c *DatatypelistContext) + + // EnterDatatype is called when entering the datatype production. + EnterDatatype(c *DatatypeContext) + + // EnterCreaterlspolicystmt is called when entering the createrlspolicystmt production. + EnterCreaterlspolicystmt(c *CreaterlspolicystmtContext) + + // EnterDescidentityproviderstmt is called when entering the descidentityproviderstmt production. + EnterDescidentityproviderstmt(c *DescidentityproviderstmtContext) + + // EnterDetachmaskingpolicystmt is called when entering the detachmaskingpolicystmt production. + EnterDetachmaskingpolicystmt(c *DetachmaskingpolicystmtContext) + + // EnterDetachrlspolicystmt is called when entering the detachrlspolicystmt production. + EnterDetachrlspolicystmt(c *DetachrlspolicystmtContext) + + // EnterRole_or_user_or_public_list is called when entering the role_or_user_or_public_list production. + EnterRole_or_user_or_public_list(c *Role_or_user_or_public_listContext) + + // EnterRole_or_user_or_public is called when entering the role_or_user_or_public production. + EnterRole_or_user_or_public(c *Role_or_user_or_publicContext) + + // EnterRlspolicyname is called when entering the rlspolicyname production. + EnterRlspolicyname(c *RlspolicynameContext) + + // EnterDropidentityproviderstmt is called when entering the dropidentityproviderstmt production. + EnterDropidentityproviderstmt(c *DropidentityproviderstmtContext) + + // EnterDroplibrarystmt is called when entering the droplibrarystmt production. + EnterDroplibrarystmt(c *DroplibrarystmtContext) + + // EnterDropmaskingpolicystmt is called when entering the dropmaskingpolicystmt production. + EnterDropmaskingpolicystmt(c *DropmaskingpolicystmtContext) + + // EnterDropmodelstmt is called when entering the dropmodelstmt production. + EnterDropmodelstmt(c *DropmodelstmtContext) + + // EnterDroprlspolicystmt is called when entering the droprlspolicystmt production. + EnterDroprlspolicystmt(c *DroprlspolicystmtContext) + + // EnterAltertableappendstmt is called when entering the altertableappendstmt production. + EnterAltertableappendstmt(c *AltertableappendstmtContext) + + // EnterAppendoptions is called when entering the appendoptions production. + EnterAppendoptions(c *AppendoptionsContext) + + // EnterAlteruserstmt is called when entering the alteruserstmt production. + EnterAlteruserstmt(c *AlteruserstmtContext) + + // EnterAlteruseropts is called when entering the alteruseropts production. + EnterAlteruseropts(c *AlteruseroptsContext) + + // EnterAnalyzecompressionstmt is called when entering the analyzecompressionstmt production. + EnterAnalyzecompressionstmt(c *AnalyzecompressionstmtContext) + + // EnterCancelstmt is called when entering the cancelstmt production. + EnterCancelstmt(c *CancelstmtContext) + + // EnterClosestmt is called when entering the closestmt production. + EnterClosestmt(c *ClosestmtContext) + + // EnterInsertexternaltablestmt is called when entering the insertexternaltablestmt production. + EnterInsertexternaltablestmt(c *InsertexternaltablestmtContext) + + // EnterSelect_or_values is called when entering the select_or_values production. + EnterSelect_or_values(c *Select_or_valuesContext) + + // EnterSelectintostmt is called when entering the selectintostmt production. + EnterSelectintostmt(c *SelectintostmtContext) + + // EnterSetsessionauthorizationstmt is called when entering the setsessionauthorizationstmt production. + EnterSetsessionauthorizationstmt(c *SetsessionauthorizationstmtContext) + + // EnterSetsessioncharacteristicsstmt is called when entering the setsessioncharacteristicsstmt production. + EnterSetsessioncharacteristicsstmt(c *SetsessioncharacteristicsstmtContext) + + // EnterShowcolumnsstmt is called when entering the showcolumnsstmt production. + EnterShowcolumnsstmt(c *ShowcolumnsstmtContext) + + // EnterShowdatabasesstmt is called when entering the showdatabasesstmt production. + EnterShowdatabasesstmt(c *ShowdatabasesstmtContext) + + // EnterShowdbsopts is called when entering the showdbsopts production. + EnterShowdbsopts(c *ShowdbsoptsContext) + + // EnterShowdatasharesstmt is called when entering the showdatasharesstmt production. + EnterShowdatasharesstmt(c *ShowdatasharesstmtContext) + + // EnterShowexternaltablestmt is called when entering the showexternaltablestmt production. + EnterShowexternaltablestmt(c *ShowexternaltablestmtContext) + + // EnterShowgrantsstmt is called when entering the showgrantsstmt production. + EnterShowgrantsstmt(c *ShowgrantsstmtContext) + + // EnterGrantobject is called when entering the grantobject production. + EnterGrantobject(c *GrantobjectContext) + + // EnterGrantprincipal is called when entering the grantprincipal production. + EnterGrantprincipal(c *GrantprincipalContext) + + // EnterShowmodelstmt is called when entering the showmodelstmt production. + EnterShowmodelstmt(c *ShowmodelstmtContext) + + // EnterShowprocedurestmt is called when entering the showprocedurestmt production. + EnterShowprocedurestmt(c *ShowprocedurestmtContext) + + // EnterShowschemasstmt is called when entering the showschemasstmt production. + EnterShowschemasstmt(c *ShowschemasstmtContext) + + // EnterShowtablestmt is called when entering the showtablestmt production. + EnterShowtablestmt(c *ShowtablestmtContext) + + // EnterShowtablesstmt is called when entering the showtablesstmt production. + EnterShowtablesstmt(c *ShowtablesstmtContext) + + // EnterShowviewstmt is called when entering the showviewstmt production. + EnterShowviewstmt(c *ShowviewstmtContext) + + // EnterUnloadstmt is called when entering the unloadstmt production. + EnterUnloadstmt(c *UnloadstmtContext) + + // EnterIamroleclause is called when entering the iamroleclause production. + EnterIamroleclause(c *IamroleclauseContext) + + // EnterUnloadoptions is called when entering the unloadoptions production. + EnterUnloadoptions(c *UnloadoptionsContext) + + // EnterFormatoption is called when entering the formatoption production. + EnterFormatoption(c *FormatoptionContext) + + // EnterPartitionbyoption is called when entering the partitionbyoption production. + EnterPartitionbyoption(c *PartitionbyoptionContext) + + // EnterManifestoption is called when entering the manifestoption production. + EnterManifestoption(c *ManifestoptionContext) + + // EnterHeaderoption is called when entering the headeroption production. + EnterHeaderoption(c *HeaderoptionContext) + + // EnterDelimiteroption is called when entering the delimiteroption production. + EnterDelimiteroption(c *DelimiteroptionContext) + + // EnterFixedwidthoption is called when entering the fixedwidthoption production. + EnterFixedwidthoption(c *FixedwidthoptionContext) + + // EnterEncryptedoption is called when entering the encryptedoption production. + EnterEncryptedoption(c *EncryptedoptionContext) + + // EnterKmskeyoption is called when entering the kmskeyoption production. + EnterKmskeyoption(c *KmskeyoptionContext) + + // EnterCompressionoption is called when entering the compressionoption production. + EnterCompressionoption(c *CompressionoptionContext) + + // EnterAddquotesoption is called when entering the addquotesoption production. + EnterAddquotesoption(c *AddquotesoptionContext) + + // EnterNullasoption is called when entering the nullasoption production. + EnterNullasoption(c *NullasoptionContext) + + // EnterEscapeoption is called when entering the escapeoption production. + EnterEscapeoption(c *EscapeoptionContext) + + // EnterAllowoverwriteoption is called when entering the allowoverwriteoption production. + EnterAllowoverwriteoption(c *AllowoverwriteoptionContext) + + // EnterCleanpathoption is called when entering the cleanpathoption production. + EnterCleanpathoption(c *CleanpathoptionContext) + + // EnterParalleloption is called when entering the paralleloption production. + EnterParalleloption(c *ParalleloptionContext) + + // EnterMaxfilesizeoption is called when entering the maxfilesizeoption production. + EnterMaxfilesizeoption(c *MaxfilesizeoptionContext) + + // EnterRowgroupsizeoption is called when entering the rowgroupsizeoption production. + EnterRowgroupsizeoption(c *RowgroupsizeoptionContext) + + // EnterSizeunit is called when entering the sizeunit production. + EnterSizeunit(c *SizeunitContext) + + // EnterRegionoption is called when entering the regionoption production. + EnterRegionoption(c *RegionoptionContext) + + // EnterExtensionoption is called when entering the extensionoption production. + EnterExtensionoption(c *ExtensionoptionContext) + + // EnterUsestmt is called when entering the usestmt production. + EnterUsestmt(c *UsestmtContext) + + // EnterCreatedbstmt is called when entering the createdbstmt production. + EnterCreatedbstmt(c *CreatedbstmtContext) + + // EnterCreatedb_opt_list is called when entering the createdb_opt_list production. + EnterCreatedb_opt_list(c *Createdb_opt_listContext) + + // EnterCreatedb_opt_items is called when entering the createdb_opt_items production. + EnterCreatedb_opt_items(c *Createdb_opt_itemsContext) + + // EnterCreatedb_opt_item is called when entering the createdb_opt_item production. + EnterCreatedb_opt_item(c *Createdb_opt_itemContext) + + // EnterCreatedb_opt_name is called when entering the createdb_opt_name production. + EnterCreatedb_opt_name(c *Createdb_opt_nameContext) + + // EnterOpt_equal is called when entering the opt_equal production. + EnterOpt_equal(c *Opt_equalContext) + + // EnterAlterdatabasestmt is called when entering the alterdatabasestmt production. + EnterAlterdatabasestmt(c *AlterdatabasestmtContext) + + // EnterAlterdatabasesetstmt is called when entering the alterdatabasesetstmt production. + EnterAlterdatabasesetstmt(c *AlterdatabasesetstmtContext) + + // EnterDropdbstmt is called when entering the dropdbstmt production. + EnterDropdbstmt(c *DropdbstmtContext) + + // EnterDrop_option_list is called when entering the drop_option_list production. + EnterDrop_option_list(c *Drop_option_listContext) + + // EnterDrop_option is called when entering the drop_option production. + EnterDrop_option(c *Drop_optionContext) + + // EnterAltercollationstmt is called when entering the altercollationstmt production. + EnterAltercollationstmt(c *AltercollationstmtContext) + + // EnterAltersystemstmt is called when entering the altersystemstmt production. + EnterAltersystemstmt(c *AltersystemstmtContext) + + // EnterCreatedomainstmt is called when entering the createdomainstmt production. + EnterCreatedomainstmt(c *CreatedomainstmtContext) + + // EnterAlterdomainstmt is called when entering the alterdomainstmt production. + EnterAlterdomainstmt(c *AlterdomainstmtContext) + + // EnterOpt_as is called when entering the opt_as production. + EnterOpt_as(c *Opt_asContext) + + // EnterAltertsdictionarystmt is called when entering the altertsdictionarystmt production. + EnterAltertsdictionarystmt(c *AltertsdictionarystmtContext) + + // EnterAltertsconfigurationstmt is called when entering the altertsconfigurationstmt production. + EnterAltertsconfigurationstmt(c *AltertsconfigurationstmtContext) + + // EnterAny_with is called when entering the any_with production. + EnterAny_with(c *Any_withContext) + + // EnterCreateconversionstmt is called when entering the createconversionstmt production. + EnterCreateconversionstmt(c *CreateconversionstmtContext) + + // EnterClusterstmt is called when entering the clusterstmt production. + EnterClusterstmt(c *ClusterstmtContext) + + // EnterCluster_index_specification is called when entering the cluster_index_specification production. + EnterCluster_index_specification(c *Cluster_index_specificationContext) + + // EnterVacuumstmt is called when entering the vacuumstmt production. + EnterVacuumstmt(c *VacuumstmtContext) + + // EnterVacuum_option is called when entering the vacuum_option production. + EnterVacuum_option(c *Vacuum_optionContext) + + // EnterAnalyzestmt is called when entering the analyzestmt production. + EnterAnalyzestmt(c *AnalyzestmtContext) + + // EnterVac_analyze_option_list is called when entering the vac_analyze_option_list production. + EnterVac_analyze_option_list(c *Vac_analyze_option_listContext) + + // EnterAnalyze_keyword is called when entering the analyze_keyword production. + EnterAnalyze_keyword(c *Analyze_keywordContext) + + // EnterVac_analyze_option_elem is called when entering the vac_analyze_option_elem production. + EnterVac_analyze_option_elem(c *Vac_analyze_option_elemContext) + + // EnterVac_analyze_option_name is called when entering the vac_analyze_option_name production. + EnterVac_analyze_option_name(c *Vac_analyze_option_nameContext) + + // EnterVac_analyze_option_arg is called when entering the vac_analyze_option_arg production. + EnterVac_analyze_option_arg(c *Vac_analyze_option_argContext) + + // EnterOpt_analyze is called when entering the opt_analyze production. + EnterOpt_analyze(c *Opt_analyzeContext) + + // EnterOpt_verbose is called when entering the opt_verbose production. + EnterOpt_verbose(c *Opt_verboseContext) + + // EnterOpt_full is called when entering the opt_full production. + EnterOpt_full(c *Opt_fullContext) + + // EnterOpt_freeze is called when entering the opt_freeze production. + EnterOpt_freeze(c *Opt_freezeContext) + + // EnterOpt_name_list is called when entering the opt_name_list production. + EnterOpt_name_list(c *Opt_name_listContext) + + // EnterVacuum_relation is called when entering the vacuum_relation production. + EnterVacuum_relation(c *Vacuum_relationContext) + + // EnterVacuum_relation_list is called when entering the vacuum_relation_list production. + EnterVacuum_relation_list(c *Vacuum_relation_listContext) + + // EnterOpt_vacuum_relation_list is called when entering the opt_vacuum_relation_list production. + EnterOpt_vacuum_relation_list(c *Opt_vacuum_relation_listContext) + + // EnterExplainstmt is called when entering the explainstmt production. + EnterExplainstmt(c *ExplainstmtContext) + + // EnterExplainablestmt is called when entering the explainablestmt production. + EnterExplainablestmt(c *ExplainablestmtContext) + + // EnterExplain_option_list is called when entering the explain_option_list production. + EnterExplain_option_list(c *Explain_option_listContext) + + // EnterExplain_option_elem is called when entering the explain_option_elem production. + EnterExplain_option_elem(c *Explain_option_elemContext) + + // EnterExplain_option_name is called when entering the explain_option_name production. + EnterExplain_option_name(c *Explain_option_nameContext) + + // EnterExplain_option_arg is called when entering the explain_option_arg production. + EnterExplain_option_arg(c *Explain_option_argContext) + + // EnterPreparestmt is called when entering the preparestmt production. + EnterPreparestmt(c *PreparestmtContext) + + // EnterPrep_type_clause is called when entering the prep_type_clause production. + EnterPrep_type_clause(c *Prep_type_clauseContext) + + // EnterPreparablestmt is called when entering the preparablestmt production. + EnterPreparablestmt(c *PreparablestmtContext) + + // EnterExecutestmt is called when entering the executestmt production. + EnterExecutestmt(c *ExecutestmtContext) + + // EnterExecute_param_clause is called when entering the execute_param_clause production. + EnterExecute_param_clause(c *Execute_param_clauseContext) + + // EnterDeallocatestmt is called when entering the deallocatestmt production. + EnterDeallocatestmt(c *DeallocatestmtContext) + + // EnterInsertstmt is called when entering the insertstmt production. + EnterInsertstmt(c *InsertstmtContext) + + // EnterInsert_target is called when entering the insert_target production. + EnterInsert_target(c *Insert_targetContext) + + // EnterInsert_rest is called when entering the insert_rest production. + EnterInsert_rest(c *Insert_restContext) + + // EnterOverride_kind is called when entering the override_kind production. + EnterOverride_kind(c *Override_kindContext) + + // EnterInsert_column_list is called when entering the insert_column_list production. + EnterInsert_column_list(c *Insert_column_listContext) + + // EnterInsert_column_item is called when entering the insert_column_item production. + EnterInsert_column_item(c *Insert_column_itemContext) + + // EnterOpt_on_conflict is called when entering the opt_on_conflict production. + EnterOpt_on_conflict(c *Opt_on_conflictContext) + + // EnterOpt_conf_expr is called when entering the opt_conf_expr production. + EnterOpt_conf_expr(c *Opt_conf_exprContext) + + // EnterReturning_clause is called when entering the returning_clause production. + EnterReturning_clause(c *Returning_clauseContext) + + // EnterMergestmt is called when entering the mergestmt production. + EnterMergestmt(c *MergestmtContext) + + // EnterMerge_when_clause is called when entering the merge_when_clause production. + EnterMerge_when_clause(c *Merge_when_clauseContext) + + // EnterMerge_insert_clause is called when entering the merge_insert_clause production. + EnterMerge_insert_clause(c *Merge_insert_clauseContext) + + // EnterMerge_update_clause is called when entering the merge_update_clause production. + EnterMerge_update_clause(c *Merge_update_clauseContext) + + // EnterMerge_delete_clause is called when entering the merge_delete_clause production. + EnterMerge_delete_clause(c *Merge_delete_clauseContext) + + // EnterDeletestmt is called when entering the deletestmt production. + EnterDeletestmt(c *DeletestmtContext) + + // EnterUsing_clause is called when entering the using_clause production. + EnterUsing_clause(c *Using_clauseContext) + + // EnterLockstmt is called when entering the lockstmt production. + EnterLockstmt(c *LockstmtContext) + + // EnterOpt_lock is called when entering the opt_lock production. + EnterOpt_lock(c *Opt_lockContext) + + // EnterLock_type is called when entering the lock_type production. + EnterLock_type(c *Lock_typeContext) + + // EnterOpt_nowait is called when entering the opt_nowait production. + EnterOpt_nowait(c *Opt_nowaitContext) + + // EnterOpt_nowait_or_skip is called when entering the opt_nowait_or_skip production. + EnterOpt_nowait_or_skip(c *Opt_nowait_or_skipContext) + + // EnterUpdatestmt is called when entering the updatestmt production. + EnterUpdatestmt(c *UpdatestmtContext) + + // EnterSet_clause_list is called when entering the set_clause_list production. + EnterSet_clause_list(c *Set_clause_listContext) + + // EnterSet_clause is called when entering the set_clause production. + EnterSet_clause(c *Set_clauseContext) + + // EnterSet_target is called when entering the set_target production. + EnterSet_target(c *Set_targetContext) + + // EnterSet_target_list is called when entering the set_target_list production. + EnterSet_target_list(c *Set_target_listContext) + + // EnterDeclarecursorstmt is called when entering the declarecursorstmt production. + EnterDeclarecursorstmt(c *DeclarecursorstmtContext) + + // EnterCursor_name is called when entering the cursor_name production. + EnterCursor_name(c *Cursor_nameContext) + + // EnterCursor_options is called when entering the cursor_options production. + EnterCursor_options(c *Cursor_optionsContext) + + // EnterOpt_hold is called when entering the opt_hold production. + EnterOpt_hold(c *Opt_holdContext) + + // EnterSelectstmt is called when entering the selectstmt production. + EnterSelectstmt(c *SelectstmtContext) + + // EnterSelect_with_parens is called when entering the select_with_parens production. + EnterSelect_with_parens(c *Select_with_parensContext) + + // EnterSelect_no_parens is called when entering the select_no_parens production. + EnterSelect_no_parens(c *Select_no_parensContext) + + // EnterSelect_clause is called when entering the select_clause production. + EnterSelect_clause(c *Select_clauseContext) + + // EnterSimple_select_intersect is called when entering the simple_select_intersect production. + EnterSimple_select_intersect(c *Simple_select_intersectContext) + + // EnterSimple_select_pramary is called when entering the simple_select_pramary production. + EnterSimple_select_pramary(c *Simple_select_pramaryContext) + + // EnterExclude_clause is called when entering the exclude_clause production. + EnterExclude_clause(c *Exclude_clauseContext) + + // EnterQualify_clause is called when entering the qualify_clause production. + EnterQualify_clause(c *Qualify_clauseContext) + + // EnterStart_with_clause is called when entering the start_with_clause production. + EnterStart_with_clause(c *Start_with_clauseContext) + + // EnterWith_clause is called when entering the with_clause production. + EnterWith_clause(c *With_clauseContext) + + // EnterCte_list is called when entering the cte_list production. + EnterCte_list(c *Cte_listContext) + + // EnterCommon_table_expr is called when entering the common_table_expr production. + EnterCommon_table_expr(c *Common_table_exprContext) + + // EnterOpt_materialized is called when entering the opt_materialized production. + EnterOpt_materialized(c *Opt_materializedContext) + + // EnterOpt_with_clause is called when entering the opt_with_clause production. + EnterOpt_with_clause(c *Opt_with_clauseContext) + + // EnterInto_clause is called when entering the into_clause production. + EnterInto_clause(c *Into_clauseContext) + + // EnterOpt_top_clause is called when entering the opt_top_clause production. + EnterOpt_top_clause(c *Opt_top_clauseContext) + + // EnterOpt_strict is called when entering the opt_strict production. + EnterOpt_strict(c *Opt_strictContext) + + // EnterOpttempTableName is called when entering the opttempTableName production. + EnterOpttempTableName(c *OpttempTableNameContext) + + // EnterOpt_table is called when entering the opt_table production. + EnterOpt_table(c *Opt_tableContext) + + // EnterAll_or_distinct is called when entering the all_or_distinct production. + EnterAll_or_distinct(c *All_or_distinctContext) + + // EnterDistinct_clause is called when entering the distinct_clause production. + EnterDistinct_clause(c *Distinct_clauseContext) + + // EnterOpt_all_clause is called when entering the opt_all_clause production. + EnterOpt_all_clause(c *Opt_all_clauseContext) + + // EnterOpt_sort_clause is called when entering the opt_sort_clause production. + EnterOpt_sort_clause(c *Opt_sort_clauseContext) + + // EnterSort_clause is called when entering the sort_clause production. + EnterSort_clause(c *Sort_clauseContext) + + // EnterSortby_list is called when entering the sortby_list production. + EnterSortby_list(c *Sortby_listContext) + + // EnterSortby is called when entering the sortby production. + EnterSortby(c *SortbyContext) + + // EnterSelect_limit is called when entering the select_limit production. + EnterSelect_limit(c *Select_limitContext) + + // EnterOpt_select_limit is called when entering the opt_select_limit production. + EnterOpt_select_limit(c *Opt_select_limitContext) + + // EnterLimit_clause is called when entering the limit_clause production. + EnterLimit_clause(c *Limit_clauseContext) + + // EnterOffset_clause is called when entering the offset_clause production. + EnterOffset_clause(c *Offset_clauseContext) + + // EnterSelect_limit_value is called when entering the select_limit_value production. + EnterSelect_limit_value(c *Select_limit_valueContext) + + // EnterSelect_offset_value is called when entering the select_offset_value production. + EnterSelect_offset_value(c *Select_offset_valueContext) + + // EnterSelect_fetch_first_value is called when entering the select_fetch_first_value production. + EnterSelect_fetch_first_value(c *Select_fetch_first_valueContext) + + // EnterI_or_f_const is called when entering the i_or_f_const production. + EnterI_or_f_const(c *I_or_f_constContext) + + // EnterRow_or_rows is called when entering the row_or_rows production. + EnterRow_or_rows(c *Row_or_rowsContext) + + // EnterFirst_or_next is called when entering the first_or_next production. + EnterFirst_or_next(c *First_or_nextContext) + + // EnterGroup_clause is called when entering the group_clause production. + EnterGroup_clause(c *Group_clauseContext) + + // EnterGroup_by_list is called when entering the group_by_list production. + EnterGroup_by_list(c *Group_by_listContext) + + // EnterGroup_by_item is called when entering the group_by_item production. + EnterGroup_by_item(c *Group_by_itemContext) + + // EnterEmpty_grouping_set is called when entering the empty_grouping_set production. + EnterEmpty_grouping_set(c *Empty_grouping_setContext) + + // EnterRollup_clause is called when entering the rollup_clause production. + EnterRollup_clause(c *Rollup_clauseContext) + + // EnterCube_clause is called when entering the cube_clause production. + EnterCube_clause(c *Cube_clauseContext) + + // EnterGrouping_sets_clause is called when entering the grouping_sets_clause production. + EnterGrouping_sets_clause(c *Grouping_sets_clauseContext) + + // EnterHaving_clause is called when entering the having_clause production. + EnterHaving_clause(c *Having_clauseContext) + + // EnterFor_locking_clause is called when entering the for_locking_clause production. + EnterFor_locking_clause(c *For_locking_clauseContext) + + // EnterOpt_for_locking_clause is called when entering the opt_for_locking_clause production. + EnterOpt_for_locking_clause(c *Opt_for_locking_clauseContext) + + // EnterFor_locking_items is called when entering the for_locking_items production. + EnterFor_locking_items(c *For_locking_itemsContext) + + // EnterFor_locking_item is called when entering the for_locking_item production. + EnterFor_locking_item(c *For_locking_itemContext) + + // EnterFor_locking_strength is called when entering the for_locking_strength production. + EnterFor_locking_strength(c *For_locking_strengthContext) + + // EnterLocked_rels_list is called when entering the locked_rels_list production. + EnterLocked_rels_list(c *Locked_rels_listContext) + + // EnterValues_clause is called when entering the values_clause production. + EnterValues_clause(c *Values_clauseContext) + + // EnterFrom_clause is called when entering the from_clause production. + EnterFrom_clause(c *From_clauseContext) + + // EnterFrom_list is called when entering the from_list production. + EnterFrom_list(c *From_listContext) + + // EnterTable_ref is called when entering the table_ref production. + EnterTable_ref(c *Table_refContext) + + // EnterJoined_table is called when entering the joined_table production. + EnterJoined_table(c *Joined_tableContext) + + // EnterAlias_clause is called when entering the alias_clause production. + EnterAlias_clause(c *Alias_clauseContext) + + // EnterOpt_alias_clause is called when entering the opt_alias_clause production. + EnterOpt_alias_clause(c *Opt_alias_clauseContext) + + // EnterTable_alias_clause is called when entering the table_alias_clause production. + EnterTable_alias_clause(c *Table_alias_clauseContext) + + // EnterFunc_alias_clause is called when entering the func_alias_clause production. + EnterFunc_alias_clause(c *Func_alias_clauseContext) + + // EnterJoin_type is called when entering the join_type production. + EnterJoin_type(c *Join_typeContext) + + // EnterJoin_qual is called when entering the join_qual production. + EnterJoin_qual(c *Join_qualContext) + + // EnterRelation_expr is called when entering the relation_expr production. + EnterRelation_expr(c *Relation_exprContext) + + // EnterRelation_expr_list is called when entering the relation_expr_list production. + EnterRelation_expr_list(c *Relation_expr_listContext) + + // EnterRelation_expr_opt_alias is called when entering the relation_expr_opt_alias production. + EnterRelation_expr_opt_alias(c *Relation_expr_opt_aliasContext) + + // EnterTablesample_clause is called when entering the tablesample_clause production. + EnterTablesample_clause(c *Tablesample_clauseContext) + + // EnterOpt_repeatable_clause is called when entering the opt_repeatable_clause production. + EnterOpt_repeatable_clause(c *Opt_repeatable_clauseContext) + + // EnterFunc_table is called when entering the func_table production. + EnterFunc_table(c *Func_tableContext) + + // EnterRowsfrom_item is called when entering the rowsfrom_item production. + EnterRowsfrom_item(c *Rowsfrom_itemContext) + + // EnterRowsfrom_list is called when entering the rowsfrom_list production. + EnterRowsfrom_list(c *Rowsfrom_listContext) + + // EnterOpt_col_def_list is called when entering the opt_col_def_list production. + EnterOpt_col_def_list(c *Opt_col_def_listContext) + + // EnterOpt_ordinality is called when entering the opt_ordinality production. + EnterOpt_ordinality(c *Opt_ordinalityContext) + + // EnterWhere_clause is called when entering the where_clause production. + EnterWhere_clause(c *Where_clauseContext) + + // EnterWhere_or_current_clause is called when entering the where_or_current_clause production. + EnterWhere_or_current_clause(c *Where_or_current_clauseContext) + + // EnterOpttablefuncelementlist is called when entering the opttablefuncelementlist production. + EnterOpttablefuncelementlist(c *OpttablefuncelementlistContext) + + // EnterTablefuncelementlist is called when entering the tablefuncelementlist production. + EnterTablefuncelementlist(c *TablefuncelementlistContext) + + // EnterTablefuncelement is called when entering the tablefuncelement production. + EnterTablefuncelement(c *TablefuncelementContext) + + // EnterXmltable is called when entering the xmltable production. + EnterXmltable(c *XmltableContext) + + // EnterXmltable_column_list is called when entering the xmltable_column_list production. + EnterXmltable_column_list(c *Xmltable_column_listContext) + + // EnterXmltable_column_el is called when entering the xmltable_column_el production. + EnterXmltable_column_el(c *Xmltable_column_elContext) + + // EnterXmltable_column_option_list is called when entering the xmltable_column_option_list production. + EnterXmltable_column_option_list(c *Xmltable_column_option_listContext) + + // EnterXmltable_column_option_el is called when entering the xmltable_column_option_el production. + EnterXmltable_column_option_el(c *Xmltable_column_option_elContext) + + // EnterXml_namespace_list is called when entering the xml_namespace_list production. + EnterXml_namespace_list(c *Xml_namespace_listContext) + + // EnterXml_namespace_el is called when entering the xml_namespace_el production. + EnterXml_namespace_el(c *Xml_namespace_elContext) + + // EnterTypename is called when entering the typename production. + EnterTypename(c *TypenameContext) + + // EnterOpt_array_bounds is called when entering the opt_array_bounds production. + EnterOpt_array_bounds(c *Opt_array_boundsContext) + + // EnterSimpletypename is called when entering the simpletypename production. + EnterSimpletypename(c *SimpletypenameContext) + + // EnterVarbyte is called when entering the varbyte production. + EnterVarbyte(c *VarbyteContext) + + // EnterJson_type is called when entering the json_type production. + EnterJson_type(c *Json_typeContext) + + // EnterConsttypename is called when entering the consttypename production. + EnterConsttypename(c *ConsttypenameContext) + + // EnterGenerictype is called when entering the generictype production. + EnterGenerictype(c *GenerictypeContext) + + // EnterOpt_type_modifiers is called when entering the opt_type_modifiers production. + EnterOpt_type_modifiers(c *Opt_type_modifiersContext) + + // EnterNumeric is called when entering the numeric production. + EnterNumeric(c *NumericContext) + + // EnterOpt_float is called when entering the opt_float production. + EnterOpt_float(c *Opt_floatContext) + + // EnterBit is called when entering the bit production. + EnterBit(c *BitContext) + + // EnterConstbit is called when entering the constbit production. + EnterConstbit(c *ConstbitContext) + + // EnterBitwithlength is called when entering the bitwithlength production. + EnterBitwithlength(c *BitwithlengthContext) + + // EnterBitwithoutlength is called when entering the bitwithoutlength production. + EnterBitwithoutlength(c *BitwithoutlengthContext) + + // EnterCharacter is called when entering the character production. + EnterCharacter(c *CharacterContext) + + // EnterConstcharacter is called when entering the constcharacter production. + EnterConstcharacter(c *ConstcharacterContext) + + // EnterCharacter_c is called when entering the character_c production. + EnterCharacter_c(c *Character_cContext) + + // EnterOpt_varying is called when entering the opt_varying production. + EnterOpt_varying(c *Opt_varyingContext) + + // EnterConstdatetime is called when entering the constdatetime production. + EnterConstdatetime(c *ConstdatetimeContext) + + // EnterConstinterval is called when entering the constinterval production. + EnterConstinterval(c *ConstintervalContext) + + // EnterOpt_timezone is called when entering the opt_timezone production. + EnterOpt_timezone(c *Opt_timezoneContext) + + // EnterOpt_interval is called when entering the opt_interval production. + EnterOpt_interval(c *Opt_intervalContext) + + // EnterInterval_second is called when entering the interval_second production. + EnterInterval_second(c *Interval_secondContext) + + // EnterOpt_escape is called when entering the opt_escape production. + EnterOpt_escape(c *Opt_escapeContext) + + // EnterA_expr is called when entering the a_expr production. + EnterA_expr(c *A_exprContext) + + // EnterA_expr_qual is called when entering the a_expr_qual production. + EnterA_expr_qual(c *A_expr_qualContext) + + // EnterA_expr_lessless is called when entering the a_expr_lessless production. + EnterA_expr_lessless(c *A_expr_lesslessContext) + + // EnterA_expr_or is called when entering the a_expr_or production. + EnterA_expr_or(c *A_expr_orContext) + + // EnterA_expr_and is called when entering the a_expr_and production. + EnterA_expr_and(c *A_expr_andContext) + + // EnterA_expr_between is called when entering the a_expr_between production. + EnterA_expr_between(c *A_expr_betweenContext) + + // EnterA_expr_in is called when entering the a_expr_in production. + EnterA_expr_in(c *A_expr_inContext) + + // EnterA_expr_unary_not is called when entering the a_expr_unary_not production. + EnterA_expr_unary_not(c *A_expr_unary_notContext) + + // EnterA_expr_isnull is called when entering the a_expr_isnull production. + EnterA_expr_isnull(c *A_expr_isnullContext) + + // EnterA_expr_is_not is called when entering the a_expr_is_not production. + EnterA_expr_is_not(c *A_expr_is_notContext) + + // EnterA_expr_compare is called when entering the a_expr_compare production. + EnterA_expr_compare(c *A_expr_compareContext) + + // EnterA_expr_prior_or_level is called when entering the a_expr_prior_or_level production. + EnterA_expr_prior_or_level(c *A_expr_prior_or_levelContext) + + // EnterA_expr_like is called when entering the a_expr_like production. + EnterA_expr_like(c *A_expr_likeContext) + + // EnterA_expr_qual_op is called when entering the a_expr_qual_op production. + EnterA_expr_qual_op(c *A_expr_qual_opContext) + + // EnterA_expr_unary_qualop is called when entering the a_expr_unary_qualop production. + EnterA_expr_unary_qualop(c *A_expr_unary_qualopContext) + + // EnterA_expr_add is called when entering the a_expr_add production. + EnterA_expr_add(c *A_expr_addContext) + + // EnterA_expr_mul is called when entering the a_expr_mul production. + EnterA_expr_mul(c *A_expr_mulContext) + + // EnterA_expr_caret is called when entering the a_expr_caret production. + EnterA_expr_caret(c *A_expr_caretContext) + + // EnterA_expr_unary_sign is called when entering the a_expr_unary_sign production. + EnterA_expr_unary_sign(c *A_expr_unary_signContext) + + // EnterA_expr_at_time_zone is called when entering the a_expr_at_time_zone production. + EnterA_expr_at_time_zone(c *A_expr_at_time_zoneContext) + + // EnterA_expr_collate is called when entering the a_expr_collate production. + EnterA_expr_collate(c *A_expr_collateContext) + + // EnterA_expr_typecast is called when entering the a_expr_typecast production. + EnterA_expr_typecast(c *A_expr_typecastContext) + + // EnterB_expr is called when entering the b_expr production. + EnterB_expr(c *B_exprContext) + + // EnterC_expr_exists is called when entering the c_expr_exists production. + EnterC_expr_exists(c *C_expr_existsContext) + + // EnterC_expr_expr is called when entering the c_expr_expr production. + EnterC_expr_expr(c *C_expr_exprContext) + + // EnterC_expr_case is called when entering the c_expr_case production. + EnterC_expr_case(c *C_expr_caseContext) + + // EnterPlsqlvariablename is called when entering the plsqlvariablename production. + EnterPlsqlvariablename(c *PlsqlvariablenameContext) + + // EnterFunc_application is called when entering the func_application production. + EnterFunc_application(c *Func_applicationContext) + + // EnterFunc_expr is called when entering the func_expr production. + EnterFunc_expr(c *Func_exprContext) + + // EnterFunc_expr_windowless is called when entering the func_expr_windowless production. + EnterFunc_expr_windowless(c *Func_expr_windowlessContext) + + // EnterFunc_expr_common_subexpr is called when entering the func_expr_common_subexpr production. + EnterFunc_expr_common_subexpr(c *Func_expr_common_subexprContext) + + // EnterXml_root_version is called when entering the xml_root_version production. + EnterXml_root_version(c *Xml_root_versionContext) + + // EnterOpt_xml_root_standalone is called when entering the opt_xml_root_standalone production. + EnterOpt_xml_root_standalone(c *Opt_xml_root_standaloneContext) + + // EnterXml_attributes is called when entering the xml_attributes production. + EnterXml_attributes(c *Xml_attributesContext) + + // EnterXml_attribute_list is called when entering the xml_attribute_list production. + EnterXml_attribute_list(c *Xml_attribute_listContext) + + // EnterXml_attribute_el is called when entering the xml_attribute_el production. + EnterXml_attribute_el(c *Xml_attribute_elContext) + + // EnterDocument_or_content is called when entering the document_or_content production. + EnterDocument_or_content(c *Document_or_contentContext) + + // EnterXml_whitespace_option is called when entering the xml_whitespace_option production. + EnterXml_whitespace_option(c *Xml_whitespace_optionContext) + + // EnterXmlexists_argument is called when entering the xmlexists_argument production. + EnterXmlexists_argument(c *Xmlexists_argumentContext) + + // EnterXml_passing_mech is called when entering the xml_passing_mech production. + EnterXml_passing_mech(c *Xml_passing_mechContext) + + // EnterWithin_group_clause is called when entering the within_group_clause production. + EnterWithin_group_clause(c *Within_group_clauseContext) + + // EnterFilter_clause is called when entering the filter_clause production. + EnterFilter_clause(c *Filter_clauseContext) + + // EnterWindow_clause is called when entering the window_clause production. + EnterWindow_clause(c *Window_clauseContext) + + // EnterWindow_definition_list is called when entering the window_definition_list production. + EnterWindow_definition_list(c *Window_definition_listContext) + + // EnterWindow_definition is called when entering the window_definition production. + EnterWindow_definition(c *Window_definitionContext) + + // EnterOver_clause is called when entering the over_clause production. + EnterOver_clause(c *Over_clauseContext) + + // EnterWindow_specification is called when entering the window_specification production. + EnterWindow_specification(c *Window_specificationContext) + + // EnterOpt_existing_window_name is called when entering the opt_existing_window_name production. + EnterOpt_existing_window_name(c *Opt_existing_window_nameContext) + + // EnterOpt_partition_clause is called when entering the opt_partition_clause production. + EnterOpt_partition_clause(c *Opt_partition_clauseContext) + + // EnterOpt_frame_clause is called when entering the opt_frame_clause production. + EnterOpt_frame_clause(c *Opt_frame_clauseContext) + + // EnterFrame_extent is called when entering the frame_extent production. + EnterFrame_extent(c *Frame_extentContext) + + // EnterFrame_bound is called when entering the frame_bound production. + EnterFrame_bound(c *Frame_boundContext) + + // EnterOpt_window_exclusion_clause is called when entering the opt_window_exclusion_clause production. + EnterOpt_window_exclusion_clause(c *Opt_window_exclusion_clauseContext) + + // EnterRow is called when entering the row production. + EnterRow(c *RowContext) + + // EnterExplicit_row is called when entering the explicit_row production. + EnterExplicit_row(c *Explicit_rowContext) + + // EnterImplicit_row is called when entering the implicit_row production. + EnterImplicit_row(c *Implicit_rowContext) + + // EnterSub_type is called when entering the sub_type production. + EnterSub_type(c *Sub_typeContext) + + // EnterAll_op is called when entering the all_op production. + EnterAll_op(c *All_opContext) + + // EnterMathop is called when entering the mathop production. + EnterMathop(c *MathopContext) + + // EnterQual_op is called when entering the qual_op production. + EnterQual_op(c *Qual_opContext) + + // EnterQual_all_op is called when entering the qual_all_op production. + EnterQual_all_op(c *Qual_all_opContext) + + // EnterSubquery_Op is called when entering the subquery_Op production. + EnterSubquery_Op(c *Subquery_OpContext) + + // EnterExpr_list is called when entering the expr_list production. + EnterExpr_list(c *Expr_listContext) + + // EnterFunc_arg_list is called when entering the func_arg_list production. + EnterFunc_arg_list(c *Func_arg_listContext) + + // EnterFunc_arg_expr is called when entering the func_arg_expr production. + EnterFunc_arg_expr(c *Func_arg_exprContext) + + // EnterType_list is called when entering the type_list production. + EnterType_list(c *Type_listContext) + + // EnterArray_expr is called when entering the array_expr production. + EnterArray_expr(c *Array_exprContext) + + // EnterArray_expr_list is called when entering the array_expr_list production. + EnterArray_expr_list(c *Array_expr_listContext) + + // EnterExtract_list is called when entering the extract_list production. + EnterExtract_list(c *Extract_listContext) + + // EnterExtract_arg is called when entering the extract_arg production. + EnterExtract_arg(c *Extract_argContext) + + // EnterUnicode_normal_form is called when entering the unicode_normal_form production. + EnterUnicode_normal_form(c *Unicode_normal_formContext) + + // EnterOverlay_list is called when entering the overlay_list production. + EnterOverlay_list(c *Overlay_listContext) + + // EnterPosition_list is called when entering the position_list production. + EnterPosition_list(c *Position_listContext) + + // EnterSubstr_list is called when entering the substr_list production. + EnterSubstr_list(c *Substr_listContext) + + // EnterTrim_list is called when entering the trim_list production. + EnterTrim_list(c *Trim_listContext) + + // EnterIn_expr_select is called when entering the in_expr_select production. + EnterIn_expr_select(c *In_expr_selectContext) + + // EnterIn_expr_list is called when entering the in_expr_list production. + EnterIn_expr_list(c *In_expr_listContext) + + // EnterCase_expr is called when entering the case_expr production. + EnterCase_expr(c *Case_exprContext) + + // EnterWhen_clause_list is called when entering the when_clause_list production. + EnterWhen_clause_list(c *When_clause_listContext) + + // EnterWhen_clause is called when entering the when_clause production. + EnterWhen_clause(c *When_clauseContext) + + // EnterCase_default is called when entering the case_default production. + EnterCase_default(c *Case_defaultContext) + + // EnterCase_arg is called when entering the case_arg production. + EnterCase_arg(c *Case_argContext) + + // EnterColumnref is called when entering the columnref production. + EnterColumnref(c *ColumnrefContext) + + // EnterIndirection_el is called when entering the indirection_el production. + EnterIndirection_el(c *Indirection_elContext) + + // EnterOpt_slice_bound is called when entering the opt_slice_bound production. + EnterOpt_slice_bound(c *Opt_slice_boundContext) + + // EnterIndirection is called when entering the indirection production. + EnterIndirection(c *IndirectionContext) + + // EnterOpt_indirection is called when entering the opt_indirection production. + EnterOpt_indirection(c *Opt_indirectionContext) + + // EnterOpt_target_list is called when entering the opt_target_list production. + EnterOpt_target_list(c *Opt_target_listContext) + + // EnterTarget_list is called when entering the target_list production. + EnterTarget_list(c *Target_listContext) + + // EnterTarget_label is called when entering the target_label production. + EnterTarget_label(c *Target_labelContext) + + // EnterTarget_star is called when entering the target_star production. + EnterTarget_star(c *Target_starContext) + + // EnterTarget_alias is called when entering the target_alias production. + EnterTarget_alias(c *Target_aliasContext) + + // EnterQualified_name_list is called when entering the qualified_name_list production. + EnterQualified_name_list(c *Qualified_name_listContext) + + // EnterQualified_name is called when entering the qualified_name production. + EnterQualified_name(c *Qualified_nameContext) + + // EnterName_list is called when entering the name_list production. + EnterName_list(c *Name_listContext) + + // EnterName is called when entering the name production. + EnterName(c *NameContext) + + // EnterAttr_name is called when entering the attr_name production. + EnterAttr_name(c *Attr_nameContext) + + // EnterFile_name is called when entering the file_name production. + EnterFile_name(c *File_nameContext) + + // EnterFunc_name is called when entering the func_name production. + EnterFunc_name(c *Func_nameContext) + + // EnterAexprconst is called when entering the aexprconst production. + EnterAexprconst(c *AexprconstContext) + + // EnterXconst is called when entering the xconst production. + EnterXconst(c *XconstContext) + + // EnterBconst is called when entering the bconst production. + EnterBconst(c *BconstContext) + + // EnterFconst is called when entering the fconst production. + EnterFconst(c *FconstContext) + + // EnterIconst is called when entering the iconst production. + EnterIconst(c *IconstContext) + + // EnterSconst is called when entering the sconst production. + EnterSconst(c *SconstContext) + + // EnterAnysconst is called when entering the anysconst production. + EnterAnysconst(c *AnysconstContext) + + // EnterOpt_uescape is called when entering the opt_uescape production. + EnterOpt_uescape(c *Opt_uescapeContext) + + // EnterSignediconst is called when entering the signediconst production. + EnterSignediconst(c *SignediconstContext) + + // EnterRoleid is called when entering the roleid production. + EnterRoleid(c *RoleidContext) + + // EnterRolespec is called when entering the rolespec production. + EnterRolespec(c *RolespecContext) + + // EnterRole_list is called when entering the role_list production. + EnterRole_list(c *Role_listContext) + + // EnterColid is called when entering the colid production. + EnterColid(c *ColidContext) + + // EnterTable_alias is called when entering the table_alias production. + EnterTable_alias(c *Table_aliasContext) + + // EnterType_function_name is called when entering the type_function_name production. + EnterType_function_name(c *Type_function_nameContext) + + // EnterNonreservedword is called when entering the nonreservedword production. + EnterNonreservedword(c *NonreservedwordContext) + + // EnterCollabel is called when entering the collabel production. + EnterCollabel(c *CollabelContext) + + // EnterIdentifier is called when entering the identifier production. + EnterIdentifier(c *IdentifierContext) + + // EnterPlsqlidentifier is called when entering the plsqlidentifier production. + EnterPlsqlidentifier(c *PlsqlidentifierContext) + + // EnterUnreserved_keyword is called when entering the unreserved_keyword production. + EnterUnreserved_keyword(c *Unreserved_keywordContext) + + // EnterCol_name_keyword is called when entering the col_name_keyword production. + EnterCol_name_keyword(c *Col_name_keywordContext) + + // EnterType_func_name_keyword is called when entering the type_func_name_keyword production. + EnterType_func_name_keyword(c *Type_func_name_keywordContext) + + // EnterReserved_keyword is called when entering the reserved_keyword production. + EnterReserved_keyword(c *Reserved_keywordContext) + + // EnterBuiltin_function_name is called when entering the builtin_function_name production. + EnterBuiltin_function_name(c *Builtin_function_nameContext) + + // EnterPl_function is called when entering the pl_function production. + EnterPl_function(c *Pl_functionContext) + + // EnterComp_options is called when entering the comp_options production. + EnterComp_options(c *Comp_optionsContext) + + // EnterComp_option is called when entering the comp_option production. + EnterComp_option(c *Comp_optionContext) + + // EnterSharp is called when entering the sharp production. + EnterSharp(c *SharpContext) + + // EnterOption_value is called when entering the option_value production. + EnterOption_value(c *Option_valueContext) + + // EnterOpt_semi is called when entering the opt_semi production. + EnterOpt_semi(c *Opt_semiContext) + + // EnterPl_block is called when entering the pl_block production. + EnterPl_block(c *Pl_blockContext) + + // EnterDecl_sect is called when entering the decl_sect production. + EnterDecl_sect(c *Decl_sectContext) + + // EnterDecl_start is called when entering the decl_start production. + EnterDecl_start(c *Decl_startContext) + + // EnterDecl_stmts is called when entering the decl_stmts production. + EnterDecl_stmts(c *Decl_stmtsContext) + + // EnterLabel_decl is called when entering the label_decl production. + EnterLabel_decl(c *Label_declContext) + + // EnterDecl_stmt is called when entering the decl_stmt production. + EnterDecl_stmt(c *Decl_stmtContext) + + // EnterDecl_statement is called when entering the decl_statement production. + EnterDecl_statement(c *Decl_statementContext) + + // EnterOpt_scrollable is called when entering the opt_scrollable production. + EnterOpt_scrollable(c *Opt_scrollableContext) + + // EnterDecl_cursor_query is called when entering the decl_cursor_query production. + EnterDecl_cursor_query(c *Decl_cursor_queryContext) + + // EnterDecl_cursor_args is called when entering the decl_cursor_args production. + EnterDecl_cursor_args(c *Decl_cursor_argsContext) + + // EnterDecl_cursor_arglist is called when entering the decl_cursor_arglist production. + EnterDecl_cursor_arglist(c *Decl_cursor_arglistContext) + + // EnterDecl_cursor_arg is called when entering the decl_cursor_arg production. + EnterDecl_cursor_arg(c *Decl_cursor_argContext) + + // EnterDecl_is_for is called when entering the decl_is_for production. + EnterDecl_is_for(c *Decl_is_forContext) + + // EnterDecl_aliasitem is called when entering the decl_aliasitem production. + EnterDecl_aliasitem(c *Decl_aliasitemContext) + + // EnterDecl_varname is called when entering the decl_varname production. + EnterDecl_varname(c *Decl_varnameContext) + + // EnterDecl_const is called when entering the decl_const production. + EnterDecl_const(c *Decl_constContext) + + // EnterDecl_datatype is called when entering the decl_datatype production. + EnterDecl_datatype(c *Decl_datatypeContext) + + // EnterDecl_collate is called when entering the decl_collate production. + EnterDecl_collate(c *Decl_collateContext) + + // EnterDecl_notnull is called when entering the decl_notnull production. + EnterDecl_notnull(c *Decl_notnullContext) + + // EnterDecl_defval is called when entering the decl_defval production. + EnterDecl_defval(c *Decl_defvalContext) + + // EnterDecl_defkey is called when entering the decl_defkey production. + EnterDecl_defkey(c *Decl_defkeyContext) + + // EnterAssign_operator is called when entering the assign_operator production. + EnterAssign_operator(c *Assign_operatorContext) + + // EnterProc_sect is called when entering the proc_sect production. + EnterProc_sect(c *Proc_sectContext) + + // EnterProc_stmt is called when entering the proc_stmt production. + EnterProc_stmt(c *Proc_stmtContext) + + // EnterStmt_perform is called when entering the stmt_perform production. + EnterStmt_perform(c *Stmt_performContext) + + // EnterStmt_call is called when entering the stmt_call production. + EnterStmt_call(c *Stmt_callContext) + + // EnterOpt_expr_list is called when entering the opt_expr_list production. + EnterOpt_expr_list(c *Opt_expr_listContext) + + // EnterStmt_assign is called when entering the stmt_assign production. + EnterStmt_assign(c *Stmt_assignContext) + + // EnterStmt_getdiag is called when entering the stmt_getdiag production. + EnterStmt_getdiag(c *Stmt_getdiagContext) + + // EnterGetdiag_area_opt is called when entering the getdiag_area_opt production. + EnterGetdiag_area_opt(c *Getdiag_area_optContext) + + // EnterGetdiag_list is called when entering the getdiag_list production. + EnterGetdiag_list(c *Getdiag_listContext) + + // EnterGetdiag_list_item is called when entering the getdiag_list_item production. + EnterGetdiag_list_item(c *Getdiag_list_itemContext) + + // EnterGetdiag_item is called when entering the getdiag_item production. + EnterGetdiag_item(c *Getdiag_itemContext) + + // EnterGetdiag_target is called when entering the getdiag_target production. + EnterGetdiag_target(c *Getdiag_targetContext) + + // EnterAssign_var is called when entering the assign_var production. + EnterAssign_var(c *Assign_varContext) + + // EnterStmt_if is called when entering the stmt_if production. + EnterStmt_if(c *Stmt_ifContext) + + // EnterStmt_elsifs is called when entering the stmt_elsifs production. + EnterStmt_elsifs(c *Stmt_elsifsContext) + + // EnterStmt_else is called when entering the stmt_else production. + EnterStmt_else(c *Stmt_elseContext) + + // EnterStmt_case is called when entering the stmt_case production. + EnterStmt_case(c *Stmt_caseContext) + + // EnterOpt_expr_until_when is called when entering the opt_expr_until_when production. + EnterOpt_expr_until_when(c *Opt_expr_until_whenContext) + + // EnterCase_when_list is called when entering the case_when_list production. + EnterCase_when_list(c *Case_when_listContext) + + // EnterCase_when is called when entering the case_when production. + EnterCase_when(c *Case_whenContext) + + // EnterOpt_case_else is called when entering the opt_case_else production. + EnterOpt_case_else(c *Opt_case_elseContext) + + // EnterStmt_loop is called when entering the stmt_loop production. + EnterStmt_loop(c *Stmt_loopContext) + + // EnterStmt_while is called when entering the stmt_while production. + EnterStmt_while(c *Stmt_whileContext) + + // EnterStmt_for is called when entering the stmt_for production. + EnterStmt_for(c *Stmt_forContext) + + // EnterFor_control is called when entering the for_control production. + EnterFor_control(c *For_controlContext) + + // EnterOpt_for_using_expression is called when entering the opt_for_using_expression production. + EnterOpt_for_using_expression(c *Opt_for_using_expressionContext) + + // EnterOpt_cursor_parameters is called when entering the opt_cursor_parameters production. + EnterOpt_cursor_parameters(c *Opt_cursor_parametersContext) + + // EnterOpt_reverse is called when entering the opt_reverse production. + EnterOpt_reverse(c *Opt_reverseContext) + + // EnterOpt_by_expression is called when entering the opt_by_expression production. + EnterOpt_by_expression(c *Opt_by_expressionContext) + + // EnterFor_variable is called when entering the for_variable production. + EnterFor_variable(c *For_variableContext) + + // EnterStmt_foreach_a is called when entering the stmt_foreach_a production. + EnterStmt_foreach_a(c *Stmt_foreach_aContext) + + // EnterForeach_slice is called when entering the foreach_slice production. + EnterForeach_slice(c *Foreach_sliceContext) + + // EnterStmt_exit is called when entering the stmt_exit production. + EnterStmt_exit(c *Stmt_exitContext) + + // EnterExit_type is called when entering the exit_type production. + EnterExit_type(c *Exit_typeContext) + + // EnterStmt_return is called when entering the stmt_return production. + EnterStmt_return(c *Stmt_returnContext) + + // EnterOpt_return_result is called when entering the opt_return_result production. + EnterOpt_return_result(c *Opt_return_resultContext) + + // EnterStmt_raise is called when entering the stmt_raise production. + EnterStmt_raise(c *Stmt_raiseContext) + + // EnterOpt_stmt_raise_level is called when entering the opt_stmt_raise_level production. + EnterOpt_stmt_raise_level(c *Opt_stmt_raise_levelContext) + + // EnterOpt_raise_list is called when entering the opt_raise_list production. + EnterOpt_raise_list(c *Opt_raise_listContext) + + // EnterOpt_raise_using is called when entering the opt_raise_using production. + EnterOpt_raise_using(c *Opt_raise_usingContext) + + // EnterOpt_raise_using_elem is called when entering the opt_raise_using_elem production. + EnterOpt_raise_using_elem(c *Opt_raise_using_elemContext) + + // EnterOpt_raise_using_elem_list is called when entering the opt_raise_using_elem_list production. + EnterOpt_raise_using_elem_list(c *Opt_raise_using_elem_listContext) + + // EnterStmt_assert is called when entering the stmt_assert production. + EnterStmt_assert(c *Stmt_assertContext) + + // EnterOpt_stmt_assert_message is called when entering the opt_stmt_assert_message production. + EnterOpt_stmt_assert_message(c *Opt_stmt_assert_messageContext) + + // EnterLoop_body is called when entering the loop_body production. + EnterLoop_body(c *Loop_bodyContext) + + // EnterStmt_execsql is called when entering the stmt_execsql production. + EnterStmt_execsql(c *Stmt_execsqlContext) + + // EnterStmt_dynexecute is called when entering the stmt_dynexecute production. + EnterStmt_dynexecute(c *Stmt_dynexecuteContext) + + // EnterOpt_execute_using is called when entering the opt_execute_using production. + EnterOpt_execute_using(c *Opt_execute_usingContext) + + // EnterOpt_execute_using_list is called when entering the opt_execute_using_list production. + EnterOpt_execute_using_list(c *Opt_execute_using_listContext) + + // EnterOpt_execute_into is called when entering the opt_execute_into production. + EnterOpt_execute_into(c *Opt_execute_intoContext) + + // EnterStmt_open is called when entering the stmt_open production. + EnterStmt_open(c *Stmt_openContext) + + // EnterOpt_open_bound_list_item is called when entering the opt_open_bound_list_item production. + EnterOpt_open_bound_list_item(c *Opt_open_bound_list_itemContext) + + // EnterOpt_open_bound_list is called when entering the opt_open_bound_list production. + EnterOpt_open_bound_list(c *Opt_open_bound_listContext) + + // EnterOpt_open_using is called when entering the opt_open_using production. + EnterOpt_open_using(c *Opt_open_usingContext) + + // EnterOpt_scroll_option is called when entering the opt_scroll_option production. + EnterOpt_scroll_option(c *Opt_scroll_optionContext) + + // EnterOpt_scroll_option_no is called when entering the opt_scroll_option_no production. + EnterOpt_scroll_option_no(c *Opt_scroll_option_noContext) + + // EnterStmt_fetch is called when entering the stmt_fetch production. + EnterStmt_fetch(c *Stmt_fetchContext) + + // EnterInto_target is called when entering the into_target production. + EnterInto_target(c *Into_targetContext) + + // EnterOpt_cursor_from is called when entering the opt_cursor_from production. + EnterOpt_cursor_from(c *Opt_cursor_fromContext) + + // EnterOpt_fetch_direction is called when entering the opt_fetch_direction production. + EnterOpt_fetch_direction(c *Opt_fetch_directionContext) + + // EnterStmt_move is called when entering the stmt_move production. + EnterStmt_move(c *Stmt_moveContext) + + // EnterStmt_close is called when entering the stmt_close production. + EnterStmt_close(c *Stmt_closeContext) + + // EnterStmt_null is called when entering the stmt_null production. + EnterStmt_null(c *Stmt_nullContext) + + // EnterStmt_commit is called when entering the stmt_commit production. + EnterStmt_commit(c *Stmt_commitContext) + + // EnterStmt_rollback is called when entering the stmt_rollback production. + EnterStmt_rollback(c *Stmt_rollbackContext) + + // EnterPlsql_opt_transaction_chain is called when entering the plsql_opt_transaction_chain production. + EnterPlsql_opt_transaction_chain(c *Plsql_opt_transaction_chainContext) + + // EnterStmt_set is called when entering the stmt_set production. + EnterStmt_set(c *Stmt_setContext) + + // EnterCursor_variable is called when entering the cursor_variable production. + EnterCursor_variable(c *Cursor_variableContext) + + // EnterException_sect is called when entering the exception_sect production. + EnterException_sect(c *Exception_sectContext) + + // EnterProc_exceptions is called when entering the proc_exceptions production. + EnterProc_exceptions(c *Proc_exceptionsContext) + + // EnterProc_exception is called when entering the proc_exception production. + EnterProc_exception(c *Proc_exceptionContext) + + // EnterProc_conditions is called when entering the proc_conditions production. + EnterProc_conditions(c *Proc_conditionsContext) + + // EnterProc_condition is called when entering the proc_condition production. + EnterProc_condition(c *Proc_conditionContext) + + // EnterOpt_block_label is called when entering the opt_block_label production. + EnterOpt_block_label(c *Opt_block_labelContext) + + // EnterOpt_loop_label is called when entering the opt_loop_label production. + EnterOpt_loop_label(c *Opt_loop_labelContext) + + // EnterOpt_label is called when entering the opt_label production. + EnterOpt_label(c *Opt_labelContext) + + // EnterOpt_exitcond is called when entering the opt_exitcond production. + EnterOpt_exitcond(c *Opt_exitcondContext) + + // EnterAny_identifier is called when entering the any_identifier production. + EnterAny_identifier(c *Any_identifierContext) + + // EnterPlsql_unreserved_keyword is called when entering the plsql_unreserved_keyword production. + EnterPlsql_unreserved_keyword(c *Plsql_unreserved_keywordContext) + + // EnterSql_expression is called when entering the sql_expression production. + EnterSql_expression(c *Sql_expressionContext) + + // EnterExpr_until_then is called when entering the expr_until_then production. + EnterExpr_until_then(c *Expr_until_thenContext) + + // EnterExpr_until_semi is called when entering the expr_until_semi production. + EnterExpr_until_semi(c *Expr_until_semiContext) + + // EnterExpr_until_rightbracket is called when entering the expr_until_rightbracket production. + EnterExpr_until_rightbracket(c *Expr_until_rightbracketContext) + + // EnterExpr_until_loop is called when entering the expr_until_loop production. + EnterExpr_until_loop(c *Expr_until_loopContext) + + // EnterMake_execsql_stmt is called when entering the make_execsql_stmt production. + EnterMake_execsql_stmt(c *Make_execsql_stmtContext) + + // EnterOpt_returning_clause_into is called when entering the opt_returning_clause_into production. + EnterOpt_returning_clause_into(c *Opt_returning_clause_intoContext) + + // ExitRoot is called when exiting the root production. + ExitRoot(c *RootContext) + + // ExitPlsqlroot is called when exiting the plsqlroot production. + ExitPlsqlroot(c *PlsqlrootContext) + + // ExitStmtblock is called when exiting the stmtblock production. + ExitStmtblock(c *StmtblockContext) + + // ExitStmtmulti is called when exiting the stmtmulti production. + ExitStmtmulti(c *StmtmultiContext) + + // ExitStmt is called when exiting the stmt production. + ExitStmt(c *StmtContext) + + // ExitPlsqlconsolecommand is called when exiting the plsqlconsolecommand production. + ExitPlsqlconsolecommand(c *PlsqlconsolecommandContext) + + // ExitCallstmt is called when exiting the callstmt production. + ExitCallstmt(c *CallstmtContext) + + // ExitCreaterolestmt is called when exiting the createrolestmt production. + ExitCreaterolestmt(c *CreaterolestmtContext) + + // ExitOpt_with is called when exiting the opt_with production. + ExitOpt_with(c *Opt_withContext) + + // ExitOptrolelist is called when exiting the optrolelist production. + ExitOptrolelist(c *OptrolelistContext) + + // ExitAlteroptrolelist is called when exiting the alteroptrolelist production. + ExitAlteroptrolelist(c *AlteroptrolelistContext) + + // ExitAlteroptroleelem is called when exiting the alteroptroleelem production. + ExitAlteroptroleelem(c *AlteroptroleelemContext) + + // ExitCreateoptroleelem is called when exiting the createoptroleelem production. + ExitCreateoptroleelem(c *CreateoptroleelemContext) + + // ExitCreateuserstmt is called when exiting the createuserstmt production. + ExitCreateuserstmt(c *CreateuserstmtContext) + + // ExitAlterrolestmt is called when exiting the alterrolestmt production. + ExitAlterrolestmt(c *AlterrolestmtContext) + + // ExitAlterroleaction is called when exiting the alterroleaction production. + ExitAlterroleaction(c *AlterroleactionContext) + + // ExitOpt_in_database is called when exiting the opt_in_database production. + ExitOpt_in_database(c *Opt_in_databaseContext) + + // ExitAlterrolesetstmt is called when exiting the alterrolesetstmt production. + ExitAlterrolesetstmt(c *AlterrolesetstmtContext) + + // ExitAlterschemastmt is called when exiting the alterschemastmt production. + ExitAlterschemastmt(c *AlterschemastmtContext) + + // ExitDroprolestmt is called when exiting the droprolestmt production. + ExitDroprolestmt(c *DroprolestmtContext) + + // ExitDropuserstmt is called when exiting the dropuserstmt production. + ExitDropuserstmt(c *DropuserstmtContext) + + // ExitDropgroupstmt is called when exiting the dropgroupstmt production. + ExitDropgroupstmt(c *DropgroupstmtContext) + + // ExitCreategroupstmt is called when exiting the creategroupstmt production. + ExitCreategroupstmt(c *CreategroupstmtContext) + + // ExitAltergroupstmt is called when exiting the altergroupstmt production. + ExitAltergroupstmt(c *AltergroupstmtContext) + + // ExitAdd_drop is called when exiting the add_drop production. + ExitAdd_drop(c *Add_dropContext) + + // ExitCreateschemastmt is called when exiting the createschemastmt production. + ExitCreateschemastmt(c *CreateschemastmtContext) + + // ExitOpt_auth_clause is called when exiting the opt_auth_clause production. + ExitOpt_auth_clause(c *Opt_auth_clauseContext) + + // ExitOpt_quota is called when exiting the opt_quota production. + ExitOpt_quota(c *Opt_quotaContext) + + // ExitOptschemaeltlist is called when exiting the optschemaeltlist production. + ExitOptschemaeltlist(c *OptschemaeltlistContext) + + // ExitSchema_stmt is called when exiting the schema_stmt production. + ExitSchema_stmt(c *Schema_stmtContext) + + // ExitVariablesetstmt is called when exiting the variablesetstmt production. + ExitVariablesetstmt(c *VariablesetstmtContext) + + // ExitSet_rest is called when exiting the set_rest production. + ExitSet_rest(c *Set_restContext) + + // ExitGeneric_set is called when exiting the generic_set production. + ExitGeneric_set(c *Generic_setContext) + + // ExitSet_rest_more is called when exiting the set_rest_more production. + ExitSet_rest_more(c *Set_rest_moreContext) + + // ExitVar_name is called when exiting the var_name production. + ExitVar_name(c *Var_nameContext) + + // ExitVar_list is called when exiting the var_list production. + ExitVar_list(c *Var_listContext) + + // ExitVar_value is called when exiting the var_value production. + ExitVar_value(c *Var_valueContext) + + // ExitIso_level is called when exiting the iso_level production. + ExitIso_level(c *Iso_levelContext) + + // ExitOpt_boolean_or_string is called when exiting the opt_boolean_or_string production. + ExitOpt_boolean_or_string(c *Opt_boolean_or_stringContext) + + // ExitZone_value is called when exiting the zone_value production. + ExitZone_value(c *Zone_valueContext) + + // ExitOpt_encoding is called when exiting the opt_encoding production. + ExitOpt_encoding(c *Opt_encodingContext) + + // ExitNonreservedword_or_sconst is called when exiting the nonreservedword_or_sconst production. + ExitNonreservedword_or_sconst(c *Nonreservedword_or_sconstContext) + + // ExitVariableresetstmt is called when exiting the variableresetstmt production. + ExitVariableresetstmt(c *VariableresetstmtContext) + + // ExitReset_rest is called when exiting the reset_rest production. + ExitReset_rest(c *Reset_restContext) + + // ExitGeneric_reset is called when exiting the generic_reset production. + ExitGeneric_reset(c *Generic_resetContext) + + // ExitSetresetclause is called when exiting the setresetclause production. + ExitSetresetclause(c *SetresetclauseContext) + + // ExitFunctionsetresetclause is called when exiting the functionsetresetclause production. + ExitFunctionsetresetclause(c *FunctionsetresetclauseContext) + + // ExitVariableshowstmt is called when exiting the variableshowstmt production. + ExitVariableshowstmt(c *VariableshowstmtContext) + + // ExitConstraintssetstmt is called when exiting the constraintssetstmt production. + ExitConstraintssetstmt(c *ConstraintssetstmtContext) + + // ExitConstraints_set_list is called when exiting the constraints_set_list production. + ExitConstraints_set_list(c *Constraints_set_listContext) + + // ExitConstraints_set_mode is called when exiting the constraints_set_mode production. + ExitConstraints_set_mode(c *Constraints_set_modeContext) + + // ExitCheckpointstmt is called when exiting the checkpointstmt production. + ExitCheckpointstmt(c *CheckpointstmtContext) + + // ExitDiscardstmt is called when exiting the discardstmt production. + ExitDiscardstmt(c *DiscardstmtContext) + + // ExitAltertablestmt is called when exiting the altertablestmt production. + ExitAltertablestmt(c *AltertablestmtContext) + + // ExitAlter_table_cmds is called when exiting the alter_table_cmds production. + ExitAlter_table_cmds(c *Alter_table_cmdsContext) + + // ExitTable_constraint is called when exiting the table_constraint production. + ExitTable_constraint(c *Table_constraintContext) + + // ExitPartition_cmd is called when exiting the partition_cmd production. + ExitPartition_cmd(c *Partition_cmdContext) + + // ExitIndex_partition_cmd is called when exiting the index_partition_cmd production. + ExitIndex_partition_cmd(c *Index_partition_cmdContext) + + // ExitAlter_table_cmd is called when exiting the alter_table_cmd production. + ExitAlter_table_cmd(c *Alter_table_cmdContext) + + // ExitAlter_column_default is called when exiting the alter_column_default production. + ExitAlter_column_default(c *Alter_column_defaultContext) + + // ExitOpt_drop_behavior is called when exiting the opt_drop_behavior production. + ExitOpt_drop_behavior(c *Opt_drop_behaviorContext) + + // ExitOpt_collate_clause is called when exiting the opt_collate_clause production. + ExitOpt_collate_clause(c *Opt_collate_clauseContext) + + // ExitAlter_using is called when exiting the alter_using production. + ExitAlter_using(c *Alter_usingContext) + + // ExitReplica_identity is called when exiting the replica_identity production. + ExitReplica_identity(c *Replica_identityContext) + + // ExitReloptions is called when exiting the reloptions production. + ExitReloptions(c *ReloptionsContext) + + // ExitOpt_reloptions is called when exiting the opt_reloptions production. + ExitOpt_reloptions(c *Opt_reloptionsContext) + + // ExitReloption_list is called when exiting the reloption_list production. + ExitReloption_list(c *Reloption_listContext) + + // ExitReloption_elem is called when exiting the reloption_elem production. + ExitReloption_elem(c *Reloption_elemContext) + + // ExitAlter_identity_column_option_list is called when exiting the alter_identity_column_option_list production. + ExitAlter_identity_column_option_list(c *Alter_identity_column_option_listContext) + + // ExitAlter_identity_column_option is called when exiting the alter_identity_column_option production. + ExitAlter_identity_column_option(c *Alter_identity_column_optionContext) + + // ExitPartitionboundspec is called when exiting the partitionboundspec production. + ExitPartitionboundspec(c *PartitionboundspecContext) + + // ExitHash_partbound_elem is called when exiting the hash_partbound_elem production. + ExitHash_partbound_elem(c *Hash_partbound_elemContext) + + // ExitHash_partbound is called when exiting the hash_partbound production. + ExitHash_partbound(c *Hash_partboundContext) + + // ExitAltercompositetypestmt is called when exiting the altercompositetypestmt production. + ExitAltercompositetypestmt(c *AltercompositetypestmtContext) + + // ExitAlter_type_cmds is called when exiting the alter_type_cmds production. + ExitAlter_type_cmds(c *Alter_type_cmdsContext) + + // ExitAlter_type_cmd is called when exiting the alter_type_cmd production. + ExitAlter_type_cmd(c *Alter_type_cmdContext) + + // ExitCloseportalstmt is called when exiting the closeportalstmt production. + ExitCloseportalstmt(c *CloseportalstmtContext) + + // ExitCopystmt is called when exiting the copystmt production. + ExitCopystmt(c *CopystmtContext) + + // ExitRedshift_copy_authorization is called when exiting the redshift_copy_authorization production. + ExitRedshift_copy_authorization(c *Redshift_copy_authorizationContext) + + // ExitRedshift_copy_format is called when exiting the redshift_copy_format production. + ExitRedshift_copy_format(c *Redshift_copy_formatContext) + + // ExitRedshift_copy_parameter is called when exiting the redshift_copy_parameter production. + ExitRedshift_copy_parameter(c *Redshift_copy_parameterContext) + + // ExitCopy_param_name is called when exiting the copy_param_name production. + ExitCopy_param_name(c *Copy_param_nameContext) + + // ExitCopy_param_value is called when exiting the copy_param_value production. + ExitCopy_param_value(c *Copy_param_valueContext) + + // ExitCopy_from is called when exiting the copy_from production. + ExitCopy_from(c *Copy_fromContext) + + // ExitOpt_program is called when exiting the opt_program production. + ExitOpt_program(c *Opt_programContext) + + // ExitCopy_file_name is called when exiting the copy_file_name production. + ExitCopy_file_name(c *Copy_file_nameContext) + + // ExitCopy_options is called when exiting the copy_options production. + ExitCopy_options(c *Copy_optionsContext) + + // ExitCopy_opt_list is called when exiting the copy_opt_list production. + ExitCopy_opt_list(c *Copy_opt_listContext) + + // ExitCopy_opt_item is called when exiting the copy_opt_item production. + ExitCopy_opt_item(c *Copy_opt_itemContext) + + // ExitOpt_binary is called when exiting the opt_binary production. + ExitOpt_binary(c *Opt_binaryContext) + + // ExitCopy_delimiter is called when exiting the copy_delimiter production. + ExitCopy_delimiter(c *Copy_delimiterContext) + + // ExitOpt_using is called when exiting the opt_using production. + ExitOpt_using(c *Opt_usingContext) + + // ExitCopy_generic_opt_list is called when exiting the copy_generic_opt_list production. + ExitCopy_generic_opt_list(c *Copy_generic_opt_listContext) + + // ExitCopy_generic_opt_elem is called when exiting the copy_generic_opt_elem production. + ExitCopy_generic_opt_elem(c *Copy_generic_opt_elemContext) + + // ExitCopy_generic_opt_arg is called when exiting the copy_generic_opt_arg production. + ExitCopy_generic_opt_arg(c *Copy_generic_opt_argContext) + + // ExitCopy_generic_opt_arg_list is called when exiting the copy_generic_opt_arg_list production. + ExitCopy_generic_opt_arg_list(c *Copy_generic_opt_arg_listContext) + + // ExitCopy_generic_opt_arg_list_item is called when exiting the copy_generic_opt_arg_list_item production. + ExitCopy_generic_opt_arg_list_item(c *Copy_generic_opt_arg_list_itemContext) + + // ExitCreatestmt is called when exiting the createstmt production. + ExitCreatestmt(c *CreatestmtContext) + + // ExitOpt_table_attributes is called when exiting the opt_table_attributes production. + ExitOpt_table_attributes(c *Opt_table_attributesContext) + + // ExitOpttemp is called when exiting the opttemp production. + ExitOpttemp(c *OpttempContext) + + // ExitOpttableelementlist is called when exiting the opttableelementlist production. + ExitOpttableelementlist(c *OpttableelementlistContext) + + // ExitOpttypedtableelementlist is called when exiting the opttypedtableelementlist production. + ExitOpttypedtableelementlist(c *OpttypedtableelementlistContext) + + // ExitTableelementlist is called when exiting the tableelementlist production. + ExitTableelementlist(c *TableelementlistContext) + + // ExitTypedtableelementlist is called when exiting the typedtableelementlist production. + ExitTypedtableelementlist(c *TypedtableelementlistContext) + + // ExitTableelement is called when exiting the tableelement production. + ExitTableelement(c *TableelementContext) + + // ExitTypedtableelement is called when exiting the typedtableelement production. + ExitTypedtableelement(c *TypedtableelementContext) + + // ExitColumnDef is called when exiting the columnDef production. + ExitColumnDef(c *ColumnDefContext) + + // ExitRs_colattributes is called when exiting the rs_colattributes production. + ExitRs_colattributes(c *Rs_colattributesContext) + + // ExitRs_colattribute is called when exiting the rs_colattribute production. + ExitRs_colattribute(c *Rs_colattributeContext) + + // ExitColumnOptions is called when exiting the columnOptions production. + ExitColumnOptions(c *ColumnOptionsContext) + + // ExitColquallist is called when exiting the colquallist production. + ExitColquallist(c *ColquallistContext) + + // ExitColconstraint is called when exiting the colconstraint production. + ExitColconstraint(c *ColconstraintContext) + + // ExitColconstraintelem is called when exiting the colconstraintelem production. + ExitColconstraintelem(c *ColconstraintelemContext) + + // ExitOpt_unique_null_treatment is called when exiting the opt_unique_null_treatment production. + ExitOpt_unique_null_treatment(c *Opt_unique_null_treatmentContext) + + // ExitGenerated_when is called when exiting the generated_when production. + ExitGenerated_when(c *Generated_whenContext) + + // ExitConstraintattr is called when exiting the constraintattr production. + ExitConstraintattr(c *ConstraintattrContext) + + // ExitTablelikeclause is called when exiting the tablelikeclause production. + ExitTablelikeclause(c *TablelikeclauseContext) + + // ExitTablelikeoptionlist is called when exiting the tablelikeoptionlist production. + ExitTablelikeoptionlist(c *TablelikeoptionlistContext) + + // ExitTablelikeoption is called when exiting the tablelikeoption production. + ExitTablelikeoption(c *TablelikeoptionContext) + + // ExitTableconstraint is called when exiting the tableconstraint production. + ExitTableconstraint(c *TableconstraintContext) + + // ExitConstraintelem is called when exiting the constraintelem production. + ExitConstraintelem(c *ConstraintelemContext) + + // ExitOpt_no_inherit is called when exiting the opt_no_inherit production. + ExitOpt_no_inherit(c *Opt_no_inheritContext) + + // ExitOpt_column_list is called when exiting the opt_column_list production. + ExitOpt_column_list(c *Opt_column_listContext) + + // ExitColumnlist is called when exiting the columnlist production. + ExitColumnlist(c *ColumnlistContext) + + // ExitColumnElem is called when exiting the columnElem production. + ExitColumnElem(c *ColumnElemContext) + + // ExitOpt_c_include is called when exiting the opt_c_include production. + ExitOpt_c_include(c *Opt_c_includeContext) + + // ExitKey_match is called when exiting the key_match production. + ExitKey_match(c *Key_matchContext) + + // ExitExclusionconstraintlist is called when exiting the exclusionconstraintlist production. + ExitExclusionconstraintlist(c *ExclusionconstraintlistContext) + + // ExitExclusionconstraintelem is called when exiting the exclusionconstraintelem production. + ExitExclusionconstraintelem(c *ExclusionconstraintelemContext) + + // ExitExclusionwhereclause is called when exiting the exclusionwhereclause production. + ExitExclusionwhereclause(c *ExclusionwhereclauseContext) + + // ExitKey_actions is called when exiting the key_actions production. + ExitKey_actions(c *Key_actionsContext) + + // ExitKey_update is called when exiting the key_update production. + ExitKey_update(c *Key_updateContext) + + // ExitKey_delete is called when exiting the key_delete production. + ExitKey_delete(c *Key_deleteContext) + + // ExitKey_action is called when exiting the key_action production. + ExitKey_action(c *Key_actionContext) + + // ExitOptinherit is called when exiting the optinherit production. + ExitOptinherit(c *OptinheritContext) + + // ExitOptpartitionspec is called when exiting the optpartitionspec production. + ExitOptpartitionspec(c *OptpartitionspecContext) + + // ExitPartitionspec is called when exiting the partitionspec production. + ExitPartitionspec(c *PartitionspecContext) + + // ExitPart_params is called when exiting the part_params production. + ExitPart_params(c *Part_paramsContext) + + // ExitPart_elem is called when exiting the part_elem production. + ExitPart_elem(c *Part_elemContext) + + // ExitTable_access_method_clause is called when exiting the table_access_method_clause production. + ExitTable_access_method_clause(c *Table_access_method_clauseContext) + + // ExitOptwith is called when exiting the optwith production. + ExitOptwith(c *OptwithContext) + + // ExitOncommitoption is called when exiting the oncommitoption production. + ExitOncommitoption(c *OncommitoptionContext) + + // ExitOpttablespace is called when exiting the opttablespace production. + ExitOpttablespace(c *OpttablespaceContext) + + // ExitOptredshifttableoptions is called when exiting the optredshifttableoptions production. + ExitOptredshifttableoptions(c *OptredshifttableoptionsContext) + + // ExitRedshifttableoption is called when exiting the redshifttableoption production. + ExitRedshifttableoption(c *RedshifttableoptionContext) + + // ExitSortkeyclause is called when exiting the sortkeyclause production. + ExitSortkeyclause(c *SortkeyclauseContext) + + // ExitSortkeyclausetype is called when exiting the sortkeyclausetype production. + ExitSortkeyclausetype(c *SortkeyclausetypeContext) + + // ExitOptconstablespace is called when exiting the optconstablespace production. + ExitOptconstablespace(c *OptconstablespaceContext) + + // ExitExistingindex is called when exiting the existingindex production. + ExitExistingindex(c *ExistingindexContext) + + // ExitCreatestatsstmt is called when exiting the createstatsstmt production. + ExitCreatestatsstmt(c *CreatestatsstmtContext) + + // ExitAlterstatsstmt is called when exiting the alterstatsstmt production. + ExitAlterstatsstmt(c *AlterstatsstmtContext) + + // ExitCreateasstmt is called when exiting the createasstmt production. + ExitCreateasstmt(c *CreateasstmtContext) + + // ExitCreate_as_target is called when exiting the create_as_target production. + ExitCreate_as_target(c *Create_as_targetContext) + + // ExitOpt_backup_clause_table_attributes is called when exiting the opt_backup_clause_table_attributes production. + ExitOpt_backup_clause_table_attributes(c *Opt_backup_clause_table_attributesContext) + + // ExitTable_attributes is called when exiting the table_attributes production. + ExitTable_attributes(c *Table_attributesContext) + + // ExitOpt_backup_clause is called when exiting the opt_backup_clause production. + ExitOpt_backup_clause(c *Opt_backup_clauseContext) + + // ExitOpt_with_data is called when exiting the opt_with_data production. + ExitOpt_with_data(c *Opt_with_dataContext) + + // ExitCreatematviewstmt is called when exiting the creatematviewstmt production. + ExitCreatematviewstmt(c *CreatematviewstmtContext) + + // ExitOpt_auto_refresh is called when exiting the opt_auto_refresh production. + ExitOpt_auto_refresh(c *Opt_auto_refreshContext) + + // ExitRefreshmatviewstmt is called when exiting the refreshmatviewstmt production. + ExitRefreshmatviewstmt(c *RefreshmatviewstmtContext) + + // ExitCreateseqstmt is called when exiting the createseqstmt production. + ExitCreateseqstmt(c *CreateseqstmtContext) + + // ExitAlterseqstmt is called when exiting the alterseqstmt production. + ExitAlterseqstmt(c *AlterseqstmtContext) + + // ExitOptseqoptlist is called when exiting the optseqoptlist production. + ExitOptseqoptlist(c *OptseqoptlistContext) + + // ExitOptparenthesizedseqoptlist is called when exiting the optparenthesizedseqoptlist production. + ExitOptparenthesizedseqoptlist(c *OptparenthesizedseqoptlistContext) + + // ExitSeqoptlist is called when exiting the seqoptlist production. + ExitSeqoptlist(c *SeqoptlistContext) + + // ExitSeqoptelem is called when exiting the seqoptelem production. + ExitSeqoptelem(c *SeqoptelemContext) + + // ExitOpt_by is called when exiting the opt_by production. + ExitOpt_by(c *Opt_byContext) + + // ExitNumericonly is called when exiting the numericonly production. + ExitNumericonly(c *NumericonlyContext) + + // ExitNumericonly_list is called when exiting the numericonly_list production. + ExitNumericonly_list(c *Numericonly_listContext) + + // ExitCreateplangstmt is called when exiting the createplangstmt production. + ExitCreateplangstmt(c *CreateplangstmtContext) + + // ExitOpt_trusted is called when exiting the opt_trusted production. + ExitOpt_trusted(c *Opt_trustedContext) + + // ExitHandler_name is called when exiting the handler_name production. + ExitHandler_name(c *Handler_nameContext) + + // ExitOpt_inline_handler is called when exiting the opt_inline_handler production. + ExitOpt_inline_handler(c *Opt_inline_handlerContext) + + // ExitValidator_clause is called when exiting the validator_clause production. + ExitValidator_clause(c *Validator_clauseContext) + + // ExitOpt_validator is called when exiting the opt_validator production. + ExitOpt_validator(c *Opt_validatorContext) + + // ExitOpt_procedural is called when exiting the opt_procedural production. + ExitOpt_procedural(c *Opt_proceduralContext) + + // ExitCreatetablespacestmt is called when exiting the createtablespacestmt production. + ExitCreatetablespacestmt(c *CreatetablespacestmtContext) + + // ExitOpttablespaceowner is called when exiting the opttablespaceowner production. + ExitOpttablespaceowner(c *OpttablespaceownerContext) + + // ExitDroptablespacestmt is called when exiting the droptablespacestmt production. + ExitDroptablespacestmt(c *DroptablespacestmtContext) + + // ExitCreateextensionstmt is called when exiting the createextensionstmt production. + ExitCreateextensionstmt(c *CreateextensionstmtContext) + + // ExitCreate_extension_opt_list is called when exiting the create_extension_opt_list production. + ExitCreate_extension_opt_list(c *Create_extension_opt_listContext) + + // ExitCreate_extension_opt_item is called when exiting the create_extension_opt_item production. + ExitCreate_extension_opt_item(c *Create_extension_opt_itemContext) + + // ExitAlterextensionstmt is called when exiting the alterextensionstmt production. + ExitAlterextensionstmt(c *AlterextensionstmtContext) + + // ExitAlter_extension_opt_list is called when exiting the alter_extension_opt_list production. + ExitAlter_extension_opt_list(c *Alter_extension_opt_listContext) + + // ExitAlter_extension_opt_item is called when exiting the alter_extension_opt_item production. + ExitAlter_extension_opt_item(c *Alter_extension_opt_itemContext) + + // ExitAlterextensioncontentsstmt is called when exiting the alterextensioncontentsstmt production. + ExitAlterextensioncontentsstmt(c *AlterextensioncontentsstmtContext) + + // ExitCreatefdwstmt is called when exiting the createfdwstmt production. + ExitCreatefdwstmt(c *CreatefdwstmtContext) + + // ExitFdw_option is called when exiting the fdw_option production. + ExitFdw_option(c *Fdw_optionContext) + + // ExitFdw_options is called when exiting the fdw_options production. + ExitFdw_options(c *Fdw_optionsContext) + + // ExitOpt_fdw_options is called when exiting the opt_fdw_options production. + ExitOpt_fdw_options(c *Opt_fdw_optionsContext) + + // ExitAlterfdwstmt is called when exiting the alterfdwstmt production. + ExitAlterfdwstmt(c *AlterfdwstmtContext) + + // ExitCreate_generic_options is called when exiting the create_generic_options production. + ExitCreate_generic_options(c *Create_generic_optionsContext) + + // ExitGeneric_option_list is called when exiting the generic_option_list production. + ExitGeneric_option_list(c *Generic_option_listContext) + + // ExitAlter_generic_options is called when exiting the alter_generic_options production. + ExitAlter_generic_options(c *Alter_generic_optionsContext) + + // ExitAlter_generic_option_list is called when exiting the alter_generic_option_list production. + ExitAlter_generic_option_list(c *Alter_generic_option_listContext) + + // ExitAlter_generic_option_elem is called when exiting the alter_generic_option_elem production. + ExitAlter_generic_option_elem(c *Alter_generic_option_elemContext) + + // ExitGeneric_option_elem is called when exiting the generic_option_elem production. + ExitGeneric_option_elem(c *Generic_option_elemContext) + + // ExitGeneric_option_name is called when exiting the generic_option_name production. + ExitGeneric_option_name(c *Generic_option_nameContext) + + // ExitGeneric_option_arg is called when exiting the generic_option_arg production. + ExitGeneric_option_arg(c *Generic_option_argContext) + + // ExitCreateforeignserverstmt is called when exiting the createforeignserverstmt production. + ExitCreateforeignserverstmt(c *CreateforeignserverstmtContext) + + // ExitOpt_type is called when exiting the opt_type production. + ExitOpt_type(c *Opt_typeContext) + + // ExitForeign_server_version is called when exiting the foreign_server_version production. + ExitForeign_server_version(c *Foreign_server_versionContext) + + // ExitOpt_foreign_server_version is called when exiting the opt_foreign_server_version production. + ExitOpt_foreign_server_version(c *Opt_foreign_server_versionContext) + + // ExitAlterforeignserverstmt is called when exiting the alterforeignserverstmt production. + ExitAlterforeignserverstmt(c *AlterforeignserverstmtContext) + + // ExitCreateforeigntablestmt is called when exiting the createforeigntablestmt production. + ExitCreateforeigntablestmt(c *CreateforeigntablestmtContext) + + // ExitImportforeignschemastmt is called when exiting the importforeignschemastmt production. + ExitImportforeignschemastmt(c *ImportforeignschemastmtContext) + + // ExitImport_qualification_type is called when exiting the import_qualification_type production. + ExitImport_qualification_type(c *Import_qualification_typeContext) + + // ExitImport_qualification is called when exiting the import_qualification production. + ExitImport_qualification(c *Import_qualificationContext) + + // ExitCreateusermappingstmt is called when exiting the createusermappingstmt production. + ExitCreateusermappingstmt(c *CreateusermappingstmtContext) + + // ExitAuth_ident is called when exiting the auth_ident production. + ExitAuth_ident(c *Auth_identContext) + + // ExitDropusermappingstmt is called when exiting the dropusermappingstmt production. + ExitDropusermappingstmt(c *DropusermappingstmtContext) + + // ExitAlterusermappingstmt is called when exiting the alterusermappingstmt production. + ExitAlterusermappingstmt(c *AlterusermappingstmtContext) + + // ExitCreatepolicystmt is called when exiting the createpolicystmt production. + ExitCreatepolicystmt(c *CreatepolicystmtContext) + + // ExitAlterpolicystmt is called when exiting the alterpolicystmt production. + ExitAlterpolicystmt(c *AlterpolicystmtContext) + + // ExitRowsecurityoptionalexpr is called when exiting the rowsecurityoptionalexpr production. + ExitRowsecurityoptionalexpr(c *RowsecurityoptionalexprContext) + + // ExitRowsecurityoptionalwithcheck is called when exiting the rowsecurityoptionalwithcheck production. + ExitRowsecurityoptionalwithcheck(c *RowsecurityoptionalwithcheckContext) + + // ExitRowsecuritydefaulttorole is called when exiting the rowsecuritydefaulttorole production. + ExitRowsecuritydefaulttorole(c *RowsecuritydefaulttoroleContext) + + // ExitRowsecurityoptionaltorole is called when exiting the rowsecurityoptionaltorole production. + ExitRowsecurityoptionaltorole(c *RowsecurityoptionaltoroleContext) + + // ExitRowsecuritydefaultpermissive is called when exiting the rowsecuritydefaultpermissive production. + ExitRowsecuritydefaultpermissive(c *RowsecuritydefaultpermissiveContext) + + // ExitRowsecuritydefaultforcmd is called when exiting the rowsecuritydefaultforcmd production. + ExitRowsecuritydefaultforcmd(c *RowsecuritydefaultforcmdContext) + + // ExitRow_security_cmd is called when exiting the row_security_cmd production. + ExitRow_security_cmd(c *Row_security_cmdContext) + + // ExitCreateamstmt is called when exiting the createamstmt production. + ExitCreateamstmt(c *CreateamstmtContext) + + // ExitAm_type is called when exiting the am_type production. + ExitAm_type(c *Am_typeContext) + + // ExitCreatetrigstmt is called when exiting the createtrigstmt production. + ExitCreatetrigstmt(c *CreatetrigstmtContext) + + // ExitTriggeractiontime is called when exiting the triggeractiontime production. + ExitTriggeractiontime(c *TriggeractiontimeContext) + + // ExitTriggerevents is called when exiting the triggerevents production. + ExitTriggerevents(c *TriggereventsContext) + + // ExitTriggeroneevent is called when exiting the triggeroneevent production. + ExitTriggeroneevent(c *TriggeroneeventContext) + + // ExitTriggerreferencing is called when exiting the triggerreferencing production. + ExitTriggerreferencing(c *TriggerreferencingContext) + + // ExitTriggertransitions is called when exiting the triggertransitions production. + ExitTriggertransitions(c *TriggertransitionsContext) + + // ExitTriggertransition is called when exiting the triggertransition production. + ExitTriggertransition(c *TriggertransitionContext) + + // ExitTransitionoldornew is called when exiting the transitionoldornew production. + ExitTransitionoldornew(c *TransitionoldornewContext) + + // ExitTransitionrowortable is called when exiting the transitionrowortable production. + ExitTransitionrowortable(c *TransitionrowortableContext) + + // ExitTransitionrelname is called when exiting the transitionrelname production. + ExitTransitionrelname(c *TransitionrelnameContext) + + // ExitTriggerforspec is called when exiting the triggerforspec production. + ExitTriggerforspec(c *TriggerforspecContext) + + // ExitTriggerforopteach is called when exiting the triggerforopteach production. + ExitTriggerforopteach(c *TriggerforopteachContext) + + // ExitTriggerfortype is called when exiting the triggerfortype production. + ExitTriggerfortype(c *TriggerfortypeContext) + + // ExitTriggerwhen is called when exiting the triggerwhen production. + ExitTriggerwhen(c *TriggerwhenContext) + + // ExitFunction_or_procedure is called when exiting the function_or_procedure production. + ExitFunction_or_procedure(c *Function_or_procedureContext) + + // ExitTriggerfuncargs is called when exiting the triggerfuncargs production. + ExitTriggerfuncargs(c *TriggerfuncargsContext) + + // ExitTriggerfuncarg is called when exiting the triggerfuncarg production. + ExitTriggerfuncarg(c *TriggerfuncargContext) + + // ExitOptconstrfromtable is called when exiting the optconstrfromtable production. + ExitOptconstrfromtable(c *OptconstrfromtableContext) + + // ExitConstraintattributespec is called when exiting the constraintattributespec production. + ExitConstraintattributespec(c *ConstraintattributespecContext) + + // ExitConstraintattributeElem is called when exiting the constraintattributeElem production. + ExitConstraintattributeElem(c *ConstraintattributeElemContext) + + // ExitCreateeventtrigstmt is called when exiting the createeventtrigstmt production. + ExitCreateeventtrigstmt(c *CreateeventtrigstmtContext) + + // ExitEvent_trigger_when_list is called when exiting the event_trigger_when_list production. + ExitEvent_trigger_when_list(c *Event_trigger_when_listContext) + + // ExitEvent_trigger_when_item is called when exiting the event_trigger_when_item production. + ExitEvent_trigger_when_item(c *Event_trigger_when_itemContext) + + // ExitEvent_trigger_value_list is called when exiting the event_trigger_value_list production. + ExitEvent_trigger_value_list(c *Event_trigger_value_listContext) + + // ExitAltereventtrigstmt is called when exiting the altereventtrigstmt production. + ExitAltereventtrigstmt(c *AltereventtrigstmtContext) + + // ExitEnable_trigger is called when exiting the enable_trigger production. + ExitEnable_trigger(c *Enable_triggerContext) + + // ExitCreateassertionstmt is called when exiting the createassertionstmt production. + ExitCreateassertionstmt(c *CreateassertionstmtContext) + + // ExitDefinestmt is called when exiting the definestmt production. + ExitDefinestmt(c *DefinestmtContext) + + // ExitDefinition is called when exiting the definition production. + ExitDefinition(c *DefinitionContext) + + // ExitDef_list is called when exiting the def_list production. + ExitDef_list(c *Def_listContext) + + // ExitDef_elem is called when exiting the def_elem production. + ExitDef_elem(c *Def_elemContext) + + // ExitDef_arg is called when exiting the def_arg production. + ExitDef_arg(c *Def_argContext) + + // ExitOld_aggr_definition is called when exiting the old_aggr_definition production. + ExitOld_aggr_definition(c *Old_aggr_definitionContext) + + // ExitOld_aggr_list is called when exiting the old_aggr_list production. + ExitOld_aggr_list(c *Old_aggr_listContext) + + // ExitOld_aggr_elem is called when exiting the old_aggr_elem production. + ExitOld_aggr_elem(c *Old_aggr_elemContext) + + // ExitOpt_enum_val_list is called when exiting the opt_enum_val_list production. + ExitOpt_enum_val_list(c *Opt_enum_val_listContext) + + // ExitEnum_val_list is called when exiting the enum_val_list production. + ExitEnum_val_list(c *Enum_val_listContext) + + // ExitAlterenumstmt is called when exiting the alterenumstmt production. + ExitAlterenumstmt(c *AlterenumstmtContext) + + // ExitOpt_if_not_exists is called when exiting the opt_if_not_exists production. + ExitOpt_if_not_exists(c *Opt_if_not_existsContext) + + // ExitCreateopclassstmt is called when exiting the createopclassstmt production. + ExitCreateopclassstmt(c *CreateopclassstmtContext) + + // ExitOpclass_item_list is called when exiting the opclass_item_list production. + ExitOpclass_item_list(c *Opclass_item_listContext) + + // ExitOpclass_item is called when exiting the opclass_item production. + ExitOpclass_item(c *Opclass_itemContext) + + // ExitOpt_default is called when exiting the opt_default production. + ExitOpt_default(c *Opt_defaultContext) + + // ExitOpt_opfamily is called when exiting the opt_opfamily production. + ExitOpt_opfamily(c *Opt_opfamilyContext) + + // ExitOpclass_purpose is called when exiting the opclass_purpose production. + ExitOpclass_purpose(c *Opclass_purposeContext) + + // ExitOpt_recheck is called when exiting the opt_recheck production. + ExitOpt_recheck(c *Opt_recheckContext) + + // ExitCreateopfamilystmt is called when exiting the createopfamilystmt production. + ExitCreateopfamilystmt(c *CreateopfamilystmtContext) + + // ExitAlteropfamilystmt is called when exiting the alteropfamilystmt production. + ExitAlteropfamilystmt(c *AlteropfamilystmtContext) + + // ExitOpclass_drop_list is called when exiting the opclass_drop_list production. + ExitOpclass_drop_list(c *Opclass_drop_listContext) + + // ExitOpclass_drop is called when exiting the opclass_drop production. + ExitOpclass_drop(c *Opclass_dropContext) + + // ExitDropopclassstmt is called when exiting the dropopclassstmt production. + ExitDropopclassstmt(c *DropopclassstmtContext) + + // ExitDropopfamilystmt is called when exiting the dropopfamilystmt production. + ExitDropopfamilystmt(c *DropopfamilystmtContext) + + // ExitDropownedstmt is called when exiting the dropownedstmt production. + ExitDropownedstmt(c *DropownedstmtContext) + + // ExitReassignownedstmt is called when exiting the reassignownedstmt production. + ExitReassignownedstmt(c *ReassignownedstmtContext) + + // ExitDropstmt is called when exiting the dropstmt production. + ExitDropstmt(c *DropstmtContext) + + // ExitObject_type_any_name is called when exiting the object_type_any_name production. + ExitObject_type_any_name(c *Object_type_any_nameContext) + + // ExitObject_type_name is called when exiting the object_type_name production. + ExitObject_type_name(c *Object_type_nameContext) + + // ExitDrop_type_name is called when exiting the drop_type_name production. + ExitDrop_type_name(c *Drop_type_nameContext) + + // ExitObject_type_name_on_any_name is called when exiting the object_type_name_on_any_name production. + ExitObject_type_name_on_any_name(c *Object_type_name_on_any_nameContext) + + // ExitAny_name_list is called when exiting the any_name_list production. + ExitAny_name_list(c *Any_name_listContext) + + // ExitAny_name is called when exiting the any_name production. + ExitAny_name(c *Any_nameContext) + + // ExitAttrs is called when exiting the attrs production. + ExitAttrs(c *AttrsContext) + + // ExitType_name_list is called when exiting the type_name_list production. + ExitType_name_list(c *Type_name_listContext) + + // ExitTruncatestmt is called when exiting the truncatestmt production. + ExitTruncatestmt(c *TruncatestmtContext) + + // ExitOpt_restart_seqs is called when exiting the opt_restart_seqs production. + ExitOpt_restart_seqs(c *Opt_restart_seqsContext) + + // ExitCommentstmt is called when exiting the commentstmt production. + ExitCommentstmt(c *CommentstmtContext) + + // ExitComment_text is called when exiting the comment_text production. + ExitComment_text(c *Comment_textContext) + + // ExitSeclabelstmt is called when exiting the seclabelstmt production. + ExitSeclabelstmt(c *SeclabelstmtContext) + + // ExitOpt_provider is called when exiting the opt_provider production. + ExitOpt_provider(c *Opt_providerContext) + + // ExitSecurity_label is called when exiting the security_label production. + ExitSecurity_label(c *Security_labelContext) + + // ExitFetchstmt is called when exiting the fetchstmt production. + ExitFetchstmt(c *FetchstmtContext) + + // ExitFetch_args is called when exiting the fetch_args production. + ExitFetch_args(c *Fetch_argsContext) + + // ExitGrantstmt is called when exiting the grantstmt production. + ExitGrantstmt(c *GrantstmtContext) + + // ExitGrant_permissions_for_rls_lookup_tables is called when exiting the grant_permissions_for_rls_lookup_tables production. + ExitGrant_permissions_for_rls_lookup_tables(c *Grant_permissions_for_rls_lookup_tablesContext) + + // ExitGrant_explain_permissions_for_row_level_security_policy_filters is called when exiting the grant_explain_permissions_for_row_level_security_policy_filters production. + ExitGrant_explain_permissions_for_row_level_security_policy_filters(c *Grant_explain_permissions_for_row_level_security_policy_filtersContext) + + // ExitGrant_machine_learning_permissions is called when exiting the grant_machine_learning_permissions production. + ExitGrant_machine_learning_permissions(c *Grant_machine_learning_permissionsContext) + + // ExitGrant_role_permissions is called when exiting the grant_role_permissions production. + ExitGrant_role_permissions(c *Grant_role_permissionsContext) + + // ExitGrant_role_permission_target_list is called when exiting the grant_role_permission_target_list production. + ExitGrant_role_permission_target_list(c *Grant_role_permission_target_listContext) + + // ExitGrant_role_permission_target_list_item is called when exiting the grant_role_permission_target_list_item production. + ExitGrant_role_permission_target_list_item(c *Grant_role_permission_target_list_itemContext) + + // ExitSystem_permissions is called when exiting the system_permissions production. + ExitSystem_permissions(c *System_permissionsContext) + + // ExitSystem_permissions_item is called when exiting the system_permissions_item production. + ExitSystem_permissions_item(c *System_permissions_itemContext) + + // ExitOpt_with_admin_option is called when exiting the opt_with_admin_option production. + ExitOpt_with_admin_option(c *Opt_with_admin_optionContext) + + // ExitGrant_scoped_permissions is called when exiting the grant_scoped_permissions production. + ExitGrant_scoped_permissions(c *Grant_scoped_permissionsContext) + + // ExitGrant_scoped_schemas_permissions is called when exiting the grant_scoped_schemas_permissions production. + ExitGrant_scoped_schemas_permissions(c *Grant_scoped_schemas_permissionsContext) + + // ExitGrant_scoped_tables_permissions is called when exiting the grant_scoped_tables_permissions production. + ExitGrant_scoped_tables_permissions(c *Grant_scoped_tables_permissionsContext) + + // ExitGrant_scoped_functions_permissions is called when exiting the grant_scoped_functions_permissions production. + ExitGrant_scoped_functions_permissions(c *Grant_scoped_functions_permissionsContext) + + // ExitGrant_scoped_procedures_permissions is called when exiting the grant_scoped_procedures_permissions production. + ExitGrant_scoped_procedures_permissions(c *Grant_scoped_procedures_permissionsContext) + + // ExitGrant_scoped_languages_permissions is called when exiting the grant_scoped_languages_permissions production. + ExitGrant_scoped_languages_permissions(c *Grant_scoped_languages_permissionsContext) + + // ExitGrant_scoped_copy_jobs_permissions is called when exiting the grant_scoped_copy_jobs_permissions production. + ExitGrant_scoped_copy_jobs_permissions(c *Grant_scoped_copy_jobs_permissionsContext) + + // ExitGrantee_list_without_public is called when exiting the grantee_list_without_public production. + ExitGrantee_list_without_public(c *Grantee_list_without_publicContext) + + // ExitGrantee_without_public is called when exiting the grantee_without_public production. + ExitGrantee_without_public(c *Grantee_without_publicContext) + + // ExitGrant_datashare_permissions is called when exiting the grant_datashare_permissions production. + ExitGrant_datashare_permissions(c *Grant_datashare_permissionsContext) + + // ExitGrant_spectrum_integration_permissions is called when exiting the grant_spectrum_integration_permissions production. + ExitGrant_spectrum_integration_permissions(c *Grant_spectrum_integration_permissionsContext) + + // ExitGrant_spectrum_integration_external_schema_permissions is called when exiting the grant_spectrum_integration_external_schema_permissions production. + ExitGrant_spectrum_integration_external_schema_permissions(c *Grant_spectrum_integration_external_schema_permissionsContext) + + // ExitSpectrum_integration_external_schema_permission_list is called when exiting the spectrum_integration_external_schema_permission_list production. + ExitSpectrum_integration_external_schema_permission_list(c *Spectrum_integration_external_schema_permission_listContext) + + // ExitSpectrum_integration_external_schema_permission is called when exiting the spectrum_integration_external_schema_permission production. + ExitSpectrum_integration_external_schema_permission(c *Spectrum_integration_external_schema_permissionContext) + + // ExitGrant_spectrum_integration_external_table_permissions is called when exiting the grant_spectrum_integration_external_table_permissions production. + ExitGrant_spectrum_integration_external_table_permissions(c *Grant_spectrum_integration_external_table_permissionsContext) + + // ExitSpectrum_integration_external_table_permission is called when exiting the spectrum_integration_external_table_permission production. + ExitSpectrum_integration_external_table_permission(c *Spectrum_integration_external_table_permissionContext) + + // ExitSpectrum_integration_external_table_permission_list is called when exiting the spectrum_integration_external_table_permission_list production. + ExitSpectrum_integration_external_table_permission_list(c *Spectrum_integration_external_table_permission_listContext) + + // ExitGrant_spectrum_integration_extenral_column_permissions is called when exiting the grant_spectrum_integration_extenral_column_permissions production. + ExitGrant_spectrum_integration_extenral_column_permissions(c *Grant_spectrum_integration_extenral_column_permissionsContext) + + // ExitIamrolelist_or_public is called when exiting the iamrolelist_or_public production. + ExitIamrolelist_or_public(c *Iamrolelist_or_publicContext) + + // ExitIamrolelist is called when exiting the iamrolelist production. + ExitIamrolelist(c *IamrolelistContext) + + // ExitGrant_assume_role_permissions is called when exiting the grant_assume_role_permissions production. + ExitGrant_assume_role_permissions(c *Grant_assume_role_permissionsContext) + + // ExitGrant_assume_role_for_list is called when exiting the grant_assume_role_for_list production. + ExitGrant_assume_role_for_list(c *Grant_assume_role_for_listContext) + + // ExitGrant_assume_role_for_item is called when exiting the grant_assume_role_for_item production. + ExitGrant_assume_role_for_item(c *Grant_assume_role_for_itemContext) + + // ExitGrant_assume_role_target is called when exiting the grant_assume_role_target production. + ExitGrant_assume_role_target(c *Grant_assume_role_targetContext) + + // ExitGrant_column_level_permissions is called when exiting the grant_column_level_permissions production. + ExitGrant_column_level_permissions(c *Grant_column_level_permissionsContext) + + // ExitColumn_privilege_target is called when exiting the column_privilege_target production. + ExitColumn_privilege_target(c *Column_privilege_targetContext) + + // ExitColumn_privilege_list is called when exiting the column_privilege_list production. + ExitColumn_privilege_list(c *Column_privilege_listContext) + + // ExitColumn_all_privilege is called when exiting the column_all_privilege production. + ExitColumn_all_privilege(c *Column_all_privilegeContext) + + // ExitColumn_select_update_privilege is called when exiting the column_select_update_privilege production. + ExitColumn_select_update_privilege(c *Column_select_update_privilegeContext) + + // ExitCommon_grant is called when exiting the common_grant production. + ExitCommon_grant(c *Common_grantContext) + + // ExitCopy_job_privilege_list is called when exiting the copy_job_privilege_list production. + ExitCopy_job_privilege_list(c *Copy_job_privilege_listContext) + + // ExitCopy_job_privilege is called when exiting the copy_job_privilege production. + ExitCopy_job_privilege(c *Copy_job_privilegeContext) + + // ExitCopy_job_target is called when exiting the copy_job_target production. + ExitCopy_job_target(c *Copy_job_targetContext) + + // ExitCopy_job_name is called when exiting the copy_job_name production. + ExitCopy_job_name(c *Copy_job_nameContext) + + // ExitLanguage_privilege_list is called when exiting the language_privilege_list production. + ExitLanguage_privilege_list(c *Language_privilege_listContext) + + // ExitGrant_language_target is called when exiting the grant_language_target production. + ExitGrant_language_target(c *Grant_language_targetContext) + + // ExitGrant_procedure_target is called when exiting the grant_procedure_target production. + ExitGrant_procedure_target(c *Grant_procedure_targetContext) + + // ExitProcedure_privilege_list is called when exiting the procedure_privilege_list production. + ExitProcedure_privilege_list(c *Procedure_privilege_listContext) + + // ExitProcedure_privilege is called when exiting the procedure_privilege production. + ExitProcedure_privilege(c *Procedure_privilegeContext) + + // ExitFunction_privilege_list is called when exiting the function_privilege_list production. + ExitFunction_privilege_list(c *Function_privilege_listContext) + + // ExitFunction_privilege is called when exiting the function_privilege production. + ExitFunction_privilege(c *Function_privilegeContext) + + // ExitGrant_function_target is called when exiting the grant_function_target production. + ExitGrant_function_target(c *Grant_function_targetContext) + + // ExitGrant_schema_target is called when exiting the grant_schema_target production. + ExitGrant_schema_target(c *Grant_schema_targetContext) + + // ExitRevoke_schema_target is called when exiting the revoke_schema_target production. + ExitRevoke_schema_target(c *Revoke_schema_targetContext) + + // ExitSchema_privilege_list is called when exiting the schema_privilege_list production. + ExitSchema_privilege_list(c *Schema_privilege_listContext) + + // ExitSchema_privilege is called when exiting the schema_privilege production. + ExitSchema_privilege(c *Schema_privilegeContext) + + // ExitDatabase_privilege_list is called when exiting the database_privilege_list production. + ExitDatabase_privilege_list(c *Database_privilege_listContext) + + // ExitDatabase_privilege is called when exiting the database_privilege production. + ExitDatabase_privilege(c *Database_privilegeContext) + + // ExitGrant_database_target is called when exiting the grant_database_target production. + ExitGrant_database_target(c *Grant_database_targetContext) + + // ExitGrant_table_target is called when exiting the grant_table_target production. + ExitGrant_table_target(c *Grant_table_targetContext) + + // ExitRevoke_table_target is called when exiting the revoke_table_target production. + ExitRevoke_table_target(c *Revoke_table_targetContext) + + // ExitAll_tables_in_schema_list is called when exiting the all_tables_in_schema_list production. + ExitAll_tables_in_schema_list(c *All_tables_in_schema_listContext) + + // ExitAll_privileges is called when exiting the all_privileges production. + ExitAll_privileges(c *All_privilegesContext) + + // ExitGrantee_list is called when exiting the grantee_list production. + ExitGrantee_list(c *Grantee_listContext) + + // ExitGrantee is called when exiting the grantee production. + ExitGrantee(c *GranteeContext) + + // ExitOpt_with_grant_option is called when exiting the opt_with_grant_option production. + ExitOpt_with_grant_option(c *Opt_with_grant_optionContext) + + // ExitTable_privilege is called when exiting the table_privilege production. + ExitTable_privilege(c *Table_privilegeContext) + + // ExitTable_privilege_list is called when exiting the table_privilege_list production. + ExitTable_privilege_list(c *Table_privilege_listContext) + + // ExitRevokestmt is called when exiting the revokestmt production. + ExitRevokestmt(c *RevokestmtContext) + + // ExitRevoke_permissions_for_rls_lookup_tables is called when exiting the revoke_permissions_for_rls_lookup_tables production. + ExitRevoke_permissions_for_rls_lookup_tables(c *Revoke_permissions_for_rls_lookup_tablesContext) + + // ExitRevoke_explain_permissions_for_row_level_security_policy_filters is called when exiting the revoke_explain_permissions_for_row_level_security_policy_filters production. + ExitRevoke_explain_permissions_for_row_level_security_policy_filters(c *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) + + // ExitRevoke_machine_learning_permissions is called when exiting the revoke_machine_learning_permissions production. + ExitRevoke_machine_learning_permissions(c *Revoke_machine_learning_permissionsContext) + + // ExitRevoke_role_permissions is called when exiting the revoke_role_permissions production. + ExitRevoke_role_permissions(c *Revoke_role_permissionsContext) + + // ExitRevoke_scoped_permissions is called when exiting the revoke_scoped_permissions production. + ExitRevoke_scoped_permissions(c *Revoke_scoped_permissionsContext) + + // ExitRevoke_scoped_schemas_permissions is called when exiting the revoke_scoped_schemas_permissions production. + ExitRevoke_scoped_schemas_permissions(c *Revoke_scoped_schemas_permissionsContext) + + // ExitRevoke_scoped_tables_permissions is called when exiting the revoke_scoped_tables_permissions production. + ExitRevoke_scoped_tables_permissions(c *Revoke_scoped_tables_permissionsContext) + + // ExitRevoke_scoped_functions_permissions is called when exiting the revoke_scoped_functions_permissions production. + ExitRevoke_scoped_functions_permissions(c *Revoke_scoped_functions_permissionsContext) + + // ExitRevoke_scoped_procedures_permissions is called when exiting the revoke_scoped_procedures_permissions production. + ExitRevoke_scoped_procedures_permissions(c *Revoke_scoped_procedures_permissionsContext) + + // ExitRevoke_scoped_languages_permissions is called when exiting the revoke_scoped_languages_permissions production. + ExitRevoke_scoped_languages_permissions(c *Revoke_scoped_languages_permissionsContext) + + // ExitRevoke_scoped_copy_jobs_permissions is called when exiting the revoke_scoped_copy_jobs_permissions production. + ExitRevoke_scoped_copy_jobs_permissions(c *Revoke_scoped_copy_jobs_permissionsContext) + + // ExitRevoke_datashare_permissions is called when exiting the revoke_datashare_permissions production. + ExitRevoke_datashare_permissions(c *Revoke_datashare_permissionsContext) + + // ExitRevoke_spectrum_integration_permissions is called when exiting the revoke_spectrum_integration_permissions production. + ExitRevoke_spectrum_integration_permissions(c *Revoke_spectrum_integration_permissionsContext) + + // ExitRevoke_spectrum_integration_external_schema_permissions is called when exiting the revoke_spectrum_integration_external_schema_permissions production. + ExitRevoke_spectrum_integration_external_schema_permissions(c *Revoke_spectrum_integration_external_schema_permissionsContext) + + // ExitRevoke_spectrum_integration_external_table_permissions is called when exiting the revoke_spectrum_integration_external_table_permissions production. + ExitRevoke_spectrum_integration_external_table_permissions(c *Revoke_spectrum_integration_external_table_permissionsContext) + + // ExitRevoke_spectrum_integration_extenral_column_permissions is called when exiting the revoke_spectrum_integration_extenral_column_permissions production. + ExitRevoke_spectrum_integration_extenral_column_permissions(c *Revoke_spectrum_integration_extenral_column_permissionsContext) + + // ExitRevoke_assume_role_permissions is called when exiting the revoke_assume_role_permissions production. + ExitRevoke_assume_role_permissions(c *Revoke_assume_role_permissionsContext) + + // ExitRevoke_column_level_permissions is called when exiting the revoke_column_level_permissions production. + ExitRevoke_column_level_permissions(c *Revoke_column_level_permissionsContext) + + // ExitCommon_revoke is called when exiting the common_revoke production. + ExitCommon_revoke(c *Common_revokeContext) + + // ExitPrivileges is called when exiting the privileges production. + ExitPrivileges(c *PrivilegesContext) + + // ExitPrivilege_list is called when exiting the privilege_list production. + ExitPrivilege_list(c *Privilege_listContext) + + // ExitPrivilege is called when exiting the privilege production. + ExitPrivilege(c *PrivilegeContext) + + // ExitPrivilege_target is called when exiting the privilege_target production. + ExitPrivilege_target(c *Privilege_targetContext) + + // ExitParameter_name_list is called when exiting the parameter_name_list production. + ExitParameter_name_list(c *Parameter_name_listContext) + + // ExitParameter_name is called when exiting the parameter_name production. + ExitParameter_name(c *Parameter_nameContext) + + // ExitOpt_grant_grant_option is called when exiting the opt_grant_grant_option production. + ExitOpt_grant_grant_option(c *Opt_grant_grant_optionContext) + + // ExitGrantrolestmt is called when exiting the grantrolestmt production. + ExitGrantrolestmt(c *GrantrolestmtContext) + + // ExitRevokerolestmt is called when exiting the revokerolestmt production. + ExitRevokerolestmt(c *RevokerolestmtContext) + + // ExitOpt_grant_admin_option is called when exiting the opt_grant_admin_option production. + ExitOpt_grant_admin_option(c *Opt_grant_admin_optionContext) + + // ExitOpt_granted_by is called when exiting the opt_granted_by production. + ExitOpt_granted_by(c *Opt_granted_byContext) + + // ExitAlterdefaultprivilegesstmt is called when exiting the alterdefaultprivilegesstmt production. + ExitAlterdefaultprivilegesstmt(c *AlterdefaultprivilegesstmtContext) + + // ExitDefacloptionlist is called when exiting the defacloptionlist production. + ExitDefacloptionlist(c *DefacloptionlistContext) + + // ExitDefacloption is called when exiting the defacloption production. + ExitDefacloption(c *DefacloptionContext) + + // ExitDefaclaction is called when exiting the defaclaction production. + ExitDefaclaction(c *DefaclactionContext) + + // ExitDefacl_privilege_target is called when exiting the defacl_privilege_target production. + ExitDefacl_privilege_target(c *Defacl_privilege_targetContext) + + // ExitIndexstmt is called when exiting the indexstmt production. + ExitIndexstmt(c *IndexstmtContext) + + // ExitOpt_unique is called when exiting the opt_unique production. + ExitOpt_unique(c *Opt_uniqueContext) + + // ExitOpt_concurrently is called when exiting the opt_concurrently production. + ExitOpt_concurrently(c *Opt_concurrentlyContext) + + // ExitOpt_index_name is called when exiting the opt_index_name production. + ExitOpt_index_name(c *Opt_index_nameContext) + + // ExitAccess_method_clause is called when exiting the access_method_clause production. + ExitAccess_method_clause(c *Access_method_clauseContext) + + // ExitIndex_params is called when exiting the index_params production. + ExitIndex_params(c *Index_paramsContext) + + // ExitIndex_elem_options is called when exiting the index_elem_options production. + ExitIndex_elem_options(c *Index_elem_optionsContext) + + // ExitIndex_elem is called when exiting the index_elem production. + ExitIndex_elem(c *Index_elemContext) + + // ExitOpt_include is called when exiting the opt_include production. + ExitOpt_include(c *Opt_includeContext) + + // ExitIndex_including_params is called when exiting the index_including_params production. + ExitIndex_including_params(c *Index_including_paramsContext) + + // ExitOpt_collate is called when exiting the opt_collate production. + ExitOpt_collate(c *Opt_collateContext) + + // ExitOpt_class is called when exiting the opt_class production. + ExitOpt_class(c *Opt_classContext) + + // ExitOpt_asc_desc is called when exiting the opt_asc_desc production. + ExitOpt_asc_desc(c *Opt_asc_descContext) + + // ExitOpt_nulls_order is called when exiting the opt_nulls_order production. + ExitOpt_nulls_order(c *Opt_nulls_orderContext) + + // ExitCreatefunctionstmt is called when exiting the createfunctionstmt production. + ExitCreatefunctionstmt(c *CreatefunctionstmtContext) + + // ExitCreateprocedurestmt is called when exiting the createprocedurestmt production. + ExitCreateprocedurestmt(c *CreateprocedurestmtContext) + + // ExitOpt_nonatomic is called when exiting the opt_nonatomic production. + ExitOpt_nonatomic(c *Opt_nonatomicContext) + + // ExitOpt_or_replace is called when exiting the opt_or_replace production. + ExitOpt_or_replace(c *Opt_or_replaceContext) + + // ExitFunc_py_args_or_sql_args is called when exiting the func_py_args_or_sql_args production. + ExitFunc_py_args_or_sql_args(c *Func_py_args_or_sql_argsContext) + + // ExitFunc_py_args_or_sql_args_list is called when exiting the func_py_args_or_sql_args_list production. + ExitFunc_py_args_or_sql_args_list(c *Func_py_args_or_sql_args_listContext) + + // ExitFunc_args is called when exiting the func_args production. + ExitFunc_args(c *Func_argsContext) + + // ExitFunc_args_list is called when exiting the func_args_list production. + ExitFunc_args_list(c *Func_args_listContext) + + // ExitFunction_with_argtypes_list is called when exiting the function_with_argtypes_list production. + ExitFunction_with_argtypes_list(c *Function_with_argtypes_listContext) + + // ExitFunction_with_argtypes is called when exiting the function_with_argtypes production. + ExitFunction_with_argtypes(c *Function_with_argtypesContext) + + // ExitFunc_args_with_defaults is called when exiting the func_args_with_defaults production. + ExitFunc_args_with_defaults(c *Func_args_with_defaultsContext) + + // ExitFunc_args_with_defaults_list is called when exiting the func_args_with_defaults_list production. + ExitFunc_args_with_defaults_list(c *Func_args_with_defaults_listContext) + + // ExitFunc_arg is called when exiting the func_arg production. + ExitFunc_arg(c *Func_argContext) + + // ExitArg_class is called when exiting the arg_class production. + ExitArg_class(c *Arg_classContext) + + // ExitParam_name is called when exiting the param_name production. + ExitParam_name(c *Param_nameContext) + + // ExitFunc_return is called when exiting the func_return production. + ExitFunc_return(c *Func_returnContext) + + // ExitFunc_type is called when exiting the func_type production. + ExitFunc_type(c *Func_typeContext) + + // ExitFunc_arg_with_default is called when exiting the func_arg_with_default production. + ExitFunc_arg_with_default(c *Func_arg_with_defaultContext) + + // ExitAggr_arg is called when exiting the aggr_arg production. + ExitAggr_arg(c *Aggr_argContext) + + // ExitAggr_args is called when exiting the aggr_args production. + ExitAggr_args(c *Aggr_argsContext) + + // ExitAggr_args_list is called when exiting the aggr_args_list production. + ExitAggr_args_list(c *Aggr_args_listContext) + + // ExitAggregate_with_argtypes is called when exiting the aggregate_with_argtypes production. + ExitAggregate_with_argtypes(c *Aggregate_with_argtypesContext) + + // ExitAggregate_with_argtypes_list is called when exiting the aggregate_with_argtypes_list production. + ExitAggregate_with_argtypes_list(c *Aggregate_with_argtypes_listContext) + + // ExitCreatefunc_opt_list is called when exiting the createfunc_opt_list production. + ExitCreatefunc_opt_list(c *Createfunc_opt_listContext) + + // ExitCommon_func_opt_item is called when exiting the common_func_opt_item production. + ExitCommon_func_opt_item(c *Common_func_opt_itemContext) + + // ExitCreatefunc_opt_item is called when exiting the createfunc_opt_item production. + ExitCreatefunc_opt_item(c *Createfunc_opt_itemContext) + + // ExitFunc_as is called when exiting the func_as production. + ExitFunc_as(c *Func_asContext) + + // ExitTransform_type_list is called when exiting the transform_type_list production. + ExitTransform_type_list(c *Transform_type_listContext) + + // ExitOpt_definition is called when exiting the opt_definition production. + ExitOpt_definition(c *Opt_definitionContext) + + // ExitTable_func_column is called when exiting the table_func_column production. + ExitTable_func_column(c *Table_func_columnContext) + + // ExitTable_func_column_list is called when exiting the table_func_column_list production. + ExitTable_func_column_list(c *Table_func_column_listContext) + + // ExitAlterfunctionstmt is called when exiting the alterfunctionstmt production. + ExitAlterfunctionstmt(c *AlterfunctionstmtContext) + + // ExitAlterprocedurestmt is called when exiting the alterprocedurestmt production. + ExitAlterprocedurestmt(c *AlterprocedurestmtContext) + + // ExitAlterfunc_opt_list is called when exiting the alterfunc_opt_list production. + ExitAlterfunc_opt_list(c *Alterfunc_opt_listContext) + + // ExitOpt_restrict is called when exiting the opt_restrict production. + ExitOpt_restrict(c *Opt_restrictContext) + + // ExitRemovefuncstmt is called when exiting the removefuncstmt production. + ExitRemovefuncstmt(c *RemovefuncstmtContext) + + // ExitRemoveaggrstmt is called when exiting the removeaggrstmt production. + ExitRemoveaggrstmt(c *RemoveaggrstmtContext) + + // ExitRemoveoperstmt is called when exiting the removeoperstmt production. + ExitRemoveoperstmt(c *RemoveoperstmtContext) + + // ExitOper_argtypes is called when exiting the oper_argtypes production. + ExitOper_argtypes(c *Oper_argtypesContext) + + // ExitAny_operator is called when exiting the any_operator production. + ExitAny_operator(c *Any_operatorContext) + + // ExitOperator_with_argtypes_list is called when exiting the operator_with_argtypes_list production. + ExitOperator_with_argtypes_list(c *Operator_with_argtypes_listContext) + + // ExitOperator_with_argtypes is called when exiting the operator_with_argtypes production. + ExitOperator_with_argtypes(c *Operator_with_argtypesContext) + + // ExitDostmt is called when exiting the dostmt production. + ExitDostmt(c *DostmtContext) + + // ExitDostmt_opt_list is called when exiting the dostmt_opt_list production. + ExitDostmt_opt_list(c *Dostmt_opt_listContext) + + // ExitDostmt_opt_item is called when exiting the dostmt_opt_item production. + ExitDostmt_opt_item(c *Dostmt_opt_itemContext) + + // ExitCreatecaststmt is called when exiting the createcaststmt production. + ExitCreatecaststmt(c *CreatecaststmtContext) + + // ExitCast_context is called when exiting the cast_context production. + ExitCast_context(c *Cast_contextContext) + + // ExitDropcaststmt is called when exiting the dropcaststmt production. + ExitDropcaststmt(c *DropcaststmtContext) + + // ExitOpt_if_exists is called when exiting the opt_if_exists production. + ExitOpt_if_exists(c *Opt_if_existsContext) + + // ExitCreatetransformstmt is called when exiting the createtransformstmt production. + ExitCreatetransformstmt(c *CreatetransformstmtContext) + + // ExitTransform_element_list is called when exiting the transform_element_list production. + ExitTransform_element_list(c *Transform_element_listContext) + + // ExitDroptransformstmt is called when exiting the droptransformstmt production. + ExitDroptransformstmt(c *DroptransformstmtContext) + + // ExitReindexstmt is called when exiting the reindexstmt production. + ExitReindexstmt(c *ReindexstmtContext) + + // ExitReindex_target_type is called when exiting the reindex_target_type production. + ExitReindex_target_type(c *Reindex_target_typeContext) + + // ExitReindex_target_multitable is called when exiting the reindex_target_multitable production. + ExitReindex_target_multitable(c *Reindex_target_multitableContext) + + // ExitReindex_option_list is called when exiting the reindex_option_list production. + ExitReindex_option_list(c *Reindex_option_listContext) + + // ExitReindex_option_elem is called when exiting the reindex_option_elem production. + ExitReindex_option_elem(c *Reindex_option_elemContext) + + // ExitAltertblspcstmt is called when exiting the altertblspcstmt production. + ExitAltertblspcstmt(c *AltertblspcstmtContext) + + // ExitRenamestmt is called when exiting the renamestmt production. + ExitRenamestmt(c *RenamestmtContext) + + // ExitOpt_column is called when exiting the opt_column production. + ExitOpt_column(c *Opt_columnContext) + + // ExitOpt_set_data is called when exiting the opt_set_data production. + ExitOpt_set_data(c *Opt_set_dataContext) + + // ExitAlterobjectdependsstmt is called when exiting the alterobjectdependsstmt production. + ExitAlterobjectdependsstmt(c *AlterobjectdependsstmtContext) + + // ExitOpt_no is called when exiting the opt_no production. + ExitOpt_no(c *Opt_noContext) + + // ExitAlterobjectschemastmt is called when exiting the alterobjectschemastmt production. + ExitAlterobjectschemastmt(c *AlterobjectschemastmtContext) + + // ExitAlteroperatorstmt is called when exiting the alteroperatorstmt production. + ExitAlteroperatorstmt(c *AlteroperatorstmtContext) + + // ExitOperator_def_list is called when exiting the operator_def_list production. + ExitOperator_def_list(c *Operator_def_listContext) + + // ExitOperator_def_elem is called when exiting the operator_def_elem production. + ExitOperator_def_elem(c *Operator_def_elemContext) + + // ExitOperator_def_arg is called when exiting the operator_def_arg production. + ExitOperator_def_arg(c *Operator_def_argContext) + + // ExitAltertypestmt is called when exiting the altertypestmt production. + ExitAltertypestmt(c *AltertypestmtContext) + + // ExitAlterownerstmt is called when exiting the alterownerstmt production. + ExitAlterownerstmt(c *AlterownerstmtContext) + + // ExitCreatepublicationstmt is called when exiting the createpublicationstmt production. + ExitCreatepublicationstmt(c *CreatepublicationstmtContext) + + // ExitPub_obj_list is called when exiting the pub_obj_list production. + ExitPub_obj_list(c *Pub_obj_listContext) + + // ExitPublication_obj_spec is called when exiting the publication_obj_spec production. + ExitPublication_obj_spec(c *Publication_obj_specContext) + + // ExitOpt_where_clause is called when exiting the opt_where_clause production. + ExitOpt_where_clause(c *Opt_where_clauseContext) + + // ExitAlterpublicationstmt is called when exiting the alterpublicationstmt production. + ExitAlterpublicationstmt(c *AlterpublicationstmtContext) + + // ExitCreatesubscriptionstmt is called when exiting the createsubscriptionstmt production. + ExitCreatesubscriptionstmt(c *CreatesubscriptionstmtContext) + + // ExitPublication_name_list is called when exiting the publication_name_list production. + ExitPublication_name_list(c *Publication_name_listContext) + + // ExitPublication_name_item is called when exiting the publication_name_item production. + ExitPublication_name_item(c *Publication_name_itemContext) + + // ExitAltersubscriptionstmt is called when exiting the altersubscriptionstmt production. + ExitAltersubscriptionstmt(c *AltersubscriptionstmtContext) + + // ExitDropsubscriptionstmt is called when exiting the dropsubscriptionstmt production. + ExitDropsubscriptionstmt(c *DropsubscriptionstmtContext) + + // ExitRulestmt is called when exiting the rulestmt production. + ExitRulestmt(c *RulestmtContext) + + // ExitRuleactionlist is called when exiting the ruleactionlist production. + ExitRuleactionlist(c *RuleactionlistContext) + + // ExitRuleactionmulti is called when exiting the ruleactionmulti production. + ExitRuleactionmulti(c *RuleactionmultiContext) + + // ExitRuleactionstmt is called when exiting the ruleactionstmt production. + ExitRuleactionstmt(c *RuleactionstmtContext) + + // ExitRuleactionstmtOrEmpty is called when exiting the ruleactionstmtOrEmpty production. + ExitRuleactionstmtOrEmpty(c *RuleactionstmtOrEmptyContext) + + // ExitEvent is called when exiting the event production. + ExitEvent(c *EventContext) + + // ExitOpt_instead is called when exiting the opt_instead production. + ExitOpt_instead(c *Opt_insteadContext) + + // ExitNotifystmt is called when exiting the notifystmt production. + ExitNotifystmt(c *NotifystmtContext) + + // ExitNotify_payload is called when exiting the notify_payload production. + ExitNotify_payload(c *Notify_payloadContext) + + // ExitListenstmt is called when exiting the listenstmt production. + ExitListenstmt(c *ListenstmtContext) + + // ExitUnlistenstmt is called when exiting the unlistenstmt production. + ExitUnlistenstmt(c *UnlistenstmtContext) + + // ExitTransactionstmt is called when exiting the transactionstmt production. + ExitTransactionstmt(c *TransactionstmtContext) + + // ExitOpt_transaction is called when exiting the opt_transaction production. + ExitOpt_transaction(c *Opt_transactionContext) + + // ExitTransaction_mode_item is called when exiting the transaction_mode_item production. + ExitTransaction_mode_item(c *Transaction_mode_itemContext) + + // ExitTransaction_mode_list is called when exiting the transaction_mode_list production. + ExitTransaction_mode_list(c *Transaction_mode_listContext) + + // ExitTransaction_mode_list_or_empty is called when exiting the transaction_mode_list_or_empty production. + ExitTransaction_mode_list_or_empty(c *Transaction_mode_list_or_emptyContext) + + // ExitOpt_transaction_chain is called when exiting the opt_transaction_chain production. + ExitOpt_transaction_chain(c *Opt_transaction_chainContext) + + // ExitViewstmt is called when exiting the viewstmt production. + ExitViewstmt(c *ViewstmtContext) + + // ExitWith_no_schema_binding is called when exiting the with_no_schema_binding production. + ExitWith_no_schema_binding(c *With_no_schema_bindingContext) + + // ExitOpt_check_option is called when exiting the opt_check_option production. + ExitOpt_check_option(c *Opt_check_optionContext) + + // ExitLoadstmt is called when exiting the loadstmt production. + ExitLoadstmt(c *LoadstmtContext) + + // ExitAlterdatasharestmt is called when exiting the alterdatasharestmt production. + ExitAlterdatasharestmt(c *AlterdatasharestmtContext) + + // ExitAlterdatashare_action is called when exiting the alterdatashare_action production. + ExitAlterdatashare_action(c *Alterdatashare_actionContext) + + // ExitAlterdatashare_add_drop is called when exiting the alterdatashare_add_drop production. + ExitAlterdatashare_add_drop(c *Alterdatashare_add_dropContext) + + // ExitAlterdatashare_objects is called when exiting the alterdatashare_objects production. + ExitAlterdatashare_objects(c *Alterdatashare_objectsContext) + + // ExitDatashare_table_list is called when exiting the datashare_table_list production. + ExitDatashare_table_list(c *Datashare_table_listContext) + + // ExitDatashare_table_name is called when exiting the datashare_table_name production. + ExitDatashare_table_name(c *Datashare_table_nameContext) + + // ExitTable_name is called when exiting the table_name production. + ExitTable_name(c *Table_nameContext) + + // ExitTemporary_table_name is called when exiting the temporary_table_name production. + ExitTemporary_table_name(c *Temporary_table_nameContext) + + // ExitDatashare_function_list is called when exiting the datashare_function_list production. + ExitDatashare_function_list(c *Datashare_function_listContext) + + // ExitDatashare_function is called when exiting the datashare_function production. + ExitDatashare_function(c *Datashare_functionContext) + + // ExitDatashare_function_name is called when exiting the datashare_function_name production. + ExitDatashare_function_name(c *Datashare_function_nameContext) + + // ExitCreatedatasharestmt is called when exiting the createdatasharestmt production. + ExitCreatedatasharestmt(c *CreatedatasharestmtContext) + + // ExitCreatedatashareoptions is called when exiting the createdatashareoptions production. + ExitCreatedatashareoptions(c *CreatedatashareoptionsContext) + + // ExitCreatedatashareoption is called when exiting the createdatashareoption production. + ExitCreatedatashareoption(c *CreatedatashareoptionContext) + + // ExitSetpublicaccessibleoption is called when exiting the setpublicaccessibleoption production. + ExitSetpublicaccessibleoption(c *SetpublicaccessibleoptionContext) + + // ExitManagedbyoption is called when exiting the managedbyoption production. + ExitManagedbyoption(c *ManagedbyoptionContext) + + // ExitDescdatasharestmt is called when exiting the descdatasharestmt production. + ExitDescdatasharestmt(c *DescdatasharestmtContext) + + // ExitDropdatasharestmt is called when exiting the dropdatasharestmt production. + ExitDropdatasharestmt(c *DropdatasharestmtContext) + + // ExitAlterexternalschemastmt is called when exiting the alterexternalschemastmt production. + ExitAlterexternalschemastmt(c *AlterexternalschemastmtContext) + + // ExitAltexternalschemaopts is called when exiting the altexternalschemaopts production. + ExitAltexternalschemaopts(c *AltexternalschemaoptsContext) + + // ExitAlterexternalviewstmt is called when exiting the alterexternalviewstmt production. + ExitAlterexternalviewstmt(c *AlterexternalviewstmtContext) + + // ExitCreateexternalschemastmt is called when exiting the createexternalschemastmt production. + ExitCreateexternalschemastmt(c *CreateexternalschemastmtContext) + + // ExitFromdatacatalogclause is called when exiting the fromdatacatalogclause production. + ExitFromdatacatalogclause(c *FromdatacatalogclauseContext) + + // ExitDropschemastmt is called when exiting the dropschemastmt production. + ExitDropschemastmt(c *DropschemastmtContext) + + // ExitImplicitdatacatalogclause is called when exiting the implicitdatacatalogclause production. + ExitImplicitdatacatalogclause(c *ImplicitdatacatalogclauseContext) + + // ExitFromhivemetastoreclause is called when exiting the fromhivemetastoreclause production. + ExitFromhivemetastoreclause(c *FromhivemetastoreclauseContext) + + // ExitFrompostgresclause is called when exiting the frompostgresclause production. + ExitFrompostgresclause(c *FrompostgresclauseContext) + + // ExitFrommysqlclause is called when exiting the frommysqlclause production. + ExitFrommysqlclause(c *FrommysqlclauseContext) + + // ExitFromkinesisclause is called when exiting the fromkinesisclause production. + ExitFromkinesisclause(c *FromkinesisclauseContext) + + // ExitFromkafkaclause is called when exiting the fromkafkaclause production. + ExitFromkafkaclause(c *FromkafkaclauseContext) + + // ExitFrommskclause is called when exiting the frommskclause production. + ExitFrommskclause(c *FrommskclauseContext) + + // ExitFromredshiftclause is called when exiting the fromredshiftclause production. + ExitFromredshiftclause(c *FromredshiftclauseContext) + + // ExitIamrolevalue is called when exiting the iamrolevalue production. + ExitIamrolevalue(c *IamrolevalueContext) + + // ExitCatalogrolevalue is called when exiting the catalogrolevalue production. + ExitCatalogrolevalue(c *CatalogrolevalueContext) + + // ExitAuthenticationvalue is called when exiting the authenticationvalue production. + ExitAuthenticationvalue(c *AuthenticationvalueContext) + + // ExitCreateexternalfunctionstmt is called when exiting the createexternalfunctionstmt production. + ExitCreateexternalfunctionstmt(c *CreateexternalfunctionstmtContext) + + // ExitExternal_func_params is called when exiting the external_func_params production. + ExitExternal_func_params(c *External_func_paramsContext) + + // ExitParamlist is called when exiting the paramlist production. + ExitParamlist(c *ParamlistContext) + + // ExitParam_spec is called when exiting the param_spec production. + ExitParam_spec(c *Param_specContext) + + // ExitCreateexternalmodelstmt is called when exiting the createexternalmodelstmt production. + ExitCreateexternalmodelstmt(c *CreateexternalmodelstmtContext) + + // ExitCreateexternaltablestmt is called when exiting the createexternaltablestmt production. + ExitCreateexternaltablestmt(c *CreateexternaltablestmtContext) + + // ExitExtern_column_list is called when exiting the extern_column_list production. + ExitExtern_column_list(c *Extern_column_listContext) + + // ExitExtern_column_def is called when exiting the extern_column_def production. + ExitExtern_column_def(c *Extern_column_defContext) + + // ExitExtern_typename is called when exiting the extern_typename production. + ExitExtern_typename(c *Extern_typenameContext) + + // ExitExtern_table_format is called when exiting the extern_table_format production. + ExitExtern_table_format(c *Extern_table_formatContext) + + // ExitRow_format_spec is called when exiting the row_format_spec production. + ExitRow_format_spec(c *Row_format_specContext) + + // ExitSerde_properties_list is called when exiting the serde_properties_list production. + ExitSerde_properties_list(c *Serde_properties_listContext) + + // ExitSerde_property is called when exiting the serde_property production. + ExitSerde_property(c *Serde_propertyContext) + + // ExitExternal_format_spec is called when exiting the external_format_spec production. + ExitExternal_format_spec(c *External_format_specContext) + + // ExitTable_properties_list is called when exiting the table_properties_list production. + ExitTable_properties_list(c *Table_properties_listContext) + + // ExitTable_property is called when exiting the table_property production. + ExitTable_property(c *Table_propertyContext) + + // ExitCreateexternalviewstmt is called when exiting the createexternalviewstmt production. + ExitCreateexternalviewstmt(c *CreateexternalviewstmtContext) + + // ExitDropexternalviewstmt is called when exiting the dropexternalviewstmt production. + ExitDropexternalviewstmt(c *DropexternalviewstmtContext) + + // ExitAlteridentityproviderstmt is called when exiting the alteridentityproviderstmt production. + ExitAlteridentityproviderstmt(c *AlteridentityproviderstmtContext) + + // ExitAlteridprovideropts is called when exiting the alteridprovideropts production. + ExitAlteridprovideropts(c *AlteridprovideroptsContext) + + // ExitAltermaskingpolicystmt is called when exiting the altermaskingpolicystmt production. + ExitAltermaskingpolicystmt(c *AltermaskingpolicystmtContext) + + // ExitAltermaterializedviewstmt is called when exiting the altermaterializedviewstmt production. + ExitAltermaterializedviewstmt(c *AltermaterializedviewstmtContext) + + // ExitAltmaskingpolicyopts is called when exiting the altmaskingpolicyopts production. + ExitAltmaskingpolicyopts(c *AltmaskingpolicyoptsContext) + + // ExitAltmaskingpolicyargs is called when exiting the altmaskingpolicyargs production. + ExitAltmaskingpolicyargs(c *AltmaskingpolicyargsContext) + + // ExitAltmaskingpolicyarg is called when exiting the altmaskingpolicyarg production. + ExitAltmaskingpolicyarg(c *AltmaskingpolicyargContext) + + // ExitAlterrlspolicystmt is called when exiting the alterrlspolicystmt production. + ExitAlterrlspolicystmt(c *AlterrlspolicystmtContext) + + // ExitAttachmaskingpolicystmt is called when exiting the attachmaskingpolicystmt production. + ExitAttachmaskingpolicystmt(c *AttachmaskingpolicystmtContext) + + // ExitAttachpolicycollist is called when exiting the attachpolicycollist production. + ExitAttachpolicycollist(c *AttachpolicycollistContext) + + // ExitAttachpolicycolumn is called when exiting the attachpolicycolumn production. + ExitAttachpolicycolumn(c *AttachpolicycolumnContext) + + // ExitAttachpolicytargets is called when exiting the attachpolicytargets production. + ExitAttachpolicytargets(c *AttachpolicytargetsContext) + + // ExitAttachpolicytarget is called when exiting the attachpolicytarget production. + ExitAttachpolicytarget(c *AttachpolicytargetContext) + + // ExitAttachrlspolicystmt is called when exiting the attachrlspolicystmt production. + ExitAttachrlspolicystmt(c *AttachrlspolicystmtContext) + + // ExitTable_name_list is called when exiting the table_name_list production. + ExitTable_name_list(c *Table_name_listContext) + + // ExitCreateidentityproviderstmt is called when exiting the createidentityproviderstmt production. + ExitCreateidentityproviderstmt(c *CreateidentityproviderstmtContext) + + // ExitCreateidprovideropts is called when exiting the createidprovideropts production. + ExitCreateidprovideropts(c *CreateidprovideroptsContext) + + // ExitGroupfilter is called when exiting the groupfilter production. + ExitGroupfilter(c *GroupfilterContext) + + // ExitCreatelibrarystmt is called when exiting the createlibrarystmt production. + ExitCreatelibrarystmt(c *CreatelibrarystmtContext) + + // ExitCreatelibraryopts is called when exiting the createlibraryopts production. + ExitCreatelibraryopts(c *CreatelibraryoptsContext) + + // ExitCreatemaskingpolicystmt is called when exiting the createmaskingpolicystmt production. + ExitCreatemaskingpolicystmt(c *CreatemaskingpolicystmtContext) + + // ExitInputcolumnlist is called when exiting the inputcolumnlist production. + ExitInputcolumnlist(c *InputcolumnlistContext) + + // ExitInputcolumn is called when exiting the inputcolumn production. + ExitInputcolumn(c *InputcolumnContext) + + // ExitMaskingexpression is called when exiting the maskingexpression production. + ExitMaskingexpression(c *MaskingexpressionContext) + + // ExitCreatemodelstmt is called when exiting the createmodelstmt production. + ExitCreatemodelstmt(c *CreatemodelstmtContext) + + // ExitCreatemodelfromclause is called when exiting the createmodelfromclause production. + ExitCreatemodelfromclause(c *CreatemodelfromclauseContext) + + // ExitIamrolespec is called when exiting the iamrolespec production. + ExitIamrolespec(c *IamrolespecContext) + + // ExitSagemakerspec is called when exiting the sagemakerspec production. + ExitSagemakerspec(c *SagemakerspecContext) + + // ExitModeltypespec is called when exiting the modeltypespec production. + ExitModeltypespec(c *ModeltypespecContext) + + // ExitProblemtypespec is called when exiting the problemtypespec production. + ExitProblemtypespec(c *ProblemtypespecContext) + + // ExitProblemtype is called when exiting the problemtype production. + ExitProblemtype(c *ProblemtypeContext) + + // ExitObjectivespec is called when exiting the objectivespec production. + ExitObjectivespec(c *ObjectivespecContext) + + // ExitHyperparametersspec is called when exiting the hyperparametersspec production. + ExitHyperparametersspec(c *HyperparametersspecContext) + + // ExitHyperparameterslist is called when exiting the hyperparameterslist production. + ExitHyperparameterslist(c *HyperparameterslistContext) + + // ExitHyperparameteritem is called when exiting the hyperparameteritem production. + ExitHyperparameteritem(c *HyperparameteritemContext) + + // ExitSettingsclause is called when exiting the settingsclause production. + ExitSettingsclause(c *SettingsclauseContext) + + // ExitSettingsitem is called when exiting the settingsitem production. + ExitSettingsitem(c *SettingsitemContext) + + // ExitDatatypelist is called when exiting the datatypelist production. + ExitDatatypelist(c *DatatypelistContext) + + // ExitDatatype is called when exiting the datatype production. + ExitDatatype(c *DatatypeContext) + + // ExitCreaterlspolicystmt is called when exiting the createrlspolicystmt production. + ExitCreaterlspolicystmt(c *CreaterlspolicystmtContext) + + // ExitDescidentityproviderstmt is called when exiting the descidentityproviderstmt production. + ExitDescidentityproviderstmt(c *DescidentityproviderstmtContext) + + // ExitDetachmaskingpolicystmt is called when exiting the detachmaskingpolicystmt production. + ExitDetachmaskingpolicystmt(c *DetachmaskingpolicystmtContext) + + // ExitDetachrlspolicystmt is called when exiting the detachrlspolicystmt production. + ExitDetachrlspolicystmt(c *DetachrlspolicystmtContext) + + // ExitRole_or_user_or_public_list is called when exiting the role_or_user_or_public_list production. + ExitRole_or_user_or_public_list(c *Role_or_user_or_public_listContext) + + // ExitRole_or_user_or_public is called when exiting the role_or_user_or_public production. + ExitRole_or_user_or_public(c *Role_or_user_or_publicContext) + + // ExitRlspolicyname is called when exiting the rlspolicyname production. + ExitRlspolicyname(c *RlspolicynameContext) + + // ExitDropidentityproviderstmt is called when exiting the dropidentityproviderstmt production. + ExitDropidentityproviderstmt(c *DropidentityproviderstmtContext) + + // ExitDroplibrarystmt is called when exiting the droplibrarystmt production. + ExitDroplibrarystmt(c *DroplibrarystmtContext) + + // ExitDropmaskingpolicystmt is called when exiting the dropmaskingpolicystmt production. + ExitDropmaskingpolicystmt(c *DropmaskingpolicystmtContext) + + // ExitDropmodelstmt is called when exiting the dropmodelstmt production. + ExitDropmodelstmt(c *DropmodelstmtContext) + + // ExitDroprlspolicystmt is called when exiting the droprlspolicystmt production. + ExitDroprlspolicystmt(c *DroprlspolicystmtContext) + + // ExitAltertableappendstmt is called when exiting the altertableappendstmt production. + ExitAltertableappendstmt(c *AltertableappendstmtContext) + + // ExitAppendoptions is called when exiting the appendoptions production. + ExitAppendoptions(c *AppendoptionsContext) + + // ExitAlteruserstmt is called when exiting the alteruserstmt production. + ExitAlteruserstmt(c *AlteruserstmtContext) + + // ExitAlteruseropts is called when exiting the alteruseropts production. + ExitAlteruseropts(c *AlteruseroptsContext) + + // ExitAnalyzecompressionstmt is called when exiting the analyzecompressionstmt production. + ExitAnalyzecompressionstmt(c *AnalyzecompressionstmtContext) + + // ExitCancelstmt is called when exiting the cancelstmt production. + ExitCancelstmt(c *CancelstmtContext) + + // ExitClosestmt is called when exiting the closestmt production. + ExitClosestmt(c *ClosestmtContext) + + // ExitInsertexternaltablestmt is called when exiting the insertexternaltablestmt production. + ExitInsertexternaltablestmt(c *InsertexternaltablestmtContext) + + // ExitSelect_or_values is called when exiting the select_or_values production. + ExitSelect_or_values(c *Select_or_valuesContext) + + // ExitSelectintostmt is called when exiting the selectintostmt production. + ExitSelectintostmt(c *SelectintostmtContext) + + // ExitSetsessionauthorizationstmt is called when exiting the setsessionauthorizationstmt production. + ExitSetsessionauthorizationstmt(c *SetsessionauthorizationstmtContext) + + // ExitSetsessioncharacteristicsstmt is called when exiting the setsessioncharacteristicsstmt production. + ExitSetsessioncharacteristicsstmt(c *SetsessioncharacteristicsstmtContext) + + // ExitShowcolumnsstmt is called when exiting the showcolumnsstmt production. + ExitShowcolumnsstmt(c *ShowcolumnsstmtContext) + + // ExitShowdatabasesstmt is called when exiting the showdatabasesstmt production. + ExitShowdatabasesstmt(c *ShowdatabasesstmtContext) + + // ExitShowdbsopts is called when exiting the showdbsopts production. + ExitShowdbsopts(c *ShowdbsoptsContext) + + // ExitShowdatasharesstmt is called when exiting the showdatasharesstmt production. + ExitShowdatasharesstmt(c *ShowdatasharesstmtContext) + + // ExitShowexternaltablestmt is called when exiting the showexternaltablestmt production. + ExitShowexternaltablestmt(c *ShowexternaltablestmtContext) + + // ExitShowgrantsstmt is called when exiting the showgrantsstmt production. + ExitShowgrantsstmt(c *ShowgrantsstmtContext) + + // ExitGrantobject is called when exiting the grantobject production. + ExitGrantobject(c *GrantobjectContext) + + // ExitGrantprincipal is called when exiting the grantprincipal production. + ExitGrantprincipal(c *GrantprincipalContext) + + // ExitShowmodelstmt is called when exiting the showmodelstmt production. + ExitShowmodelstmt(c *ShowmodelstmtContext) + + // ExitShowprocedurestmt is called when exiting the showprocedurestmt production. + ExitShowprocedurestmt(c *ShowprocedurestmtContext) + + // ExitShowschemasstmt is called when exiting the showschemasstmt production. + ExitShowschemasstmt(c *ShowschemasstmtContext) + + // ExitShowtablestmt is called when exiting the showtablestmt production. + ExitShowtablestmt(c *ShowtablestmtContext) + + // ExitShowtablesstmt is called when exiting the showtablesstmt production. + ExitShowtablesstmt(c *ShowtablesstmtContext) + + // ExitShowviewstmt is called when exiting the showviewstmt production. + ExitShowviewstmt(c *ShowviewstmtContext) + + // ExitUnloadstmt is called when exiting the unloadstmt production. + ExitUnloadstmt(c *UnloadstmtContext) + + // ExitIamroleclause is called when exiting the iamroleclause production. + ExitIamroleclause(c *IamroleclauseContext) + + // ExitUnloadoptions is called when exiting the unloadoptions production. + ExitUnloadoptions(c *UnloadoptionsContext) + + // ExitFormatoption is called when exiting the formatoption production. + ExitFormatoption(c *FormatoptionContext) + + // ExitPartitionbyoption is called when exiting the partitionbyoption production. + ExitPartitionbyoption(c *PartitionbyoptionContext) + + // ExitManifestoption is called when exiting the manifestoption production. + ExitManifestoption(c *ManifestoptionContext) + + // ExitHeaderoption is called when exiting the headeroption production. + ExitHeaderoption(c *HeaderoptionContext) + + // ExitDelimiteroption is called when exiting the delimiteroption production. + ExitDelimiteroption(c *DelimiteroptionContext) + + // ExitFixedwidthoption is called when exiting the fixedwidthoption production. + ExitFixedwidthoption(c *FixedwidthoptionContext) + + // ExitEncryptedoption is called when exiting the encryptedoption production. + ExitEncryptedoption(c *EncryptedoptionContext) + + // ExitKmskeyoption is called when exiting the kmskeyoption production. + ExitKmskeyoption(c *KmskeyoptionContext) + + // ExitCompressionoption is called when exiting the compressionoption production. + ExitCompressionoption(c *CompressionoptionContext) + + // ExitAddquotesoption is called when exiting the addquotesoption production. + ExitAddquotesoption(c *AddquotesoptionContext) + + // ExitNullasoption is called when exiting the nullasoption production. + ExitNullasoption(c *NullasoptionContext) + + // ExitEscapeoption is called when exiting the escapeoption production. + ExitEscapeoption(c *EscapeoptionContext) + + // ExitAllowoverwriteoption is called when exiting the allowoverwriteoption production. + ExitAllowoverwriteoption(c *AllowoverwriteoptionContext) + + // ExitCleanpathoption is called when exiting the cleanpathoption production. + ExitCleanpathoption(c *CleanpathoptionContext) + + // ExitParalleloption is called when exiting the paralleloption production. + ExitParalleloption(c *ParalleloptionContext) + + // ExitMaxfilesizeoption is called when exiting the maxfilesizeoption production. + ExitMaxfilesizeoption(c *MaxfilesizeoptionContext) + + // ExitRowgroupsizeoption is called when exiting the rowgroupsizeoption production. + ExitRowgroupsizeoption(c *RowgroupsizeoptionContext) + + // ExitSizeunit is called when exiting the sizeunit production. + ExitSizeunit(c *SizeunitContext) + + // ExitRegionoption is called when exiting the regionoption production. + ExitRegionoption(c *RegionoptionContext) + + // ExitExtensionoption is called when exiting the extensionoption production. + ExitExtensionoption(c *ExtensionoptionContext) + + // ExitUsestmt is called when exiting the usestmt production. + ExitUsestmt(c *UsestmtContext) + + // ExitCreatedbstmt is called when exiting the createdbstmt production. + ExitCreatedbstmt(c *CreatedbstmtContext) + + // ExitCreatedb_opt_list is called when exiting the createdb_opt_list production. + ExitCreatedb_opt_list(c *Createdb_opt_listContext) + + // ExitCreatedb_opt_items is called when exiting the createdb_opt_items production. + ExitCreatedb_opt_items(c *Createdb_opt_itemsContext) + + // ExitCreatedb_opt_item is called when exiting the createdb_opt_item production. + ExitCreatedb_opt_item(c *Createdb_opt_itemContext) + + // ExitCreatedb_opt_name is called when exiting the createdb_opt_name production. + ExitCreatedb_opt_name(c *Createdb_opt_nameContext) + + // ExitOpt_equal is called when exiting the opt_equal production. + ExitOpt_equal(c *Opt_equalContext) + + // ExitAlterdatabasestmt is called when exiting the alterdatabasestmt production. + ExitAlterdatabasestmt(c *AlterdatabasestmtContext) + + // ExitAlterdatabasesetstmt is called when exiting the alterdatabasesetstmt production. + ExitAlterdatabasesetstmt(c *AlterdatabasesetstmtContext) + + // ExitDropdbstmt is called when exiting the dropdbstmt production. + ExitDropdbstmt(c *DropdbstmtContext) + + // ExitDrop_option_list is called when exiting the drop_option_list production. + ExitDrop_option_list(c *Drop_option_listContext) + + // ExitDrop_option is called when exiting the drop_option production. + ExitDrop_option(c *Drop_optionContext) + + // ExitAltercollationstmt is called when exiting the altercollationstmt production. + ExitAltercollationstmt(c *AltercollationstmtContext) + + // ExitAltersystemstmt is called when exiting the altersystemstmt production. + ExitAltersystemstmt(c *AltersystemstmtContext) + + // ExitCreatedomainstmt is called when exiting the createdomainstmt production. + ExitCreatedomainstmt(c *CreatedomainstmtContext) + + // ExitAlterdomainstmt is called when exiting the alterdomainstmt production. + ExitAlterdomainstmt(c *AlterdomainstmtContext) + + // ExitOpt_as is called when exiting the opt_as production. + ExitOpt_as(c *Opt_asContext) + + // ExitAltertsdictionarystmt is called when exiting the altertsdictionarystmt production. + ExitAltertsdictionarystmt(c *AltertsdictionarystmtContext) + + // ExitAltertsconfigurationstmt is called when exiting the altertsconfigurationstmt production. + ExitAltertsconfigurationstmt(c *AltertsconfigurationstmtContext) + + // ExitAny_with is called when exiting the any_with production. + ExitAny_with(c *Any_withContext) + + // ExitCreateconversionstmt is called when exiting the createconversionstmt production. + ExitCreateconversionstmt(c *CreateconversionstmtContext) + + // ExitClusterstmt is called when exiting the clusterstmt production. + ExitClusterstmt(c *ClusterstmtContext) + + // ExitCluster_index_specification is called when exiting the cluster_index_specification production. + ExitCluster_index_specification(c *Cluster_index_specificationContext) + + // ExitVacuumstmt is called when exiting the vacuumstmt production. + ExitVacuumstmt(c *VacuumstmtContext) + + // ExitVacuum_option is called when exiting the vacuum_option production. + ExitVacuum_option(c *Vacuum_optionContext) + + // ExitAnalyzestmt is called when exiting the analyzestmt production. + ExitAnalyzestmt(c *AnalyzestmtContext) + + // ExitVac_analyze_option_list is called when exiting the vac_analyze_option_list production. + ExitVac_analyze_option_list(c *Vac_analyze_option_listContext) + + // ExitAnalyze_keyword is called when exiting the analyze_keyword production. + ExitAnalyze_keyword(c *Analyze_keywordContext) + + // ExitVac_analyze_option_elem is called when exiting the vac_analyze_option_elem production. + ExitVac_analyze_option_elem(c *Vac_analyze_option_elemContext) + + // ExitVac_analyze_option_name is called when exiting the vac_analyze_option_name production. + ExitVac_analyze_option_name(c *Vac_analyze_option_nameContext) + + // ExitVac_analyze_option_arg is called when exiting the vac_analyze_option_arg production. + ExitVac_analyze_option_arg(c *Vac_analyze_option_argContext) + + // ExitOpt_analyze is called when exiting the opt_analyze production. + ExitOpt_analyze(c *Opt_analyzeContext) + + // ExitOpt_verbose is called when exiting the opt_verbose production. + ExitOpt_verbose(c *Opt_verboseContext) + + // ExitOpt_full is called when exiting the opt_full production. + ExitOpt_full(c *Opt_fullContext) + + // ExitOpt_freeze is called when exiting the opt_freeze production. + ExitOpt_freeze(c *Opt_freezeContext) + + // ExitOpt_name_list is called when exiting the opt_name_list production. + ExitOpt_name_list(c *Opt_name_listContext) + + // ExitVacuum_relation is called when exiting the vacuum_relation production. + ExitVacuum_relation(c *Vacuum_relationContext) + + // ExitVacuum_relation_list is called when exiting the vacuum_relation_list production. + ExitVacuum_relation_list(c *Vacuum_relation_listContext) + + // ExitOpt_vacuum_relation_list is called when exiting the opt_vacuum_relation_list production. + ExitOpt_vacuum_relation_list(c *Opt_vacuum_relation_listContext) + + // ExitExplainstmt is called when exiting the explainstmt production. + ExitExplainstmt(c *ExplainstmtContext) + + // ExitExplainablestmt is called when exiting the explainablestmt production. + ExitExplainablestmt(c *ExplainablestmtContext) + + // ExitExplain_option_list is called when exiting the explain_option_list production. + ExitExplain_option_list(c *Explain_option_listContext) + + // ExitExplain_option_elem is called when exiting the explain_option_elem production. + ExitExplain_option_elem(c *Explain_option_elemContext) + + // ExitExplain_option_name is called when exiting the explain_option_name production. + ExitExplain_option_name(c *Explain_option_nameContext) + + // ExitExplain_option_arg is called when exiting the explain_option_arg production. + ExitExplain_option_arg(c *Explain_option_argContext) + + // ExitPreparestmt is called when exiting the preparestmt production. + ExitPreparestmt(c *PreparestmtContext) + + // ExitPrep_type_clause is called when exiting the prep_type_clause production. + ExitPrep_type_clause(c *Prep_type_clauseContext) + + // ExitPreparablestmt is called when exiting the preparablestmt production. + ExitPreparablestmt(c *PreparablestmtContext) + + // ExitExecutestmt is called when exiting the executestmt production. + ExitExecutestmt(c *ExecutestmtContext) + + // ExitExecute_param_clause is called when exiting the execute_param_clause production. + ExitExecute_param_clause(c *Execute_param_clauseContext) + + // ExitDeallocatestmt is called when exiting the deallocatestmt production. + ExitDeallocatestmt(c *DeallocatestmtContext) + + // ExitInsertstmt is called when exiting the insertstmt production. + ExitInsertstmt(c *InsertstmtContext) + + // ExitInsert_target is called when exiting the insert_target production. + ExitInsert_target(c *Insert_targetContext) + + // ExitInsert_rest is called when exiting the insert_rest production. + ExitInsert_rest(c *Insert_restContext) + + // ExitOverride_kind is called when exiting the override_kind production. + ExitOverride_kind(c *Override_kindContext) + + // ExitInsert_column_list is called when exiting the insert_column_list production. + ExitInsert_column_list(c *Insert_column_listContext) + + // ExitInsert_column_item is called when exiting the insert_column_item production. + ExitInsert_column_item(c *Insert_column_itemContext) + + // ExitOpt_on_conflict is called when exiting the opt_on_conflict production. + ExitOpt_on_conflict(c *Opt_on_conflictContext) + + // ExitOpt_conf_expr is called when exiting the opt_conf_expr production. + ExitOpt_conf_expr(c *Opt_conf_exprContext) + + // ExitReturning_clause is called when exiting the returning_clause production. + ExitReturning_clause(c *Returning_clauseContext) + + // ExitMergestmt is called when exiting the mergestmt production. + ExitMergestmt(c *MergestmtContext) + + // ExitMerge_when_clause is called when exiting the merge_when_clause production. + ExitMerge_when_clause(c *Merge_when_clauseContext) + + // ExitMerge_insert_clause is called when exiting the merge_insert_clause production. + ExitMerge_insert_clause(c *Merge_insert_clauseContext) + + // ExitMerge_update_clause is called when exiting the merge_update_clause production. + ExitMerge_update_clause(c *Merge_update_clauseContext) + + // ExitMerge_delete_clause is called when exiting the merge_delete_clause production. + ExitMerge_delete_clause(c *Merge_delete_clauseContext) + + // ExitDeletestmt is called when exiting the deletestmt production. + ExitDeletestmt(c *DeletestmtContext) + + // ExitUsing_clause is called when exiting the using_clause production. + ExitUsing_clause(c *Using_clauseContext) + + // ExitLockstmt is called when exiting the lockstmt production. + ExitLockstmt(c *LockstmtContext) + + // ExitOpt_lock is called when exiting the opt_lock production. + ExitOpt_lock(c *Opt_lockContext) + + // ExitLock_type is called when exiting the lock_type production. + ExitLock_type(c *Lock_typeContext) + + // ExitOpt_nowait is called when exiting the opt_nowait production. + ExitOpt_nowait(c *Opt_nowaitContext) + + // ExitOpt_nowait_or_skip is called when exiting the opt_nowait_or_skip production. + ExitOpt_nowait_or_skip(c *Opt_nowait_or_skipContext) + + // ExitUpdatestmt is called when exiting the updatestmt production. + ExitUpdatestmt(c *UpdatestmtContext) + + // ExitSet_clause_list is called when exiting the set_clause_list production. + ExitSet_clause_list(c *Set_clause_listContext) + + // ExitSet_clause is called when exiting the set_clause production. + ExitSet_clause(c *Set_clauseContext) + + // ExitSet_target is called when exiting the set_target production. + ExitSet_target(c *Set_targetContext) + + // ExitSet_target_list is called when exiting the set_target_list production. + ExitSet_target_list(c *Set_target_listContext) + + // ExitDeclarecursorstmt is called when exiting the declarecursorstmt production. + ExitDeclarecursorstmt(c *DeclarecursorstmtContext) + + // ExitCursor_name is called when exiting the cursor_name production. + ExitCursor_name(c *Cursor_nameContext) + + // ExitCursor_options is called when exiting the cursor_options production. + ExitCursor_options(c *Cursor_optionsContext) + + // ExitOpt_hold is called when exiting the opt_hold production. + ExitOpt_hold(c *Opt_holdContext) + + // ExitSelectstmt is called when exiting the selectstmt production. + ExitSelectstmt(c *SelectstmtContext) + + // ExitSelect_with_parens is called when exiting the select_with_parens production. + ExitSelect_with_parens(c *Select_with_parensContext) + + // ExitSelect_no_parens is called when exiting the select_no_parens production. + ExitSelect_no_parens(c *Select_no_parensContext) + + // ExitSelect_clause is called when exiting the select_clause production. + ExitSelect_clause(c *Select_clauseContext) + + // ExitSimple_select_intersect is called when exiting the simple_select_intersect production. + ExitSimple_select_intersect(c *Simple_select_intersectContext) + + // ExitSimple_select_pramary is called when exiting the simple_select_pramary production. + ExitSimple_select_pramary(c *Simple_select_pramaryContext) + + // ExitExclude_clause is called when exiting the exclude_clause production. + ExitExclude_clause(c *Exclude_clauseContext) + + // ExitQualify_clause is called when exiting the qualify_clause production. + ExitQualify_clause(c *Qualify_clauseContext) + + // ExitStart_with_clause is called when exiting the start_with_clause production. + ExitStart_with_clause(c *Start_with_clauseContext) + + // ExitWith_clause is called when exiting the with_clause production. + ExitWith_clause(c *With_clauseContext) + + // ExitCte_list is called when exiting the cte_list production. + ExitCte_list(c *Cte_listContext) + + // ExitCommon_table_expr is called when exiting the common_table_expr production. + ExitCommon_table_expr(c *Common_table_exprContext) + + // ExitOpt_materialized is called when exiting the opt_materialized production. + ExitOpt_materialized(c *Opt_materializedContext) + + // ExitOpt_with_clause is called when exiting the opt_with_clause production. + ExitOpt_with_clause(c *Opt_with_clauseContext) + + // ExitInto_clause is called when exiting the into_clause production. + ExitInto_clause(c *Into_clauseContext) + + // ExitOpt_top_clause is called when exiting the opt_top_clause production. + ExitOpt_top_clause(c *Opt_top_clauseContext) + + // ExitOpt_strict is called when exiting the opt_strict production. + ExitOpt_strict(c *Opt_strictContext) + + // ExitOpttempTableName is called when exiting the opttempTableName production. + ExitOpttempTableName(c *OpttempTableNameContext) + + // ExitOpt_table is called when exiting the opt_table production. + ExitOpt_table(c *Opt_tableContext) + + // ExitAll_or_distinct is called when exiting the all_or_distinct production. + ExitAll_or_distinct(c *All_or_distinctContext) + + // ExitDistinct_clause is called when exiting the distinct_clause production. + ExitDistinct_clause(c *Distinct_clauseContext) + + // ExitOpt_all_clause is called when exiting the opt_all_clause production. + ExitOpt_all_clause(c *Opt_all_clauseContext) + + // ExitOpt_sort_clause is called when exiting the opt_sort_clause production. + ExitOpt_sort_clause(c *Opt_sort_clauseContext) + + // ExitSort_clause is called when exiting the sort_clause production. + ExitSort_clause(c *Sort_clauseContext) + + // ExitSortby_list is called when exiting the sortby_list production. + ExitSortby_list(c *Sortby_listContext) + + // ExitSortby is called when exiting the sortby production. + ExitSortby(c *SortbyContext) + + // ExitSelect_limit is called when exiting the select_limit production. + ExitSelect_limit(c *Select_limitContext) + + // ExitOpt_select_limit is called when exiting the opt_select_limit production. + ExitOpt_select_limit(c *Opt_select_limitContext) + + // ExitLimit_clause is called when exiting the limit_clause production. + ExitLimit_clause(c *Limit_clauseContext) + + // ExitOffset_clause is called when exiting the offset_clause production. + ExitOffset_clause(c *Offset_clauseContext) + + // ExitSelect_limit_value is called when exiting the select_limit_value production. + ExitSelect_limit_value(c *Select_limit_valueContext) + + // ExitSelect_offset_value is called when exiting the select_offset_value production. + ExitSelect_offset_value(c *Select_offset_valueContext) + + // ExitSelect_fetch_first_value is called when exiting the select_fetch_first_value production. + ExitSelect_fetch_first_value(c *Select_fetch_first_valueContext) + + // ExitI_or_f_const is called when exiting the i_or_f_const production. + ExitI_or_f_const(c *I_or_f_constContext) + + // ExitRow_or_rows is called when exiting the row_or_rows production. + ExitRow_or_rows(c *Row_or_rowsContext) + + // ExitFirst_or_next is called when exiting the first_or_next production. + ExitFirst_or_next(c *First_or_nextContext) + + // ExitGroup_clause is called when exiting the group_clause production. + ExitGroup_clause(c *Group_clauseContext) + + // ExitGroup_by_list is called when exiting the group_by_list production. + ExitGroup_by_list(c *Group_by_listContext) + + // ExitGroup_by_item is called when exiting the group_by_item production. + ExitGroup_by_item(c *Group_by_itemContext) + + // ExitEmpty_grouping_set is called when exiting the empty_grouping_set production. + ExitEmpty_grouping_set(c *Empty_grouping_setContext) + + // ExitRollup_clause is called when exiting the rollup_clause production. + ExitRollup_clause(c *Rollup_clauseContext) + + // ExitCube_clause is called when exiting the cube_clause production. + ExitCube_clause(c *Cube_clauseContext) + + // ExitGrouping_sets_clause is called when exiting the grouping_sets_clause production. + ExitGrouping_sets_clause(c *Grouping_sets_clauseContext) + + // ExitHaving_clause is called when exiting the having_clause production. + ExitHaving_clause(c *Having_clauseContext) + + // ExitFor_locking_clause is called when exiting the for_locking_clause production. + ExitFor_locking_clause(c *For_locking_clauseContext) + + // ExitOpt_for_locking_clause is called when exiting the opt_for_locking_clause production. + ExitOpt_for_locking_clause(c *Opt_for_locking_clauseContext) + + // ExitFor_locking_items is called when exiting the for_locking_items production. + ExitFor_locking_items(c *For_locking_itemsContext) + + // ExitFor_locking_item is called when exiting the for_locking_item production. + ExitFor_locking_item(c *For_locking_itemContext) + + // ExitFor_locking_strength is called when exiting the for_locking_strength production. + ExitFor_locking_strength(c *For_locking_strengthContext) + + // ExitLocked_rels_list is called when exiting the locked_rels_list production. + ExitLocked_rels_list(c *Locked_rels_listContext) + + // ExitValues_clause is called when exiting the values_clause production. + ExitValues_clause(c *Values_clauseContext) + + // ExitFrom_clause is called when exiting the from_clause production. + ExitFrom_clause(c *From_clauseContext) + + // ExitFrom_list is called when exiting the from_list production. + ExitFrom_list(c *From_listContext) + + // ExitTable_ref is called when exiting the table_ref production. + ExitTable_ref(c *Table_refContext) + + // ExitJoined_table is called when exiting the joined_table production. + ExitJoined_table(c *Joined_tableContext) + + // ExitAlias_clause is called when exiting the alias_clause production. + ExitAlias_clause(c *Alias_clauseContext) + + // ExitOpt_alias_clause is called when exiting the opt_alias_clause production. + ExitOpt_alias_clause(c *Opt_alias_clauseContext) + + // ExitTable_alias_clause is called when exiting the table_alias_clause production. + ExitTable_alias_clause(c *Table_alias_clauseContext) + + // ExitFunc_alias_clause is called when exiting the func_alias_clause production. + ExitFunc_alias_clause(c *Func_alias_clauseContext) + + // ExitJoin_type is called when exiting the join_type production. + ExitJoin_type(c *Join_typeContext) + + // ExitJoin_qual is called when exiting the join_qual production. + ExitJoin_qual(c *Join_qualContext) + + // ExitRelation_expr is called when exiting the relation_expr production. + ExitRelation_expr(c *Relation_exprContext) + + // ExitRelation_expr_list is called when exiting the relation_expr_list production. + ExitRelation_expr_list(c *Relation_expr_listContext) + + // ExitRelation_expr_opt_alias is called when exiting the relation_expr_opt_alias production. + ExitRelation_expr_opt_alias(c *Relation_expr_opt_aliasContext) + + // ExitTablesample_clause is called when exiting the tablesample_clause production. + ExitTablesample_clause(c *Tablesample_clauseContext) + + // ExitOpt_repeatable_clause is called when exiting the opt_repeatable_clause production. + ExitOpt_repeatable_clause(c *Opt_repeatable_clauseContext) + + // ExitFunc_table is called when exiting the func_table production. + ExitFunc_table(c *Func_tableContext) + + // ExitRowsfrom_item is called when exiting the rowsfrom_item production. + ExitRowsfrom_item(c *Rowsfrom_itemContext) + + // ExitRowsfrom_list is called when exiting the rowsfrom_list production. + ExitRowsfrom_list(c *Rowsfrom_listContext) + + // ExitOpt_col_def_list is called when exiting the opt_col_def_list production. + ExitOpt_col_def_list(c *Opt_col_def_listContext) + + // ExitOpt_ordinality is called when exiting the opt_ordinality production. + ExitOpt_ordinality(c *Opt_ordinalityContext) + + // ExitWhere_clause is called when exiting the where_clause production. + ExitWhere_clause(c *Where_clauseContext) + + // ExitWhere_or_current_clause is called when exiting the where_or_current_clause production. + ExitWhere_or_current_clause(c *Where_or_current_clauseContext) + + // ExitOpttablefuncelementlist is called when exiting the opttablefuncelementlist production. + ExitOpttablefuncelementlist(c *OpttablefuncelementlistContext) + + // ExitTablefuncelementlist is called when exiting the tablefuncelementlist production. + ExitTablefuncelementlist(c *TablefuncelementlistContext) + + // ExitTablefuncelement is called when exiting the tablefuncelement production. + ExitTablefuncelement(c *TablefuncelementContext) + + // ExitXmltable is called when exiting the xmltable production. + ExitXmltable(c *XmltableContext) + + // ExitXmltable_column_list is called when exiting the xmltable_column_list production. + ExitXmltable_column_list(c *Xmltable_column_listContext) + + // ExitXmltable_column_el is called when exiting the xmltable_column_el production. + ExitXmltable_column_el(c *Xmltable_column_elContext) + + // ExitXmltable_column_option_list is called when exiting the xmltable_column_option_list production. + ExitXmltable_column_option_list(c *Xmltable_column_option_listContext) + + // ExitXmltable_column_option_el is called when exiting the xmltable_column_option_el production. + ExitXmltable_column_option_el(c *Xmltable_column_option_elContext) + + // ExitXml_namespace_list is called when exiting the xml_namespace_list production. + ExitXml_namespace_list(c *Xml_namespace_listContext) + + // ExitXml_namespace_el is called when exiting the xml_namespace_el production. + ExitXml_namespace_el(c *Xml_namespace_elContext) + + // ExitTypename is called when exiting the typename production. + ExitTypename(c *TypenameContext) + + // ExitOpt_array_bounds is called when exiting the opt_array_bounds production. + ExitOpt_array_bounds(c *Opt_array_boundsContext) + + // ExitSimpletypename is called when exiting the simpletypename production. + ExitSimpletypename(c *SimpletypenameContext) + + // ExitVarbyte is called when exiting the varbyte production. + ExitVarbyte(c *VarbyteContext) + + // ExitJson_type is called when exiting the json_type production. + ExitJson_type(c *Json_typeContext) + + // ExitConsttypename is called when exiting the consttypename production. + ExitConsttypename(c *ConsttypenameContext) + + // ExitGenerictype is called when exiting the generictype production. + ExitGenerictype(c *GenerictypeContext) + + // ExitOpt_type_modifiers is called when exiting the opt_type_modifiers production. + ExitOpt_type_modifiers(c *Opt_type_modifiersContext) + + // ExitNumeric is called when exiting the numeric production. + ExitNumeric(c *NumericContext) + + // ExitOpt_float is called when exiting the opt_float production. + ExitOpt_float(c *Opt_floatContext) + + // ExitBit is called when exiting the bit production. + ExitBit(c *BitContext) + + // ExitConstbit is called when exiting the constbit production. + ExitConstbit(c *ConstbitContext) + + // ExitBitwithlength is called when exiting the bitwithlength production. + ExitBitwithlength(c *BitwithlengthContext) + + // ExitBitwithoutlength is called when exiting the bitwithoutlength production. + ExitBitwithoutlength(c *BitwithoutlengthContext) + + // ExitCharacter is called when exiting the character production. + ExitCharacter(c *CharacterContext) + + // ExitConstcharacter is called when exiting the constcharacter production. + ExitConstcharacter(c *ConstcharacterContext) + + // ExitCharacter_c is called when exiting the character_c production. + ExitCharacter_c(c *Character_cContext) + + // ExitOpt_varying is called when exiting the opt_varying production. + ExitOpt_varying(c *Opt_varyingContext) + + // ExitConstdatetime is called when exiting the constdatetime production. + ExitConstdatetime(c *ConstdatetimeContext) + + // ExitConstinterval is called when exiting the constinterval production. + ExitConstinterval(c *ConstintervalContext) + + // ExitOpt_timezone is called when exiting the opt_timezone production. + ExitOpt_timezone(c *Opt_timezoneContext) + + // ExitOpt_interval is called when exiting the opt_interval production. + ExitOpt_interval(c *Opt_intervalContext) + + // ExitInterval_second is called when exiting the interval_second production. + ExitInterval_second(c *Interval_secondContext) + + // ExitOpt_escape is called when exiting the opt_escape production. + ExitOpt_escape(c *Opt_escapeContext) + + // ExitA_expr is called when exiting the a_expr production. + ExitA_expr(c *A_exprContext) + + // ExitA_expr_qual is called when exiting the a_expr_qual production. + ExitA_expr_qual(c *A_expr_qualContext) + + // ExitA_expr_lessless is called when exiting the a_expr_lessless production. + ExitA_expr_lessless(c *A_expr_lesslessContext) + + // ExitA_expr_or is called when exiting the a_expr_or production. + ExitA_expr_or(c *A_expr_orContext) + + // ExitA_expr_and is called when exiting the a_expr_and production. + ExitA_expr_and(c *A_expr_andContext) + + // ExitA_expr_between is called when exiting the a_expr_between production. + ExitA_expr_between(c *A_expr_betweenContext) + + // ExitA_expr_in is called when exiting the a_expr_in production. + ExitA_expr_in(c *A_expr_inContext) + + // ExitA_expr_unary_not is called when exiting the a_expr_unary_not production. + ExitA_expr_unary_not(c *A_expr_unary_notContext) + + // ExitA_expr_isnull is called when exiting the a_expr_isnull production. + ExitA_expr_isnull(c *A_expr_isnullContext) + + // ExitA_expr_is_not is called when exiting the a_expr_is_not production. + ExitA_expr_is_not(c *A_expr_is_notContext) + + // ExitA_expr_compare is called when exiting the a_expr_compare production. + ExitA_expr_compare(c *A_expr_compareContext) + + // ExitA_expr_prior_or_level is called when exiting the a_expr_prior_or_level production. + ExitA_expr_prior_or_level(c *A_expr_prior_or_levelContext) + + // ExitA_expr_like is called when exiting the a_expr_like production. + ExitA_expr_like(c *A_expr_likeContext) + + // ExitA_expr_qual_op is called when exiting the a_expr_qual_op production. + ExitA_expr_qual_op(c *A_expr_qual_opContext) + + // ExitA_expr_unary_qualop is called when exiting the a_expr_unary_qualop production. + ExitA_expr_unary_qualop(c *A_expr_unary_qualopContext) + + // ExitA_expr_add is called when exiting the a_expr_add production. + ExitA_expr_add(c *A_expr_addContext) + + // ExitA_expr_mul is called when exiting the a_expr_mul production. + ExitA_expr_mul(c *A_expr_mulContext) + + // ExitA_expr_caret is called when exiting the a_expr_caret production. + ExitA_expr_caret(c *A_expr_caretContext) + + // ExitA_expr_unary_sign is called when exiting the a_expr_unary_sign production. + ExitA_expr_unary_sign(c *A_expr_unary_signContext) + + // ExitA_expr_at_time_zone is called when exiting the a_expr_at_time_zone production. + ExitA_expr_at_time_zone(c *A_expr_at_time_zoneContext) + + // ExitA_expr_collate is called when exiting the a_expr_collate production. + ExitA_expr_collate(c *A_expr_collateContext) + + // ExitA_expr_typecast is called when exiting the a_expr_typecast production. + ExitA_expr_typecast(c *A_expr_typecastContext) + + // ExitB_expr is called when exiting the b_expr production. + ExitB_expr(c *B_exprContext) + + // ExitC_expr_exists is called when exiting the c_expr_exists production. + ExitC_expr_exists(c *C_expr_existsContext) + + // ExitC_expr_expr is called when exiting the c_expr_expr production. + ExitC_expr_expr(c *C_expr_exprContext) + + // ExitC_expr_case is called when exiting the c_expr_case production. + ExitC_expr_case(c *C_expr_caseContext) + + // ExitPlsqlvariablename is called when exiting the plsqlvariablename production. + ExitPlsqlvariablename(c *PlsqlvariablenameContext) + + // ExitFunc_application is called when exiting the func_application production. + ExitFunc_application(c *Func_applicationContext) + + // ExitFunc_expr is called when exiting the func_expr production. + ExitFunc_expr(c *Func_exprContext) + + // ExitFunc_expr_windowless is called when exiting the func_expr_windowless production. + ExitFunc_expr_windowless(c *Func_expr_windowlessContext) + + // ExitFunc_expr_common_subexpr is called when exiting the func_expr_common_subexpr production. + ExitFunc_expr_common_subexpr(c *Func_expr_common_subexprContext) + + // ExitXml_root_version is called when exiting the xml_root_version production. + ExitXml_root_version(c *Xml_root_versionContext) + + // ExitOpt_xml_root_standalone is called when exiting the opt_xml_root_standalone production. + ExitOpt_xml_root_standalone(c *Opt_xml_root_standaloneContext) + + // ExitXml_attributes is called when exiting the xml_attributes production. + ExitXml_attributes(c *Xml_attributesContext) + + // ExitXml_attribute_list is called when exiting the xml_attribute_list production. + ExitXml_attribute_list(c *Xml_attribute_listContext) + + // ExitXml_attribute_el is called when exiting the xml_attribute_el production. + ExitXml_attribute_el(c *Xml_attribute_elContext) + + // ExitDocument_or_content is called when exiting the document_or_content production. + ExitDocument_or_content(c *Document_or_contentContext) + + // ExitXml_whitespace_option is called when exiting the xml_whitespace_option production. + ExitXml_whitespace_option(c *Xml_whitespace_optionContext) + + // ExitXmlexists_argument is called when exiting the xmlexists_argument production. + ExitXmlexists_argument(c *Xmlexists_argumentContext) + + // ExitXml_passing_mech is called when exiting the xml_passing_mech production. + ExitXml_passing_mech(c *Xml_passing_mechContext) + + // ExitWithin_group_clause is called when exiting the within_group_clause production. + ExitWithin_group_clause(c *Within_group_clauseContext) + + // ExitFilter_clause is called when exiting the filter_clause production. + ExitFilter_clause(c *Filter_clauseContext) + + // ExitWindow_clause is called when exiting the window_clause production. + ExitWindow_clause(c *Window_clauseContext) + + // ExitWindow_definition_list is called when exiting the window_definition_list production. + ExitWindow_definition_list(c *Window_definition_listContext) + + // ExitWindow_definition is called when exiting the window_definition production. + ExitWindow_definition(c *Window_definitionContext) + + // ExitOver_clause is called when exiting the over_clause production. + ExitOver_clause(c *Over_clauseContext) + + // ExitWindow_specification is called when exiting the window_specification production. + ExitWindow_specification(c *Window_specificationContext) + + // ExitOpt_existing_window_name is called when exiting the opt_existing_window_name production. + ExitOpt_existing_window_name(c *Opt_existing_window_nameContext) + + // ExitOpt_partition_clause is called when exiting the opt_partition_clause production. + ExitOpt_partition_clause(c *Opt_partition_clauseContext) + + // ExitOpt_frame_clause is called when exiting the opt_frame_clause production. + ExitOpt_frame_clause(c *Opt_frame_clauseContext) + + // ExitFrame_extent is called when exiting the frame_extent production. + ExitFrame_extent(c *Frame_extentContext) + + // ExitFrame_bound is called when exiting the frame_bound production. + ExitFrame_bound(c *Frame_boundContext) + + // ExitOpt_window_exclusion_clause is called when exiting the opt_window_exclusion_clause production. + ExitOpt_window_exclusion_clause(c *Opt_window_exclusion_clauseContext) + + // ExitRow is called when exiting the row production. + ExitRow(c *RowContext) + + // ExitExplicit_row is called when exiting the explicit_row production. + ExitExplicit_row(c *Explicit_rowContext) + + // ExitImplicit_row is called when exiting the implicit_row production. + ExitImplicit_row(c *Implicit_rowContext) + + // ExitSub_type is called when exiting the sub_type production. + ExitSub_type(c *Sub_typeContext) + + // ExitAll_op is called when exiting the all_op production. + ExitAll_op(c *All_opContext) + + // ExitMathop is called when exiting the mathop production. + ExitMathop(c *MathopContext) + + // ExitQual_op is called when exiting the qual_op production. + ExitQual_op(c *Qual_opContext) + + // ExitQual_all_op is called when exiting the qual_all_op production. + ExitQual_all_op(c *Qual_all_opContext) + + // ExitSubquery_Op is called when exiting the subquery_Op production. + ExitSubquery_Op(c *Subquery_OpContext) + + // ExitExpr_list is called when exiting the expr_list production. + ExitExpr_list(c *Expr_listContext) + + // ExitFunc_arg_list is called when exiting the func_arg_list production. + ExitFunc_arg_list(c *Func_arg_listContext) + + // ExitFunc_arg_expr is called when exiting the func_arg_expr production. + ExitFunc_arg_expr(c *Func_arg_exprContext) + + // ExitType_list is called when exiting the type_list production. + ExitType_list(c *Type_listContext) + + // ExitArray_expr is called when exiting the array_expr production. + ExitArray_expr(c *Array_exprContext) + + // ExitArray_expr_list is called when exiting the array_expr_list production. + ExitArray_expr_list(c *Array_expr_listContext) + + // ExitExtract_list is called when exiting the extract_list production. + ExitExtract_list(c *Extract_listContext) + + // ExitExtract_arg is called when exiting the extract_arg production. + ExitExtract_arg(c *Extract_argContext) + + // ExitUnicode_normal_form is called when exiting the unicode_normal_form production. + ExitUnicode_normal_form(c *Unicode_normal_formContext) + + // ExitOverlay_list is called when exiting the overlay_list production. + ExitOverlay_list(c *Overlay_listContext) + + // ExitPosition_list is called when exiting the position_list production. + ExitPosition_list(c *Position_listContext) + + // ExitSubstr_list is called when exiting the substr_list production. + ExitSubstr_list(c *Substr_listContext) + + // ExitTrim_list is called when exiting the trim_list production. + ExitTrim_list(c *Trim_listContext) + + // ExitIn_expr_select is called when exiting the in_expr_select production. + ExitIn_expr_select(c *In_expr_selectContext) + + // ExitIn_expr_list is called when exiting the in_expr_list production. + ExitIn_expr_list(c *In_expr_listContext) + + // ExitCase_expr is called when exiting the case_expr production. + ExitCase_expr(c *Case_exprContext) + + // ExitWhen_clause_list is called when exiting the when_clause_list production. + ExitWhen_clause_list(c *When_clause_listContext) + + // ExitWhen_clause is called when exiting the when_clause production. + ExitWhen_clause(c *When_clauseContext) + + // ExitCase_default is called when exiting the case_default production. + ExitCase_default(c *Case_defaultContext) + + // ExitCase_arg is called when exiting the case_arg production. + ExitCase_arg(c *Case_argContext) + + // ExitColumnref is called when exiting the columnref production. + ExitColumnref(c *ColumnrefContext) + + // ExitIndirection_el is called when exiting the indirection_el production. + ExitIndirection_el(c *Indirection_elContext) + + // ExitOpt_slice_bound is called when exiting the opt_slice_bound production. + ExitOpt_slice_bound(c *Opt_slice_boundContext) + + // ExitIndirection is called when exiting the indirection production. + ExitIndirection(c *IndirectionContext) + + // ExitOpt_indirection is called when exiting the opt_indirection production. + ExitOpt_indirection(c *Opt_indirectionContext) + + // ExitOpt_target_list is called when exiting the opt_target_list production. + ExitOpt_target_list(c *Opt_target_listContext) + + // ExitTarget_list is called when exiting the target_list production. + ExitTarget_list(c *Target_listContext) + + // ExitTarget_label is called when exiting the target_label production. + ExitTarget_label(c *Target_labelContext) + + // ExitTarget_star is called when exiting the target_star production. + ExitTarget_star(c *Target_starContext) + + // ExitTarget_alias is called when exiting the target_alias production. + ExitTarget_alias(c *Target_aliasContext) + + // ExitQualified_name_list is called when exiting the qualified_name_list production. + ExitQualified_name_list(c *Qualified_name_listContext) + + // ExitQualified_name is called when exiting the qualified_name production. + ExitQualified_name(c *Qualified_nameContext) + + // ExitName_list is called when exiting the name_list production. + ExitName_list(c *Name_listContext) + + // ExitName is called when exiting the name production. + ExitName(c *NameContext) + + // ExitAttr_name is called when exiting the attr_name production. + ExitAttr_name(c *Attr_nameContext) + + // ExitFile_name is called when exiting the file_name production. + ExitFile_name(c *File_nameContext) + + // ExitFunc_name is called when exiting the func_name production. + ExitFunc_name(c *Func_nameContext) + + // ExitAexprconst is called when exiting the aexprconst production. + ExitAexprconst(c *AexprconstContext) + + // ExitXconst is called when exiting the xconst production. + ExitXconst(c *XconstContext) + + // ExitBconst is called when exiting the bconst production. + ExitBconst(c *BconstContext) + + // ExitFconst is called when exiting the fconst production. + ExitFconst(c *FconstContext) + + // ExitIconst is called when exiting the iconst production. + ExitIconst(c *IconstContext) + + // ExitSconst is called when exiting the sconst production. + ExitSconst(c *SconstContext) + + // ExitAnysconst is called when exiting the anysconst production. + ExitAnysconst(c *AnysconstContext) + + // ExitOpt_uescape is called when exiting the opt_uescape production. + ExitOpt_uescape(c *Opt_uescapeContext) + + // ExitSignediconst is called when exiting the signediconst production. + ExitSignediconst(c *SignediconstContext) + + // ExitRoleid is called when exiting the roleid production. + ExitRoleid(c *RoleidContext) + + // ExitRolespec is called when exiting the rolespec production. + ExitRolespec(c *RolespecContext) + + // ExitRole_list is called when exiting the role_list production. + ExitRole_list(c *Role_listContext) + + // ExitColid is called when exiting the colid production. + ExitColid(c *ColidContext) + + // ExitTable_alias is called when exiting the table_alias production. + ExitTable_alias(c *Table_aliasContext) + + // ExitType_function_name is called when exiting the type_function_name production. + ExitType_function_name(c *Type_function_nameContext) + + // ExitNonreservedword is called when exiting the nonreservedword production. + ExitNonreservedword(c *NonreservedwordContext) + + // ExitCollabel is called when exiting the collabel production. + ExitCollabel(c *CollabelContext) + + // ExitIdentifier is called when exiting the identifier production. + ExitIdentifier(c *IdentifierContext) + + // ExitPlsqlidentifier is called when exiting the plsqlidentifier production. + ExitPlsqlidentifier(c *PlsqlidentifierContext) + + // ExitUnreserved_keyword is called when exiting the unreserved_keyword production. + ExitUnreserved_keyword(c *Unreserved_keywordContext) + + // ExitCol_name_keyword is called when exiting the col_name_keyword production. + ExitCol_name_keyword(c *Col_name_keywordContext) + + // ExitType_func_name_keyword is called when exiting the type_func_name_keyword production. + ExitType_func_name_keyword(c *Type_func_name_keywordContext) + + // ExitReserved_keyword is called when exiting the reserved_keyword production. + ExitReserved_keyword(c *Reserved_keywordContext) + + // ExitBuiltin_function_name is called when exiting the builtin_function_name production. + ExitBuiltin_function_name(c *Builtin_function_nameContext) + + // ExitPl_function is called when exiting the pl_function production. + ExitPl_function(c *Pl_functionContext) + + // ExitComp_options is called when exiting the comp_options production. + ExitComp_options(c *Comp_optionsContext) + + // ExitComp_option is called when exiting the comp_option production. + ExitComp_option(c *Comp_optionContext) + + // ExitSharp is called when exiting the sharp production. + ExitSharp(c *SharpContext) + + // ExitOption_value is called when exiting the option_value production. + ExitOption_value(c *Option_valueContext) + + // ExitOpt_semi is called when exiting the opt_semi production. + ExitOpt_semi(c *Opt_semiContext) + + // ExitPl_block is called when exiting the pl_block production. + ExitPl_block(c *Pl_blockContext) + + // ExitDecl_sect is called when exiting the decl_sect production. + ExitDecl_sect(c *Decl_sectContext) + + // ExitDecl_start is called when exiting the decl_start production. + ExitDecl_start(c *Decl_startContext) + + // ExitDecl_stmts is called when exiting the decl_stmts production. + ExitDecl_stmts(c *Decl_stmtsContext) + + // ExitLabel_decl is called when exiting the label_decl production. + ExitLabel_decl(c *Label_declContext) + + // ExitDecl_stmt is called when exiting the decl_stmt production. + ExitDecl_stmt(c *Decl_stmtContext) + + // ExitDecl_statement is called when exiting the decl_statement production. + ExitDecl_statement(c *Decl_statementContext) + + // ExitOpt_scrollable is called when exiting the opt_scrollable production. + ExitOpt_scrollable(c *Opt_scrollableContext) + + // ExitDecl_cursor_query is called when exiting the decl_cursor_query production. + ExitDecl_cursor_query(c *Decl_cursor_queryContext) + + // ExitDecl_cursor_args is called when exiting the decl_cursor_args production. + ExitDecl_cursor_args(c *Decl_cursor_argsContext) + + // ExitDecl_cursor_arglist is called when exiting the decl_cursor_arglist production. + ExitDecl_cursor_arglist(c *Decl_cursor_arglistContext) + + // ExitDecl_cursor_arg is called when exiting the decl_cursor_arg production. + ExitDecl_cursor_arg(c *Decl_cursor_argContext) + + // ExitDecl_is_for is called when exiting the decl_is_for production. + ExitDecl_is_for(c *Decl_is_forContext) + + // ExitDecl_aliasitem is called when exiting the decl_aliasitem production. + ExitDecl_aliasitem(c *Decl_aliasitemContext) + + // ExitDecl_varname is called when exiting the decl_varname production. + ExitDecl_varname(c *Decl_varnameContext) + + // ExitDecl_const is called when exiting the decl_const production. + ExitDecl_const(c *Decl_constContext) + + // ExitDecl_datatype is called when exiting the decl_datatype production. + ExitDecl_datatype(c *Decl_datatypeContext) + + // ExitDecl_collate is called when exiting the decl_collate production. + ExitDecl_collate(c *Decl_collateContext) + + // ExitDecl_notnull is called when exiting the decl_notnull production. + ExitDecl_notnull(c *Decl_notnullContext) + + // ExitDecl_defval is called when exiting the decl_defval production. + ExitDecl_defval(c *Decl_defvalContext) + + // ExitDecl_defkey is called when exiting the decl_defkey production. + ExitDecl_defkey(c *Decl_defkeyContext) + + // ExitAssign_operator is called when exiting the assign_operator production. + ExitAssign_operator(c *Assign_operatorContext) + + // ExitProc_sect is called when exiting the proc_sect production. + ExitProc_sect(c *Proc_sectContext) + + // ExitProc_stmt is called when exiting the proc_stmt production. + ExitProc_stmt(c *Proc_stmtContext) + + // ExitStmt_perform is called when exiting the stmt_perform production. + ExitStmt_perform(c *Stmt_performContext) + + // ExitStmt_call is called when exiting the stmt_call production. + ExitStmt_call(c *Stmt_callContext) + + // ExitOpt_expr_list is called when exiting the opt_expr_list production. + ExitOpt_expr_list(c *Opt_expr_listContext) + + // ExitStmt_assign is called when exiting the stmt_assign production. + ExitStmt_assign(c *Stmt_assignContext) + + // ExitStmt_getdiag is called when exiting the stmt_getdiag production. + ExitStmt_getdiag(c *Stmt_getdiagContext) + + // ExitGetdiag_area_opt is called when exiting the getdiag_area_opt production. + ExitGetdiag_area_opt(c *Getdiag_area_optContext) + + // ExitGetdiag_list is called when exiting the getdiag_list production. + ExitGetdiag_list(c *Getdiag_listContext) + + // ExitGetdiag_list_item is called when exiting the getdiag_list_item production. + ExitGetdiag_list_item(c *Getdiag_list_itemContext) + + // ExitGetdiag_item is called when exiting the getdiag_item production. + ExitGetdiag_item(c *Getdiag_itemContext) + + // ExitGetdiag_target is called when exiting the getdiag_target production. + ExitGetdiag_target(c *Getdiag_targetContext) + + // ExitAssign_var is called when exiting the assign_var production. + ExitAssign_var(c *Assign_varContext) + + // ExitStmt_if is called when exiting the stmt_if production. + ExitStmt_if(c *Stmt_ifContext) + + // ExitStmt_elsifs is called when exiting the stmt_elsifs production. + ExitStmt_elsifs(c *Stmt_elsifsContext) + + // ExitStmt_else is called when exiting the stmt_else production. + ExitStmt_else(c *Stmt_elseContext) + + // ExitStmt_case is called when exiting the stmt_case production. + ExitStmt_case(c *Stmt_caseContext) + + // ExitOpt_expr_until_when is called when exiting the opt_expr_until_when production. + ExitOpt_expr_until_when(c *Opt_expr_until_whenContext) + + // ExitCase_when_list is called when exiting the case_when_list production. + ExitCase_when_list(c *Case_when_listContext) + + // ExitCase_when is called when exiting the case_when production. + ExitCase_when(c *Case_whenContext) + + // ExitOpt_case_else is called when exiting the opt_case_else production. + ExitOpt_case_else(c *Opt_case_elseContext) + + // ExitStmt_loop is called when exiting the stmt_loop production. + ExitStmt_loop(c *Stmt_loopContext) + + // ExitStmt_while is called when exiting the stmt_while production. + ExitStmt_while(c *Stmt_whileContext) + + // ExitStmt_for is called when exiting the stmt_for production. + ExitStmt_for(c *Stmt_forContext) + + // ExitFor_control is called when exiting the for_control production. + ExitFor_control(c *For_controlContext) + + // ExitOpt_for_using_expression is called when exiting the opt_for_using_expression production. + ExitOpt_for_using_expression(c *Opt_for_using_expressionContext) + + // ExitOpt_cursor_parameters is called when exiting the opt_cursor_parameters production. + ExitOpt_cursor_parameters(c *Opt_cursor_parametersContext) + + // ExitOpt_reverse is called when exiting the opt_reverse production. + ExitOpt_reverse(c *Opt_reverseContext) + + // ExitOpt_by_expression is called when exiting the opt_by_expression production. + ExitOpt_by_expression(c *Opt_by_expressionContext) + + // ExitFor_variable is called when exiting the for_variable production. + ExitFor_variable(c *For_variableContext) + + // ExitStmt_foreach_a is called when exiting the stmt_foreach_a production. + ExitStmt_foreach_a(c *Stmt_foreach_aContext) + + // ExitForeach_slice is called when exiting the foreach_slice production. + ExitForeach_slice(c *Foreach_sliceContext) + + // ExitStmt_exit is called when exiting the stmt_exit production. + ExitStmt_exit(c *Stmt_exitContext) + + // ExitExit_type is called when exiting the exit_type production. + ExitExit_type(c *Exit_typeContext) + + // ExitStmt_return is called when exiting the stmt_return production. + ExitStmt_return(c *Stmt_returnContext) + + // ExitOpt_return_result is called when exiting the opt_return_result production. + ExitOpt_return_result(c *Opt_return_resultContext) + + // ExitStmt_raise is called when exiting the stmt_raise production. + ExitStmt_raise(c *Stmt_raiseContext) + + // ExitOpt_stmt_raise_level is called when exiting the opt_stmt_raise_level production. + ExitOpt_stmt_raise_level(c *Opt_stmt_raise_levelContext) + + // ExitOpt_raise_list is called when exiting the opt_raise_list production. + ExitOpt_raise_list(c *Opt_raise_listContext) + + // ExitOpt_raise_using is called when exiting the opt_raise_using production. + ExitOpt_raise_using(c *Opt_raise_usingContext) + + // ExitOpt_raise_using_elem is called when exiting the opt_raise_using_elem production. + ExitOpt_raise_using_elem(c *Opt_raise_using_elemContext) + + // ExitOpt_raise_using_elem_list is called when exiting the opt_raise_using_elem_list production. + ExitOpt_raise_using_elem_list(c *Opt_raise_using_elem_listContext) + + // ExitStmt_assert is called when exiting the stmt_assert production. + ExitStmt_assert(c *Stmt_assertContext) + + // ExitOpt_stmt_assert_message is called when exiting the opt_stmt_assert_message production. + ExitOpt_stmt_assert_message(c *Opt_stmt_assert_messageContext) + + // ExitLoop_body is called when exiting the loop_body production. + ExitLoop_body(c *Loop_bodyContext) + + // ExitStmt_execsql is called when exiting the stmt_execsql production. + ExitStmt_execsql(c *Stmt_execsqlContext) + + // ExitStmt_dynexecute is called when exiting the stmt_dynexecute production. + ExitStmt_dynexecute(c *Stmt_dynexecuteContext) + + // ExitOpt_execute_using is called when exiting the opt_execute_using production. + ExitOpt_execute_using(c *Opt_execute_usingContext) + + // ExitOpt_execute_using_list is called when exiting the opt_execute_using_list production. + ExitOpt_execute_using_list(c *Opt_execute_using_listContext) + + // ExitOpt_execute_into is called when exiting the opt_execute_into production. + ExitOpt_execute_into(c *Opt_execute_intoContext) + + // ExitStmt_open is called when exiting the stmt_open production. + ExitStmt_open(c *Stmt_openContext) + + // ExitOpt_open_bound_list_item is called when exiting the opt_open_bound_list_item production. + ExitOpt_open_bound_list_item(c *Opt_open_bound_list_itemContext) + + // ExitOpt_open_bound_list is called when exiting the opt_open_bound_list production. + ExitOpt_open_bound_list(c *Opt_open_bound_listContext) + + // ExitOpt_open_using is called when exiting the opt_open_using production. + ExitOpt_open_using(c *Opt_open_usingContext) + + // ExitOpt_scroll_option is called when exiting the opt_scroll_option production. + ExitOpt_scroll_option(c *Opt_scroll_optionContext) + + // ExitOpt_scroll_option_no is called when exiting the opt_scroll_option_no production. + ExitOpt_scroll_option_no(c *Opt_scroll_option_noContext) + + // ExitStmt_fetch is called when exiting the stmt_fetch production. + ExitStmt_fetch(c *Stmt_fetchContext) + + // ExitInto_target is called when exiting the into_target production. + ExitInto_target(c *Into_targetContext) + + // ExitOpt_cursor_from is called when exiting the opt_cursor_from production. + ExitOpt_cursor_from(c *Opt_cursor_fromContext) + + // ExitOpt_fetch_direction is called when exiting the opt_fetch_direction production. + ExitOpt_fetch_direction(c *Opt_fetch_directionContext) + + // ExitStmt_move is called when exiting the stmt_move production. + ExitStmt_move(c *Stmt_moveContext) + + // ExitStmt_close is called when exiting the stmt_close production. + ExitStmt_close(c *Stmt_closeContext) + + // ExitStmt_null is called when exiting the stmt_null production. + ExitStmt_null(c *Stmt_nullContext) + + // ExitStmt_commit is called when exiting the stmt_commit production. + ExitStmt_commit(c *Stmt_commitContext) + + // ExitStmt_rollback is called when exiting the stmt_rollback production. + ExitStmt_rollback(c *Stmt_rollbackContext) + + // ExitPlsql_opt_transaction_chain is called when exiting the plsql_opt_transaction_chain production. + ExitPlsql_opt_transaction_chain(c *Plsql_opt_transaction_chainContext) + + // ExitStmt_set is called when exiting the stmt_set production. + ExitStmt_set(c *Stmt_setContext) + + // ExitCursor_variable is called when exiting the cursor_variable production. + ExitCursor_variable(c *Cursor_variableContext) + + // ExitException_sect is called when exiting the exception_sect production. + ExitException_sect(c *Exception_sectContext) + + // ExitProc_exceptions is called when exiting the proc_exceptions production. + ExitProc_exceptions(c *Proc_exceptionsContext) + + // ExitProc_exception is called when exiting the proc_exception production. + ExitProc_exception(c *Proc_exceptionContext) + + // ExitProc_conditions is called when exiting the proc_conditions production. + ExitProc_conditions(c *Proc_conditionsContext) + + // ExitProc_condition is called when exiting the proc_condition production. + ExitProc_condition(c *Proc_conditionContext) + + // ExitOpt_block_label is called when exiting the opt_block_label production. + ExitOpt_block_label(c *Opt_block_labelContext) + + // ExitOpt_loop_label is called when exiting the opt_loop_label production. + ExitOpt_loop_label(c *Opt_loop_labelContext) + + // ExitOpt_label is called when exiting the opt_label production. + ExitOpt_label(c *Opt_labelContext) + + // ExitOpt_exitcond is called when exiting the opt_exitcond production. + ExitOpt_exitcond(c *Opt_exitcondContext) + + // ExitAny_identifier is called when exiting the any_identifier production. + ExitAny_identifier(c *Any_identifierContext) + + // ExitPlsql_unreserved_keyword is called when exiting the plsql_unreserved_keyword production. + ExitPlsql_unreserved_keyword(c *Plsql_unreserved_keywordContext) + + // ExitSql_expression is called when exiting the sql_expression production. + ExitSql_expression(c *Sql_expressionContext) + + // ExitExpr_until_then is called when exiting the expr_until_then production. + ExitExpr_until_then(c *Expr_until_thenContext) + + // ExitExpr_until_semi is called when exiting the expr_until_semi production. + ExitExpr_until_semi(c *Expr_until_semiContext) + + // ExitExpr_until_rightbracket is called when exiting the expr_until_rightbracket production. + ExitExpr_until_rightbracket(c *Expr_until_rightbracketContext) + + // ExitExpr_until_loop is called when exiting the expr_until_loop production. + ExitExpr_until_loop(c *Expr_until_loopContext) + + // ExitMake_execsql_stmt is called when exiting the make_execsql_stmt production. + ExitMake_execsql_stmt(c *Make_execsql_stmtContext) + + // ExitOpt_returning_clause_into is called when exiting the opt_returning_clause_into production. + ExitOpt_returning_clause_into(c *Opt_returning_clause_intoContext) +} diff --git a/redshift/redshiftparser_visitor.go b/redshift/redshiftparser_visitor.go new file mode 100644 index 0000000..65b7f7c --- /dev/null +++ b/redshift/redshiftparser_visitor.go @@ -0,0 +1,3285 @@ +// Code generated from RedshiftParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package redshift // RedshiftParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by RedshiftParser. +type RedshiftParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by RedshiftParser#root. + VisitRoot(ctx *RootContext) interface{} + + // Visit a parse tree produced by RedshiftParser#plsqlroot. + VisitPlsqlroot(ctx *PlsqlrootContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmtblock. + VisitStmtblock(ctx *StmtblockContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmtmulti. + VisitStmtmulti(ctx *StmtmultiContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt. + VisitStmt(ctx *StmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#plsqlconsolecommand. + VisitPlsqlconsolecommand(ctx *PlsqlconsolecommandContext) interface{} + + // Visit a parse tree produced by RedshiftParser#callstmt. + VisitCallstmt(ctx *CallstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createrolestmt. + VisitCreaterolestmt(ctx *CreaterolestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_with. + VisitOpt_with(ctx *Opt_withContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optrolelist. + VisitOptrolelist(ctx *OptrolelistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteroptrolelist. + VisitAlteroptrolelist(ctx *AlteroptrolelistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteroptroleelem. + VisitAlteroptroleelem(ctx *AlteroptroleelemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createoptroleelem. + VisitCreateoptroleelem(ctx *CreateoptroleelemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createuserstmt. + VisitCreateuserstmt(ctx *CreateuserstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterrolestmt. + VisitAlterrolestmt(ctx *AlterrolestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterroleaction. + VisitAlterroleaction(ctx *AlterroleactionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_in_database. + VisitOpt_in_database(ctx *Opt_in_databaseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterrolesetstmt. + VisitAlterrolesetstmt(ctx *AlterrolesetstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterschemastmt. + VisitAlterschemastmt(ctx *AlterschemastmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#droprolestmt. + VisitDroprolestmt(ctx *DroprolestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropuserstmt. + VisitDropuserstmt(ctx *DropuserstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropgroupstmt. + VisitDropgroupstmt(ctx *DropgroupstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#creategroupstmt. + VisitCreategroupstmt(ctx *CreategroupstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altergroupstmt. + VisitAltergroupstmt(ctx *AltergroupstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#add_drop. + VisitAdd_drop(ctx *Add_dropContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createschemastmt. + VisitCreateschemastmt(ctx *CreateschemastmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_auth_clause. + VisitOpt_auth_clause(ctx *Opt_auth_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_quota. + VisitOpt_quota(ctx *Opt_quotaContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optschemaeltlist. + VisitOptschemaeltlist(ctx *OptschemaeltlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#schema_stmt. + VisitSchema_stmt(ctx *Schema_stmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#variablesetstmt. + VisitVariablesetstmt(ctx *VariablesetstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#set_rest. + VisitSet_rest(ctx *Set_restContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generic_set. + VisitGeneric_set(ctx *Generic_setContext) interface{} + + // Visit a parse tree produced by RedshiftParser#set_rest_more. + VisitSet_rest_more(ctx *Set_rest_moreContext) interface{} + + // Visit a parse tree produced by RedshiftParser#var_name. + VisitVar_name(ctx *Var_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#var_list. + VisitVar_list(ctx *Var_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#var_value. + VisitVar_value(ctx *Var_valueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#iso_level. + VisitIso_level(ctx *Iso_levelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_boolean_or_string. + VisitOpt_boolean_or_string(ctx *Opt_boolean_or_stringContext) interface{} + + // Visit a parse tree produced by RedshiftParser#zone_value. + VisitZone_value(ctx *Zone_valueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_encoding. + VisitOpt_encoding(ctx *Opt_encodingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#nonreservedword_or_sconst. + VisitNonreservedword_or_sconst(ctx *Nonreservedword_or_sconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#variableresetstmt. + VisitVariableresetstmt(ctx *VariableresetstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reset_rest. + VisitReset_rest(ctx *Reset_restContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generic_reset. + VisitGeneric_reset(ctx *Generic_resetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#setresetclause. + VisitSetresetclause(ctx *SetresetclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#functionsetresetclause. + VisitFunctionsetresetclause(ctx *FunctionsetresetclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#variableshowstmt. + VisitVariableshowstmt(ctx *VariableshowstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constraintssetstmt. + VisitConstraintssetstmt(ctx *ConstraintssetstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constraints_set_list. + VisitConstraints_set_list(ctx *Constraints_set_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constraints_set_mode. + VisitConstraints_set_mode(ctx *Constraints_set_modeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#checkpointstmt. + VisitCheckpointstmt(ctx *CheckpointstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#discardstmt. + VisitDiscardstmt(ctx *DiscardstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altertablestmt. + VisitAltertablestmt(ctx *AltertablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_table_cmds. + VisitAlter_table_cmds(ctx *Alter_table_cmdsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_constraint. + VisitTable_constraint(ctx *Table_constraintContext) interface{} + + // Visit a parse tree produced by RedshiftParser#partition_cmd. + VisitPartition_cmd(ctx *Partition_cmdContext) interface{} + + // Visit a parse tree produced by RedshiftParser#index_partition_cmd. + VisitIndex_partition_cmd(ctx *Index_partition_cmdContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_table_cmd. + VisitAlter_table_cmd(ctx *Alter_table_cmdContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_column_default. + VisitAlter_column_default(ctx *Alter_column_defaultContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_drop_behavior. + VisitOpt_drop_behavior(ctx *Opt_drop_behaviorContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_collate_clause. + VisitOpt_collate_clause(ctx *Opt_collate_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_using. + VisitAlter_using(ctx *Alter_usingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#replica_identity. + VisitReplica_identity(ctx *Replica_identityContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reloptions. + VisitReloptions(ctx *ReloptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_reloptions. + VisitOpt_reloptions(ctx *Opt_reloptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reloption_list. + VisitReloption_list(ctx *Reloption_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reloption_elem. + VisitReloption_elem(ctx *Reloption_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_identity_column_option_list. + VisitAlter_identity_column_option_list(ctx *Alter_identity_column_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_identity_column_option. + VisitAlter_identity_column_option(ctx *Alter_identity_column_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#partitionboundspec. + VisitPartitionboundspec(ctx *PartitionboundspecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#hash_partbound_elem. + VisitHash_partbound_elem(ctx *Hash_partbound_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#hash_partbound. + VisitHash_partbound(ctx *Hash_partboundContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altercompositetypestmt. + VisitAltercompositetypestmt(ctx *AltercompositetypestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_type_cmds. + VisitAlter_type_cmds(ctx *Alter_type_cmdsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_type_cmd. + VisitAlter_type_cmd(ctx *Alter_type_cmdContext) interface{} + + // Visit a parse tree produced by RedshiftParser#closeportalstmt. + VisitCloseportalstmt(ctx *CloseportalstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copystmt. + VisitCopystmt(ctx *CopystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#redshift_copy_authorization. + VisitRedshift_copy_authorization(ctx *Redshift_copy_authorizationContext) interface{} + + // Visit a parse tree produced by RedshiftParser#redshift_copy_format. + VisitRedshift_copy_format(ctx *Redshift_copy_formatContext) interface{} + + // Visit a parse tree produced by RedshiftParser#redshift_copy_parameter. + VisitRedshift_copy_parameter(ctx *Redshift_copy_parameterContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_param_name. + VisitCopy_param_name(ctx *Copy_param_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_param_value. + VisitCopy_param_value(ctx *Copy_param_valueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_from. + VisitCopy_from(ctx *Copy_fromContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_program. + VisitOpt_program(ctx *Opt_programContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_file_name. + VisitCopy_file_name(ctx *Copy_file_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_options. + VisitCopy_options(ctx *Copy_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_opt_list. + VisitCopy_opt_list(ctx *Copy_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_opt_item. + VisitCopy_opt_item(ctx *Copy_opt_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_binary. + VisitOpt_binary(ctx *Opt_binaryContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_delimiter. + VisitCopy_delimiter(ctx *Copy_delimiterContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_using. + VisitOpt_using(ctx *Opt_usingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_generic_opt_list. + VisitCopy_generic_opt_list(ctx *Copy_generic_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_generic_opt_elem. + VisitCopy_generic_opt_elem(ctx *Copy_generic_opt_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_generic_opt_arg. + VisitCopy_generic_opt_arg(ctx *Copy_generic_opt_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_generic_opt_arg_list. + VisitCopy_generic_opt_arg_list(ctx *Copy_generic_opt_arg_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_generic_opt_arg_list_item. + VisitCopy_generic_opt_arg_list_item(ctx *Copy_generic_opt_arg_list_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createstmt. + VisitCreatestmt(ctx *CreatestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_table_attributes. + VisitOpt_table_attributes(ctx *Opt_table_attributesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opttemp. + VisitOpttemp(ctx *OpttempContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opttableelementlist. + VisitOpttableelementlist(ctx *OpttableelementlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opttypedtableelementlist. + VisitOpttypedtableelementlist(ctx *OpttypedtableelementlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tableelementlist. + VisitTableelementlist(ctx *TableelementlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#typedtableelementlist. + VisitTypedtableelementlist(ctx *TypedtableelementlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tableelement. + VisitTableelement(ctx *TableelementContext) interface{} + + // Visit a parse tree produced by RedshiftParser#typedtableelement. + VisitTypedtableelement(ctx *TypedtableelementContext) interface{} + + // Visit a parse tree produced by RedshiftParser#columnDef. + VisitColumnDef(ctx *ColumnDefContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rs_colattributes. + VisitRs_colattributes(ctx *Rs_colattributesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rs_colattribute. + VisitRs_colattribute(ctx *Rs_colattributeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#columnOptions. + VisitColumnOptions(ctx *ColumnOptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#colquallist. + VisitColquallist(ctx *ColquallistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#colconstraint. + VisitColconstraint(ctx *ColconstraintContext) interface{} + + // Visit a parse tree produced by RedshiftParser#colconstraintelem. + VisitColconstraintelem(ctx *ColconstraintelemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_unique_null_treatment. + VisitOpt_unique_null_treatment(ctx *Opt_unique_null_treatmentContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generated_when. + VisitGenerated_when(ctx *Generated_whenContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constraintattr. + VisitConstraintattr(ctx *ConstraintattrContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tablelikeclause. + VisitTablelikeclause(ctx *TablelikeclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tablelikeoptionlist. + VisitTablelikeoptionlist(ctx *TablelikeoptionlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tablelikeoption. + VisitTablelikeoption(ctx *TablelikeoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tableconstraint. + VisitTableconstraint(ctx *TableconstraintContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constraintelem. + VisitConstraintelem(ctx *ConstraintelemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_no_inherit. + VisitOpt_no_inherit(ctx *Opt_no_inheritContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_column_list. + VisitOpt_column_list(ctx *Opt_column_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#columnlist. + VisitColumnlist(ctx *ColumnlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#columnElem. + VisitColumnElem(ctx *ColumnElemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_c_include. + VisitOpt_c_include(ctx *Opt_c_includeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#key_match. + VisitKey_match(ctx *Key_matchContext) interface{} + + // Visit a parse tree produced by RedshiftParser#exclusionconstraintlist. + VisitExclusionconstraintlist(ctx *ExclusionconstraintlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#exclusionconstraintelem. + VisitExclusionconstraintelem(ctx *ExclusionconstraintelemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#exclusionwhereclause. + VisitExclusionwhereclause(ctx *ExclusionwhereclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#key_actions. + VisitKey_actions(ctx *Key_actionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#key_update. + VisitKey_update(ctx *Key_updateContext) interface{} + + // Visit a parse tree produced by RedshiftParser#key_delete. + VisitKey_delete(ctx *Key_deleteContext) interface{} + + // Visit a parse tree produced by RedshiftParser#key_action. + VisitKey_action(ctx *Key_actionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optinherit. + VisitOptinherit(ctx *OptinheritContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optpartitionspec. + VisitOptpartitionspec(ctx *OptpartitionspecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#partitionspec. + VisitPartitionspec(ctx *PartitionspecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#part_params. + VisitPart_params(ctx *Part_paramsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#part_elem. + VisitPart_elem(ctx *Part_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_access_method_clause. + VisitTable_access_method_clause(ctx *Table_access_method_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optwith. + VisitOptwith(ctx *OptwithContext) interface{} + + // Visit a parse tree produced by RedshiftParser#oncommitoption. + VisitOncommitoption(ctx *OncommitoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opttablespace. + VisitOpttablespace(ctx *OpttablespaceContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optredshifttableoptions. + VisitOptredshifttableoptions(ctx *OptredshifttableoptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#redshifttableoption. + VisitRedshifttableoption(ctx *RedshifttableoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sortkeyclause. + VisitSortkeyclause(ctx *SortkeyclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sortkeyclausetype. + VisitSortkeyclausetype(ctx *SortkeyclausetypeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optconstablespace. + VisitOptconstablespace(ctx *OptconstablespaceContext) interface{} + + // Visit a parse tree produced by RedshiftParser#existingindex. + VisitExistingindex(ctx *ExistingindexContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createstatsstmt. + VisitCreatestatsstmt(ctx *CreatestatsstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterstatsstmt. + VisitAlterstatsstmt(ctx *AlterstatsstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createasstmt. + VisitCreateasstmt(ctx *CreateasstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#create_as_target. + VisitCreate_as_target(ctx *Create_as_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_backup_clause_table_attributes. + VisitOpt_backup_clause_table_attributes(ctx *Opt_backup_clause_table_attributesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_attributes. + VisitTable_attributes(ctx *Table_attributesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_backup_clause. + VisitOpt_backup_clause(ctx *Opt_backup_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_with_data. + VisitOpt_with_data(ctx *Opt_with_dataContext) interface{} + + // Visit a parse tree produced by RedshiftParser#creatematviewstmt. + VisitCreatematviewstmt(ctx *CreatematviewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_auto_refresh. + VisitOpt_auto_refresh(ctx *Opt_auto_refreshContext) interface{} + + // Visit a parse tree produced by RedshiftParser#refreshmatviewstmt. + VisitRefreshmatviewstmt(ctx *RefreshmatviewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createseqstmt. + VisitCreateseqstmt(ctx *CreateseqstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterseqstmt. + VisitAlterseqstmt(ctx *AlterseqstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optseqoptlist. + VisitOptseqoptlist(ctx *OptseqoptlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optparenthesizedseqoptlist. + VisitOptparenthesizedseqoptlist(ctx *OptparenthesizedseqoptlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#seqoptlist. + VisitSeqoptlist(ctx *SeqoptlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#seqoptelem. + VisitSeqoptelem(ctx *SeqoptelemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_by. + VisitOpt_by(ctx *Opt_byContext) interface{} + + // Visit a parse tree produced by RedshiftParser#numericonly. + VisitNumericonly(ctx *NumericonlyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#numericonly_list. + VisitNumericonly_list(ctx *Numericonly_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createplangstmt. + VisitCreateplangstmt(ctx *CreateplangstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_trusted. + VisitOpt_trusted(ctx *Opt_trustedContext) interface{} + + // Visit a parse tree produced by RedshiftParser#handler_name. + VisitHandler_name(ctx *Handler_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_inline_handler. + VisitOpt_inline_handler(ctx *Opt_inline_handlerContext) interface{} + + // Visit a parse tree produced by RedshiftParser#validator_clause. + VisitValidator_clause(ctx *Validator_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_validator. + VisitOpt_validator(ctx *Opt_validatorContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_procedural. + VisitOpt_procedural(ctx *Opt_proceduralContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createtablespacestmt. + VisitCreatetablespacestmt(ctx *CreatetablespacestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opttablespaceowner. + VisitOpttablespaceowner(ctx *OpttablespaceownerContext) interface{} + + // Visit a parse tree produced by RedshiftParser#droptablespacestmt. + VisitDroptablespacestmt(ctx *DroptablespacestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createextensionstmt. + VisitCreateextensionstmt(ctx *CreateextensionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#create_extension_opt_list. + VisitCreate_extension_opt_list(ctx *Create_extension_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#create_extension_opt_item. + VisitCreate_extension_opt_item(ctx *Create_extension_opt_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterextensionstmt. + VisitAlterextensionstmt(ctx *AlterextensionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_extension_opt_list. + VisitAlter_extension_opt_list(ctx *Alter_extension_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_extension_opt_item. + VisitAlter_extension_opt_item(ctx *Alter_extension_opt_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterextensioncontentsstmt. + VisitAlterextensioncontentsstmt(ctx *AlterextensioncontentsstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createfdwstmt. + VisitCreatefdwstmt(ctx *CreatefdwstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fdw_option. + VisitFdw_option(ctx *Fdw_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fdw_options. + VisitFdw_options(ctx *Fdw_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_fdw_options. + VisitOpt_fdw_options(ctx *Opt_fdw_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterfdwstmt. + VisitAlterfdwstmt(ctx *AlterfdwstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#create_generic_options. + VisitCreate_generic_options(ctx *Create_generic_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generic_option_list. + VisitGeneric_option_list(ctx *Generic_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_generic_options. + VisitAlter_generic_options(ctx *Alter_generic_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_generic_option_list. + VisitAlter_generic_option_list(ctx *Alter_generic_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alter_generic_option_elem. + VisitAlter_generic_option_elem(ctx *Alter_generic_option_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generic_option_elem. + VisitGeneric_option_elem(ctx *Generic_option_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generic_option_name. + VisitGeneric_option_name(ctx *Generic_option_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generic_option_arg. + VisitGeneric_option_arg(ctx *Generic_option_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createforeignserverstmt. + VisitCreateforeignserverstmt(ctx *CreateforeignserverstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_type. + VisitOpt_type(ctx *Opt_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#foreign_server_version. + VisitForeign_server_version(ctx *Foreign_server_versionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_foreign_server_version. + VisitOpt_foreign_server_version(ctx *Opt_foreign_server_versionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterforeignserverstmt. + VisitAlterforeignserverstmt(ctx *AlterforeignserverstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createforeigntablestmt. + VisitCreateforeigntablestmt(ctx *CreateforeigntablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#importforeignschemastmt. + VisitImportforeignschemastmt(ctx *ImportforeignschemastmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#import_qualification_type. + VisitImport_qualification_type(ctx *Import_qualification_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#import_qualification. + VisitImport_qualification(ctx *Import_qualificationContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createusermappingstmt. + VisitCreateusermappingstmt(ctx *CreateusermappingstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#auth_ident. + VisitAuth_ident(ctx *Auth_identContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropusermappingstmt. + VisitDropusermappingstmt(ctx *DropusermappingstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterusermappingstmt. + VisitAlterusermappingstmt(ctx *AlterusermappingstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createpolicystmt. + VisitCreatepolicystmt(ctx *CreatepolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterpolicystmt. + VisitAlterpolicystmt(ctx *AlterpolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsecurityoptionalexpr. + VisitRowsecurityoptionalexpr(ctx *RowsecurityoptionalexprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsecurityoptionalwithcheck. + VisitRowsecurityoptionalwithcheck(ctx *RowsecurityoptionalwithcheckContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsecuritydefaulttorole. + VisitRowsecuritydefaulttorole(ctx *RowsecuritydefaulttoroleContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsecurityoptionaltorole. + VisitRowsecurityoptionaltorole(ctx *RowsecurityoptionaltoroleContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsecuritydefaultpermissive. + VisitRowsecuritydefaultpermissive(ctx *RowsecuritydefaultpermissiveContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsecuritydefaultforcmd. + VisitRowsecuritydefaultforcmd(ctx *RowsecuritydefaultforcmdContext) interface{} + + // Visit a parse tree produced by RedshiftParser#row_security_cmd. + VisitRow_security_cmd(ctx *Row_security_cmdContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createamstmt. + VisitCreateamstmt(ctx *CreateamstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#am_type. + VisitAm_type(ctx *Am_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createtrigstmt. + VisitCreatetrigstmt(ctx *CreatetrigstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggeractiontime. + VisitTriggeractiontime(ctx *TriggeractiontimeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerevents. + VisitTriggerevents(ctx *TriggereventsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggeroneevent. + VisitTriggeroneevent(ctx *TriggeroneeventContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerreferencing. + VisitTriggerreferencing(ctx *TriggerreferencingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggertransitions. + VisitTriggertransitions(ctx *TriggertransitionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggertransition. + VisitTriggertransition(ctx *TriggertransitionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transitionoldornew. + VisitTransitionoldornew(ctx *TransitionoldornewContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transitionrowortable. + VisitTransitionrowortable(ctx *TransitionrowortableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transitionrelname. + VisitTransitionrelname(ctx *TransitionrelnameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerforspec. + VisitTriggerforspec(ctx *TriggerforspecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerforopteach. + VisitTriggerforopteach(ctx *TriggerforopteachContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerfortype. + VisitTriggerfortype(ctx *TriggerfortypeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerwhen. + VisitTriggerwhen(ctx *TriggerwhenContext) interface{} + + // Visit a parse tree produced by RedshiftParser#function_or_procedure. + VisitFunction_or_procedure(ctx *Function_or_procedureContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerfuncargs. + VisitTriggerfuncargs(ctx *TriggerfuncargsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#triggerfuncarg. + VisitTriggerfuncarg(ctx *TriggerfuncargContext) interface{} + + // Visit a parse tree produced by RedshiftParser#optconstrfromtable. + VisitOptconstrfromtable(ctx *OptconstrfromtableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constraintattributespec. + VisitConstraintattributespec(ctx *ConstraintattributespecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constraintattributeElem. + VisitConstraintattributeElem(ctx *ConstraintattributeElemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createeventtrigstmt. + VisitCreateeventtrigstmt(ctx *CreateeventtrigstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#event_trigger_when_list. + VisitEvent_trigger_when_list(ctx *Event_trigger_when_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#event_trigger_when_item. + VisitEvent_trigger_when_item(ctx *Event_trigger_when_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#event_trigger_value_list. + VisitEvent_trigger_value_list(ctx *Event_trigger_value_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altereventtrigstmt. + VisitAltereventtrigstmt(ctx *AltereventtrigstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#enable_trigger. + VisitEnable_trigger(ctx *Enable_triggerContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createassertionstmt. + VisitCreateassertionstmt(ctx *CreateassertionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#definestmt. + VisitDefinestmt(ctx *DefinestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#definition. + VisitDefinition(ctx *DefinitionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#def_list. + VisitDef_list(ctx *Def_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#def_elem. + VisitDef_elem(ctx *Def_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#def_arg. + VisitDef_arg(ctx *Def_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#old_aggr_definition. + VisitOld_aggr_definition(ctx *Old_aggr_definitionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#old_aggr_list. + VisitOld_aggr_list(ctx *Old_aggr_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#old_aggr_elem. + VisitOld_aggr_elem(ctx *Old_aggr_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_enum_val_list. + VisitOpt_enum_val_list(ctx *Opt_enum_val_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#enum_val_list. + VisitEnum_val_list(ctx *Enum_val_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterenumstmt. + VisitAlterenumstmt(ctx *AlterenumstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_if_not_exists. + VisitOpt_if_not_exists(ctx *Opt_if_not_existsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createopclassstmt. + VisitCreateopclassstmt(ctx *CreateopclassstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opclass_item_list. + VisitOpclass_item_list(ctx *Opclass_item_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opclass_item. + VisitOpclass_item(ctx *Opclass_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_default. + VisitOpt_default(ctx *Opt_defaultContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_opfamily. + VisitOpt_opfamily(ctx *Opt_opfamilyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opclass_purpose. + VisitOpclass_purpose(ctx *Opclass_purposeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_recheck. + VisitOpt_recheck(ctx *Opt_recheckContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createopfamilystmt. + VisitCreateopfamilystmt(ctx *CreateopfamilystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteropfamilystmt. + VisitAlteropfamilystmt(ctx *AlteropfamilystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opclass_drop_list. + VisitOpclass_drop_list(ctx *Opclass_drop_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opclass_drop. + VisitOpclass_drop(ctx *Opclass_dropContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropopclassstmt. + VisitDropopclassstmt(ctx *DropopclassstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropopfamilystmt. + VisitDropopfamilystmt(ctx *DropopfamilystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropownedstmt. + VisitDropownedstmt(ctx *DropownedstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reassignownedstmt. + VisitReassignownedstmt(ctx *ReassignownedstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropstmt. + VisitDropstmt(ctx *DropstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#object_type_any_name. + VisitObject_type_any_name(ctx *Object_type_any_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#object_type_name. + VisitObject_type_name(ctx *Object_type_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#drop_type_name. + VisitDrop_type_name(ctx *Drop_type_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#object_type_name_on_any_name. + VisitObject_type_name_on_any_name(ctx *Object_type_name_on_any_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#any_name_list. + VisitAny_name_list(ctx *Any_name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#any_name. + VisitAny_name(ctx *Any_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attrs. + VisitAttrs(ctx *AttrsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#type_name_list. + VisitType_name_list(ctx *Type_name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#truncatestmt. + VisitTruncatestmt(ctx *TruncatestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_restart_seqs. + VisitOpt_restart_seqs(ctx *Opt_restart_seqsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#commentstmt. + VisitCommentstmt(ctx *CommentstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#comment_text. + VisitComment_text(ctx *Comment_textContext) interface{} + + // Visit a parse tree produced by RedshiftParser#seclabelstmt. + VisitSeclabelstmt(ctx *SeclabelstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_provider. + VisitOpt_provider(ctx *Opt_providerContext) interface{} + + // Visit a parse tree produced by RedshiftParser#security_label. + VisitSecurity_label(ctx *Security_labelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fetchstmt. + VisitFetchstmt(ctx *FetchstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fetch_args. + VisitFetch_args(ctx *Fetch_argsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantstmt. + VisitGrantstmt(ctx *GrantstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_permissions_for_rls_lookup_tables. + VisitGrant_permissions_for_rls_lookup_tables(ctx *Grant_permissions_for_rls_lookup_tablesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_explain_permissions_for_row_level_security_policy_filters. + VisitGrant_explain_permissions_for_row_level_security_policy_filters(ctx *Grant_explain_permissions_for_row_level_security_policy_filtersContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_machine_learning_permissions. + VisitGrant_machine_learning_permissions(ctx *Grant_machine_learning_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_role_permissions. + VisitGrant_role_permissions(ctx *Grant_role_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_role_permission_target_list. + VisitGrant_role_permission_target_list(ctx *Grant_role_permission_target_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_role_permission_target_list_item. + VisitGrant_role_permission_target_list_item(ctx *Grant_role_permission_target_list_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#system_permissions. + VisitSystem_permissions(ctx *System_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#system_permissions_item. + VisitSystem_permissions_item(ctx *System_permissions_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_with_admin_option. + VisitOpt_with_admin_option(ctx *Opt_with_admin_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_scoped_permissions. + VisitGrant_scoped_permissions(ctx *Grant_scoped_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_scoped_schemas_permissions. + VisitGrant_scoped_schemas_permissions(ctx *Grant_scoped_schemas_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_scoped_tables_permissions. + VisitGrant_scoped_tables_permissions(ctx *Grant_scoped_tables_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_scoped_functions_permissions. + VisitGrant_scoped_functions_permissions(ctx *Grant_scoped_functions_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_scoped_procedures_permissions. + VisitGrant_scoped_procedures_permissions(ctx *Grant_scoped_procedures_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_scoped_languages_permissions. + VisitGrant_scoped_languages_permissions(ctx *Grant_scoped_languages_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_scoped_copy_jobs_permissions. + VisitGrant_scoped_copy_jobs_permissions(ctx *Grant_scoped_copy_jobs_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantee_list_without_public. + VisitGrantee_list_without_public(ctx *Grantee_list_without_publicContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantee_without_public. + VisitGrantee_without_public(ctx *Grantee_without_publicContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_datashare_permissions. + VisitGrant_datashare_permissions(ctx *Grant_datashare_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_spectrum_integration_permissions. + VisitGrant_spectrum_integration_permissions(ctx *Grant_spectrum_integration_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_spectrum_integration_external_schema_permissions. + VisitGrant_spectrum_integration_external_schema_permissions(ctx *Grant_spectrum_integration_external_schema_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#spectrum_integration_external_schema_permission_list. + VisitSpectrum_integration_external_schema_permission_list(ctx *Spectrum_integration_external_schema_permission_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#spectrum_integration_external_schema_permission. + VisitSpectrum_integration_external_schema_permission(ctx *Spectrum_integration_external_schema_permissionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_spectrum_integration_external_table_permissions. + VisitGrant_spectrum_integration_external_table_permissions(ctx *Grant_spectrum_integration_external_table_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#spectrum_integration_external_table_permission. + VisitSpectrum_integration_external_table_permission(ctx *Spectrum_integration_external_table_permissionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#spectrum_integration_external_table_permission_list. + VisitSpectrum_integration_external_table_permission_list(ctx *Spectrum_integration_external_table_permission_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_spectrum_integration_extenral_column_permissions. + VisitGrant_spectrum_integration_extenral_column_permissions(ctx *Grant_spectrum_integration_extenral_column_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#iamrolelist_or_public. + VisitIamrolelist_or_public(ctx *Iamrolelist_or_publicContext) interface{} + + // Visit a parse tree produced by RedshiftParser#iamrolelist. + VisitIamrolelist(ctx *IamrolelistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_assume_role_permissions. + VisitGrant_assume_role_permissions(ctx *Grant_assume_role_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_assume_role_for_list. + VisitGrant_assume_role_for_list(ctx *Grant_assume_role_for_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_assume_role_for_item. + VisitGrant_assume_role_for_item(ctx *Grant_assume_role_for_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_assume_role_target. + VisitGrant_assume_role_target(ctx *Grant_assume_role_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_column_level_permissions. + VisitGrant_column_level_permissions(ctx *Grant_column_level_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#column_privilege_target. + VisitColumn_privilege_target(ctx *Column_privilege_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#column_privilege_list. + VisitColumn_privilege_list(ctx *Column_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#column_all_privilege. + VisitColumn_all_privilege(ctx *Column_all_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#column_select_update_privilege. + VisitColumn_select_update_privilege(ctx *Column_select_update_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#common_grant. + VisitCommon_grant(ctx *Common_grantContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_job_privilege_list. + VisitCopy_job_privilege_list(ctx *Copy_job_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_job_privilege. + VisitCopy_job_privilege(ctx *Copy_job_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_job_target. + VisitCopy_job_target(ctx *Copy_job_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#copy_job_name. + VisitCopy_job_name(ctx *Copy_job_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#language_privilege_list. + VisitLanguage_privilege_list(ctx *Language_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_language_target. + VisitGrant_language_target(ctx *Grant_language_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_procedure_target. + VisitGrant_procedure_target(ctx *Grant_procedure_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#procedure_privilege_list. + VisitProcedure_privilege_list(ctx *Procedure_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#procedure_privilege. + VisitProcedure_privilege(ctx *Procedure_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#function_privilege_list. + VisitFunction_privilege_list(ctx *Function_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#function_privilege. + VisitFunction_privilege(ctx *Function_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_function_target. + VisitGrant_function_target(ctx *Grant_function_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_schema_target. + VisitGrant_schema_target(ctx *Grant_schema_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_schema_target. + VisitRevoke_schema_target(ctx *Revoke_schema_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#schema_privilege_list. + VisitSchema_privilege_list(ctx *Schema_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#schema_privilege. + VisitSchema_privilege(ctx *Schema_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#database_privilege_list. + VisitDatabase_privilege_list(ctx *Database_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#database_privilege. + VisitDatabase_privilege(ctx *Database_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_database_target. + VisitGrant_database_target(ctx *Grant_database_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grant_table_target. + VisitGrant_table_target(ctx *Grant_table_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_table_target. + VisitRevoke_table_target(ctx *Revoke_table_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#all_tables_in_schema_list. + VisitAll_tables_in_schema_list(ctx *All_tables_in_schema_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#all_privileges. + VisitAll_privileges(ctx *All_privilegesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantee_list. + VisitGrantee_list(ctx *Grantee_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantee. + VisitGrantee(ctx *GranteeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_with_grant_option. + VisitOpt_with_grant_option(ctx *Opt_with_grant_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_privilege. + VisitTable_privilege(ctx *Table_privilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_privilege_list. + VisitTable_privilege_list(ctx *Table_privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revokestmt. + VisitRevokestmt(ctx *RevokestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_permissions_for_rls_lookup_tables. + VisitRevoke_permissions_for_rls_lookup_tables(ctx *Revoke_permissions_for_rls_lookup_tablesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_explain_permissions_for_row_level_security_policy_filters. + VisitRevoke_explain_permissions_for_row_level_security_policy_filters(ctx *Revoke_explain_permissions_for_row_level_security_policy_filtersContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_machine_learning_permissions. + VisitRevoke_machine_learning_permissions(ctx *Revoke_machine_learning_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_role_permissions. + VisitRevoke_role_permissions(ctx *Revoke_role_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_scoped_permissions. + VisitRevoke_scoped_permissions(ctx *Revoke_scoped_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_scoped_schemas_permissions. + VisitRevoke_scoped_schemas_permissions(ctx *Revoke_scoped_schemas_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_scoped_tables_permissions. + VisitRevoke_scoped_tables_permissions(ctx *Revoke_scoped_tables_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_scoped_functions_permissions. + VisitRevoke_scoped_functions_permissions(ctx *Revoke_scoped_functions_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_scoped_procedures_permissions. + VisitRevoke_scoped_procedures_permissions(ctx *Revoke_scoped_procedures_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_scoped_languages_permissions. + VisitRevoke_scoped_languages_permissions(ctx *Revoke_scoped_languages_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_scoped_copy_jobs_permissions. + VisitRevoke_scoped_copy_jobs_permissions(ctx *Revoke_scoped_copy_jobs_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_datashare_permissions. + VisitRevoke_datashare_permissions(ctx *Revoke_datashare_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_spectrum_integration_permissions. + VisitRevoke_spectrum_integration_permissions(ctx *Revoke_spectrum_integration_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_spectrum_integration_external_schema_permissions. + VisitRevoke_spectrum_integration_external_schema_permissions(ctx *Revoke_spectrum_integration_external_schema_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_spectrum_integration_external_table_permissions. + VisitRevoke_spectrum_integration_external_table_permissions(ctx *Revoke_spectrum_integration_external_table_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_spectrum_integration_extenral_column_permissions. + VisitRevoke_spectrum_integration_extenral_column_permissions(ctx *Revoke_spectrum_integration_extenral_column_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_assume_role_permissions. + VisitRevoke_assume_role_permissions(ctx *Revoke_assume_role_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revoke_column_level_permissions. + VisitRevoke_column_level_permissions(ctx *Revoke_column_level_permissionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#common_revoke. + VisitCommon_revoke(ctx *Common_revokeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#privileges. + VisitPrivileges(ctx *PrivilegesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#privilege_list. + VisitPrivilege_list(ctx *Privilege_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#privilege. + VisitPrivilege(ctx *PrivilegeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#privilege_target. + VisitPrivilege_target(ctx *Privilege_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#parameter_name_list. + VisitParameter_name_list(ctx *Parameter_name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#parameter_name. + VisitParameter_name(ctx *Parameter_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_grant_grant_option. + VisitOpt_grant_grant_option(ctx *Opt_grant_grant_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantrolestmt. + VisitGrantrolestmt(ctx *GrantrolestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#revokerolestmt. + VisitRevokerolestmt(ctx *RevokerolestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_grant_admin_option. + VisitOpt_grant_admin_option(ctx *Opt_grant_admin_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_granted_by. + VisitOpt_granted_by(ctx *Opt_granted_byContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdefaultprivilegesstmt. + VisitAlterdefaultprivilegesstmt(ctx *AlterdefaultprivilegesstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#defacloptionlist. + VisitDefacloptionlist(ctx *DefacloptionlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#defacloption. + VisitDefacloption(ctx *DefacloptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#defaclaction. + VisitDefaclaction(ctx *DefaclactionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#defacl_privilege_target. + VisitDefacl_privilege_target(ctx *Defacl_privilege_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#indexstmt. + VisitIndexstmt(ctx *IndexstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_unique. + VisitOpt_unique(ctx *Opt_uniqueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_concurrently. + VisitOpt_concurrently(ctx *Opt_concurrentlyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_index_name. + VisitOpt_index_name(ctx *Opt_index_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#access_method_clause. + VisitAccess_method_clause(ctx *Access_method_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#index_params. + VisitIndex_params(ctx *Index_paramsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#index_elem_options. + VisitIndex_elem_options(ctx *Index_elem_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#index_elem. + VisitIndex_elem(ctx *Index_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_include. + VisitOpt_include(ctx *Opt_includeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#index_including_params. + VisitIndex_including_params(ctx *Index_including_paramsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_collate. + VisitOpt_collate(ctx *Opt_collateContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_class. + VisitOpt_class(ctx *Opt_classContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_asc_desc. + VisitOpt_asc_desc(ctx *Opt_asc_descContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_nulls_order. + VisitOpt_nulls_order(ctx *Opt_nulls_orderContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createfunctionstmt. + VisitCreatefunctionstmt(ctx *CreatefunctionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createprocedurestmt. + VisitCreateprocedurestmt(ctx *CreateprocedurestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_nonatomic. + VisitOpt_nonatomic(ctx *Opt_nonatomicContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_or_replace. + VisitOpt_or_replace(ctx *Opt_or_replaceContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_py_args_or_sql_args. + VisitFunc_py_args_or_sql_args(ctx *Func_py_args_or_sql_argsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_py_args_or_sql_args_list. + VisitFunc_py_args_or_sql_args_list(ctx *Func_py_args_or_sql_args_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_args. + VisitFunc_args(ctx *Func_argsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_args_list. + VisitFunc_args_list(ctx *Func_args_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#function_with_argtypes_list. + VisitFunction_with_argtypes_list(ctx *Function_with_argtypes_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#function_with_argtypes. + VisitFunction_with_argtypes(ctx *Function_with_argtypesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_args_with_defaults. + VisitFunc_args_with_defaults(ctx *Func_args_with_defaultsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_args_with_defaults_list. + VisitFunc_args_with_defaults_list(ctx *Func_args_with_defaults_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_arg. + VisitFunc_arg(ctx *Func_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#arg_class. + VisitArg_class(ctx *Arg_classContext) interface{} + + // Visit a parse tree produced by RedshiftParser#param_name. + VisitParam_name(ctx *Param_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_return. + VisitFunc_return(ctx *Func_returnContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_type. + VisitFunc_type(ctx *Func_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_arg_with_default. + VisitFunc_arg_with_default(ctx *Func_arg_with_defaultContext) interface{} + + // Visit a parse tree produced by RedshiftParser#aggr_arg. + VisitAggr_arg(ctx *Aggr_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#aggr_args. + VisitAggr_args(ctx *Aggr_argsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#aggr_args_list. + VisitAggr_args_list(ctx *Aggr_args_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#aggregate_with_argtypes. + VisitAggregate_with_argtypes(ctx *Aggregate_with_argtypesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#aggregate_with_argtypes_list. + VisitAggregate_with_argtypes_list(ctx *Aggregate_with_argtypes_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createfunc_opt_list. + VisitCreatefunc_opt_list(ctx *Createfunc_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#common_func_opt_item. + VisitCommon_func_opt_item(ctx *Common_func_opt_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createfunc_opt_item. + VisitCreatefunc_opt_item(ctx *Createfunc_opt_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_as. + VisitFunc_as(ctx *Func_asContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transform_type_list. + VisitTransform_type_list(ctx *Transform_type_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_definition. + VisitOpt_definition(ctx *Opt_definitionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_func_column. + VisitTable_func_column(ctx *Table_func_columnContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_func_column_list. + VisitTable_func_column_list(ctx *Table_func_column_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterfunctionstmt. + VisitAlterfunctionstmt(ctx *AlterfunctionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterprocedurestmt. + VisitAlterprocedurestmt(ctx *AlterprocedurestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterfunc_opt_list. + VisitAlterfunc_opt_list(ctx *Alterfunc_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_restrict. + VisitOpt_restrict(ctx *Opt_restrictContext) interface{} + + // Visit a parse tree produced by RedshiftParser#removefuncstmt. + VisitRemovefuncstmt(ctx *RemovefuncstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#removeaggrstmt. + VisitRemoveaggrstmt(ctx *RemoveaggrstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#removeoperstmt. + VisitRemoveoperstmt(ctx *RemoveoperstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#oper_argtypes. + VisitOper_argtypes(ctx *Oper_argtypesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#any_operator. + VisitAny_operator(ctx *Any_operatorContext) interface{} + + // Visit a parse tree produced by RedshiftParser#operator_with_argtypes_list. + VisitOperator_with_argtypes_list(ctx *Operator_with_argtypes_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#operator_with_argtypes. + VisitOperator_with_argtypes(ctx *Operator_with_argtypesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dostmt. + VisitDostmt(ctx *DostmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dostmt_opt_list. + VisitDostmt_opt_list(ctx *Dostmt_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dostmt_opt_item. + VisitDostmt_opt_item(ctx *Dostmt_opt_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createcaststmt. + VisitCreatecaststmt(ctx *CreatecaststmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cast_context. + VisitCast_context(ctx *Cast_contextContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropcaststmt. + VisitDropcaststmt(ctx *DropcaststmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_if_exists. + VisitOpt_if_exists(ctx *Opt_if_existsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createtransformstmt. + VisitCreatetransformstmt(ctx *CreatetransformstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transform_element_list. + VisitTransform_element_list(ctx *Transform_element_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#droptransformstmt. + VisitDroptransformstmt(ctx *DroptransformstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reindexstmt. + VisitReindexstmt(ctx *ReindexstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reindex_target_type. + VisitReindex_target_type(ctx *Reindex_target_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reindex_target_multitable. + VisitReindex_target_multitable(ctx *Reindex_target_multitableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reindex_option_list. + VisitReindex_option_list(ctx *Reindex_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reindex_option_elem. + VisitReindex_option_elem(ctx *Reindex_option_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altertblspcstmt. + VisitAltertblspcstmt(ctx *AltertblspcstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#renamestmt. + VisitRenamestmt(ctx *RenamestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_column. + VisitOpt_column(ctx *Opt_columnContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_set_data. + VisitOpt_set_data(ctx *Opt_set_dataContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterobjectdependsstmt. + VisitAlterobjectdependsstmt(ctx *AlterobjectdependsstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_no. + VisitOpt_no(ctx *Opt_noContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterobjectschemastmt. + VisitAlterobjectschemastmt(ctx *AlterobjectschemastmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteroperatorstmt. + VisitAlteroperatorstmt(ctx *AlteroperatorstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#operator_def_list. + VisitOperator_def_list(ctx *Operator_def_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#operator_def_elem. + VisitOperator_def_elem(ctx *Operator_def_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#operator_def_arg. + VisitOperator_def_arg(ctx *Operator_def_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altertypestmt. + VisitAltertypestmt(ctx *AltertypestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterownerstmt. + VisitAlterownerstmt(ctx *AlterownerstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createpublicationstmt. + VisitCreatepublicationstmt(ctx *CreatepublicationstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#pub_obj_list. + VisitPub_obj_list(ctx *Pub_obj_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#publication_obj_spec. + VisitPublication_obj_spec(ctx *Publication_obj_specContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_where_clause. + VisitOpt_where_clause(ctx *Opt_where_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterpublicationstmt. + VisitAlterpublicationstmt(ctx *AlterpublicationstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createsubscriptionstmt. + VisitCreatesubscriptionstmt(ctx *CreatesubscriptionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#publication_name_list. + VisitPublication_name_list(ctx *Publication_name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#publication_name_item. + VisitPublication_name_item(ctx *Publication_name_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altersubscriptionstmt. + VisitAltersubscriptionstmt(ctx *AltersubscriptionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropsubscriptionstmt. + VisitDropsubscriptionstmt(ctx *DropsubscriptionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rulestmt. + VisitRulestmt(ctx *RulestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#ruleactionlist. + VisitRuleactionlist(ctx *RuleactionlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#ruleactionmulti. + VisitRuleactionmulti(ctx *RuleactionmultiContext) interface{} + + // Visit a parse tree produced by RedshiftParser#ruleactionstmt. + VisitRuleactionstmt(ctx *RuleactionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#ruleactionstmtOrEmpty. + VisitRuleactionstmtOrEmpty(ctx *RuleactionstmtOrEmptyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#event. + VisitEvent(ctx *EventContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_instead. + VisitOpt_instead(ctx *Opt_insteadContext) interface{} + + // Visit a parse tree produced by RedshiftParser#notifystmt. + VisitNotifystmt(ctx *NotifystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#notify_payload. + VisitNotify_payload(ctx *Notify_payloadContext) interface{} + + // Visit a parse tree produced by RedshiftParser#listenstmt. + VisitListenstmt(ctx *ListenstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#unlistenstmt. + VisitUnlistenstmt(ctx *UnlistenstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transactionstmt. + VisitTransactionstmt(ctx *TransactionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_transaction. + VisitOpt_transaction(ctx *Opt_transactionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transaction_mode_item. + VisitTransaction_mode_item(ctx *Transaction_mode_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transaction_mode_list. + VisitTransaction_mode_list(ctx *Transaction_mode_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#transaction_mode_list_or_empty. + VisitTransaction_mode_list_or_empty(ctx *Transaction_mode_list_or_emptyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_transaction_chain. + VisitOpt_transaction_chain(ctx *Opt_transaction_chainContext) interface{} + + // Visit a parse tree produced by RedshiftParser#viewstmt. + VisitViewstmt(ctx *ViewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#with_no_schema_binding. + VisitWith_no_schema_binding(ctx *With_no_schema_bindingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_check_option. + VisitOpt_check_option(ctx *Opt_check_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#loadstmt. + VisitLoadstmt(ctx *LoadstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdatasharestmt. + VisitAlterdatasharestmt(ctx *AlterdatasharestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdatashare_action. + VisitAlterdatashare_action(ctx *Alterdatashare_actionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdatashare_add_drop. + VisitAlterdatashare_add_drop(ctx *Alterdatashare_add_dropContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdatashare_objects. + VisitAlterdatashare_objects(ctx *Alterdatashare_objectsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#datashare_table_list. + VisitDatashare_table_list(ctx *Datashare_table_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#datashare_table_name. + VisitDatashare_table_name(ctx *Datashare_table_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_name. + VisitTable_name(ctx *Table_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#temporary_table_name. + VisitTemporary_table_name(ctx *Temporary_table_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#datashare_function_list. + VisitDatashare_function_list(ctx *Datashare_function_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#datashare_function. + VisitDatashare_function(ctx *Datashare_functionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#datashare_function_name. + VisitDatashare_function_name(ctx *Datashare_function_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdatasharestmt. + VisitCreatedatasharestmt(ctx *CreatedatasharestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdatashareoptions. + VisitCreatedatashareoptions(ctx *CreatedatashareoptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdatashareoption. + VisitCreatedatashareoption(ctx *CreatedatashareoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#setpublicaccessibleoption. + VisitSetpublicaccessibleoption(ctx *SetpublicaccessibleoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#managedbyoption. + VisitManagedbyoption(ctx *ManagedbyoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#descdatasharestmt. + VisitDescdatasharestmt(ctx *DescdatasharestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropdatasharestmt. + VisitDropdatasharestmt(ctx *DropdatasharestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterexternalschemastmt. + VisitAlterexternalschemastmt(ctx *AlterexternalschemastmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altexternalschemaopts. + VisitAltexternalschemaopts(ctx *AltexternalschemaoptsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterexternalviewstmt. + VisitAlterexternalviewstmt(ctx *AlterexternalviewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createexternalschemastmt. + VisitCreateexternalschemastmt(ctx *CreateexternalschemastmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fromdatacatalogclause. + VisitFromdatacatalogclause(ctx *FromdatacatalogclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropschemastmt. + VisitDropschemastmt(ctx *DropschemastmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#implicitdatacatalogclause. + VisitImplicitdatacatalogclause(ctx *ImplicitdatacatalogclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fromhivemetastoreclause. + VisitFromhivemetastoreclause(ctx *FromhivemetastoreclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#frompostgresclause. + VisitFrompostgresclause(ctx *FrompostgresclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#frommysqlclause. + VisitFrommysqlclause(ctx *FrommysqlclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fromkinesisclause. + VisitFromkinesisclause(ctx *FromkinesisclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fromkafkaclause. + VisitFromkafkaclause(ctx *FromkafkaclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#frommskclause. + VisitFrommskclause(ctx *FrommskclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fromredshiftclause. + VisitFromredshiftclause(ctx *FromredshiftclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#iamrolevalue. + VisitIamrolevalue(ctx *IamrolevalueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#catalogrolevalue. + VisitCatalogrolevalue(ctx *CatalogrolevalueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#authenticationvalue. + VisitAuthenticationvalue(ctx *AuthenticationvalueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createexternalfunctionstmt. + VisitCreateexternalfunctionstmt(ctx *CreateexternalfunctionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#external_func_params. + VisitExternal_func_params(ctx *External_func_paramsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#paramlist. + VisitParamlist(ctx *ParamlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#param_spec. + VisitParam_spec(ctx *Param_specContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createexternalmodelstmt. + VisitCreateexternalmodelstmt(ctx *CreateexternalmodelstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createexternaltablestmt. + VisitCreateexternaltablestmt(ctx *CreateexternaltablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#extern_column_list. + VisitExtern_column_list(ctx *Extern_column_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#extern_column_def. + VisitExtern_column_def(ctx *Extern_column_defContext) interface{} + + // Visit a parse tree produced by RedshiftParser#extern_typename. + VisitExtern_typename(ctx *Extern_typenameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#extern_table_format. + VisitExtern_table_format(ctx *Extern_table_formatContext) interface{} + + // Visit a parse tree produced by RedshiftParser#row_format_spec. + VisitRow_format_spec(ctx *Row_format_specContext) interface{} + + // Visit a parse tree produced by RedshiftParser#serde_properties_list. + VisitSerde_properties_list(ctx *Serde_properties_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#serde_property. + VisitSerde_property(ctx *Serde_propertyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#external_format_spec. + VisitExternal_format_spec(ctx *External_format_specContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_properties_list. + VisitTable_properties_list(ctx *Table_properties_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_property. + VisitTable_property(ctx *Table_propertyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createexternalviewstmt. + VisitCreateexternalviewstmt(ctx *CreateexternalviewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropexternalviewstmt. + VisitDropexternalviewstmt(ctx *DropexternalviewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteridentityproviderstmt. + VisitAlteridentityproviderstmt(ctx *AlteridentityproviderstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteridprovideropts. + VisitAlteridprovideropts(ctx *AlteridprovideroptsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altermaskingpolicystmt. + VisitAltermaskingpolicystmt(ctx *AltermaskingpolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altermaterializedviewstmt. + VisitAltermaterializedviewstmt(ctx *AltermaterializedviewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altmaskingpolicyopts. + VisitAltmaskingpolicyopts(ctx *AltmaskingpolicyoptsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altmaskingpolicyargs. + VisitAltmaskingpolicyargs(ctx *AltmaskingpolicyargsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altmaskingpolicyarg. + VisitAltmaskingpolicyarg(ctx *AltmaskingpolicyargContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterrlspolicystmt. + VisitAlterrlspolicystmt(ctx *AlterrlspolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attachmaskingpolicystmt. + VisitAttachmaskingpolicystmt(ctx *AttachmaskingpolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attachpolicycollist. + VisitAttachpolicycollist(ctx *AttachpolicycollistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attachpolicycolumn. + VisitAttachpolicycolumn(ctx *AttachpolicycolumnContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attachpolicytargets. + VisitAttachpolicytargets(ctx *AttachpolicytargetsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attachpolicytarget. + VisitAttachpolicytarget(ctx *AttachpolicytargetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attachrlspolicystmt. + VisitAttachrlspolicystmt(ctx *AttachrlspolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_name_list. + VisitTable_name_list(ctx *Table_name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createidentityproviderstmt. + VisitCreateidentityproviderstmt(ctx *CreateidentityproviderstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createidprovideropts. + VisitCreateidprovideropts(ctx *CreateidprovideroptsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#groupfilter. + VisitGroupfilter(ctx *GroupfilterContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createlibrarystmt. + VisitCreatelibrarystmt(ctx *CreatelibrarystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createlibraryopts. + VisitCreatelibraryopts(ctx *CreatelibraryoptsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createmaskingpolicystmt. + VisitCreatemaskingpolicystmt(ctx *CreatemaskingpolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#inputcolumnlist. + VisitInputcolumnlist(ctx *InputcolumnlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#inputcolumn. + VisitInputcolumn(ctx *InputcolumnContext) interface{} + + // Visit a parse tree produced by RedshiftParser#maskingexpression. + VisitMaskingexpression(ctx *MaskingexpressionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createmodelstmt. + VisitCreatemodelstmt(ctx *CreatemodelstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createmodelfromclause. + VisitCreatemodelfromclause(ctx *CreatemodelfromclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#iamrolespec. + VisitIamrolespec(ctx *IamrolespecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sagemakerspec. + VisitSagemakerspec(ctx *SagemakerspecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#modeltypespec. + VisitModeltypespec(ctx *ModeltypespecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#problemtypespec. + VisitProblemtypespec(ctx *ProblemtypespecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#problemtype. + VisitProblemtype(ctx *ProblemtypeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#objectivespec. + VisitObjectivespec(ctx *ObjectivespecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#hyperparametersspec. + VisitHyperparametersspec(ctx *HyperparametersspecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#hyperparameterslist. + VisitHyperparameterslist(ctx *HyperparameterslistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#hyperparameteritem. + VisitHyperparameteritem(ctx *HyperparameteritemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#settingsclause. + VisitSettingsclause(ctx *SettingsclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#settingsitem. + VisitSettingsitem(ctx *SettingsitemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#datatypelist. + VisitDatatypelist(ctx *DatatypelistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#datatype. + VisitDatatype(ctx *DatatypeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createrlspolicystmt. + VisitCreaterlspolicystmt(ctx *CreaterlspolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#descidentityproviderstmt. + VisitDescidentityproviderstmt(ctx *DescidentityproviderstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#detachmaskingpolicystmt. + VisitDetachmaskingpolicystmt(ctx *DetachmaskingpolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#detachrlspolicystmt. + VisitDetachrlspolicystmt(ctx *DetachrlspolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#role_or_user_or_public_list. + VisitRole_or_user_or_public_list(ctx *Role_or_user_or_public_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#role_or_user_or_public. + VisitRole_or_user_or_public(ctx *Role_or_user_or_publicContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rlspolicyname. + VisitRlspolicyname(ctx *RlspolicynameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropidentityproviderstmt. + VisitDropidentityproviderstmt(ctx *DropidentityproviderstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#droplibrarystmt. + VisitDroplibrarystmt(ctx *DroplibrarystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropmaskingpolicystmt. + VisitDropmaskingpolicystmt(ctx *DropmaskingpolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropmodelstmt. + VisitDropmodelstmt(ctx *DropmodelstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#droprlspolicystmt. + VisitDroprlspolicystmt(ctx *DroprlspolicystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altertableappendstmt. + VisitAltertableappendstmt(ctx *AltertableappendstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#appendoptions. + VisitAppendoptions(ctx *AppendoptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteruserstmt. + VisitAlteruserstmt(ctx *AlteruserstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alteruseropts. + VisitAlteruseropts(ctx *AlteruseroptsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#analyzecompressionstmt. + VisitAnalyzecompressionstmt(ctx *AnalyzecompressionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cancelstmt. + VisitCancelstmt(ctx *CancelstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#closestmt. + VisitClosestmt(ctx *ClosestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#insertexternaltablestmt. + VisitInsertexternaltablestmt(ctx *InsertexternaltablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_or_values. + VisitSelect_or_values(ctx *Select_or_valuesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#selectintostmt. + VisitSelectintostmt(ctx *SelectintostmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#setsessionauthorizationstmt. + VisitSetsessionauthorizationstmt(ctx *SetsessionauthorizationstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#setsessioncharacteristicsstmt. + VisitSetsessioncharacteristicsstmt(ctx *SetsessioncharacteristicsstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showcolumnsstmt. + VisitShowcolumnsstmt(ctx *ShowcolumnsstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showdatabasesstmt. + VisitShowdatabasesstmt(ctx *ShowdatabasesstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showdbsopts. + VisitShowdbsopts(ctx *ShowdbsoptsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showdatasharesstmt. + VisitShowdatasharesstmt(ctx *ShowdatasharesstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showexternaltablestmt. + VisitShowexternaltablestmt(ctx *ShowexternaltablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showgrantsstmt. + VisitShowgrantsstmt(ctx *ShowgrantsstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantobject. + VisitGrantobject(ctx *GrantobjectContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grantprincipal. + VisitGrantprincipal(ctx *GrantprincipalContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showmodelstmt. + VisitShowmodelstmt(ctx *ShowmodelstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showprocedurestmt. + VisitShowprocedurestmt(ctx *ShowprocedurestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showschemasstmt. + VisitShowschemasstmt(ctx *ShowschemasstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showtablestmt. + VisitShowtablestmt(ctx *ShowtablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showtablesstmt. + VisitShowtablesstmt(ctx *ShowtablesstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#showviewstmt. + VisitShowviewstmt(ctx *ShowviewstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#unloadstmt. + VisitUnloadstmt(ctx *UnloadstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#iamroleclause. + VisitIamroleclause(ctx *IamroleclauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#unloadoptions. + VisitUnloadoptions(ctx *UnloadoptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#formatoption. + VisitFormatoption(ctx *FormatoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#partitionbyoption. + VisitPartitionbyoption(ctx *PartitionbyoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#manifestoption. + VisitManifestoption(ctx *ManifestoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#headeroption. + VisitHeaderoption(ctx *HeaderoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#delimiteroption. + VisitDelimiteroption(ctx *DelimiteroptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fixedwidthoption. + VisitFixedwidthoption(ctx *FixedwidthoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#encryptedoption. + VisitEncryptedoption(ctx *EncryptedoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#kmskeyoption. + VisitKmskeyoption(ctx *KmskeyoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#compressionoption. + VisitCompressionoption(ctx *CompressionoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#addquotesoption. + VisitAddquotesoption(ctx *AddquotesoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#nullasoption. + VisitNullasoption(ctx *NullasoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#escapeoption. + VisitEscapeoption(ctx *EscapeoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#allowoverwriteoption. + VisitAllowoverwriteoption(ctx *AllowoverwriteoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cleanpathoption. + VisitCleanpathoption(ctx *CleanpathoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#paralleloption. + VisitParalleloption(ctx *ParalleloptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#maxfilesizeoption. + VisitMaxfilesizeoption(ctx *MaxfilesizeoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowgroupsizeoption. + VisitRowgroupsizeoption(ctx *RowgroupsizeoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sizeunit. + VisitSizeunit(ctx *SizeunitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#regionoption. + VisitRegionoption(ctx *RegionoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#extensionoption. + VisitExtensionoption(ctx *ExtensionoptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#usestmt. + VisitUsestmt(ctx *UsestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdbstmt. + VisitCreatedbstmt(ctx *CreatedbstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdb_opt_list. + VisitCreatedb_opt_list(ctx *Createdb_opt_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdb_opt_items. + VisitCreatedb_opt_items(ctx *Createdb_opt_itemsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdb_opt_item. + VisitCreatedb_opt_item(ctx *Createdb_opt_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdb_opt_name. + VisitCreatedb_opt_name(ctx *Createdb_opt_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_equal. + VisitOpt_equal(ctx *Opt_equalContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdatabasestmt. + VisitAlterdatabasestmt(ctx *AlterdatabasestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdatabasesetstmt. + VisitAlterdatabasesetstmt(ctx *AlterdatabasesetstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#dropdbstmt. + VisitDropdbstmt(ctx *DropdbstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#drop_option_list. + VisitDrop_option_list(ctx *Drop_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#drop_option. + VisitDrop_option(ctx *Drop_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altercollationstmt. + VisitAltercollationstmt(ctx *AltercollationstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altersystemstmt. + VisitAltersystemstmt(ctx *AltersystemstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createdomainstmt. + VisitCreatedomainstmt(ctx *CreatedomainstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alterdomainstmt. + VisitAlterdomainstmt(ctx *AlterdomainstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_as. + VisitOpt_as(ctx *Opt_asContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altertsdictionarystmt. + VisitAltertsdictionarystmt(ctx *AltertsdictionarystmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#altertsconfigurationstmt. + VisitAltertsconfigurationstmt(ctx *AltertsconfigurationstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#any_with. + VisitAny_with(ctx *Any_withContext) interface{} + + // Visit a parse tree produced by RedshiftParser#createconversionstmt. + VisitCreateconversionstmt(ctx *CreateconversionstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#clusterstmt. + VisitClusterstmt(ctx *ClusterstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cluster_index_specification. + VisitCluster_index_specification(ctx *Cluster_index_specificationContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vacuumstmt. + VisitVacuumstmt(ctx *VacuumstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vacuum_option. + VisitVacuum_option(ctx *Vacuum_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#analyzestmt. + VisitAnalyzestmt(ctx *AnalyzestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vac_analyze_option_list. + VisitVac_analyze_option_list(ctx *Vac_analyze_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#analyze_keyword. + VisitAnalyze_keyword(ctx *Analyze_keywordContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vac_analyze_option_elem. + VisitVac_analyze_option_elem(ctx *Vac_analyze_option_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vac_analyze_option_name. + VisitVac_analyze_option_name(ctx *Vac_analyze_option_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vac_analyze_option_arg. + VisitVac_analyze_option_arg(ctx *Vac_analyze_option_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_analyze. + VisitOpt_analyze(ctx *Opt_analyzeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_verbose. + VisitOpt_verbose(ctx *Opt_verboseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_full. + VisitOpt_full(ctx *Opt_fullContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_freeze. + VisitOpt_freeze(ctx *Opt_freezeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_name_list. + VisitOpt_name_list(ctx *Opt_name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vacuum_relation. + VisitVacuum_relation(ctx *Vacuum_relationContext) interface{} + + // Visit a parse tree produced by RedshiftParser#vacuum_relation_list. + VisitVacuum_relation_list(ctx *Vacuum_relation_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_vacuum_relation_list. + VisitOpt_vacuum_relation_list(ctx *Opt_vacuum_relation_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#explainstmt. + VisitExplainstmt(ctx *ExplainstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#explainablestmt. + VisitExplainablestmt(ctx *ExplainablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#explain_option_list. + VisitExplain_option_list(ctx *Explain_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#explain_option_elem. + VisitExplain_option_elem(ctx *Explain_option_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#explain_option_name. + VisitExplain_option_name(ctx *Explain_option_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#explain_option_arg. + VisitExplain_option_arg(ctx *Explain_option_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#preparestmt. + VisitPreparestmt(ctx *PreparestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#prep_type_clause. + VisitPrep_type_clause(ctx *Prep_type_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#preparablestmt. + VisitPreparablestmt(ctx *PreparablestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#executestmt. + VisitExecutestmt(ctx *ExecutestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#execute_param_clause. + VisitExecute_param_clause(ctx *Execute_param_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#deallocatestmt. + VisitDeallocatestmt(ctx *DeallocatestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#insertstmt. + VisitInsertstmt(ctx *InsertstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#insert_target. + VisitInsert_target(ctx *Insert_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#insert_rest. + VisitInsert_rest(ctx *Insert_restContext) interface{} + + // Visit a parse tree produced by RedshiftParser#override_kind. + VisitOverride_kind(ctx *Override_kindContext) interface{} + + // Visit a parse tree produced by RedshiftParser#insert_column_list. + VisitInsert_column_list(ctx *Insert_column_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#insert_column_item. + VisitInsert_column_item(ctx *Insert_column_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_on_conflict. + VisitOpt_on_conflict(ctx *Opt_on_conflictContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_conf_expr. + VisitOpt_conf_expr(ctx *Opt_conf_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#returning_clause. + VisitReturning_clause(ctx *Returning_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#mergestmt. + VisitMergestmt(ctx *MergestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#merge_when_clause. + VisitMerge_when_clause(ctx *Merge_when_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#merge_insert_clause. + VisitMerge_insert_clause(ctx *Merge_insert_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#merge_update_clause. + VisitMerge_update_clause(ctx *Merge_update_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#merge_delete_clause. + VisitMerge_delete_clause(ctx *Merge_delete_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#deletestmt. + VisitDeletestmt(ctx *DeletestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#using_clause. + VisitUsing_clause(ctx *Using_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#lockstmt. + VisitLockstmt(ctx *LockstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_lock. + VisitOpt_lock(ctx *Opt_lockContext) interface{} + + // Visit a parse tree produced by RedshiftParser#lock_type. + VisitLock_type(ctx *Lock_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_nowait. + VisitOpt_nowait(ctx *Opt_nowaitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_nowait_or_skip. + VisitOpt_nowait_or_skip(ctx *Opt_nowait_or_skipContext) interface{} + + // Visit a parse tree produced by RedshiftParser#updatestmt. + VisitUpdatestmt(ctx *UpdatestmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#set_clause_list. + VisitSet_clause_list(ctx *Set_clause_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#set_clause. + VisitSet_clause(ctx *Set_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#set_target. + VisitSet_target(ctx *Set_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#set_target_list. + VisitSet_target_list(ctx *Set_target_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#declarecursorstmt. + VisitDeclarecursorstmt(ctx *DeclarecursorstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cursor_name. + VisitCursor_name(ctx *Cursor_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cursor_options. + VisitCursor_options(ctx *Cursor_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_hold. + VisitOpt_hold(ctx *Opt_holdContext) interface{} + + // Visit a parse tree produced by RedshiftParser#selectstmt. + VisitSelectstmt(ctx *SelectstmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_with_parens. + VisitSelect_with_parens(ctx *Select_with_parensContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_no_parens. + VisitSelect_no_parens(ctx *Select_no_parensContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_clause. + VisitSelect_clause(ctx *Select_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#simple_select_intersect. + VisitSimple_select_intersect(ctx *Simple_select_intersectContext) interface{} + + // Visit a parse tree produced by RedshiftParser#simple_select_pramary. + VisitSimple_select_pramary(ctx *Simple_select_pramaryContext) interface{} + + // Visit a parse tree produced by RedshiftParser#exclude_clause. + VisitExclude_clause(ctx *Exclude_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#qualify_clause. + VisitQualify_clause(ctx *Qualify_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#start_with_clause. + VisitStart_with_clause(ctx *Start_with_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#with_clause. + VisitWith_clause(ctx *With_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cte_list. + VisitCte_list(ctx *Cte_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#common_table_expr. + VisitCommon_table_expr(ctx *Common_table_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_materialized. + VisitOpt_materialized(ctx *Opt_materializedContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_with_clause. + VisitOpt_with_clause(ctx *Opt_with_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#into_clause. + VisitInto_clause(ctx *Into_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_top_clause. + VisitOpt_top_clause(ctx *Opt_top_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_strict. + VisitOpt_strict(ctx *Opt_strictContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opttempTableName. + VisitOpttempTableName(ctx *OpttempTableNameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_table. + VisitOpt_table(ctx *Opt_tableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#all_or_distinct. + VisitAll_or_distinct(ctx *All_or_distinctContext) interface{} + + // Visit a parse tree produced by RedshiftParser#distinct_clause. + VisitDistinct_clause(ctx *Distinct_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_all_clause. + VisitOpt_all_clause(ctx *Opt_all_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_sort_clause. + VisitOpt_sort_clause(ctx *Opt_sort_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sort_clause. + VisitSort_clause(ctx *Sort_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sortby_list. + VisitSortby_list(ctx *Sortby_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sortby. + VisitSortby(ctx *SortbyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_limit. + VisitSelect_limit(ctx *Select_limitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_select_limit. + VisitOpt_select_limit(ctx *Opt_select_limitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#limit_clause. + VisitLimit_clause(ctx *Limit_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#offset_clause. + VisitOffset_clause(ctx *Offset_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_limit_value. + VisitSelect_limit_value(ctx *Select_limit_valueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_offset_value. + VisitSelect_offset_value(ctx *Select_offset_valueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#select_fetch_first_value. + VisitSelect_fetch_first_value(ctx *Select_fetch_first_valueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#i_or_f_const. + VisitI_or_f_const(ctx *I_or_f_constContext) interface{} + + // Visit a parse tree produced by RedshiftParser#row_or_rows. + VisitRow_or_rows(ctx *Row_or_rowsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#first_or_next. + VisitFirst_or_next(ctx *First_or_nextContext) interface{} + + // Visit a parse tree produced by RedshiftParser#group_clause. + VisitGroup_clause(ctx *Group_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#group_by_list. + VisitGroup_by_list(ctx *Group_by_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#group_by_item. + VisitGroup_by_item(ctx *Group_by_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#empty_grouping_set. + VisitEmpty_grouping_set(ctx *Empty_grouping_setContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rollup_clause. + VisitRollup_clause(ctx *Rollup_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cube_clause. + VisitCube_clause(ctx *Cube_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#grouping_sets_clause. + VisitGrouping_sets_clause(ctx *Grouping_sets_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#having_clause. + VisitHaving_clause(ctx *Having_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#for_locking_clause. + VisitFor_locking_clause(ctx *For_locking_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_for_locking_clause. + VisitOpt_for_locking_clause(ctx *Opt_for_locking_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#for_locking_items. + VisitFor_locking_items(ctx *For_locking_itemsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#for_locking_item. + VisitFor_locking_item(ctx *For_locking_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#for_locking_strength. + VisitFor_locking_strength(ctx *For_locking_strengthContext) interface{} + + // Visit a parse tree produced by RedshiftParser#locked_rels_list. + VisitLocked_rels_list(ctx *Locked_rels_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#values_clause. + VisitValues_clause(ctx *Values_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#from_clause. + VisitFrom_clause(ctx *From_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#from_list. + VisitFrom_list(ctx *From_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_ref. + VisitTable_ref(ctx *Table_refContext) interface{} + + // Visit a parse tree produced by RedshiftParser#joined_table. + VisitJoined_table(ctx *Joined_tableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#alias_clause. + VisitAlias_clause(ctx *Alias_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_alias_clause. + VisitOpt_alias_clause(ctx *Opt_alias_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_alias_clause. + VisitTable_alias_clause(ctx *Table_alias_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_alias_clause. + VisitFunc_alias_clause(ctx *Func_alias_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#join_type. + VisitJoin_type(ctx *Join_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#join_qual. + VisitJoin_qual(ctx *Join_qualContext) interface{} + + // Visit a parse tree produced by RedshiftParser#relation_expr. + VisitRelation_expr(ctx *Relation_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#relation_expr_list. + VisitRelation_expr_list(ctx *Relation_expr_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#relation_expr_opt_alias. + VisitRelation_expr_opt_alias(ctx *Relation_expr_opt_aliasContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tablesample_clause. + VisitTablesample_clause(ctx *Tablesample_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_repeatable_clause. + VisitOpt_repeatable_clause(ctx *Opt_repeatable_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_table. + VisitFunc_table(ctx *Func_tableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsfrom_item. + VisitRowsfrom_item(ctx *Rowsfrom_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rowsfrom_list. + VisitRowsfrom_list(ctx *Rowsfrom_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_col_def_list. + VisitOpt_col_def_list(ctx *Opt_col_def_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_ordinality. + VisitOpt_ordinality(ctx *Opt_ordinalityContext) interface{} + + // Visit a parse tree produced by RedshiftParser#where_clause. + VisitWhere_clause(ctx *Where_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#where_or_current_clause. + VisitWhere_or_current_clause(ctx *Where_or_current_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opttablefuncelementlist. + VisitOpttablefuncelementlist(ctx *OpttablefuncelementlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tablefuncelementlist. + VisitTablefuncelementlist(ctx *TablefuncelementlistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#tablefuncelement. + VisitTablefuncelement(ctx *TablefuncelementContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xmltable. + VisitXmltable(ctx *XmltableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xmltable_column_list. + VisitXmltable_column_list(ctx *Xmltable_column_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xmltable_column_el. + VisitXmltable_column_el(ctx *Xmltable_column_elContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xmltable_column_option_list. + VisitXmltable_column_option_list(ctx *Xmltable_column_option_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xmltable_column_option_el. + VisitXmltable_column_option_el(ctx *Xmltable_column_option_elContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_namespace_list. + VisitXml_namespace_list(ctx *Xml_namespace_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_namespace_el. + VisitXml_namespace_el(ctx *Xml_namespace_elContext) interface{} + + // Visit a parse tree produced by RedshiftParser#typename. + VisitTypename(ctx *TypenameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_array_bounds. + VisitOpt_array_bounds(ctx *Opt_array_boundsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#simpletypename. + VisitSimpletypename(ctx *SimpletypenameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#varbyte. + VisitVarbyte(ctx *VarbyteContext) interface{} + + // Visit a parse tree produced by RedshiftParser#json_type. + VisitJson_type(ctx *Json_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#consttypename. + VisitConsttypename(ctx *ConsttypenameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#generictype. + VisitGenerictype(ctx *GenerictypeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_type_modifiers. + VisitOpt_type_modifiers(ctx *Opt_type_modifiersContext) interface{} + + // Visit a parse tree produced by RedshiftParser#numeric. + VisitNumeric(ctx *NumericContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_float. + VisitOpt_float(ctx *Opt_floatContext) interface{} + + // Visit a parse tree produced by RedshiftParser#bit. + VisitBit(ctx *BitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constbit. + VisitConstbit(ctx *ConstbitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#bitwithlength. + VisitBitwithlength(ctx *BitwithlengthContext) interface{} + + // Visit a parse tree produced by RedshiftParser#bitwithoutlength. + VisitBitwithoutlength(ctx *BitwithoutlengthContext) interface{} + + // Visit a parse tree produced by RedshiftParser#character. + VisitCharacter(ctx *CharacterContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constcharacter. + VisitConstcharacter(ctx *ConstcharacterContext) interface{} + + // Visit a parse tree produced by RedshiftParser#character_c. + VisitCharacter_c(ctx *Character_cContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_varying. + VisitOpt_varying(ctx *Opt_varyingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constdatetime. + VisitConstdatetime(ctx *ConstdatetimeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#constinterval. + VisitConstinterval(ctx *ConstintervalContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_timezone. + VisitOpt_timezone(ctx *Opt_timezoneContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_interval. + VisitOpt_interval(ctx *Opt_intervalContext) interface{} + + // Visit a parse tree produced by RedshiftParser#interval_second. + VisitInterval_second(ctx *Interval_secondContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_escape. + VisitOpt_escape(ctx *Opt_escapeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr. + VisitA_expr(ctx *A_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_qual. + VisitA_expr_qual(ctx *A_expr_qualContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_lessless. + VisitA_expr_lessless(ctx *A_expr_lesslessContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_or. + VisitA_expr_or(ctx *A_expr_orContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_and. + VisitA_expr_and(ctx *A_expr_andContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_between. + VisitA_expr_between(ctx *A_expr_betweenContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_in. + VisitA_expr_in(ctx *A_expr_inContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_unary_not. + VisitA_expr_unary_not(ctx *A_expr_unary_notContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_isnull. + VisitA_expr_isnull(ctx *A_expr_isnullContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_is_not. + VisitA_expr_is_not(ctx *A_expr_is_notContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_compare. + VisitA_expr_compare(ctx *A_expr_compareContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_prior_or_level. + VisitA_expr_prior_or_level(ctx *A_expr_prior_or_levelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_like. + VisitA_expr_like(ctx *A_expr_likeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_qual_op. + VisitA_expr_qual_op(ctx *A_expr_qual_opContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_unary_qualop. + VisitA_expr_unary_qualop(ctx *A_expr_unary_qualopContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_add. + VisitA_expr_add(ctx *A_expr_addContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_mul. + VisitA_expr_mul(ctx *A_expr_mulContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_caret. + VisitA_expr_caret(ctx *A_expr_caretContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_unary_sign. + VisitA_expr_unary_sign(ctx *A_expr_unary_signContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_at_time_zone. + VisitA_expr_at_time_zone(ctx *A_expr_at_time_zoneContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_collate. + VisitA_expr_collate(ctx *A_expr_collateContext) interface{} + + // Visit a parse tree produced by RedshiftParser#a_expr_typecast. + VisitA_expr_typecast(ctx *A_expr_typecastContext) interface{} + + // Visit a parse tree produced by RedshiftParser#b_expr. + VisitB_expr(ctx *B_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#c_expr_exists. + VisitC_expr_exists(ctx *C_expr_existsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#c_expr_expr. + VisitC_expr_expr(ctx *C_expr_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#c_expr_case. + VisitC_expr_case(ctx *C_expr_caseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#plsqlvariablename. + VisitPlsqlvariablename(ctx *PlsqlvariablenameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_application. + VisitFunc_application(ctx *Func_applicationContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_expr. + VisitFunc_expr(ctx *Func_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_expr_windowless. + VisitFunc_expr_windowless(ctx *Func_expr_windowlessContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_expr_common_subexpr. + VisitFunc_expr_common_subexpr(ctx *Func_expr_common_subexprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_root_version. + VisitXml_root_version(ctx *Xml_root_versionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_xml_root_standalone. + VisitOpt_xml_root_standalone(ctx *Opt_xml_root_standaloneContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_attributes. + VisitXml_attributes(ctx *Xml_attributesContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_attribute_list. + VisitXml_attribute_list(ctx *Xml_attribute_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_attribute_el. + VisitXml_attribute_el(ctx *Xml_attribute_elContext) interface{} + + // Visit a parse tree produced by RedshiftParser#document_or_content. + VisitDocument_or_content(ctx *Document_or_contentContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_whitespace_option. + VisitXml_whitespace_option(ctx *Xml_whitespace_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xmlexists_argument. + VisitXmlexists_argument(ctx *Xmlexists_argumentContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xml_passing_mech. + VisitXml_passing_mech(ctx *Xml_passing_mechContext) interface{} + + // Visit a parse tree produced by RedshiftParser#within_group_clause. + VisitWithin_group_clause(ctx *Within_group_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#filter_clause. + VisitFilter_clause(ctx *Filter_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#window_clause. + VisitWindow_clause(ctx *Window_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#window_definition_list. + VisitWindow_definition_list(ctx *Window_definition_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#window_definition. + VisitWindow_definition(ctx *Window_definitionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#over_clause. + VisitOver_clause(ctx *Over_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#window_specification. + VisitWindow_specification(ctx *Window_specificationContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_existing_window_name. + VisitOpt_existing_window_name(ctx *Opt_existing_window_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_partition_clause. + VisitOpt_partition_clause(ctx *Opt_partition_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_frame_clause. + VisitOpt_frame_clause(ctx *Opt_frame_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#frame_extent. + VisitFrame_extent(ctx *Frame_extentContext) interface{} + + // Visit a parse tree produced by RedshiftParser#frame_bound. + VisitFrame_bound(ctx *Frame_boundContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_window_exclusion_clause. + VisitOpt_window_exclusion_clause(ctx *Opt_window_exclusion_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#row. + VisitRow(ctx *RowContext) interface{} + + // Visit a parse tree produced by RedshiftParser#explicit_row. + VisitExplicit_row(ctx *Explicit_rowContext) interface{} + + // Visit a parse tree produced by RedshiftParser#implicit_row. + VisitImplicit_row(ctx *Implicit_rowContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sub_type. + VisitSub_type(ctx *Sub_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#all_op. + VisitAll_op(ctx *All_opContext) interface{} + + // Visit a parse tree produced by RedshiftParser#mathop. + VisitMathop(ctx *MathopContext) interface{} + + // Visit a parse tree produced by RedshiftParser#qual_op. + VisitQual_op(ctx *Qual_opContext) interface{} + + // Visit a parse tree produced by RedshiftParser#qual_all_op. + VisitQual_all_op(ctx *Qual_all_opContext) interface{} + + // Visit a parse tree produced by RedshiftParser#subquery_Op. + VisitSubquery_Op(ctx *Subquery_OpContext) interface{} + + // Visit a parse tree produced by RedshiftParser#expr_list. + VisitExpr_list(ctx *Expr_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_arg_list. + VisitFunc_arg_list(ctx *Func_arg_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_arg_expr. + VisitFunc_arg_expr(ctx *Func_arg_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#type_list. + VisitType_list(ctx *Type_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#array_expr. + VisitArray_expr(ctx *Array_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#array_expr_list. + VisitArray_expr_list(ctx *Array_expr_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#extract_list. + VisitExtract_list(ctx *Extract_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#extract_arg. + VisitExtract_arg(ctx *Extract_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#unicode_normal_form. + VisitUnicode_normal_form(ctx *Unicode_normal_formContext) interface{} + + // Visit a parse tree produced by RedshiftParser#overlay_list. + VisitOverlay_list(ctx *Overlay_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#position_list. + VisitPosition_list(ctx *Position_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#substr_list. + VisitSubstr_list(ctx *Substr_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#trim_list. + VisitTrim_list(ctx *Trim_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#in_expr_select. + VisitIn_expr_select(ctx *In_expr_selectContext) interface{} + + // Visit a parse tree produced by RedshiftParser#in_expr_list. + VisitIn_expr_list(ctx *In_expr_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#case_expr. + VisitCase_expr(ctx *Case_exprContext) interface{} + + // Visit a parse tree produced by RedshiftParser#when_clause_list. + VisitWhen_clause_list(ctx *When_clause_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#when_clause. + VisitWhen_clause(ctx *When_clauseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#case_default. + VisitCase_default(ctx *Case_defaultContext) interface{} + + // Visit a parse tree produced by RedshiftParser#case_arg. + VisitCase_arg(ctx *Case_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#columnref. + VisitColumnref(ctx *ColumnrefContext) interface{} + + // Visit a parse tree produced by RedshiftParser#indirection_el. + VisitIndirection_el(ctx *Indirection_elContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_slice_bound. + VisitOpt_slice_bound(ctx *Opt_slice_boundContext) interface{} + + // Visit a parse tree produced by RedshiftParser#indirection. + VisitIndirection(ctx *IndirectionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_indirection. + VisitOpt_indirection(ctx *Opt_indirectionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_target_list. + VisitOpt_target_list(ctx *Opt_target_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#target_list. + VisitTarget_list(ctx *Target_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#target_label. + VisitTarget_label(ctx *Target_labelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#target_star. + VisitTarget_star(ctx *Target_starContext) interface{} + + // Visit a parse tree produced by RedshiftParser#target_alias. + VisitTarget_alias(ctx *Target_aliasContext) interface{} + + // Visit a parse tree produced by RedshiftParser#qualified_name_list. + VisitQualified_name_list(ctx *Qualified_name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#qualified_name. + VisitQualified_name(ctx *Qualified_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#name_list. + VisitName_list(ctx *Name_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#name. + VisitName(ctx *NameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#attr_name. + VisitAttr_name(ctx *Attr_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#file_name. + VisitFile_name(ctx *File_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#func_name. + VisitFunc_name(ctx *Func_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#aexprconst. + VisitAexprconst(ctx *AexprconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#xconst. + VisitXconst(ctx *XconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#bconst. + VisitBconst(ctx *BconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#fconst. + VisitFconst(ctx *FconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#iconst. + VisitIconst(ctx *IconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sconst. + VisitSconst(ctx *SconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#anysconst. + VisitAnysconst(ctx *AnysconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_uescape. + VisitOpt_uescape(ctx *Opt_uescapeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#signediconst. + VisitSignediconst(ctx *SignediconstContext) interface{} + + // Visit a parse tree produced by RedshiftParser#roleid. + VisitRoleid(ctx *RoleidContext) interface{} + + // Visit a parse tree produced by RedshiftParser#rolespec. + VisitRolespec(ctx *RolespecContext) interface{} + + // Visit a parse tree produced by RedshiftParser#role_list. + VisitRole_list(ctx *Role_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#colid. + VisitColid(ctx *ColidContext) interface{} + + // Visit a parse tree produced by RedshiftParser#table_alias. + VisitTable_alias(ctx *Table_aliasContext) interface{} + + // Visit a parse tree produced by RedshiftParser#type_function_name. + VisitType_function_name(ctx *Type_function_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#nonreservedword. + VisitNonreservedword(ctx *NonreservedwordContext) interface{} + + // Visit a parse tree produced by RedshiftParser#collabel. + VisitCollabel(ctx *CollabelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#identifier. + VisitIdentifier(ctx *IdentifierContext) interface{} + + // Visit a parse tree produced by RedshiftParser#plsqlidentifier. + VisitPlsqlidentifier(ctx *PlsqlidentifierContext) interface{} + + // Visit a parse tree produced by RedshiftParser#unreserved_keyword. + VisitUnreserved_keyword(ctx *Unreserved_keywordContext) interface{} + + // Visit a parse tree produced by RedshiftParser#col_name_keyword. + VisitCol_name_keyword(ctx *Col_name_keywordContext) interface{} + + // Visit a parse tree produced by RedshiftParser#type_func_name_keyword. + VisitType_func_name_keyword(ctx *Type_func_name_keywordContext) interface{} + + // Visit a parse tree produced by RedshiftParser#reserved_keyword. + VisitReserved_keyword(ctx *Reserved_keywordContext) interface{} + + // Visit a parse tree produced by RedshiftParser#builtin_function_name. + VisitBuiltin_function_name(ctx *Builtin_function_nameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#pl_function. + VisitPl_function(ctx *Pl_functionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#comp_options. + VisitComp_options(ctx *Comp_optionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#comp_option. + VisitComp_option(ctx *Comp_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sharp. + VisitSharp(ctx *SharpContext) interface{} + + // Visit a parse tree produced by RedshiftParser#option_value. + VisitOption_value(ctx *Option_valueContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_semi. + VisitOpt_semi(ctx *Opt_semiContext) interface{} + + // Visit a parse tree produced by RedshiftParser#pl_block. + VisitPl_block(ctx *Pl_blockContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_sect. + VisitDecl_sect(ctx *Decl_sectContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_start. + VisitDecl_start(ctx *Decl_startContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_stmts. + VisitDecl_stmts(ctx *Decl_stmtsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#label_decl. + VisitLabel_decl(ctx *Label_declContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_stmt. + VisitDecl_stmt(ctx *Decl_stmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_statement. + VisitDecl_statement(ctx *Decl_statementContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_scrollable. + VisitOpt_scrollable(ctx *Opt_scrollableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_cursor_query. + VisitDecl_cursor_query(ctx *Decl_cursor_queryContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_cursor_args. + VisitDecl_cursor_args(ctx *Decl_cursor_argsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_cursor_arglist. + VisitDecl_cursor_arglist(ctx *Decl_cursor_arglistContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_cursor_arg. + VisitDecl_cursor_arg(ctx *Decl_cursor_argContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_is_for. + VisitDecl_is_for(ctx *Decl_is_forContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_aliasitem. + VisitDecl_aliasitem(ctx *Decl_aliasitemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_varname. + VisitDecl_varname(ctx *Decl_varnameContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_const. + VisitDecl_const(ctx *Decl_constContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_datatype. + VisitDecl_datatype(ctx *Decl_datatypeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_collate. + VisitDecl_collate(ctx *Decl_collateContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_notnull. + VisitDecl_notnull(ctx *Decl_notnullContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_defval. + VisitDecl_defval(ctx *Decl_defvalContext) interface{} + + // Visit a parse tree produced by RedshiftParser#decl_defkey. + VisitDecl_defkey(ctx *Decl_defkeyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#assign_operator. + VisitAssign_operator(ctx *Assign_operatorContext) interface{} + + // Visit a parse tree produced by RedshiftParser#proc_sect. + VisitProc_sect(ctx *Proc_sectContext) interface{} + + // Visit a parse tree produced by RedshiftParser#proc_stmt. + VisitProc_stmt(ctx *Proc_stmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_perform. + VisitStmt_perform(ctx *Stmt_performContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_call. + VisitStmt_call(ctx *Stmt_callContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_expr_list. + VisitOpt_expr_list(ctx *Opt_expr_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_assign. + VisitStmt_assign(ctx *Stmt_assignContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_getdiag. + VisitStmt_getdiag(ctx *Stmt_getdiagContext) interface{} + + // Visit a parse tree produced by RedshiftParser#getdiag_area_opt. + VisitGetdiag_area_opt(ctx *Getdiag_area_optContext) interface{} + + // Visit a parse tree produced by RedshiftParser#getdiag_list. + VisitGetdiag_list(ctx *Getdiag_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#getdiag_list_item. + VisitGetdiag_list_item(ctx *Getdiag_list_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#getdiag_item. + VisitGetdiag_item(ctx *Getdiag_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#getdiag_target. + VisitGetdiag_target(ctx *Getdiag_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#assign_var. + VisitAssign_var(ctx *Assign_varContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_if. + VisitStmt_if(ctx *Stmt_ifContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_elsifs. + VisitStmt_elsifs(ctx *Stmt_elsifsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_else. + VisitStmt_else(ctx *Stmt_elseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_case. + VisitStmt_case(ctx *Stmt_caseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_expr_until_when. + VisitOpt_expr_until_when(ctx *Opt_expr_until_whenContext) interface{} + + // Visit a parse tree produced by RedshiftParser#case_when_list. + VisitCase_when_list(ctx *Case_when_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#case_when. + VisitCase_when(ctx *Case_whenContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_case_else. + VisitOpt_case_else(ctx *Opt_case_elseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_loop. + VisitStmt_loop(ctx *Stmt_loopContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_while. + VisitStmt_while(ctx *Stmt_whileContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_for. + VisitStmt_for(ctx *Stmt_forContext) interface{} + + // Visit a parse tree produced by RedshiftParser#for_control. + VisitFor_control(ctx *For_controlContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_for_using_expression. + VisitOpt_for_using_expression(ctx *Opt_for_using_expressionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_cursor_parameters. + VisitOpt_cursor_parameters(ctx *Opt_cursor_parametersContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_reverse. + VisitOpt_reverse(ctx *Opt_reverseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_by_expression. + VisitOpt_by_expression(ctx *Opt_by_expressionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#for_variable. + VisitFor_variable(ctx *For_variableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_foreach_a. + VisitStmt_foreach_a(ctx *Stmt_foreach_aContext) interface{} + + // Visit a parse tree produced by RedshiftParser#foreach_slice. + VisitForeach_slice(ctx *Foreach_sliceContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_exit. + VisitStmt_exit(ctx *Stmt_exitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#exit_type. + VisitExit_type(ctx *Exit_typeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_return. + VisitStmt_return(ctx *Stmt_returnContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_return_result. + VisitOpt_return_result(ctx *Opt_return_resultContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_raise. + VisitStmt_raise(ctx *Stmt_raiseContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_stmt_raise_level. + VisitOpt_stmt_raise_level(ctx *Opt_stmt_raise_levelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_raise_list. + VisitOpt_raise_list(ctx *Opt_raise_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_raise_using. + VisitOpt_raise_using(ctx *Opt_raise_usingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_raise_using_elem. + VisitOpt_raise_using_elem(ctx *Opt_raise_using_elemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_raise_using_elem_list. + VisitOpt_raise_using_elem_list(ctx *Opt_raise_using_elem_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_assert. + VisitStmt_assert(ctx *Stmt_assertContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_stmt_assert_message. + VisitOpt_stmt_assert_message(ctx *Opt_stmt_assert_messageContext) interface{} + + // Visit a parse tree produced by RedshiftParser#loop_body. + VisitLoop_body(ctx *Loop_bodyContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_execsql. + VisitStmt_execsql(ctx *Stmt_execsqlContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_dynexecute. + VisitStmt_dynexecute(ctx *Stmt_dynexecuteContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_execute_using. + VisitOpt_execute_using(ctx *Opt_execute_usingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_execute_using_list. + VisitOpt_execute_using_list(ctx *Opt_execute_using_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_execute_into. + VisitOpt_execute_into(ctx *Opt_execute_intoContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_open. + VisitStmt_open(ctx *Stmt_openContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_open_bound_list_item. + VisitOpt_open_bound_list_item(ctx *Opt_open_bound_list_itemContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_open_bound_list. + VisitOpt_open_bound_list(ctx *Opt_open_bound_listContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_open_using. + VisitOpt_open_using(ctx *Opt_open_usingContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_scroll_option. + VisitOpt_scroll_option(ctx *Opt_scroll_optionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_scroll_option_no. + VisitOpt_scroll_option_no(ctx *Opt_scroll_option_noContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_fetch. + VisitStmt_fetch(ctx *Stmt_fetchContext) interface{} + + // Visit a parse tree produced by RedshiftParser#into_target. + VisitInto_target(ctx *Into_targetContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_cursor_from. + VisitOpt_cursor_from(ctx *Opt_cursor_fromContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_fetch_direction. + VisitOpt_fetch_direction(ctx *Opt_fetch_directionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_move. + VisitStmt_move(ctx *Stmt_moveContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_close. + VisitStmt_close(ctx *Stmt_closeContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_null. + VisitStmt_null(ctx *Stmt_nullContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_commit. + VisitStmt_commit(ctx *Stmt_commitContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_rollback. + VisitStmt_rollback(ctx *Stmt_rollbackContext) interface{} + + // Visit a parse tree produced by RedshiftParser#plsql_opt_transaction_chain. + VisitPlsql_opt_transaction_chain(ctx *Plsql_opt_transaction_chainContext) interface{} + + // Visit a parse tree produced by RedshiftParser#stmt_set. + VisitStmt_set(ctx *Stmt_setContext) interface{} + + // Visit a parse tree produced by RedshiftParser#cursor_variable. + VisitCursor_variable(ctx *Cursor_variableContext) interface{} + + // Visit a parse tree produced by RedshiftParser#exception_sect. + VisitException_sect(ctx *Exception_sectContext) interface{} + + // Visit a parse tree produced by RedshiftParser#proc_exceptions. + VisitProc_exceptions(ctx *Proc_exceptionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#proc_exception. + VisitProc_exception(ctx *Proc_exceptionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#proc_conditions. + VisitProc_conditions(ctx *Proc_conditionsContext) interface{} + + // Visit a parse tree produced by RedshiftParser#proc_condition. + VisitProc_condition(ctx *Proc_conditionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_block_label. + VisitOpt_block_label(ctx *Opt_block_labelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_loop_label. + VisitOpt_loop_label(ctx *Opt_loop_labelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_label. + VisitOpt_label(ctx *Opt_labelContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_exitcond. + VisitOpt_exitcond(ctx *Opt_exitcondContext) interface{} + + // Visit a parse tree produced by RedshiftParser#any_identifier. + VisitAny_identifier(ctx *Any_identifierContext) interface{} + + // Visit a parse tree produced by RedshiftParser#plsql_unreserved_keyword. + VisitPlsql_unreserved_keyword(ctx *Plsql_unreserved_keywordContext) interface{} + + // Visit a parse tree produced by RedshiftParser#sql_expression. + VisitSql_expression(ctx *Sql_expressionContext) interface{} + + // Visit a parse tree produced by RedshiftParser#expr_until_then. + VisitExpr_until_then(ctx *Expr_until_thenContext) interface{} + + // Visit a parse tree produced by RedshiftParser#expr_until_semi. + VisitExpr_until_semi(ctx *Expr_until_semiContext) interface{} + + // Visit a parse tree produced by RedshiftParser#expr_until_rightbracket. + VisitExpr_until_rightbracket(ctx *Expr_until_rightbracketContext) interface{} + + // Visit a parse tree produced by RedshiftParser#expr_until_loop. + VisitExpr_until_loop(ctx *Expr_until_loopContext) interface{} + + // Visit a parse tree produced by RedshiftParser#make_execsql_stmt. + VisitMake_execsql_stmt(ctx *Make_execsql_stmtContext) interface{} + + // Visit a parse tree produced by RedshiftParser#opt_returning_clause_into. + VisitOpt_returning_clause_into(ctx *Opt_returning_clause_intoContext) interface{} +} diff --git a/redshift/string_stack.go b/redshift/string_stack.go new file mode 100644 index 0000000..c89020d --- /dev/null +++ b/redshift/string_stack.go @@ -0,0 +1,57 @@ +package redshift + +import ( + "errors" +) + +var ( + ErrorStackEmpty = errors.New("stack empty") +) + +type StringStack struct { + items []string +} + +func (receiver *StringStack) Push(value string) { + receiver.items = append(receiver.items, value) +} + +func (receiver *StringStack) Pop() (string, error) { + if receiver.IsEmpty() { + return "", ErrorStackEmpty + } + value := receiver.items[0] + receiver.items = receiver.items[1:] + return value, nil +} + +func (receiver *StringStack) PopOrEmpty() string { + value, err := receiver.Pop() + if err != nil { + return "" + } + return value +} + +func (receiver *StringStack) Peek() (string, error) { + if receiver.IsEmpty() { + return "", ErrorStackEmpty + } + return receiver.items[0], nil +} + +func (receiver *StringStack) PeekOrEmpty() string { + value, err := receiver.Peek() + if err != nil { + return "" + } + return value +} + +func (receiver *StringStack) Size() int { + return len(receiver.items) +} + +func (receiver *StringStack) IsEmpty() bool { + return receiver.Size() == 0 +} diff --git a/test.sh b/test.sh new file mode 100755 index 0000000..7945333 --- /dev/null +++ b/test.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +# List of all available parsers +ALL_PARSERS="redshift" +# Add more parsers here as they are added to the repository +# ALL_PARSERS="redshift mysql postgresql" + +CHANGED_FILES=".github/workflows/tests.yml .gitignore go.mod go.sum redshift/CLAUDE.md redshift/Makefile redshift/README.md redshift/RedshiftLexer.g4 redshift/RedshiftLexer.interp redshift/RedshiftLexer.tokens redshift/RedshiftParser.g4 redshift/RedshiftParser.interp redshift/RedshiftParser.tokens redshift/builtin_function.go redshift/examples/redshift/abort.sql redshift/examples/redshift/abort_command.sql redshift/examples/redshift/alter_database.sql redshift/examples/redshift/alter_datashare.sql redshift/examples/redshift/alter_default_privileges.sql redshift/examples/redshift/alter_external_schema.sql redshift/examples/redshift/alter_external_view.sql redshift/examples/redshift/alter_function.sql redshift/examples/redshift/alter_group.sql redshift/examples/redshift/alter_identity_provider.sql redshift/examples/redshift/alter_masking_policy.sql redshift/examples/redshift/alter_materialized_view.sql redshift/examples/redshift/alter_procedure.sql redshift/examples/redshift/alter_rls_policy.sql redshift/examples/redshift/alter_role.sql redshift/examples/redshift/alter_schema.sql redshift/examples/redshift/alter_system.sql redshift/examples/redshift/alter_table.sql redshift/examples/redshift/alter_table_append.sql redshift/examples/redshift/alter_user.sql redshift/examples/redshift/analyze.sql redshift/examples/redshift/analyze_compression.sql redshift/examples/redshift/attach_masking_policy.sql redshift/examples/redshift/attach_rls_policy.sql redshift/examples/redshift/begin.sql redshift/examples/redshift/c_create_commands.sql redshift/examples/redshift/call.sql redshift/examples/redshift/cancel.sql redshift/examples/redshift/close.sql redshift/examples/redshift/comment.sql redshift/examples/redshift/commit.sql redshift/examples/redshift/copy.sql redshift/examples/redshift/create_database.sql redshift/examples/redshift/create_datashare.sql redshift/examples/redshift/create_external_function.sql redshift/examples/redshift/create_external_model.sql redshift/examples/redshift/create_external_schema.sql redshift/examples/redshift/create_external_table.sql redshift/examples/redshift/create_external_view.sql redshift/examples/redshift/create_function.sql redshift/examples/redshift/create_group.sql redshift/examples/redshift/create_identity_provider.sql redshift/examples/redshift/create_library.sql redshift/examples/redshift/create_masking_policy.sql redshift/examples/redshift/create_materialized_view.sql redshift/examples/redshift/create_model.sql redshift/examples/redshift/create_procedure.sql redshift/examples/redshift/create_rls_policy.sql redshift/examples/redshift/create_role.sql redshift/examples/redshift/create_schema.sql redshift/examples/redshift/create_table.sql redshift/examples/redshift/create_table_as.sql redshift/examples/redshift/create_user.sql redshift/examples/redshift/create_view.sql redshift/examples/redshift/deallocate.sql redshift/examples/redshift/declare.sql redshift/examples/redshift/delete.sql redshift/examples/redshift/desc_datashare.sql redshift/examples/redshift/desc_identity_provider.sql redshift/examples/redshift/detach_masking_policy.sql redshift/examples/redshift/detach_rls_policy.sql redshift/examples/redshift/drop_database.sql redshift/examples/redshift/drop_datashare.sql redshift/examples/redshift/drop_external_view.sql redshift/examples/redshift/drop_function.sql redshift/examples/redshift/drop_group.sql redshift/examples/redshift/drop_identity_provider.sql redshift/examples/redshift/drop_library.sql redshift/examples/redshift/drop_masking_policy.sql redshift/examples/redshift/drop_materialized_view.sql redshift/examples/redshift/drop_model.sql redshift/examples/redshift/drop_procedure.sql redshift/examples/redshift/drop_rls_policy.sql redshift/examples/redshift/drop_role.sql redshift/examples/redshift/drop_schema.sql redshift/examples/redshift/drop_table.sql redshift/examples/redshift/drop_user.sql redshift/examples/redshift/drop_view.sql redshift/examples/redshift/end.sql redshift/examples/redshift/execute.sql redshift/examples/redshift/explain.sql redshift/examples/redshift/fetch.sql redshift/examples/redshift/grant.sql redshift/examples/redshift/insert.sql redshift/examples/redshift/insert_external_table.sql redshift/examples/redshift/lock.sql redshift/examples/redshift/merge.sql redshift/examples/redshift/prepare.sql redshift/examples/redshift/refresh_materialized_view.sql redshift/examples/redshift/reset.sql redshift/examples/redshift/revoke.sql redshift/examples/redshift/rollback.sql redshift/examples/redshift/select.sql redshift/examples/redshift/select_into.sql redshift/examples/redshift/set.sql redshift/examples/redshift/set_session_authorization.sql redshift/examples/redshift/set_session_characteristics.sql redshift/examples/redshift/show.sql redshift/examples/redshift/show_columns.sql redshift/examples/redshift/show_databases.sql redshift/examples/redshift/show_datashares.sql redshift/examples/redshift/show_external_table.sql redshift/examples/redshift/show_grants.sql redshift/examples/redshift/show_model.sql redshift/examples/redshift/show_procedure.sql redshift/examples/redshift/show_schemas.sql redshift/examples/redshift/show_table.sql redshift/examples/redshift/show_tables.sql redshift/examples/redshift/show_view.sql redshift/examples/redshift/start_transaction.sql redshift/examples/redshift/truncate.sql redshift/examples/redshift/unload.sql redshift/examples/redshift/update.sql redshift/examples/redshift/use.sql redshift/examples/redshift/vacuum.sql redshift/keywords.go redshift/parser_test.go redshift/redshift_lexer.go redshift/redshift_lexer_base.go redshift/redshift_parse_error.go redshift/redshift_parser.go redshift/redshift_parser_base.go redshift/redshift_parser_error_listener.go redshift/redshiftparser_base_listener.go redshift/redshiftparser_base_visitor.go redshift/redshiftparser_listener.go redshift/redshiftparser_visitor.go redshift/string_stack.go" +echo "Debug: Changed files: $CHANGED_FILES" +CHANGED_PARSERS="" + +for parser in $ALL_PARSERS; do + echo "Checking changes for parser: $parser" + if echo "$CHANGED_FILES" | grep -q "^$parser/"; then + echo "True - $parser has changes." + if [ -z "$CHANGED_PARSERS" ]; then + CHANGED_PARSERS="\"$parser\"" + else + CHANGED_PARSERS="$CHANGED_PARSERS,\"$parser\"" + fi + fi +done